src/ec/google/chromeec/crosec_proto.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2013 Google Inc.  All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; version 2 of the License
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  18  */
  19
  20 #include <arch/io.h>
  21 #include <console/console.h>
  22 #include <delay.h>
  23 #include <stdint.h>
  24 #include <string.h>
  25 #include "ec.h"
  26 #include "ec_commands.h"
  27 #include "ec_message.h"
  28
  29 /* Common utilities */
  30
  31 /* Dumps EC command / response data into debug output.
  32  *
  33  * @param name  Message prefix name.
  34  * @param cmd   Command code, or -1 to ignore cmd message.
  35  * @param data  Data buffer to print.
  36  * @param len   Length of data.
  37  */
  38 static void cros_ec_dump_data(const char *name, int cmd, const uint8_t *data,
  39                               int len)
  40 {
  41         int i;
  42
  43         printk(BIOS_DEBUG, "%s: ", name);
  44         if (cmd != -1)
  45                 printk(BIOS_DEBUG, "cmd=%#x: ", cmd);
  46         for (i = 0; i < len; i++)
  47                 printk(BIOS_DEBUG, "%02x ", data[i]);
  48         printk(BIOS_DEBUG, "\n");
  49 }
  50
  51 /* Calculate a simple 8-bit checksum of a data block
  52  *
  53  * @param data  Data block to checksum
  54  * @param size  Size of data block in bytes
  55  * @return checksum value (0 to 255)
  56  */
  57 static int cros_ec_calc_checksum(const uint8_t *data, int size)
  58 {
  59         int csum, i;
  60
  61         for (i = csum = 0; i < size; i++)
  62                 csum += data[i];
  63         return csum & 0xff;
  64 }
  65
  66 /* Standard Chrome EC protocol, version 3 */
  67
  68 struct ec_command_v3 {
  69         struct ec_host_request header;
  70         uint8_t data[MSG_BYTES];
  71 };
  72
  73 struct ec_response_v3 {
  74         struct ec_host_response header;
  75         uint8_t data[MSG_BYTES];
  76 };
  77
  78 /**
  79  * Create a request packet for protocol version 3.
  80  *
  81  * @param cec_command   Command description.
  82  * @param cmd           Packed command bit stream.
  83  * @return packet size in bytes, or <0 if error.
  84  */
  85 static int create_proto3_request(const struct chromeec_command *cec_command,
  86                                  struct ec_command_v3 *cmd)
  87 {
  88         struct ec_host_request *rq = &cmd->header;
  89         int out_bytes = cec_command->cmd_size_in + sizeof(*rq);
  90
  91         /* Fail if output size is too big */
  92         if (out_bytes > sizeof(*cmd)) {
  93                 printk(BIOS_ERR, "%s: Cannot send %d bytes\n", __func__,
  94                        cec_command->cmd_size_in);
  95                 return -EC_RES_REQUEST_TRUNCATED;
  96         }
  97
  98         /* Fill in request packet */
  99         rq->struct_version = EC_HOST_REQUEST_VERSION;
 100         rq->checksum = 0;
 101         rq->command = cec_command->cmd_code;
 102         rq->command_version = cec_command->cmd_version;
 103         rq->reserved = 0;
 104         rq->data_len = cec_command->cmd_size_in;
 105
 106         /* Copy data after header */
 107         memcpy(cmd->data, cec_command->cmd_data_in, cec_command->cmd_size_in);
 108
 109         /* Write checksum field so the entire packet sums to 0 */
 110         rq->checksum = (uint8_t)(-cros_ec_calc_checksum(
 111                         (const uint8_t*)cmd, out_bytes));
 112
 113         cros_ec_dump_data("out", rq->command, (const uint8_t *)cmd, out_bytes);
 114
 115         /* Return size of request packet */
 116         return out_bytes;
 117 }
 118
 119 /**
 120  * Prepare the device to receive a protocol version 3 response.
 121  *
 122  * @param cec_command   Command description.
 123  * @param resp          Response buffer.
 124  * @return maximum expected number of bytes in response, or <0 if error.
 125  */
 126 static int prepare_proto3_response_buffer(
 127                 const struct chromeec_command *cec_command,
 128                 struct ec_response_v3 *resp)
 129 {
 130         int in_bytes = cec_command->cmd_size_out + sizeof(resp->header);
 131
 132         /* Fail if input size is too big */
 133         if (in_bytes > sizeof(*resp)) {
 134                 printk(BIOS_ERR, "%s: Cannot receive %d bytes\n", __func__,
 135                        cec_command->cmd_size_out);
 136                 return -EC_RES_RESPONSE_TOO_BIG;
 137         }
 138
 139         /* Return expected size of response packet */
 140         return in_bytes;
 141 }
 142
 143 /**
 144  * Handle a protocol version 3 response packet.
 145  *
 146  * The packet must already be stored in the response buffer.
 147  *
 148  * @param resp          Response buffer.
 149  * @param cec_command   Command structure to receive valid response.
 150  * @return number of bytes of response data, or <0 if error
 151  */
 152 static int handle_proto3_response(struct ec_response_v3 *resp,
 153                                   struct chromeec_command *cec_command)
 154 {
 155         struct ec_host_response *rs = &resp->header;
 156         int in_bytes;
 157         int csum;
 158
 159         cros_ec_dump_data("in-header", -1, (const uint8_t*)rs, sizeof(*rs));
 160
 161         /* Check input data */
 162         if (rs->struct_version != EC_HOST_RESPONSE_VERSION) {
 163                 printk(BIOS_ERR, "%s: EC response version mismatch\n", __func__);
 164                 return -EC_RES_INVALID_RESPONSE;
 165         }
 166
 167         if (rs->reserved) {
 168                 printk(BIOS_ERR, "%s: EC response reserved != 0\n", __func__);
 169                 return -EC_RES_INVALID_RESPONSE;
 170         }
 171
 172         if (rs->data_len > sizeof(resp->data) ||
 173             rs->data_len > cec_command->cmd_size_out) {
 174                 printk(BIOS_ERR, "%s: EC returned too much data\n", __func__);
 175                 return -EC_RES_RESPONSE_TOO_BIG;
 176         }
 177
 178         cros_ec_dump_data("in-data", -1, resp->data, rs->data_len);
 179
 180         /* Update in_bytes to actual data size */
 181         in_bytes = sizeof(*rs) + rs->data_len;
 182
 183         /* Verify checksum */
 184         csum = cros_ec_calc_checksum((const uint8_t *)resp, in_bytes);
 185         if (csum) {
 186                 printk(BIOS_ERR, "%s: EC response checksum invalid: 0x%02x\n",
 187                        __func__, csum);
 188                 return -EC_RES_INVALID_CHECKSUM;
 189         }
 190
 191         /* Return raw response. */
 192         cec_command->cmd_code = rs->result;
 193         cec_command->cmd_size_out = rs->data_len;
 194         memcpy(cec_command->cmd_data_out, resp->data, rs->data_len);
 195
 196         /* Return error result, if any */
 197         if (rs->result) {
 198                 printk(BIOS_ERR, "%s: EC response with error code: %d\n",
 199                        __func__, rs->result);
 200                 return -(int)rs->result;
 201         }
 202
 203         return rs->data_len;
 204 }
 205
 206 static int send_command_proto3(struct chromeec_command *cec_command,
 207                                crosec_io_t crosec_io, void *context)
 208 {
 209         int out_bytes, in_bytes;
 210         int rv;
 211         struct ec_command_v3 cmd = { {0}, };
 212         struct ec_response_v3 resp = { {0}, };
 213
 214         /* Create request packet */
 215         out_bytes = create_proto3_request(cec_command, &cmd);
 216         if (out_bytes < 0) {
 217                 return out_bytes;
 218         }
 219
 220         /* Prepare response buffer */
 221         in_bytes = prepare_proto3_response_buffer(cec_command, &resp);
 222         if (in_bytes < 0) {
 223                 return in_bytes;
 224         }
 225
 226         rv = crosec_io((uint8_t *)&cmd, out_bytes, (uint8_t *)&resp, in_bytes,
 227                        context);
 228         if (rv != 0) {
 229                 printk(BIOS_ERR, "%s: failed to complete I/O: Err = %#x.",
 230                        __func__, rv >= 0 ? rv : -rv);
 231                 return -EC_RES_ERROR;
 232         }
 233
 234         /* Process the response */
 235         return handle_proto3_response(&resp, cec_command);
 236 }
 237
 238 static int crosec_command_proto_v3(struct chromeec_command *cec_command,
 239                                    crosec_io_t crosec_io, void *context)
 240 {
 241         int rv = send_command_proto3(cec_command, crosec_io, context);
 242         if (rv < 0) {
 243                 cec_command->cmd_code = rv;
 244                 return 1;
 245         }
 246         return 0;
 247 }
 248
 249 int crosec_command_proto(struct chromeec_command *cec_command,
 250                          crosec_io_t crosec_io, void *context)
 251 {
 252         // TODO(hungte) Detect and fallback to v2 if we need.
 253         return crosec_command_proto_v3(cec_command, crosec_io, context);
 254 }