| // SPDX-License-Identifier: GPL-2.0+ | |
| /* | |
| * Driver for the OLPC XO-1.75 Embedded Controller. | |
| * | |
| * The EC protocol is documented at: | |
| * http://wiki.laptop.org/go/XO_1.75_HOST_to_EC_Protocol | |
| * | |
| * Copyright (C) 2010 One Laptop per Child Foundation. | |
| * Copyright (C) 2018 Lubomir Rintel <lkundrak@v3.sk> | |
| */ | |
| #include <linux/completion.h> | |
| #include <linux/ctype.h> | |
| #include <linux/delay.h> | |
| #include <linux/gpio/consumer.h> | |
| #include <linux/input.h> | |
| #include <linux/kfifo.h> | |
| #include <linux/module.h> | |
| #include <linux/olpc-ec.h> | |
| #include <linux/platform_device.h> | |
| #include <linux/power_supply.h> | |
| #include <linux/reboot.h> | |
| #include <linux/slab.h> | |
| #include <linux/spinlock.h> | |
| #include <linux/spi/spi.h> | |
| struct ec_cmd_t { | |
| u8 cmd; | |
| u8 bytes_returned; | |
| }; | |
| enum ec_chan_t { | |
| CHAN_NONE = 0, | |
| CHAN_SWITCH, | |
| CHAN_CMD_RESP, | |
| CHAN_KEYBOARD, | |
| CHAN_TOUCHPAD, | |
| CHAN_EVENT, | |
| CHAN_DEBUG, | |
| CHAN_CMD_ERROR, | |
| }; | |
| /* | |
| * EC events | |
| */ | |
| #define EVENT_AC_CHANGE 1 /* AC plugged/unplugged */ | |
| #define EVENT_BATTERY_STATUS 2 /* Battery low/full/error/gone */ | |
| #define EVENT_BATTERY_CRITICAL 3 /* Battery critical voltage */ | |
| #define EVENT_BATTERY_SOC_CHANGE 4 /* 1% SOC Change */ | |
| #define EVENT_BATTERY_ERROR 5 /* Abnormal error, query for cause */ | |
| #define EVENT_POWER_PRESSED 6 /* Power button was pressed */ | |
| #define EVENT_POWER_PRESS_WAKE 7 /* Woken up with a power button */ | |
| #define EVENT_TIMED_HOST_WAKE 8 /* Host wake timer */ | |
| #define EVENT_OLS_HIGH_LIMIT 9 /* OLS crossed dark threshold */ | |
| #define EVENT_OLS_LOW_LIMIT 10 /* OLS crossed light threshold */ | |
| /* | |
| * EC commands | |
| * (from http://dev.laptop.org/git/users/rsmith/ec-1.75/tree/ec_cmd.h) | |
| */ | |
| #define CMD_GET_API_VERSION 0x08 /* out: u8 */ | |
| #define CMD_READ_VOLTAGE 0x10 /* out: u16, *9.76/32, mV */ | |
| #define CMD_READ_CURRENT 0x11 /* out: s16, *15.625/120, mA */ | |
| #define CMD_READ_ACR 0x12 /* out: s16, *6250/15, uAh */ | |
| #define CMD_READ_BATT_TEMPERATURE 0x13 /* out: u16, *100/256, deg C */ | |
| #define CMD_READ_AMBIENT_TEMPERATURE 0x14 /* unimplemented, no hardware */ | |
| #define CMD_READ_BATTERY_STATUS 0x15 /* out: u8, bitmask */ | |
| #define CMD_READ_SOC 0x16 /* out: u8, percentage */ | |
| #define CMD_READ_GAUGE_ID 0x17 /* out: u8 * 8 */ | |
| #define CMD_READ_GAUGE_DATA 0x18 /* in: u8 addr, out: u8 data */ | |
| #define CMD_READ_BOARD_ID 0x19 /* out: u16 (platform id) */ | |
| #define CMD_READ_BATT_ERR_CODE 0x1f /* out: u8, error bitmask */ | |
| #define CMD_SET_DCON_POWER 0x26 /* in: u8 */ | |
| #define CMD_RESET_EC 0x28 /* none */ | |
| #define CMD_READ_BATTERY_TYPE 0x2c /* out: u8 */ | |
| #define CMD_SET_AUTOWAK 0x33 /* out: u8 */ | |
| #define CMD_SET_EC_WAKEUP_TIMER 0x36 /* in: u32, out: ? */ | |
| #define CMD_READ_EXT_SCI_MASK 0x37 /* ? */ | |
| #define CMD_WRITE_EXT_SCI_MASK 0x38 /* ? */ | |
| #define CMD_CLEAR_EC_WAKEUP_TIMER 0x39 /* none */ | |
| #define CMD_ENABLE_RUNIN_DISCHARGE 0x3B /* none */ | |
| #define CMD_DISABLE_RUNIN_DISCHARGE 0x3C /* none */ | |
| #define CMD_READ_MPPT_ACTIVE 0x3d /* out: u8 */ | |
| #define CMD_READ_MPPT_LIMIT 0x3e /* out: u8 */ | |
| #define CMD_SET_MPPT_LIMIT 0x3f /* in: u8 */ | |
| #define CMD_DISABLE_MPPT 0x40 /* none */ | |
| #define CMD_ENABLE_MPPT 0x41 /* none */ | |
| #define CMD_READ_VIN 0x42 /* out: u16 */ | |
| #define CMD_EXT_SCI_QUERY 0x43 /* ? */ | |
| #define RSP_KEYBOARD_DATA 0x48 /* ? */ | |
| #define RSP_TOUCHPAD_DATA 0x49 /* ? */ | |
| #define CMD_GET_FW_VERSION 0x4a /* out: u8 * 16 */ | |
| #define CMD_POWER_CYCLE 0x4b /* none */ | |
| #define CMD_POWER_OFF 0x4c /* none */ | |
| #define CMD_RESET_EC_SOFT 0x4d /* none */ | |
| #define CMD_READ_GAUGE_U16 0x4e /* ? */ | |
| #define CMD_ENABLE_MOUSE 0x4f /* ? */ | |
| #define CMD_ECHO 0x52 /* in: u8 * 5, out: u8 * 5 */ | |
| #define CMD_GET_FW_DATE 0x53 /* out: u8 * 16 */ | |
| #define CMD_GET_FW_USER 0x54 /* out: u8 * 16 */ | |
| #define CMD_TURN_OFF_POWER 0x55 /* none (same as 0x4c) */ | |
| #define CMD_READ_OLS 0x56 /* out: u16 */ | |
| #define CMD_OLS_SMT_LEDON 0x57 /* none */ | |
| #define CMD_OLS_SMT_LEDOFF 0x58 /* none */ | |
| #define CMD_START_OLS_ASSY 0x59 /* none */ | |
| #define CMD_STOP_OLS_ASSY 0x5a /* none */ | |
| #define CMD_OLS_SMTTEST_STOP 0x5b /* none */ | |
| #define CMD_READ_VIN_SCALED 0x5c /* out: u16 */ | |
| #define CMD_READ_BAT_MIN_W 0x5d /* out: u16 */ | |
| #define CMD_READ_BAR_MAX_W 0x5e /* out: u16 */ | |
| #define CMD_RESET_BAT_MINMAX_W 0x5f /* none */ | |
| #define CMD_READ_LOCATION 0x60 /* in: u16 addr, out: u8 data */ | |
| #define CMD_WRITE_LOCATION 0x61 /* in: u16 addr, u8 data */ | |
| #define CMD_KEYBOARD_CMD 0x62 /* in: u8, out: ? */ | |
| #define CMD_TOUCHPAD_CMD 0x63 /* in: u8, out: ? */ | |
| #define CMD_GET_FW_HASH 0x64 /* out: u8 * 16 */ | |
| #define CMD_SUSPEND_HINT 0x65 /* in: u8 */ | |
| #define CMD_ENABLE_WAKE_TIMER 0x66 /* in: u8 */ | |
| #define CMD_SET_WAKE_TIMER 0x67 /* in: 32 */ | |
| #define CMD_ENABLE_WAKE_AUTORESET 0x68 /* in: u8 */ | |
| #define CMD_OLS_SET_LIMITS 0x69 /* in: u16, u16 */ | |
| #define CMD_OLS_GET_LIMITS 0x6a /* out: u16, u16 */ | |
| #define CMD_OLS_SET_CEILING 0x6b /* in: u16 */ | |
| #define CMD_OLS_GET_CEILING 0x6c /* out: u16 */ | |
| /* | |
| * Accepted EC commands, and how many bytes they return. There are plenty | |
| * of EC commands that are no longer implemented, or are implemented only on | |
| * certain older boards. | |
| */ | |
| static const struct ec_cmd_t olpc_xo175_ec_cmds[] = { | |
| { CMD_GET_API_VERSION, 1 }, | |
| { CMD_READ_VOLTAGE, 2 }, | |
| { CMD_READ_CURRENT, 2 }, | |
| { CMD_READ_ACR, 2 }, | |
| { CMD_READ_BATT_TEMPERATURE, 2 }, | |
| { CMD_READ_BATTERY_STATUS, 1 }, | |
| { CMD_READ_SOC, 1 }, | |
| { CMD_READ_GAUGE_ID, 8 }, | |
| { CMD_READ_GAUGE_DATA, 1 }, | |
| { CMD_READ_BOARD_ID, 2 }, | |
| { CMD_READ_BATT_ERR_CODE, 1 }, | |
| { CMD_SET_DCON_POWER, 0 }, | |
| { CMD_RESET_EC, 0 }, | |
| { CMD_READ_BATTERY_TYPE, 1 }, | |
| { CMD_ENABLE_RUNIN_DISCHARGE, 0 }, | |
| { CMD_DISABLE_RUNIN_DISCHARGE, 0 }, | |
| { CMD_READ_MPPT_ACTIVE, 1 }, | |
| { CMD_READ_MPPT_LIMIT, 1 }, | |
| { CMD_SET_MPPT_LIMIT, 0 }, | |
| { CMD_DISABLE_MPPT, 0 }, | |
| { CMD_ENABLE_MPPT, 0 }, | |
| { CMD_READ_VIN, 2 }, | |
| { CMD_GET_FW_VERSION, 16 }, | |
| { CMD_POWER_CYCLE, 0 }, | |
| { CMD_POWER_OFF, 0 }, | |
| { CMD_RESET_EC_SOFT, 0 }, | |
| { CMD_ECHO, 5 }, | |
| { CMD_GET_FW_DATE, 16 }, | |
| { CMD_GET_FW_USER, 16 }, | |
| { CMD_TURN_OFF_POWER, 0 }, | |
| { CMD_READ_OLS, 2 }, | |
| { CMD_OLS_SMT_LEDON, 0 }, | |
| { CMD_OLS_SMT_LEDOFF, 0 }, | |
| { CMD_START_OLS_ASSY, 0 }, | |
| { CMD_STOP_OLS_ASSY, 0 }, | |
| { CMD_OLS_SMTTEST_STOP, 0 }, | |
| { CMD_READ_VIN_SCALED, 2 }, | |
| { CMD_READ_BAT_MIN_W, 2 }, | |
| { CMD_READ_BAR_MAX_W, 2 }, | |
| { CMD_RESET_BAT_MINMAX_W, 0 }, | |
| { CMD_READ_LOCATION, 1 }, | |
| { CMD_WRITE_LOCATION, 0 }, | |
| { CMD_GET_FW_HASH, 16 }, | |
| { CMD_SUSPEND_HINT, 0 }, | |
| { CMD_ENABLE_WAKE_TIMER, 0 }, | |
| { CMD_SET_WAKE_TIMER, 0 }, | |
| { CMD_ENABLE_WAKE_AUTORESET, 0 }, | |
| { CMD_OLS_SET_LIMITS, 0 }, | |
| { CMD_OLS_GET_LIMITS, 4 }, | |
| { CMD_OLS_SET_CEILING, 0 }, | |
| { CMD_OLS_GET_CEILING, 2 }, | |
| { CMD_READ_EXT_SCI_MASK, 2 }, | |
| { CMD_WRITE_EXT_SCI_MASK, 0 }, | |
| { } | |
| }; | |
| #define EC_MAX_CMD_DATA_LEN 5 | |
| #define EC_MAX_RESP_LEN 16 | |
| #define LOG_BUF_SIZE 128 | |
| #define PM_WAKEUP_TIME 1000 | |
| #define EC_ALL_EVENTS GENMASK(15, 0) | |
| enum ec_state_t { | |
| CMD_STATE_IDLE = 0, | |
| CMD_STATE_WAITING_FOR_SWITCH, | |
| CMD_STATE_CMD_IN_TX_FIFO, | |
| CMD_STATE_CMD_SENT, | |
| CMD_STATE_RESP_RECEIVED, | |
| CMD_STATE_ERROR_RECEIVED, | |
| }; | |
| struct olpc_xo175_ec_cmd { | |
| u8 command; | |
| u8 nr_args; | |
| u8 data_len; | |
| u8 args[EC_MAX_CMD_DATA_LEN]; | |
| }; | |
| struct olpc_xo175_ec_resp { | |
| u8 channel; | |
| u8 byte; | |
| }; | |
| struct olpc_xo175_ec { | |
| bool suspended; | |
| /* SPI related stuff. */ | |
| struct spi_device *spi; | |
| struct spi_transfer xfer; | |
| struct spi_message msg; | |
| union { | |
| struct olpc_xo175_ec_cmd cmd; | |
| struct olpc_xo175_ec_resp resp; | |
| } tx_buf, rx_buf; | |
| /* GPIO for the CMD signals. */ | |
| struct gpio_desc *gpio_cmd; | |
| /* Command handling related state. */ | |
| spinlock_t cmd_state_lock; | |
| int cmd_state; | |
| bool cmd_running; | |
| struct completion cmd_done; | |
| struct olpc_xo175_ec_cmd cmd; | |
| u8 resp_data[EC_MAX_RESP_LEN]; | |
| int expected_resp_len; | |
| int resp_len; | |
| /* Power button. */ | |
| struct input_dev *pwrbtn; | |
| /* Debug handling. */ | |
| char logbuf[LOG_BUF_SIZE]; | |
| int logbuf_len; | |
| }; | |
| static struct platform_device *olpc_ec; | |
| static int olpc_xo175_ec_resp_len(u8 cmd) | |
| { | |
| const struct ec_cmd_t *p; | |
| for (p = olpc_xo175_ec_cmds; p->cmd; p++) { | |
| if (p->cmd == cmd) | |
| return p->bytes_returned; | |
| } | |
| return -EINVAL; | |
| } | |
| static void olpc_xo175_ec_flush_logbuf(struct olpc_xo175_ec *priv) | |
| { | |
| dev_dbg(&priv->spi->dev, "got debug string [%*pE]\n", | |
| priv->logbuf_len, priv->logbuf); | |
| priv->logbuf_len = 0; | |
| } | |
| static void olpc_xo175_ec_complete(void *arg); | |
| static void olpc_xo175_ec_send_command(struct olpc_xo175_ec *priv, void *cmd, | |
| size_t cmdlen) | |
| { | |
| int ret; | |
| memcpy(&priv->tx_buf, cmd, cmdlen); | |
| priv->xfer.len = cmdlen; | |
| spi_message_init_with_transfers(&priv->msg, &priv->xfer, 1); | |
| priv->msg.complete = olpc_xo175_ec_complete; | |
| priv->msg.context = priv; | |
| ret = spi_async(priv->spi, &priv->msg); | |
| if (ret) | |
| dev_err(&priv->spi->dev, "spi_async() failed %d\n", ret); | |
| } | |
| static void olpc_xo175_ec_read_packet(struct olpc_xo175_ec *priv) | |
| { | |
| u8 nonce[] = {0xA5, 0x5A}; | |
| olpc_xo175_ec_send_command(priv, nonce, sizeof(nonce)); | |
| } | |
| static void olpc_xo175_ec_complete(void *arg) | |
| { | |
| struct olpc_xo175_ec *priv = arg; | |
| struct device *dev = &priv->spi->dev; | |
| struct power_supply *psy; | |
| unsigned long flags; | |
| u8 channel; | |
| u8 byte; | |
| int ret; | |
| ret = priv->msg.status; | |
| if (ret) { | |
| dev_err(dev, "SPI transfer failed: %d\n", ret); | |
| spin_lock_irqsave(&priv->cmd_state_lock, flags); | |
| if (priv->cmd_running) { | |
| priv->resp_len = 0; | |
| priv->cmd_state = CMD_STATE_ERROR_RECEIVED; | |
| complete(&priv->cmd_done); | |
| } | |
| spin_unlock_irqrestore(&priv->cmd_state_lock, flags); | |
| if (ret != -EINTR) | |
| olpc_xo175_ec_read_packet(priv); | |
| return; | |
| } | |
| channel = priv->rx_buf.resp.channel; | |
| byte = priv->rx_buf.resp.byte; | |
| switch (channel) { | |
| case CHAN_NONE: | |
| spin_lock_irqsave(&priv->cmd_state_lock, flags); | |
| if (!priv->cmd_running) { | |
| /* We can safely ignore these */ | |
| dev_err(dev, "spurious FIFO read packet\n"); | |
| spin_unlock_irqrestore(&priv->cmd_state_lock, flags); | |
| return; | |
| } | |
| priv->cmd_state = CMD_STATE_CMD_SENT; | |
| if (!priv->expected_resp_len) | |
| complete(&priv->cmd_done); | |
| olpc_xo175_ec_read_packet(priv); | |
| spin_unlock_irqrestore(&priv->cmd_state_lock, flags); | |
| return; | |
| case CHAN_SWITCH: | |
| spin_lock_irqsave(&priv->cmd_state_lock, flags); | |
| if (!priv->cmd_running) { | |
| /* Just go with the flow */ | |
| dev_err(dev, "spurious SWITCH packet\n"); | |
| memset(&priv->cmd, 0, sizeof(priv->cmd)); | |
| priv->cmd.command = CMD_ECHO; | |
| } | |
| priv->cmd_state = CMD_STATE_CMD_IN_TX_FIFO; | |
| /* Throw command into TxFIFO */ | |
| gpiod_set_value_cansleep(priv->gpio_cmd, 0); | |
| olpc_xo175_ec_send_command(priv, &priv->cmd, sizeof(priv->cmd)); | |
| spin_unlock_irqrestore(&priv->cmd_state_lock, flags); | |
| return; | |
| case CHAN_CMD_RESP: | |
| spin_lock_irqsave(&priv->cmd_state_lock, flags); | |
| if (!priv->cmd_running) { | |
| dev_err(dev, "spurious response packet\n"); | |
| } else if (priv->resp_len >= priv->expected_resp_len) { | |
| dev_err(dev, "too many response packets\n"); | |
| } else { | |
| priv->resp_data[priv->resp_len++] = byte; | |
| if (priv->resp_len == priv->expected_resp_len) { | |
| priv->cmd_state = CMD_STATE_RESP_RECEIVED; | |
| complete(&priv->cmd_done); | |
| } | |
| } | |
| spin_unlock_irqrestore(&priv->cmd_state_lock, flags); | |
| break; | |
| case CHAN_CMD_ERROR: | |
| spin_lock_irqsave(&priv->cmd_state_lock, flags); | |
| if (!priv->cmd_running) { | |
| dev_err(dev, "spurious cmd error packet\n"); | |
| } else { | |
| priv->resp_data[0] = byte; | |
| priv->resp_len = 1; | |
| priv->cmd_state = CMD_STATE_ERROR_RECEIVED; | |
| complete(&priv->cmd_done); | |
| } | |
| spin_unlock_irqrestore(&priv->cmd_state_lock, flags); | |
| break; | |
| case CHAN_KEYBOARD: | |
| dev_warn(dev, "keyboard is not supported\n"); | |
| break; | |
| case CHAN_TOUCHPAD: | |
| dev_warn(dev, "touchpad is not supported\n"); | |
| break; | |
| case CHAN_EVENT: | |
| dev_dbg(dev, "got event %.2x\n", byte); | |
| switch (byte) { | |
| case EVENT_AC_CHANGE: | |
| psy = power_supply_get_by_name("olpc_ac"); | |
| if (psy) { | |
| power_supply_changed(psy); | |
| power_supply_put(psy); | |
| } | |
| break; | |
| case EVENT_BATTERY_STATUS: | |
| case EVENT_BATTERY_CRITICAL: | |
| case EVENT_BATTERY_SOC_CHANGE: | |
| case EVENT_BATTERY_ERROR: | |
| psy = power_supply_get_by_name("olpc_battery"); | |
| if (psy) { | |
| power_supply_changed(psy); | |
| power_supply_put(psy); | |
| } | |
| break; | |
| case EVENT_POWER_PRESSED: | |
| input_report_key(priv->pwrbtn, KEY_POWER, 1); | |
| input_sync(priv->pwrbtn); | |
| input_report_key(priv->pwrbtn, KEY_POWER, 0); | |
| input_sync(priv->pwrbtn); | |
| fallthrough; | |
| case EVENT_POWER_PRESS_WAKE: | |
| case EVENT_TIMED_HOST_WAKE: | |
| pm_wakeup_event(priv->pwrbtn->dev.parent, | |
| PM_WAKEUP_TIME); | |
| break; | |
| default: | |
| dev_dbg(dev, "ignored unknown event %.2x\n", byte); | |
| break; | |
| } | |
| break; | |
| case CHAN_DEBUG: | |
| if (byte == '\n') { | |
| olpc_xo175_ec_flush_logbuf(priv); | |
| } else if (isprint(byte)) { | |
| priv->logbuf[priv->logbuf_len++] = byte; | |
| if (priv->logbuf_len == LOG_BUF_SIZE) | |
| olpc_xo175_ec_flush_logbuf(priv); | |
| } | |
| break; | |
| default: | |
| dev_warn(dev, "unknown channel: %d, %.2x\n", channel, byte); | |
| break; | |
| } | |
| /* Most non-command packets get the TxFIFO refilled and an ACK. */ | |
| olpc_xo175_ec_read_packet(priv); | |
| } | |
| /* | |
| * This function is protected with a mutex. We can safely assume that | |
| * there will be only one instance of this function running at a time. | |
| * One of the ways in which we enforce this is by waiting until we get | |
| * all response bytes back from the EC, rather than just the number that | |
| * the caller requests (otherwise, we might start a new command while an | |
| * old command's response bytes are still incoming). | |
| */ | |
| static int olpc_xo175_ec_cmd(u8 cmd, u8 *inbuf, size_t inlen, u8 *resp, | |
| size_t resp_len, void *ec_cb_arg) | |
| { | |
| struct olpc_xo175_ec *priv = ec_cb_arg; | |
| struct device *dev = &priv->spi->dev; | |
| unsigned long flags; | |
| size_t nr_bytes; | |
| int ret = 0; | |
| dev_dbg(dev, "CMD %x, %zd bytes expected\n", cmd, resp_len); | |
| if (inlen > 5) { | |
| dev_err(dev, "command len %zd too big!\n", inlen); | |
| return -EOVERFLOW; | |
| } | |
| /* Suspending in the middle of an EC command hoses things badly! */ | |
| if (WARN_ON(priv->suspended)) | |
| return -EBUSY; | |
| /* Ensure a valid command and return bytes */ | |
| ret = olpc_xo175_ec_resp_len(cmd); | |
| if (ret < 0) { | |
| dev_err_ratelimited(dev, "unknown command 0x%x\n", cmd); | |
| /* | |
| * Assume the best in our callers, and allow unknown commands | |
| * through. I'm not the charitable type, but it was beaten | |
| * into me. Just maintain a minimum standard of sanity. | |
| */ | |
| if (resp_len > sizeof(priv->resp_data)) { | |
| dev_err(dev, "response too big: %zd!\n", resp_len); | |
| return -EOVERFLOW; | |
| } | |
| nr_bytes = resp_len; | |
| } else { | |
| nr_bytes = (size_t)ret; | |
| ret = 0; | |
| } | |
| resp_len = min(resp_len, nr_bytes); | |
| spin_lock_irqsave(&priv->cmd_state_lock, flags); | |
| /* Initialize the state machine */ | |
| init_completion(&priv->cmd_done); | |
| priv->cmd_running = true; | |
| priv->cmd_state = CMD_STATE_WAITING_FOR_SWITCH; | |
| memset(&priv->cmd, 0, sizeof(priv->cmd)); | |
| priv->cmd.command = cmd; | |
| priv->cmd.nr_args = inlen; | |
| priv->cmd.data_len = 0; | |
| memcpy(priv->cmd.args, inbuf, inlen); | |
| priv->expected_resp_len = nr_bytes; | |
| priv->resp_len = 0; | |
| /* Tickle the cmd gpio to get things started */ | |
| gpiod_set_value_cansleep(priv->gpio_cmd, 1); | |
| spin_unlock_irqrestore(&priv->cmd_state_lock, flags); | |
| /* The irq handler should do the rest */ | |
| if (!wait_for_completion_timeout(&priv->cmd_done, | |
| msecs_to_jiffies(4000))) { | |
| dev_err(dev, "EC cmd error: timeout in STATE %d\n", | |
| priv->cmd_state); | |
| gpiod_set_value_cansleep(priv->gpio_cmd, 0); | |
| spi_target_abort(priv->spi); | |
| olpc_xo175_ec_read_packet(priv); | |
| return -ETIMEDOUT; | |
| } | |
| spin_lock_irqsave(&priv->cmd_state_lock, flags); | |
| /* Deal with the results. */ | |
| if (priv->cmd_state == CMD_STATE_ERROR_RECEIVED) { | |
| /* EC-provided error is in the single response byte */ | |
| dev_err(dev, "command 0x%x returned error 0x%x\n", | |
| cmd, priv->resp_data[0]); | |
| ret = -EREMOTEIO; | |
| } else if (priv->resp_len != nr_bytes) { | |
| dev_err(dev, "command 0x%x returned %d bytes, expected %zd bytes\n", | |
| cmd, priv->resp_len, nr_bytes); | |
| ret = -EREMOTEIO; | |
| } else { | |
| /* | |
| * We may have 8 bytes in priv->resp, but we only care about | |
| * what we've been asked for. If the caller asked for only 2 | |
| * bytes, give them that. We've guaranteed that | |
| * resp_len <= priv->resp_len and priv->resp_len == nr_bytes. | |
| */ | |
| memcpy(resp, priv->resp_data, resp_len); | |
| } | |
| /* This should already be low, but just in case. */ | |
| gpiod_set_value_cansleep(priv->gpio_cmd, 0); | |
| priv->cmd_running = false; | |
| spin_unlock_irqrestore(&priv->cmd_state_lock, flags); | |
| return ret; | |
| } | |
| static int olpc_xo175_ec_set_event_mask(unsigned int mask) | |
| { | |
| u8 args[2]; | |
| args[0] = mask >> 0; | |
| args[1] = mask >> 8; | |
| return olpc_ec_cmd(CMD_WRITE_EXT_SCI_MASK, args, 2, NULL, 0); | |
| } | |
| static void olpc_xo175_ec_power_off(void) | |
| { | |
| while (1) { | |
| olpc_ec_cmd(CMD_POWER_OFF, NULL, 0, NULL, 0); | |
| mdelay(1000); | |
| } | |
| } | |
| static int __maybe_unused olpc_xo175_ec_suspend(struct device *dev) | |
| { | |
| struct olpc_xo175_ec *priv = dev_get_drvdata(dev); | |
| static struct { | |
| u8 suspend; | |
| u32 suspend_count; | |
| } __packed hintargs; | |
| static unsigned int suspend_count; | |
| /* | |
| * SOC_SLEEP is not wired to the EC on B3 and earlier boards. | |
| * This command lets the EC know instead. The suspend count doesn't seem | |
| * to be used anywhere but in the EC debug output. | |
| */ | |
| hintargs.suspend = 1; | |
| hintargs.suspend_count = suspend_count++; | |
| olpc_ec_cmd(CMD_SUSPEND_HINT, (void *)&hintargs, sizeof(hintargs), | |
| NULL, 0); | |
| /* | |
| * After we've sent the suspend hint, don't allow further EC commands | |
| * to be run until we've resumed. Userspace tasks should be frozen, | |
| * but kernel threads and interrupts could still schedule EC commands. | |
| */ | |
| priv->suspended = true; | |
| return 0; | |
| } | |
| static int __maybe_unused olpc_xo175_ec_resume_noirq(struct device *dev) | |
| { | |
| struct olpc_xo175_ec *priv = dev_get_drvdata(dev); | |
| priv->suspended = false; | |
| return 0; | |
| } | |
| static int __maybe_unused olpc_xo175_ec_resume(struct device *dev) | |
| { | |
| u8 x = 0; | |
| /* | |
| * The resume hint is only needed if no other commands are | |
| * being sent during resume. all it does is tell the EC | |
| * the SoC is definitely awake. | |
| */ | |
| olpc_ec_cmd(CMD_SUSPEND_HINT, &x, 1, NULL, 0); | |
| /* Enable all EC events while we're awake */ | |
| olpc_xo175_ec_set_event_mask(EC_ALL_EVENTS); | |
| return 0; | |
| } | |
| static struct olpc_ec_driver olpc_xo175_ec_driver = { | |
| .ec_cmd = olpc_xo175_ec_cmd, | |
| }; | |
| static void olpc_xo175_ec_remove(struct spi_device *spi) | |
| { | |
| if (pm_power_off == olpc_xo175_ec_power_off) | |
| pm_power_off = NULL; | |
| spi_target_abort(spi); | |
| platform_device_unregister(olpc_ec); | |
| olpc_ec = NULL; | |
| } | |
| static int olpc_xo175_ec_probe(struct spi_device *spi) | |
| { | |
| struct olpc_xo175_ec *priv; | |
| int ret; | |
| if (olpc_ec) { | |
| dev_err(&spi->dev, "OLPC EC already registered.\n"); | |
| return -EBUSY; | |
| } | |
| priv = devm_kzalloc(&spi->dev, sizeof(*priv), GFP_KERNEL); | |
| if (!priv) | |
| return -ENOMEM; | |
| priv->gpio_cmd = devm_gpiod_get(&spi->dev, "cmd", GPIOD_OUT_LOW); | |
| if (IS_ERR(priv->gpio_cmd)) { | |
| dev_err(&spi->dev, "failed to get cmd gpio: %ld\n", | |
| PTR_ERR(priv->gpio_cmd)); | |
| return PTR_ERR(priv->gpio_cmd); | |
| } | |
| priv->spi = spi; | |
| spin_lock_init(&priv->cmd_state_lock); | |
| priv->cmd_state = CMD_STATE_IDLE; | |
| init_completion(&priv->cmd_done); | |
| priv->logbuf_len = 0; | |
| /* Set up power button input device */ | |
| priv->pwrbtn = devm_input_allocate_device(&spi->dev); | |
| if (!priv->pwrbtn) | |
| return -ENOMEM; | |
| priv->pwrbtn->name = "Power Button"; | |
| priv->pwrbtn->dev.parent = &spi->dev; | |
| input_set_capability(priv->pwrbtn, EV_KEY, KEY_POWER); | |
| ret = input_register_device(priv->pwrbtn); | |
| if (ret) { | |
| dev_err(&spi->dev, "error registering input device: %d\n", ret); | |
| return ret; | |
| } | |
| spi_set_drvdata(spi, priv); | |
| priv->xfer.rx_buf = &priv->rx_buf; | |
| priv->xfer.tx_buf = &priv->tx_buf; | |
| olpc_xo175_ec_read_packet(priv); | |
| olpc_ec_driver_register(&olpc_xo175_ec_driver, priv); | |
| olpc_ec = platform_device_register_resndata(&spi->dev, "olpc-ec", -1, | |
| NULL, 0, NULL, 0); | |
| /* Enable all EC events while we're awake */ | |
| olpc_xo175_ec_set_event_mask(EC_ALL_EVENTS); | |
| if (pm_power_off == NULL) | |
| pm_power_off = olpc_xo175_ec_power_off; | |
| dev_info(&spi->dev, "OLPC XO-1.75 Embedded Controller driver\n"); | |
| return 0; | |
| } | |
| static const struct dev_pm_ops olpc_xo175_ec_pm_ops = { | |
| SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(NULL, olpc_xo175_ec_resume_noirq) | |
| SET_RUNTIME_PM_OPS(olpc_xo175_ec_suspend, olpc_xo175_ec_resume, NULL) | |
| }; | |
| static const struct of_device_id olpc_xo175_ec_of_match[] = { | |
| { .compatible = "olpc,xo1.75-ec" }, | |
| { } | |
| }; | |
| MODULE_DEVICE_TABLE(of, olpc_xo175_ec_of_match); | |
| static const struct spi_device_id olpc_xo175_ec_id_table[] = { | |
| { "xo1.75-ec", 0 }, | |
| {} | |
| }; | |
| MODULE_DEVICE_TABLE(spi, olpc_xo175_ec_id_table); | |
| static struct spi_driver olpc_xo175_ec_spi_driver = { | |
| .driver = { | |
| .name = "olpc-xo175-ec", | |
| .of_match_table = olpc_xo175_ec_of_match, | |
| .pm = &olpc_xo175_ec_pm_ops, | |
| }, | |
| .id_table = olpc_xo175_ec_id_table, | |
| .probe = olpc_xo175_ec_probe, | |
| .remove = olpc_xo175_ec_remove, | |
| }; | |
| module_spi_driver(olpc_xo175_ec_spi_driver); | |
| MODULE_DESCRIPTION("OLPC XO-1.75 Embedded Controller driver"); | |
| MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>"); /* Functionality */ | |
| MODULE_AUTHOR("Lubomir Rintel <lkundrak@v3.sk>"); /* Bugs */ | |
| MODULE_LICENSE("GPL"); |