/* make ec goto idle mode */
static int ec_init_idle_mode(void)
{
int timeout;
unsigned char status = 0;
int ret = 0;
ec_query_seq(CMD_INIT_IDLE_MODE);
/* make the action take active */
timeout = EC_CMD_TIMEOUT;
status = ec_read(REG_POWER_MODE) & FLAG_IDLE_MODE;
while (timeout--) {
if (status) {
udelay(EC_REG_DELAY);
break;
}
status = ec_read(REG_POWER_MODE) & FLAG_IDLE_MODE;
udelay(EC_REG_DELAY);
}
if (timeout <= 0) {
printk(KERN_ERR "ec rom fixup : can't check out the status.\n");
ret = -EINVAL;
} else
printk(KERN_INFO "(%d/%d)0xf710 : 0x%x\n", timeout,
EC_CMD_TIMEOUT - timeout, ec_read(REG_POWER_MODE));
printk(KERN_INFO "entering idle mode ok...................\n");
return ret;
}
static void mainboard_smi_hotkey(u8 hotkey)
{
u8 reg8;
switch (hotkey) {
case 0x3b: break; // Fn+F1
case 0x3c: break; // Fn+F2
case 0x3d: break; // Fn+F3
case 0x3e: break; // Fn+F4
case 0x3f: break; // Fn+F5
case 0x40: // Fn+F6 (Decrease Display Brightness)
reg8 = ec_read(0x17);
reg8 = (reg8 > 8) ? (reg8 - 8) : 0;
ec_write(0x17, reg8);
return;
case 0x41: // Fn+F7 (Increase Display Brightness)
reg8 = ec_read(0x17);
reg8 += 8;
reg8 = (reg8 >= MAX_LCD_BRIGHTNESS) ? MAX_LCD_BRIGHTNESS : reg8;
ec_write(0x17, reg8);
return;
case 0x42: break; // Fn+F8
case 0x43: break; // Fn+F9
case 0x44: break; // Fn+F10
case 0x57: break; // Fn+F11
case 0x58: break; // Fn+F12
}
printk(BIOS_DEBUG, "EC hotkey: %02x\n", hotkey);
}
static int get_battery_temp(void)
{
int value;
value = (ec_read(REG_BAT_TEMPERATURE_HIGH) << 8) |
(ec_read(REG_BAT_TEMPERATURE_LOW));
return value * 1000;
}
static int get_battery_voltage(void)
{
int value;
value = (ec_read(REG_BAT_VOLTAGE_HIGH) << 8) |
(ec_read(REG_BAT_VOLTAGE_LOW));
return value;
}
static int get_fan_rpm(void)
{
int value = 0;
value = FAN_SPEED_DIVIDER /
(((ec_read(REG_FAN_SPEED_HIGH) & 0x0f) << 8) |
ec_read(REG_FAN_SPEED_LOW));
return value;
}
static int get_battery_current(void)
{
int value;
value = (ec_read(REG_BAT_CURRENT_HIGH) << 8) |
(ec_read(REG_BAT_CURRENT_LOW));
if (value & 0x8000)
value = 0xffff - value;
return value;
}
/* enable the chip reset mode */
static int ec_init_reset_mode(void)
{
int timeout;
unsigned char status = 0;
int ret = 0;
/* make chip goto reset mode */
ret = ec_query_seq(CMD_INIT_RESET_MODE);
if (ret < 0) {
printk(KERN_ERR "ec init reset mode failed.\n");
goto out;
}
/* make the action take active */
timeout = EC_CMD_TIMEOUT;
status = ec_read(REG_POWER_MODE) & FLAG_RESET_MODE;
while (timeout--) {
if (status) {
udelay(EC_REG_DELAY);
break;
}
status = ec_read(REG_POWER_MODE) & FLAG_RESET_MODE;
udelay(EC_REG_DELAY);
}
if (timeout <= 0) {
printk(KERN_ERR "ec rom fixup : can't check reset status.\n");
ret = -EINVAL;
} else
printk(KERN_INFO "(%d/%d)reset 0xf710 : 0x%x\n", timeout,
EC_CMD_TIMEOUT - timeout, status);
/* set MCU to reset mode */
udelay(EC_REG_DELAY);
status = ec_read(REG_PXCFG);
status |= (1 << 0);
ec_write(REG_PXCFG, status);
udelay(EC_REG_DELAY);
/* disable FWH/LPC */
udelay(EC_REG_DELAY);
status = ec_read(REG_LPCCFG);
status &= ~(1 << 7);
ec_write(REG_LPCCFG, status);
udelay(EC_REG_DELAY);
printk(KERN_INFO "entering reset mode ok..............\n");
out:
return ret;
}
/* make ec exit from reset mode */
static void ec_exit_reset_mode(void)
{
unsigned char regval;
udelay(EC_REG_DELAY);
regval = ec_read(REG_LPCCFG);
regval |= (1 << 7);
ec_write(REG_LPCCFG, regval);
regval = ec_read(REG_PXCFG);
regval &= ~(1 << 0);
ec_write(REG_PXCFG, regval);
printk(KERN_INFO "exit reset mode ok..................\n");
return;
}
static ssize_t acpi_ec_read_io(struct file *f, char __user *buf,
size_t count, loff_t *off)
{
/* Use this if support reading/writing multiple ECs exists in ec.c:
* struct acpi_ec *ec = ((struct seq_file *)f->private_data)->private;
*/
unsigned int size = EC_SPACE_SIZE;
u8 *data = (u8 *) buf;
loff_t init_off = *off;
int err = 0;
if (*off >= size)
return 0;
if (*off + count >= size) {
size -= *off;
count = size;
} else
size = count;
while (size) {
err = ec_read(*off, &data[*off - init_off]);
if (err)
return err;
*off += 1;
size--;
}
return count;
}
/* backlight */
static int get_backlight_brightness(struct backlight_device *b)
{
u8 value;
ec_read(OT_EC_BL_BRIGHTNESS_ADDRESS, &value);
return value;
}
ssize_t lensl_ec_read_procmem(struct file *file, char __user *buffer,
size_t count, loff_t *offset)
{
int err, len = 0;
u8 i, result;
char ec_buf[EC_MAX * 3 + (EC_MAX / 16 + (EC_MAX % 16 ? 1 : 0)) * 4 + 1];
int off = *offset;
if (off < 0 || off >= sizeof(ec_buf) || count <= 0) {
return 0;
}
if (count > sizeof(ec_buf) || count + off > sizeof(ec_buf)) {
count = sizeof(ec_buf) - off;
}
/* note: ec_read at i = 255 locks up my SL300 hard. -AR */
for (i = 0; i < EC_MAX; i++) {
if (!(i % 16)) {
if (i)
len += sprintf(ec_buf+len, "\n");
len += sprintf(ec_buf+len, "%02X:", i);
}
err = ec_read(i, &result);
if (!err)
len += sprintf(ec_buf+len, " %02X", result);
else
len += sprintf(ec_buf+len, " **");
}
len += sprintf(ec_buf+len, "\n");
copy_to_user(buffer, ec_buf + off, count);
*offset += count;
return count;
}
static int get_fan_pwm_enable(void)
{
int level, mode;
level = ec_read(REG_FAN_SPEED_LEVEL);
mode = ec_read(REG_FAN_AUTO_MAN_SWITCH);
if (level == MAX_FAN_SPEED && mode == BIT_FAN_MANUAL)
mode = 0;
else if (mode == BIT_FAN_MANUAL)
mode = 1;
else
mode = 2;
return mode;
}
/*
* The recovery-switch is virtual on Stout and is handled via the EC.
* Stout recovery mode is only valid if RTC_PWR_STS is set and the EC
* indicated the recovery keys were pressed. We use a global flag for
* rec_mode to be used after RTC_POWER_STS has been cleared. This function
* is complicated by romstage support, which can't use a global variable.
* Note, rec_mode is the only time the EC is in RO mode, otherwise, RW.
*/
int get_recovery_mode_switch(void)
{
#ifdef __PRE_RAM__
device_t dev = PCI_DEV(0, 0x1f, 0);
#else
static int ec_in_rec_mode = 0;
static int ec_rec_flag_good = 0;
device_t dev = dev_find_slot(0, PCI_DEVFN(0x1f,0));
#endif
u8 ec_status = ec_read(EC_STATUS_REG);
u8 reg8 = pci_read_config8(dev, GEN_PMCON_3);
printk(BIOS_SPEW,"%s: EC status:%#x RTC_BAT: %x\n",
__func__, ec_status, reg8 & RTC_BATTERY_DEAD);
#ifdef __PRE_RAM__
return (((reg8 & RTC_BATTERY_DEAD) != 0) &&
((ec_status & 0x3) == EC_IN_RECOVERY_MODE));
#else
if (!ec_rec_flag_good) {
ec_in_rec_mode = (((reg8 & RTC_BATTERY_DEAD) != 0) &&
((ec_status & 0x3) == EC_IN_RECOVERY_MODE));
ec_rec_flag_good = 1;
}
return ec_in_rec_mode;
#endif
}
static ssize_t acpi_ec_read_io(struct file *f, char __user *buf,
size_t count, loff_t *off)
{
/* Use this if support reading/writing multiple ECs exists in ec.c:
* struct acpi_ec *ec = ((struct seq_file *)f->private_data)->private;
*/
unsigned int size = EC_SPACE_SIZE;
loff_t init_off = *off;
int err = 0;
if (*off >= size)
return 0;
if (*off + count >= size) {
size -= *off;
count = size;
} else
size = count;
while (size) {
u8 byte_read;
err = ec_read(*off, &byte_read);
if (err)
return err;
if (put_user(byte_read, buf + *off - init_off)) {
if (*off - init_off)
return *off - init_off; /* partial read */
return -EFAULT;
}
*off += 1;
size--;
}
return count;
}
static ssize_t set_device_state(const char *buf, size_t count, u8 mask)
{
int status;
u8 wdata = 0, rdata;
int result;
if (sscanf(buf, "%i", &status) != 1 || (status < 0 || status > 1))
return -EINVAL;
/* read current device state */
result = ec_read(MSI_STANDARD_EC_COMMAND_ADDRESS, &rdata);
if (result < 0)
return -EINVAL;
if (!!(rdata & mask) != status) {
/* reverse device bit */
if (rdata & mask)
wdata = rdata & ~mask;
else
wdata = rdata | mask;
result = ec_write(MSI_STANDARD_EC_COMMAND_ADDRESS, wdata);
if (result < 0)
return -EINVAL;
}
return count;
}
void acpi_create_gnvs(global_nvs_t *gnvs)
{
gnvs_ = gnvs;
/*
* Disable 3G in suspend by default.
* Provide option to enable for http://crosbug.com/p/7925
*/
gnvs->s33g = 0;
/* Disable USB ports in S3 by default */
gnvs->s3u0 = 0;
gnvs->s3u1 = 0;
/* Disable USB ports in S5 by default */
gnvs->s5u0 = 0;
gnvs->s5u1 = 0;
/* IGD Displays */
gnvs->ndid = 3;
gnvs->did[0] = 0x80000100;
gnvs->did[1] = 0x80000240;
gnvs->did[2] = 0x80000410;
gnvs->did[3] = 0x80000410;
gnvs->did[4] = 0x00000005;
acpi_update_thermal_table(gnvs);
gnvs->chromeos.vbt2 = ec_read(0xcb) ? ACTIVE_ECFW_RW : ACTIVE_ECFW_RO;
}
static int load_scm_model_init(struct platform_device *sdev)
{
u8 data;
int result;
/* allow userland write sysfs file */
dev_attr_bluetooth.store = store_bluetooth;
dev_attr_wlan.store = store_wlan;
dev_attr_threeg.store = store_threeg;
dev_attr_bluetooth.attr.mode |= S_IWUSR;
dev_attr_wlan.attr.mode |= S_IWUSR;
dev_attr_threeg.attr.mode |= S_IWUSR;
/* disable hardware control by fn key */
result = ec_read(MSI_STANDARD_EC_SCM_LOAD_ADDRESS, &data);
if (result < 0)
return result;
result = ec_write(MSI_STANDARD_EC_SCM_LOAD_ADDRESS,
data | MSI_STANDARD_EC_SCM_LOAD_MASK);
if (result < 0)
return result;
/* initial rfkill */
result = rfkill_init(sdev);
if (result < 0)
return result;
return 0;
}
static int omnibook_ec_read(const struct omnibook_operation *io_op, u8 * data)
{
int retval;
#ifdef CONFIG_ACPI_EC
if (likely(!acpi_disabled)) {
retval = ec_read((u8) io_op->read_addr, data);
if (io_op->read_mask)
*data &= io_op->read_mask;
// dprintk("ACPI EC read at %lx success %i.\n", io_op->read_addr, retval);
return retval;
}
#endif
spin_lock_irq(&omnibook_ec_lock);
retval = omnibook_ec_wait(OMNIBOOK_EC_STAT_IBF);
if (retval)
goto end;
outb(OMNIBOOK_EC_CMD_READ, OMNIBOOK_EC_SC);
retval = omnibook_ec_wait(OMNIBOOK_EC_STAT_IBF);
if (retval)
goto end;
outb((u8) io_op->read_addr, OMNIBOOK_EC_DATA);
retval = omnibook_ec_wait(OMNIBOOK_EC_STAT_OBF);
if (retval)
goto end;
*data = inb(OMNIBOOK_EC_DATA);
if (io_op->read_mask)
*data &= io_op->read_mask;
end:
spin_unlock_irq(&omnibook_ec_lock);
// dprintk("Custom EC read at %lx success %i.\n", io_op->read_addr, retval);
return retval;
}
static int crt_video_output_set(struct output_device *od)
{
unsigned long status = od->request_state;
int value;
if (status == BIT_CRT_DETECT_PLUG) {
if (ec_read(REG_CRT_DETECT) == BIT_CRT_DETECT_PLUG) {
/* open CRT */
outb(0x21, 0x3c4);
value = inb(0x3c5);
value &= ~(1 << 7);
outb(0x21, 0x3c4);
outb(value, 0x3c5);
}
} else {
/* close CRT */
outb(0x21, 0x3c4);
value = inb(0x3c5);
value |= (1 << 7);
outb(0x21, 0x3c4);
outb(value, 0x3c5);
}
return 0;
}
static int get_lcd_level(void)
{
u8 result;
ec_read(COMPAL_EC_COMMAND_LCD_LEVEL, &result);
return (int) result;
}
void ec_it8518_enable_wake_events(void)
{
/*
* Set the bit in ECRAM that will enable the Lid switch as a wake source
*/
u8 reg8 = ec_read(EC_WAKE_SRC_ENABLE);
ec_write(EC_WAKE_SRC_ENABLE, reg8 | EC_LID_WAKE_ENABLE);
}
static ssize_t show_raw(struct device *dev,
struct device_attribute *attr, char *buf)
{
u8 result;
ec_read(COMPAL_EC_COMMAND_WIRELESS, &result);
return sprintf(buf, "%i\n", result);
}
/* start the action to spi rom function */
static void ec_start_spi(void)
{
unsigned char val;
delay_spi(SPI_FINISH_WAIT_TIME);
val = ec_read(REG_XBISPICFG) | SPICFG_EN_SPICMD | SPICFG_AUTO_CHECK;
ec_write(REG_XBISPICFG, val);
delay_spi(SPI_FINISH_WAIT_TIME);
}
static void set_fan_pwm(int value)
{
int status, mode;
mode = ec_read(REG_FAN_AUTO_MAN_SWITCH);
if (mode != BIT_FAN_MANUAL)
return;
value = SENSORS_LIMIT(value, MIN_FAN_SPEED, MAX_FAN_SPEED);
/* If value is not ZERO, We should ensure it is on */
if (value != 0) {
status = ec_read(REG_FAN_STATUS);
if (status == 0)
ec_write(REG_FAN_CONTROL, BIT_FAN_CONTROL_ON);
}
ec_write(REG_FAN_SPEED_LEVEL, value);
}
static int __init load_scm_model_init(struct platform_device *sdev)
{
u8 data;
int result;
if (!quirks->ec_read_only) {
/* allow userland write sysfs file */
pax_open_kernel();
*(void **)&dev_attr_bluetooth.store = store_bluetooth;
*(void **)&dev_attr_wlan.store = store_wlan;
*(void **)&dev_attr_threeg.store = store_threeg;
*(umode_t *)&dev_attr_bluetooth.attr.mode |= S_IWUSR;
*(umode_t *)&dev_attr_wlan.attr.mode |= S_IWUSR;
*(umode_t *)&dev_attr_threeg.attr.mode |= S_IWUSR;
pax_close_kernel();
}
/* disable hardware control by fn key */
result = ec_read(MSI_STANDARD_EC_SCM_LOAD_ADDRESS, &data);
if (result < 0)
return result;
result = ec_write(MSI_STANDARD_EC_SCM_LOAD_ADDRESS,
data | MSI_STANDARD_EC_SCM_LOAD_MASK);
if (result < 0)
return result;
/* initial rfkill */
result = rfkill_init(sdev);
if (result < 0)
goto fail_rfkill;
/* setup input device */
result = msi_laptop_input_setup();
if (result)
goto fail_input;
result = i8042_install_filter(msi_laptop_i8042_filter);
if (result) {
pr_err("Unable to install key filter\n");
goto fail_filter;
}
return 0;
fail_filter:
msi_laptop_input_destroy();
fail_input:
rfkill_cleanup();
fail_rfkill:
return result;
}
static void compal_rfkill_poll(struct rfkill *rfkill, void *data)
{
u8 result;
bool hw_blocked;
ec_read(COMPAL_EC_COMMAND_WIRELESS, &result);
hw_blocked = !(result & KILLSWITCH_MASK);
rfkill_set_hw_state(rfkill, hw_blocked);
}
/* To see if the ec is in busy state or not. */
static inline int ec_flash_busy(unsigned long timeout)
{
/* assurance the first command be going to rom */
if (ec_instruction_cycle() < 0)
return EC_STATE_BUSY;
#if 1
timeout = timeout / EC_MAX_DELAY_UNIT;
while (timeout-- > 0) {
/* check the rom's status of busy flag */
ec_write(REG_XBISPICMD, SPICMD_READ_STATUS);
if (ec_instruction_cycle() < 0)
return EC_STATE_BUSY;
if ((ec_read(REG_XBISPIDAT) & 0x01) == 0x00)
return EC_STATE_IDLE;
udelay(EC_MAX_DELAY_UNIT);
}
if (timeout <= 0) {
printk(KERN_ERR
"EC_FLASH_BUSY : timeout for check rom flag.\n");
return EC_STATE_BUSY;
}
#else
/* check the rom's status of busy flag */
ec_write(REG_XBISPICMD, SPICMD_READ_STATUS);
if (ec_instruction_cycle() < 0)
return EC_STATE_BUSY;
timeout = timeout / EC_MAX_DELAY_UNIT;
while (timeout-- > 0) {
if ((ec_read(REG_XBISPIDAT) & 0x01) == 0x00)
return EC_STATE_IDLE;
udelay(EC_MAX_DELAY_UNIT);
}
if (timeout <= 0) {
printk(KERN_ERR
"EC_FLASH_BUSY : timeout for check rom flag.\n");
return EC_STATE_BUSY;
}
#endif
return EC_STATE_IDLE;
}
void mainboard_smi_sleep(u8 slp_typ)
{
if (slp_typ == 3) {
u8 ec_wake = ec_read(0x32);
/* If EC wake events are enabled, enable wake on EC WAKE GPE. */
if (ec_wake & 0x14) {
/* Redirect EC WAKE GPE to SCI. */
gpi_route_interrupt(GPE_EC_WAKE, GPI_IS_SCI);
}
}
}
/* make ec enable WDD */
static void ec_enable_WDD(void)
{
unsigned char status;
udelay(EC_REG_DELAY);
status = ec_read(REG_WDTCFG);
ec_write(REG_WDT, 0x28); /* set WDT 5sec(0x28) */
ec_write(REG_WDTCFG, (status & 0x80) | 0x03);
printk(KERN_INFO "Enable WDD ok..................\n");
return;
}
static int acpi_ec_sbs_read(struct acpi_sbs *sbs, u8 address, u8 * data)
{
u8 val;
int err;
err = ec_read(sbs->base + address, &val);
if (!err) {
*data = val;
}
xmsleep(ACPI_EC_SMB_TRANSACTION_SLEEP);
return (err);
}
