1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Mailbox interface for Wilco Embedded Controller
4  *
5  * Copyright 2018 Google LLC
6  *
7  * The Wilco EC is similar to a typical ChromeOS embedded controller.
8  * It uses the same MEC based low-level communication and a similar
9  * protocol, but with some important differences.  The EC firmware does
10  * not support the same mailbox commands so it is not registered as a
11  * cros_ec device type.
12  *
13  * Most messages follow a standard format, but there are some exceptions
14  * and an interface is provided to do direct/raw transactions that do not
15  * make assumptions about byte placement.
16  */
17 
18 #include <linux/delay.h>
19 #include <linux/device.h>
20 #include <linux/io.h>
21 #include <linux/platform_data/wilco-ec.h>
22 #include <linux/platform_device.h>
23 
24 #include "../cros_ec_lpc_mec.h"
25 
26 /* Version of mailbox interface */
27 #define EC_MAILBOX_VERSION		0
28 
29 /* Command to start mailbox transaction */
30 #define EC_MAILBOX_START_COMMAND	0xda
31 
32 /* Version of EC protocol */
33 #define EC_MAILBOX_PROTO_VERSION	3
34 
35 /* Number of header bytes to be counted as data bytes */
36 #define EC_MAILBOX_DATA_EXTRA		2
37 
38 /* Maximum timeout */
39 #define EC_MAILBOX_TIMEOUT		HZ
40 
41 /* EC response flags */
42 #define EC_CMDR_DATA		BIT(0)	/* Data ready for host to read */
43 #define EC_CMDR_PENDING		BIT(1)	/* Write pending to EC */
44 #define EC_CMDR_BUSY		BIT(2)	/* EC is busy processing a command */
45 #define EC_CMDR_CMD		BIT(3)	/* Last host write was a command */
46 
47 /**
48  * wilco_ec_response_timed_out() - Wait for EC response.
49  * @ec: EC device.
50  *
51  * Return: true if EC timed out, false if EC did not time out.
52  */
wilco_ec_response_timed_out(struct wilco_ec_device * ec)53 static bool wilco_ec_response_timed_out(struct wilco_ec_device *ec)
54 {
55 	unsigned long timeout = jiffies + EC_MAILBOX_TIMEOUT;
56 
57 	do {
58 		if (!(inb(ec->io_command->start) &
59 		      (EC_CMDR_PENDING | EC_CMDR_BUSY)))
60 			return false;
61 		usleep_range(100, 200);
62 	} while (time_before(jiffies, timeout));
63 
64 	return true;
65 }
66 
67 /**
68  * wilco_ec_checksum() - Compute 8-bit checksum over data range.
69  * @data: Data to checksum.
70  * @size: Number of bytes to checksum.
71  *
72  * Return: 8-bit checksum of provided data.
73  */
wilco_ec_checksum(const void * data,size_t size)74 static u8 wilco_ec_checksum(const void *data, size_t size)
75 {
76 	u8 *data_bytes = (u8 *)data;
77 	u8 checksum = 0;
78 	size_t i;
79 
80 	for (i = 0; i < size; i++)
81 		checksum += data_bytes[i];
82 
83 	return checksum;
84 }
85 
86 /**
87  * wilco_ec_prepare() - Prepare the request structure for the EC.
88  * @msg: EC message with request information.
89  * @rq: EC request structure to fill.
90  */
wilco_ec_prepare(struct wilco_ec_message * msg,struct wilco_ec_request * rq)91 static void wilco_ec_prepare(struct wilco_ec_message *msg,
92 			     struct wilco_ec_request *rq)
93 {
94 	memset(rq, 0, sizeof(*rq));
95 	rq->struct_version = EC_MAILBOX_PROTO_VERSION;
96 	rq->mailbox_id = msg->type;
97 	rq->mailbox_version = EC_MAILBOX_VERSION;
98 	rq->data_size = msg->request_size;
99 
100 	/* Checksum header and data */
101 	rq->checksum = wilco_ec_checksum(rq, sizeof(*rq));
102 	rq->checksum += wilco_ec_checksum(msg->request_data, msg->request_size);
103 	rq->checksum = -rq->checksum;
104 }
105 
106 /**
107  * wilco_ec_transfer() - Perform actual data transfer.
108  * @ec: EC device.
109  * @msg: EC message data for request and response.
110  * @rq: Filled in request structure
111  *
112  * Context: ec->mailbox_lock should be held while using this function.
113  * Return: number of bytes received or negative error code on failure.
114  */
wilco_ec_transfer(struct wilco_ec_device * ec,struct wilco_ec_message * msg,struct wilco_ec_request * rq)115 static int wilco_ec_transfer(struct wilco_ec_device *ec,
116 			     struct wilco_ec_message *msg,
117 			     struct wilco_ec_request *rq)
118 {
119 	struct wilco_ec_response *rs;
120 	u8 checksum;
121 	u8 flag;
122 
123 	/* Write request header, then data */
124 	cros_ec_lpc_io_bytes_mec(MEC_IO_WRITE, 0, sizeof(*rq), (u8 *)rq);
125 	cros_ec_lpc_io_bytes_mec(MEC_IO_WRITE, sizeof(*rq), msg->request_size,
126 				 msg->request_data);
127 
128 	/* Start the command */
129 	outb(EC_MAILBOX_START_COMMAND, ec->io_command->start);
130 
131 	/* For some commands (eg shutdown) the EC will not respond, that's OK */
132 	if (msg->flags & WILCO_EC_FLAG_NO_RESPONSE) {
133 		dev_dbg(ec->dev, "EC does not respond to this command\n");
134 		return 0;
135 	}
136 
137 	/* Wait for it to complete */
138 	if (wilco_ec_response_timed_out(ec)) {
139 		dev_dbg(ec->dev, "response timed out\n");
140 		return -ETIMEDOUT;
141 	}
142 
143 	/* Check result */
144 	flag = inb(ec->io_data->start);
145 	if (flag) {
146 		dev_dbg(ec->dev, "bad response: 0x%02x\n", flag);
147 		return -EIO;
148 	}
149 
150 	/* Read back response */
151 	rs = ec->data_buffer;
152 	checksum = cros_ec_lpc_io_bytes_mec(MEC_IO_READ, 0,
153 					    sizeof(*rs) + EC_MAILBOX_DATA_SIZE,
154 					    (u8 *)rs);
155 	if (checksum) {
156 		dev_dbg(ec->dev, "bad packet checksum 0x%02x\n", rs->checksum);
157 		return -EBADMSG;
158 	}
159 
160 	if (rs->result) {
161 		dev_dbg(ec->dev, "EC reported failure: 0x%02x\n", rs->result);
162 		return -EBADMSG;
163 	}
164 
165 	if (rs->data_size != EC_MAILBOX_DATA_SIZE) {
166 		dev_dbg(ec->dev, "unexpected packet size (%u != %u)\n",
167 			rs->data_size, EC_MAILBOX_DATA_SIZE);
168 		return -EMSGSIZE;
169 	}
170 
171 	if (rs->data_size < msg->response_size) {
172 		dev_dbg(ec->dev, "EC didn't return enough data (%u < %zu)\n",
173 			rs->data_size, msg->response_size);
174 		return -EMSGSIZE;
175 	}
176 
177 	memcpy(msg->response_data, rs->data, msg->response_size);
178 
179 	return rs->data_size;
180 }
181 
182 /**
183  * wilco_ec_mailbox() - Send EC request and receive EC response.
184  * @ec: EC device.
185  * @msg: EC message data for request and response.
186  *
187  * On entry msg->type, msg->request_size, and msg->request_data should all be
188  * filled in. If desired, msg->flags can be set.
189  *
190  * If a response is expected, msg->response_size should be set, and
191  * msg->response_data should point to a buffer with enough space. On exit
192  * msg->response_data will be filled.
193  *
194  * Return: number of bytes received or negative error code on failure.
195  */
wilco_ec_mailbox(struct wilco_ec_device * ec,struct wilco_ec_message * msg)196 int wilco_ec_mailbox(struct wilco_ec_device *ec, struct wilco_ec_message *msg)
197 {
198 	struct wilco_ec_request *rq;
199 	int ret;
200 
201 	dev_dbg(ec->dev, "type=%04x flags=%02x rslen=%zu rqlen=%zu\n",
202 		msg->type, msg->flags, msg->response_size, msg->request_size);
203 
204 	mutex_lock(&ec->mailbox_lock);
205 	/* Prepare request packet */
206 	rq = ec->data_buffer;
207 	wilco_ec_prepare(msg, rq);
208 
209 	ret = wilco_ec_transfer(ec, msg, rq);
210 	mutex_unlock(&ec->mailbox_lock);
211 
212 	return ret;
213 
214 }
215 EXPORT_SYMBOL_GPL(wilco_ec_mailbox);
216