mirror of
https://github.com/Telecominfraproject/OpenCellular.git
synced 2025-12-28 02:35:28 +00:00
fe293908ed
Not needed with kernel fix:
Commands are currenly limited to 252 bytes. Even if EC support protocol
v3, ectool would only limit the command sizes, never go beyond 252
bytes.
This reverts commit be0bd9b835.
It also remove a TODO.
CQ-DEPEND=CL:262870
TEST=With proper kernel, and firmware supporting commands > 252 bytes,
check that ectool console does not crash anymore.
/usr/sbin/ectool --name cros_sh console
returns more character than before.
Check ectool version as well.
/usr/sbin/ectool --name cros_sh version
BUG=chromium:399057,chromium:454324,chrome-os-partner:31989,chrome-os-partner:23823
BRANCH=none
Change-Id: I058ab0e6df96196a0fae186d1ffedcfa16e5dc3b
Signed-off-by: Gwendal Grignou <gwendal@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/262885
Reviewed-by: Puthikorn Voravootivat <puthik@chromium.org>
131 lines
3.0 KiB
C
131 lines
3.0 KiB
C
/* Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include <errno.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "comm-host.h"
|
|
#include "ec_commands.h"
|
|
|
|
int (*ec_command_proto)(int command, int version,
|
|
const void *outdata, int outsize,
|
|
void *indata, int insize);
|
|
|
|
int (*ec_readmem)(int offset, int bytes, void *dest);
|
|
|
|
int ec_max_outsize, ec_max_insize;
|
|
void *ec_outbuf;
|
|
void *ec_inbuf;
|
|
static int command_offset;
|
|
|
|
int comm_init_dev(const char *device_name) __attribute__((weak));
|
|
int comm_init_lpc(void) __attribute__((weak));
|
|
int comm_init_i2c(void) __attribute__((weak));
|
|
|
|
static int fake_readmem(int offset, int bytes, void *dest)
|
|
{
|
|
struct ec_params_read_memmap p;
|
|
int c;
|
|
char *buf;
|
|
|
|
p.offset = offset;
|
|
|
|
if (bytes) {
|
|
p.size = bytes;
|
|
c = ec_command(EC_CMD_READ_MEMMAP, 0, &p, sizeof(p),
|
|
dest, p.size);
|
|
if (c < 0)
|
|
return c;
|
|
return p.size;
|
|
}
|
|
|
|
p.size = EC_MEMMAP_TEXT_MAX;
|
|
|
|
c = ec_command(EC_CMD_READ_MEMMAP, 0, &p, sizeof(p), dest, p.size);
|
|
if (c < 0)
|
|
return c;
|
|
|
|
buf = dest;
|
|
for (c = 0; c < EC_MEMMAP_TEXT_MAX; c++) {
|
|
if (buf[c] == 0)
|
|
return c;
|
|
}
|
|
|
|
buf[EC_MEMMAP_TEXT_MAX - 1] = 0;
|
|
return EC_MEMMAP_TEXT_MAX - 1;
|
|
}
|
|
|
|
void set_command_offset(int offset)
|
|
{
|
|
command_offset = offset;
|
|
}
|
|
|
|
int ec_command(int command, int version,
|
|
const void *outdata, int outsize,
|
|
void *indata, int insize)
|
|
{
|
|
/* Offset command code to support sub-devices */
|
|
return ec_command_proto(command_offset + command, version,
|
|
outdata, outsize,
|
|
indata, insize);
|
|
}
|
|
|
|
int comm_init(int interfaces, const char *device_name)
|
|
{
|
|
struct ec_response_get_protocol_info info;
|
|
|
|
/* Default memmap access */
|
|
ec_readmem = fake_readmem;
|
|
|
|
/* Prefer new /dev method */
|
|
if ((interfaces & COMM_DEV) && comm_init_dev &&
|
|
!comm_init_dev(device_name))
|
|
goto init_ok;
|
|
|
|
/* Fallback to direct LPC on x86 */
|
|
if ((interfaces & COMM_LPC) && comm_init_lpc && !comm_init_lpc())
|
|
goto init_ok;
|
|
|
|
/* Fallback to direct i2c on ARM */
|
|
if ((interfaces & COMM_I2C) && comm_init_i2c && !comm_init_i2c())
|
|
goto init_ok;
|
|
|
|
/* Give up */
|
|
fprintf(stderr, "Unable to establish host communication\n");
|
|
return 1;
|
|
|
|
init_ok:
|
|
/* Allocate shared I/O buffers */
|
|
ec_outbuf = malloc(ec_max_outsize);
|
|
ec_inbuf = malloc(ec_max_insize);
|
|
if (!ec_outbuf || !ec_inbuf) {
|
|
fprintf(stderr, "Unable to allocate buffers\n");
|
|
return 1;
|
|
}
|
|
|
|
/* read max request / response size from ec for protocol v3+ */
|
|
if (ec_command(EC_CMD_GET_PROTOCOL_INFO, 0, NULL, 0, &info,
|
|
sizeof(info)) == sizeof(info)) {
|
|
ec_max_outsize = info.max_request_packet_size -
|
|
sizeof(struct ec_host_request);
|
|
ec_max_insize = info.max_response_packet_size -
|
|
sizeof(struct ec_host_response);
|
|
|
|
ec_outbuf = realloc(ec_outbuf, ec_max_outsize);
|
|
ec_inbuf = realloc(ec_inbuf, ec_max_insize);
|
|
|
|
if (!ec_outbuf || !ec_inbuf) {
|
|
fprintf(stderr, "Unable to reallocate buffers\n");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|