/* 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); }