Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Nick Crews | 728 | 100.00% | 3 | 100.00% |
Total | 728 | 3 |
// SPDX-License-Identifier: GPL-2.0 /* * Mailbox interface for Wilco Embedded Controller * * Copyright 2018 Google LLC * * The Wilco EC is similar to a typical ChromeOS embedded controller. * It uses the same MEC based low-level communication and a similar * protocol, but with some important differences. The EC firmware does * not support the same mailbox commands so it is not registered as a * cros_ec device type. * * Most messages follow a standard format, but there are some exceptions * and an interface is provided to do direct/raw transactions that do not * make assumptions about byte placement. */ #include <linux/delay.h> #include <linux/device.h> #include <linux/io.h> #include <linux/platform_data/wilco-ec.h> #include <linux/platform_device.h> #include "../cros_ec_lpc_mec.h" /* Version of mailbox interface */ #define EC_MAILBOX_VERSION 0 /* Command to start mailbox transaction */ #define EC_MAILBOX_START_COMMAND 0xda /* Version of EC protocol */ #define EC_MAILBOX_PROTO_VERSION 3 /* Number of header bytes to be counted as data bytes */ #define EC_MAILBOX_DATA_EXTRA 2 /* Maximum timeout */ #define EC_MAILBOX_TIMEOUT HZ /* EC response flags */ #define EC_CMDR_DATA BIT(0) /* Data ready for host to read */ #define EC_CMDR_PENDING BIT(1) /* Write pending to EC */ #define EC_CMDR_BUSY BIT(2) /* EC is busy processing a command */ #define EC_CMDR_CMD BIT(3) /* Last host write was a command */ /** * wilco_ec_response_timed_out() - Wait for EC response. * @ec: EC device. * * Return: true if EC timed out, false if EC did not time out. */ static bool wilco_ec_response_timed_out(struct wilco_ec_device *ec) { unsigned long timeout = jiffies + EC_MAILBOX_TIMEOUT; do { if (!(inb(ec->io_command->start) & (EC_CMDR_PENDING | EC_CMDR_BUSY))) return false; usleep_range(100, 200); } while (time_before(jiffies, timeout)); return true; } /** * wilco_ec_checksum() - Compute 8-bit checksum over data range. * @data: Data to checksum. * @size: Number of bytes to checksum. * * Return: 8-bit checksum of provided data. */ static u8 wilco_ec_checksum(const void *data, size_t size) { u8 *data_bytes = (u8 *)data; u8 checksum = 0; size_t i; for (i = 0; i < size; i++) checksum += data_bytes[i]; return checksum; } /** * wilco_ec_prepare() - Prepare the request structure for the EC. * @msg: EC message with request information. * @rq: EC request structure to fill. */ static void wilco_ec_prepare(struct wilco_ec_message *msg, struct wilco_ec_request *rq) { memset(rq, 0, sizeof(*rq)); rq->struct_version = EC_MAILBOX_PROTO_VERSION; rq->mailbox_id = msg->type; rq->mailbox_version = EC_MAILBOX_VERSION; rq->data_size = msg->request_size; /* Checksum header and data */ rq->checksum = wilco_ec_checksum(rq, sizeof(*rq)); rq->checksum += wilco_ec_checksum(msg->request_data, msg->request_size); rq->checksum = -rq->checksum; } /** * wilco_ec_transfer() - Perform actual data transfer. * @ec: EC device. * @msg: EC message data for request and response. * @rq: Filled in request structure * * Context: ec->mailbox_lock should be held while using this function. * Return: number of bytes received or negative error code on failure. */ static int wilco_ec_transfer(struct wilco_ec_device *ec, struct wilco_ec_message *msg, struct wilco_ec_request *rq) { struct wilco_ec_response *rs; u8 checksum; u8 flag; size_t size; /* Write request header, then data */ cros_ec_lpc_io_bytes_mec(MEC_IO_WRITE, 0, sizeof(*rq), (u8 *)rq); cros_ec_lpc_io_bytes_mec(MEC_IO_WRITE, sizeof(*rq), msg->request_size, msg->request_data); /* Start the command */ outb(EC_MAILBOX_START_COMMAND, ec->io_command->start); /* For some commands (eg shutdown) the EC will not respond, that's OK */ if (msg->flags & WILCO_EC_FLAG_NO_RESPONSE) { dev_dbg(ec->dev, "EC does not respond to this command\n"); return 0; } /* Wait for it to complete */ if (wilco_ec_response_timed_out(ec)) { dev_dbg(ec->dev, "response timed out\n"); return -ETIMEDOUT; } /* Check result */ flag = inb(ec->io_data->start); if (flag) { dev_dbg(ec->dev, "bad response: 0x%02x\n", flag); return -EIO; } /* * The EC always returns either EC_MAILBOX_DATA_SIZE or * EC_MAILBOX_DATA_SIZE_EXTENDED bytes of data, so we need to * calculate the checksum on **all** of this data, even if we * won't use all of it. */ if (msg->flags & WILCO_EC_FLAG_EXTENDED_DATA) size = EC_MAILBOX_DATA_SIZE_EXTENDED; else size = EC_MAILBOX_DATA_SIZE; /* Read back response */ rs = ec->data_buffer; checksum = cros_ec_lpc_io_bytes_mec(MEC_IO_READ, 0, sizeof(*rs) + size, (u8 *)rs); if (checksum) { dev_dbg(ec->dev, "bad packet checksum 0x%02x\n", rs->checksum); return -EBADMSG; } if (rs->result) { dev_dbg(ec->dev, "EC reported failure: 0x%02x\n", rs->result); return -EBADMSG; } if (rs->data_size != size) { dev_dbg(ec->dev, "unexpected packet size (%u != %zu)", rs->data_size, size); return -EMSGSIZE; } if (rs->data_size < msg->response_size) { dev_dbg(ec->dev, "EC didn't return enough data (%u < %zu)", rs->data_size, msg->response_size); return -EMSGSIZE; } memcpy(msg->response_data, rs->data, msg->response_size); return rs->data_size; } /** * wilco_ec_mailbox() - Send EC request and receive EC response. * @ec: EC device. * @msg: EC message data for request and response. * * On entry msg->type, msg->request_size, and msg->request_data should all be * filled in. If desired, msg->flags can be set. * * If a response is expected, msg->response_size should be set, and * msg->response_data should point to a buffer with enough space. On exit * msg->response_data will be filled. * * Return: number of bytes received or negative error code on failure. */ int wilco_ec_mailbox(struct wilco_ec_device *ec, struct wilco_ec_message *msg) { struct wilco_ec_request *rq; int ret; dev_dbg(ec->dev, "type=%04x flags=%02x rslen=%zu rqlen=%zu\n", msg->type, msg->flags, msg->response_size, msg->request_size); mutex_lock(&ec->mailbox_lock); /* Prepare request packet */ rq = ec->data_buffer; wilco_ec_prepare(msg, rq); ret = wilco_ec_transfer(ec, msg, rq); mutex_unlock(&ec->mailbox_lock); return ret; } EXPORT_SYMBOL_GPL(wilco_ec_mailbox);
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1