static void audio_allow_sleep(struct audio *audio) { pm_qos_update_request(&audio->pm_qos_req, PM_QOS_DEFAULT_VALUE); wake_unlock(&audio->wakelock); MM_DBG("\n"); /* Macro prints the file name and function */ }
static void musb_id_pin_work(struct work_struct *data) { //u8 devctl = 0; unsigned long flags; spin_lock_irqsave(&mtk_musb->lock, flags); musb_generic_disable(mtk_musb); spin_unlock_irqrestore(&mtk_musb->lock, flags); down(&mtk_musb->musb_lock); DBG(0, "work start, is_host=%d\n", mtk_musb->is_host); if(mtk_musb->in_ipo_off) { DBG(0, "do nothing due to in_ipo_off\n"); goto out; } mtk_musb ->is_host = musb_is_host(); DBG(0,"musb is as %s\n",mtk_musb->is_host?"host":"device"); switch_set_state((struct switch_dev *)&otg_state, mtk_musb->is_host); if (mtk_musb->is_host) { //setup fifo for host mode ep_config_from_table_for_host(mtk_musb); wake_lock(&mtk_musb->usb_lock); musb_platform_set_vbus(mtk_musb, 1); /* for no VBUS sensing IP*/ #if 0 /* wait VBUS ready */ msleep(100); /* clear session*/ devctl = musb_readb(mtk_musb->mregs,MUSB_DEVCTL); musb_writeb(mtk_musb->mregs, MUSB_DEVCTL, (devctl&(~MUSB_DEVCTL_SESSION))); /* USB MAC OFF*/ /* VBUSVALID=0, AVALID=0, BVALID=0, SESSEND=1, IDDIG=X */ USBPHY_SET8(0x6c, 0x10); USBPHY_CLR8(0x6c, 0x2e); USBPHY_SET8(0x6d, 0x3e); DBG(0,"force PHY to idle, 0x6d=%x, 0x6c=%x\n",USBPHY_READ8(0x6d), USBPHY_READ8(0x6c)); /* wait */ msleep(5); /* restart session */ devctl = musb_readb(mtk_musb->mregs,MUSB_DEVCTL); musb_writeb(mtk_musb->mregs, MUSB_DEVCTL, (devctl| MUSB_DEVCTL_SESSION)); /* USB MAC ONand Host Mode*/ /* VBUSVALID=1, AVALID=1, BVALID=1, SESSEND=0, IDDIG=0 */ USBPHY_CLR8(0x6c, 0x10); USBPHY_SET8(0x6c, 0x2c); USBPHY_SET8(0x6d, 0x3e); DBG(0,"force PHY to host mode, 0x6d=%x, 0x6c=%x\n",USBPHY_READ8(0x6d), USBPHY_READ8(0x6c)); #endif musb_start(mtk_musb); MUSB_HST_MODE(mtk_musb); switch_int_to_device(mtk_musb); } else { DBG(0,"devctl is %x\n",musb_readb(mtk_musb->mregs,MUSB_DEVCTL)); musb_writeb(mtk_musb->mregs,MUSB_DEVCTL,0); if (wake_lock_active(&mtk_musb->usb_lock)) wake_unlock(&mtk_musb->usb_lock); musb_platform_set_vbus(mtk_musb, 0); /* for no VBUS sensing IP */ #if 0 /* USB MAC OFF*/ /* VBUSVALID=0, AVALID=0, BVALID=0, SESSEND=1, IDDIG=X */ USBPHY_SET8(0x6c, 0x10); USBPHY_CLR8(0x6c, 0x2e); USBPHY_SET8(0x6d, 0x3e); DBG(0,"force PHY to idle, 0x6d=%x, 0x6c=%x\n", USBPHY_READ8(0x6d), USBPHY_READ8(0x6c)); #endif musb_stop(mtk_musb); mtk_musb->xceiv->state = OTG_STATE_B_IDLE; MUSB_DEV_MODE(mtk_musb); switch_int_to_host(mtk_musb); } out: DBG(0, "work end, is_host=%d\n", mtk_musb->is_host); up(&mtk_musb->musb_lock); }
static void audio_allow_sleep(struct pcm *audio) { pr_debug("%s:\n", __func__); wake_unlock(&audio->wakelock); }
static inline void allow_suspend(void) { wake_unlock(&adsp_wake_lock); }
static void link_pm_hub_work(struct work_struct *work) { int err; struct link_pm_data *pm_data = container_of(work, struct link_pm_data, link_pm_hub.work); if (pm_data->hub_status == HUB_STATE_ACTIVE) return; if (!pm_data->port_enable) { pr_err("mif: %s: hub power func not assinged\n", __func__); return; } wake_lock(&pm_data->hub_lock); /* If kernel if suspend, wait the ehci resume */ if (pm_data->dpm_suspending) { pr_info("mif: %s: dpm_suspending\n", __func__); schedule_delayed_work(&pm_data->link_pm_hub, msecs_to_jiffies(500)); goto exit; } switch (pm_data->hub_status) { case HUB_STATE_OFF: pm_data->hub_status = HUB_STATE_RESUMMING; pr_info("mif: %s: hub off->on\n", __func__); /* skip 1st time before first probe */ if (pm_data->root_hub) pm_runtime_get_sync(pm_data->root_hub); err = pm_data->port_enable(2, 1); if (err < 0) { pr_err("mif: %s: hub on fail err=%d\n", __func__, err); err = pm_data->port_enable(2, 0); if (err < 0) pr_err("mif: %s: hub off fail err=%d\n", __func__, err); pm_data->hub_status = HUB_STATE_OFF; if (pm_data->root_hub) pm_runtime_put_sync(pm_data->root_hub); goto exit; } /* resume root hub */ schedule_delayed_work(&pm_data->link_pm_hub, msecs_to_jiffies(100)); break; case HUB_STATE_RESUMMING: if (pm_data->hub_on_retry_cnt++ > 50) { pm_data->hub_on_retry_cnt = 0; pm_data->hub_status = HUB_STATE_OFF; if (pm_data->root_hub) pm_runtime_put_sync(pm_data->root_hub); } pr_info("mif: %s: hub resumming\n", __func__); schedule_delayed_work(&pm_data->link_pm_hub, msecs_to_jiffies(200)); break; case HUB_STATE_PREACTIVE: pm_data->hub_status = HUB_STATE_ACTIVE; pr_info("hub active\n"); pm_data->hub_on_retry_cnt = 0; wake_unlock(&pm_data->hub_lock); complete(&pm_data->hub_active); if (pm_data->root_hub) pm_runtime_put_sync(pm_data->root_hub); break; } exit: return; }
static void bq24192_irq_worker(struct work_struct *work) { struct bq24192_chip *chip = container_of(work, struct bq24192_chip, irq_work); union power_supply_propval ret = {0,}; bool ext_pwr; bool wlc_pwr = 0; bool chg_done = false; u8 temp; int rc; unsigned long flags; wake_lock(&chip->irq_wake_lock); msleep(100 * chip->irq_scheduled_time_status); rc = bq24192_read_reg(chip->client, SYSTEM_STATUS_REG, &temp); /* Open up for next possible interrupt handler beyond read reg * asap, lest we miss an interrupt */ spin_lock_irqsave(&chip->irq_work_lock, flags); chip->irq_scheduled_time_status = 0; spin_unlock_irqrestore(&chip->irq_work_lock, flags); if (rc) { pr_err("failed to read SYSTEM_STATUS_REG rc=%d\n", rc); goto irq_worker_exit; } ext_pwr = !!(temp & PG_STAT_MASK); chg_done = (temp & CHARGING_MASK) == 0x30 ? true : false; if (chg_done) { if (chip->batt_health != POWER_SUPPLY_HEALTH_OVERHEAT && bq24192_get_soc_from_batt_psy(chip) < 100) { wake_lock(&chip->extra_chg_lock); bq24192_enable_chg_term(chip, false); bq24192_trigger_recharge(chip); schedule_delayed_work(&chip->extra_chg_work, msecs_to_jiffies(EXTRA_CHG_TIME_MS)); } else { if (chip->batt_health != POWER_SUPPLY_HEALTH_OVERHEAT) bq24192_set_rechg_voltage(chip, VRECHG_300MV); power_supply_changed(&chip->ac_psy); pr_debug("charge done!!\n"); } } if (chip->wlc_psy) { chip->wlc_psy->get_property(chip->wlc_psy, POWER_SUPPLY_PROP_PRESENT, &ret); wlc_pwr = ret.intval; } if ((chip->ext_pwr ^ ext_pwr) || (chip->wlc_pwr ^ wlc_pwr)) { pr_debug("power source changed! ext_pwr = %d wlc_pwr = %d\n", ext_pwr, wlc_pwr); if (wake_lock_active(&chip->icl_wake_lock)) wake_unlock(&chip->icl_wake_lock); if (wake_lock_active(&chip->extra_chg_lock)) wake_unlock(&chip->extra_chg_lock); cancel_delayed_work_sync(&chip->input_limit_work); cancel_delayed_work_sync(&chip->therm_work); cancel_delayed_work_sync(&chip->extra_chg_work); bq24192_enable_chg_term(chip, true); bq24192_step_down_detect_disable(chip); chip->saved_ibat_ma = 0; chip->set_chg_current_ma = chip->chg_current_ma; chip->max_input_i_ma = INPUT_CURRENT_LIMIT_MAX_MA; if (chip->wlc_psy) { if (wlc_pwr && ext_pwr) { chip->wlc_pwr = true; power_supply_set_online(chip->wlc_psy, true); } else if (chip->wlc_pwr && !(ext_pwr && wlc_pwr)) { chip->wlc_pwr = false; power_supply_set_online(chip->wlc_psy, false); } } if (!wlc_pwr) { pr_debug("notify vbus to usb otg ext_pwr = %d\n", ext_pwr); power_supply_set_present(chip->usb_psy, ext_pwr); } chip->ext_pwr = ext_pwr; } irq_worker_exit: wake_lock_timeout(&chip->irq_wake_lock, 2*HZ); }
static inline void allow_suspend(void) { wake_unlock(&mt9t013_wake_lock); }
static int msm_hsic_suspend(struct msm_hsic_hcd *mehci) { struct usb_hcd *hcd = hsic_to_hcd(mehci); int cnt = 0, ret; u32 val; int none_vol, max_vol; if (atomic_read(&mehci->in_lpm)) { dev_dbg(mehci->dev, "%s called in lpm\n", __func__); return 0; } if (!(readl_relaxed(USB_PORTSC) & PORT_PE)) { dev_dbg(mehci->dev, "%s:port is not enabled skip suspend\n", __func__); return -EAGAIN; } disable_irq(hcd->irq); /* make sure we don't race against a remote wakeup */ if (test_bit(HCD_FLAG_WAKEUP_PENDING, &hcd->flags) || readl_relaxed(USB_PORTSC) & PORT_RESUME) { dev_dbg(mehci->dev, "wakeup pending, aborting suspend\n"); enable_irq(hcd->irq); return -EBUSY; } /* * PHY may take some time or even fail to enter into low power * mode (LPM). Hence poll for 500 msec and reset the PHY and link * in failure case. */ val = readl_relaxed(USB_PORTSC); val &= ~PORT_RWC_BITS; val |= PORTSC_PHCD; writel_relaxed(val, USB_PORTSC); while (cnt < PHY_SUSPEND_TIMEOUT_USEC) { if (readl_relaxed(USB_PORTSC) & PORTSC_PHCD) break; udelay(1); cnt++; } if (cnt >= PHY_SUSPEND_TIMEOUT_USEC) { dev_err(mehci->dev, "Unable to suspend PHY\n"); msm_hsic_config_gpios(mehci, 0); msm_hsic_reset(mehci); } /* * PHY has capability to generate interrupt asynchronously in low * power mode (LPM). This interrupt is level triggered. So USB IRQ * line must be disabled till async interrupt enable bit is cleared * in USBCMD register. Assert STP (ULPI interface STOP signal) to * block data communication from PHY. */ writel_relaxed(readl_relaxed(USB_USBCMD) | ASYNC_INTR_CTRL | ULPI_STP_CTRL, USB_USBCMD); /* * Ensure that hardware is put in low power mode before * clocks are turned OFF and VDD is allowed to minimize. */ mb(); clk_disable_unprepare(mehci->core_clk); clk_disable_unprepare(mehci->phy_clk); clk_disable_unprepare(mehci->cal_clk); clk_disable_unprepare(mehci->ahb_clk); none_vol = vdd_val[mehci->vdd_type][VDD_NONE]; max_vol = vdd_val[mehci->vdd_type][VDD_MAX]; ret = regulator_set_voltage(mehci->hsic_vddcx, none_vol, max_vol); if (ret < 0) dev_err(mehci->dev, "unable to set vddcx voltage for VDD MIN\n"); if (mehci->bus_perf_client && debug_bus_voting_enabled) { mehci->bus_vote = false; queue_work(ehci_wq, &mehci->bus_vote_w); } atomic_set(&mehci->in_lpm, 1); enable_irq(hcd->irq); mehci->wakeup_irq_enabled = 1; enable_irq_wake(mehci->wakeup_irq); enable_irq(mehci->wakeup_irq); wake_unlock(&mehci->wlock); dev_dbg(mehci->dev, "HSIC-USB in low power mode\n"); return 0; }
static int plat_kim_chip_asleep(void) { wake_unlock(&st_wk_lock); return 0; }
//extern void mv_usb_connect_change(int status); // khMa static void tsu8111_detect_dev(struct tsu8111_usbsw *usbsw, u8 intr) { u8 val1, val2;// , ctrl,temp; struct fsa880_muic *fsa880_muic = fsa880_muic_ptr; struct tsu8111_platform_data *pdata = usbsw->pdata; struct i2c_client *client = usbsw->client; printk("[TSU8111] tsu8111_detect_dev.........\n"); tsu8111_read_reg(client, TSU8111_REG_DEV_T1, &val1); tsu8111_read_reg(client, TSU8111_REG_DEV_T2, &val2); if((intr==0x01) &&(val1==0x00) && (val2==0x00) && (isProbe == 0)) { printk("[tsu8111] (intr==0x01) &&(val1==0x00) && (val2==0x00) !!!!!\n"); tsu8111_read_adc_value(); return; } /* Attached */ if (intr & (1 << 0)) { if (val1 & TSU8111_DEV_T1_USB_MASK || val2 & TSU8111_DEV_T2_USB_MASK) { printk("[TSU8111] TSU8111_USB ATTACHED*****\n"); fsa880_muic->charger_type = PMU_MUIC_CHGTYP_USB; CALL_EVENT_HANDLER(MAX8986_MUIC_EVENT_CHARGER_TYPE,PMU_MUIC_CHGTYP_USB); } if (val1 & TSU8111_DEV_T1_CHARGER_MASK) { printk("[TSU8111] Charger ATTACHED*****\n"); fsa880_muic->charger_type = PMU_MUIC_CHGTYP_DEDICATED_CHGR; CALL_EVENT_HANDLER(MAX8986_MUIC_EVENT_CHARGER_TYPE,PMU_MUIC_CHGTYP_DEDICATED_CHGR); } if (val2 & TSU8111_DEV_T2_JIG_MASK) { printk("[TSU8111] JIG ATTACHED*****\n"); wake_lock(&JIGConnect_idle_wake); wake_lock(&JIGConnect_suspend_wake); fsa880_muic->charger_type = PMU_MUIC_CHGTYP_NONE; fsa880_muic->jig_status = 1; } } else if (intr & (1 << 1)) { /* DETACH */ fsa880_muic->charger_type = PMU_MUIC_CHGTYP_NONE; if (usbsw->dev1 & TSU8111_DEV_T1_USB_MASK || usbsw->dev2 & TSU8111_DEV_T2_USB_MASK) { printk("[TSU8111] TSU8111_USB Detached*****\n"); CALL_EVENT_HANDLER(MAX8986_MUIC_EVENT_CHARGER_TYPE,PMU_MUIC_CHGTYP_NONE); } if (usbsw->dev1 & TSU8111_DEV_T1_CHARGER_MASK) { printk("[TSU8111] Charger Detached*****\n"); CALL_EVENT_HANDLER(MAX8986_MUIC_EVENT_CHARGER_TYPE,PMU_MUIC_CHGTYP_NONE); } if (usbsw->dev2 & TSU8111_DEV_T2_JIG_MASK) { printk("[TSU8111] JIG Detached*****\n"); wake_unlock(&JIGConnect_idle_wake); wake_unlock(&JIGConnect_suspend_wake); fsa880_muic->jig_status = 0; } } usbsw->dev1 = val1; usbsw->dev2 = val2; chip->dev1 = val1; chip->dev2 = val2; }
int smb345_set_InputCurrentlimit(struct i2c_client *client, u32 current_setting) { int ret = 0, retval; u8 setting = 0; wake_lock(&charger_wakelock); ret = smb345_volatile_writes(client, smb345_ENABLE_WRITE); if (ret < 0) { dev_err(&client->dev, "%s() error in configuring charger..\n", __func__); goto error; } if (charge_en_flag) smb345_pin_control(0); retval = smb345_read(client, smb345_VRS_FUNC); if (retval < 0) { dev_err(&client->dev, "%s(): Failed in reading 0x%02x", __func__, smb345_VRS_FUNC); goto error; } setting = retval & (~(BIT(4))); SMB_NOTICE("Disable AICL, retval=%x setting=%x\n", retval, setting); ret = smb345_write(client, smb345_VRS_FUNC, setting); if (ret < 0) { dev_err(&client->dev, "%s(): Failed in writing 0x%02x to register" "0x%02x\n", __func__, setting, smb345_VRS_FUNC); goto error; } retval = smb345_read(client, smb345_CHRG_CRNTS); if (retval < 0) { dev_err(&client->dev, "%s(): Failed in reading 0x%02x", __func__, smb345_CHRG_CRNTS); goto error; } setting = retval & 0xF0; if(current_setting == 2000) setting |= 0x07; else if(current_setting == 1800) setting |= 0x06; else if (current_setting == 1200) setting |= 0x04; else if(current_setting == 900) setting |= 0x03; else if(current_setting == 500) setting |= 0x01; else setting |= 0x07; SMB_NOTICE("Set ICL=%u retval =%x setting=%x\n", current_setting, retval, setting); ret = smb345_write(client, smb345_CHRG_CRNTS, setting); if (ret < 0) { dev_err(&client->dev, "%s(): Failed in writing 0x%02x to register" "0x%02x\n", __func__, setting, smb345_CHRG_CRNTS); goto error; } if(current_setting == 2000) charger->curr_limit = 2000; else if(current_setting == 1800) charger->curr_limit = 1800; else if (current_setting == 1200) charger->curr_limit = 1200; else if(current_setting == 900) charger->curr_limit = 900; else if(current_setting == 500) charger->curr_limit = 500; else charger->curr_limit = 2000; if (current_setting > 900) { charger->time_of_1800mA_limit = jiffies; } else{ charger->time_of_1800mA_limit = 0; } retval = smb345_read(client, smb345_VRS_FUNC); if (retval < 0) { dev_err(&client->dev, "%s(): Failed in reading 0x%02x", __func__, smb345_VRS_FUNC); goto error; } setting = retval | BIT(4); SMB_NOTICE("Re-enable AICL, setting=%x\n", setting); msleep(20); ret = smb345_write(client, smb345_VRS_FUNC, setting); if (ret < 0) { dev_err(&client->dev, "%s(): Failed in writing 0x%02x to register" "0x%02x\n", __func__, setting, smb345_VRS_FUNC); goto error; } if (charge_en_flag) smb345_pin_control(1); ret = smb345_volatile_writes(client, smb345_DISABLE_WRITE); if (ret < 0) { dev_err(&client->dev, "%s() error in configuring charger..\n", __func__); goto error; } error: wake_unlock(&charger_wakelock); return ret; }
void baseband_xmm_set_power_status(unsigned int status) { struct baseband_power_platform_data *data = xmm_power_drv_data.pdata; int value = 0; unsigned long flags; if (baseband_xmm_powerstate == status) return; pr_debug("%s\n", __func__); switch (status) { case BBXMM_PS_L0: if (modem_sleep_flag) { /* We dont have L3 state now, should be handled from L2 * xmm_power_driver_handle_resume(data); */ } pr_info("L0\n"); baseband_xmm_powerstate = status; if (!wake_lock_active(&wakelock)) wake_lock_timeout(&wakelock, HZ*2); value = gpio_get_value(data->modem.xmm.ipc_hsic_active); pr_debug("before L0 ipc_hsic_active=%d\n", value); if (!value) { pr_debug("L0 gpio set ipc_hsic_active=1 ->\n"); gpio_set_value(data->modem.xmm.ipc_hsic_active, 1); } if (modem_power_on) { modem_power_on = false; baseband_modem_power_on(data); } break; case BBXMM_PS_L2: pr_info("L2\n"); baseband_xmm_powerstate = status; spin_lock_irqsave(&xmm_lock, flags); if (wakeup_pending) { spin_unlock_irqrestore(&xmm_lock, flags); pr_debug("%s: wakeup pending\n", __func__); xmm_power_l2_resume(); } else { spin_unlock_irqrestore(&xmm_lock, flags); if (wake_lock_active(&wakelock)) wake_unlock(&wakelock); modem_sleep_flag = true; } break; case BBXMM_PS_L2TOL0: pr_debug("L2TOL0\n"); spin_lock_irqsave(&xmm_lock, flags); system_suspending = false; wakeup_pending = false; spin_unlock_irqrestore(&xmm_lock, flags); /* do this only from L2 state */ if (baseband_xmm_powerstate == BBXMM_PS_L2) { baseband_xmm_powerstate = status; pr_debug("BB XMM POWER STATE = %d\n", status); xmm_power_l2_resume(); } baseband_xmm_powerstate = status; break; default: baseband_xmm_powerstate = status; break; } pr_debug("BB XMM POWER STATE = %d\n", status); }
static int sec_fg_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { struct sec_fuelgauge_info *fuelgauge = container_of(psy, struct sec_fuelgauge_info, psy_fg); int soc_type = val->intval; switch (psp) { case POWER_SUPPLY_PROP_VOLTAGE_NOW: case POWER_SUPPLY_PROP_VOLTAGE_AVG: case POWER_SUPPLY_PROP_CURRENT_NOW: case POWER_SUPPLY_PROP_CURRENT_AVG: case POWER_SUPPLY_PROP_ENERGY_NOW: case POWER_SUPPLY_PROP_CAPACITY: case POWER_SUPPLY_PROP_TEMP: case POWER_SUPPLY_PROP_TEMP_AMBIENT: if (!sec_hal_fg_get_property(fuelgauge->client, psp, val)) return -EINVAL; if (psp == POWER_SUPPLY_PROP_CAPACITY) { if (soc_type == SEC_FUELGAUGE_CAPACITY_TYPE_RAW) break; if (fuelgauge->pdata->capacity_calculation_type & (SEC_FUELGAUGE_CAPACITY_TYPE_SCALE | SEC_FUELGAUGE_CAPACITY_TYPE_DYNAMIC_SCALE)) sec_fg_get_scaled_capacity(fuelgauge, val); /* capacity should be between 0% and 100% * (0.1% degree) */ if (val->intval > 1000) val->intval = 1000; if (val->intval < 0) val->intval = 0; /* get only integer part */ val->intval /= 10; /* check whether doing the wake_unlock */ if ((val->intval > fuelgauge->pdata->fuel_alert_soc) && fuelgauge->is_fuel_alerted) { wake_unlock(&fuelgauge->fuel_alert_wake_lock); sec_hal_fg_fuelalert_init(fuelgauge->client, fuelgauge->pdata->fuel_alert_soc); } /* (Only for atomic capacity) * In initial time, capacity_old is 0. * and in resume from sleep, * capacity_old is too different from actual soc. * should update capacity_old * by val->intval in booting or resume. */ if (fuelgauge->initial_update_of_soc) { /* updated old capacity */ fuelgauge->capacity_old = val->intval; fuelgauge->initial_update_of_soc = false; break; } if (fuelgauge->pdata->capacity_calculation_type & (SEC_FUELGAUGE_CAPACITY_TYPE_ATOMIC | SEC_FUELGAUGE_CAPACITY_TYPE_SKIP_ABNORMAL)) sec_fg_get_atomic_capacity(fuelgauge, val); } break; case POWER_SUPPLY_PROP_STATUS: case POWER_SUPPLY_PROP_CHARGE_FULL: return -ENODATA; default: return -EINVAL; } return 0; }
static int bluetooth_set_power(void *data, enum rfkill_user_states state) { int ret = 0; int irq; /* BT Host Wake IRQ */ irq = IRQ_BT_HOST_WAKE; switch (state) { case RFKILL_USER_STATE_UNBLOCKED: pr_debug("[BT] Device Powering ON\n"); s3c_setup_uart_cfg_gpio(0); if (gpio_is_valid(GPIO_WLAN_BT_EN)) gpio_direction_output(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH); if (gpio_is_valid(GPIO_BT_nRST)) gpio_direction_output(GPIO_BT_nRST, GPIO_LEVEL_LOW); pr_debug("[BT] GPIO_BT_nRST = %d\n", gpio_get_value(GPIO_BT_nRST)); /* Set GPIO_BT_WLAN_REG_ON high */ s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH); s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT1); s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); pr_debug("[BT] GPIO_WLAN_BT_EN = %d\n", gpio_get_value(GPIO_WLAN_BT_EN)); /* * FIXME sleep should be enabled disabled since the device is * not booting if its enabled */ /* * 100msec, delay between reg_on & rst. * (bcm4329 powerup sequence) */ msleep(100); /* Set GPIO_BT_nRST high */ s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_HIGH); s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_OUT1); s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); pr_debug("[BT] GPIO_BT_nRST = %d\n", gpio_get_value(GPIO_BT_nRST)); /* * 50msec, delay after bt rst * (bcm4329 powerup sequence) */ msleep(50); ret = enable_irq_wake(irq); if (ret < 0) pr_err("[BT] set wakeup src failed\n"); enable_irq(irq); break; case RFKILL_USER_STATE_SOFT_BLOCKED: pr_debug("[BT] Device Powering OFF\n"); #ifdef CONFIG_CPU_DIDLE bt_running = false; #endif ret = disable_irq_wake(irq); if (ret < 0) pr_err("[BT] unset wakeup src failed\n"); disable_irq(irq); wake_unlock(&rfkill_wake_lock); s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_LOW); s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_OUT0); s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); pr_debug("[BT] GPIO_BT_nRST = %d\n", gpio_get_value(GPIO_BT_nRST)); if (gpio_get_value(GPIO_WLAN_nRST) == 0) { s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_LOW); s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT0); s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); pr_debug("[BT] GPIO_WLAN_BT_EN = %d\n", gpio_get_value(GPIO_WLAN_BT_EN)); } break; default: pr_err("[BT] Bad bluetooth rfkill state %d\n", state); } return 0; }
/************************************************* * * Worker thread to dump CP crash log information. * * *****************************************************/ void ProcessCPCrashedDump(struct work_struct *work) { char crashReason[40] = { 0 }; char crashFile[40] = { 0 }; char crashThread[40] = { 0 }; char outString[512] = { 0 }; IPC_U32 *Dump; void __iomem *DumpVAddr; #ifdef CONFIG_FB_BRCM_CP_CRASH_DUMP_IMAGE_SUPPORT rhea_display_crash_image(CP_CRASH_DUMP_START); #endif #ifdef CONFIG_BCM_AP_PANIC_ON_CPCRASH if (BCMLOG_OUTDEV_SDCARD == BCMLOG_GetCpCrashLogDevice() #ifdef CONFIG_CDEBUGGER && ramdump_enable == 1 #endif #ifdef CONFIG_APANIC_ON_MMC && ap_triggered == 0 #endif ) { /* we kill AP when CP crashes */ IPC_DEBUG(DBG_ERROR, "Crashing AP for Ramdump ...\n\n"); #ifdef CONFIG_SEC_DEBUG cp_abort(); #else abort(); #endif /* CONFIG_SEC_DEBUG */ } if ((BCMLOG_OUTDEV_NONE == BCMLOG_GetCpCrashLogDevice() || BCMLOG_OUTDEV_PANIC == BCMLOG_GetCpCrashLogDevice() || BCMLOG_OUTDEV_STM == BCMLOG_GetCpCrashLogDevice() || BCMLOG_OUTDEV_RNDIS == BCMLOG_GetCpCrashLogDevice()) #ifdef CONFIG_APANIC_ON_MMC && ap_triggered == 0 #endif ) { /* we kill AP when CP crashes */ IPC_DEBUG(DBG_ERROR, "Crashing AP now ...\n\n"); #ifdef CONFIG_SEC_DEBUG cp_abort(); #else abort(); #endif /* CONFIG_SEC_DEBUG */ } #endif /* check for CP Reset here? Assuming CP Reset is just signified by a different crash code */ if (SmLocalControl.SmControl->CrashCode == IPC_CP_SILENT_RESET_READY) { HandleCPResetStart(); return; } IPC_Dump(); RpcDbgDumpHistoryLogging(0, 0); #if defined(CONFIG_BRCM_CP_CRASH_DUMP) \ || defined(CONFIG_BRCM_CP_CRASH_DUMP_EMMC) \ || defined(CONFIG_BCM_AP_PANIC_ON_CPCRASH) while (SmLocalControl.SmControl->CrashDump == NULL) ; /* No op */ #endif /* **NOTE** for now, continue doing simple dump out IPC_DEBUG so there * is some indication of CP crash in console * (in case user not running MTT) */ Dump = (void *)SmLocalControl.SmControl->CrashDump; IPC_DEBUG(DBG_ERROR, "ioremap_nocache\n"); DumpVAddr = ioremap_nocache((UInt32) Dump, sizeof(struct T_CRASH_SUMMARY)); if (NULL == DumpVAddr) { IPC_DEBUG(DBG_ERROR, "VirtualAlloc failed\n"); goto cleanUp; } IPC_DEBUG(DBG_ERROR, "Crash Summary Virtual Addr: 0x%08X\n", (unsigned int)DumpVAddr); dumped_crash_summary_ptr = (struct T_CRASH_SUMMARY *)DumpVAddr; IPC_DEBUG(DBG_ERROR, "===== COMMS_PROCESSOR crash summary =====\r\n"); if (dumped_crash_summary_ptr->link_signature) { GetStringFromPA((UInt32) dumped_crash_summary_ptr-> link_signature, outString, 128); IPC_DEBUG(DBG_ERROR, "%s\r\n", outString); } if (dumped_crash_summary_ptr->project_version) { GetStringFromPA((UInt32) dumped_crash_summary_ptr-> project_version, outString, 128); IPC_DEBUG(DBG_ERROR, "%s\r\n", outString); } if (dumped_crash_summary_ptr->DSP_version) { GetStringFromPA((UInt32) dumped_crash_summary_ptr->DSP_version, outString, 128); IPC_DEBUG(DBG_ERROR, "%s\r\n", outString); } if (dumped_crash_summary_ptr->FW_version) { GetStringFromPA((UInt32) dumped_crash_summary_ptr->FW_version, outString, 128); IPC_DEBUG(DBG_ERROR, "%s\r\n", outString); } if (dumped_crash_summary_ptr->decoder_version) { GetStringFromPA((UInt32) dumped_crash_summary_ptr-> decoder_version, outString, 128); IPC_DEBUG(DBG_ERROR, "%s\r\n", outString); } GetStringFromPA((UInt32) dumped_crash_summary_ptr->reason, crashReason, 40); GetStringFromPA((UInt32) dumped_crash_summary_ptr->file, crashFile, 40); GetStringFromPA((UInt32) dumped_crash_summary_ptr->thread, crashThread, 40); IPC_DEBUG(DBG_ERROR, "%s f=%s l=%d v=%d/0x%x t=%s TS=%d\r\n", crashReason, crashFile, dumped_crash_summary_ptr->line, dumped_crash_summary_ptr->value, dumped_crash_summary_ptr->value, crashThread, dumped_crash_summary_ptr->time); #ifndef CONFIG_BCM_AP_PANIC_ON_CPCRASH /* done with "simple" dump, so now pull the full assert * log from CP and dump out to MTT */ DUMP_CP_assert_log(); #endif cleanUp: if (NULL != DumpVAddr) iounmap(DumpVAddr); #ifdef CONFIG_HAS_WAKELOCK wake_unlock(&ipc_wake_lock); #endif #ifdef CONFIG_BCM_AP_PANIC_ON_CPCRASH #ifdef CONFIG_SEC_DEBUG cp_abort(); #endif /* CONFIG_SEC_DEBUG */ #endif /* CONFIG_AP_PANIC_ON_CPCRASH */ }
static long alarm_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { int rv = 0; unsigned long flags; struct timespec new_alarm_time; struct timespec new_rtc_time; struct timespec tmp_time; enum android_alarm_type alarm_type = ANDROID_ALARM_IOCTL_TO_TYPE(cmd); uint32_t alarm_type_mask = 0; if (alarm_type == ANDROID_ALARM_RTC_DEVICEUP) { alarm_type = ANDROID_ALARM_POWEROFF_WAKEUP; //set_alarm_rtc_deviceup_type(1); } //else { //set_alarm_rtc_deviceup_type(0); //} alarm_type_mask = 1U << alarm_type; if (alarm_type >= ANDROID_ALARM_TYPE_COUNT) return -EINVAL; if (ANDROID_ALARM_BASE_CMD(cmd) != ANDROID_ALARM_GET_TIME(0)) { if ((file->f_flags & O_ACCMODE) == O_RDONLY) return -EPERM; if (file->private_data == NULL && cmd != ANDROID_ALARM_SET_RTC) { spin_lock_irqsave(&alarm_slock, flags); if (alarm_opened) { spin_unlock_irqrestore(&alarm_slock, flags); return -EBUSY; } alarm_opened = 1; file->private_data = (void *)1; spin_unlock_irqrestore(&alarm_slock, flags); } } switch (ANDROID_ALARM_BASE_CMD(cmd)) { case ANDROID_ALARM_CLEAR(0): spin_lock_irqsave(&alarm_slock, flags); pr_alarm(IO, "alarm %d clear\n", alarm_type); alarm_try_to_cancel(&alarms[alarm_type]); if (alarm_pending) { alarm_pending &= ~alarm_type_mask; if (!alarm_pending && !wait_pending) wake_unlock(&alarm_wake_lock); } alarm_enabled &= ~alarm_type_mask; spin_unlock_irqrestore(&alarm_slock, flags); break; case ANDROID_ALARM_SET_OLD: case ANDROID_ALARM_SET_AND_WAIT_OLD: if (get_user(new_alarm_time.tv_sec, (int __user *)arg)) { rv = -EFAULT; goto err1; } new_alarm_time.tv_nsec = 0; goto from_old_alarm_set; case ANDROID_ALARM_SET_AND_WAIT(0): case ANDROID_ALARM_SET(0): if (copy_from_user(&new_alarm_time, (void __user *)arg, sizeof(new_alarm_time))) { rv = -EFAULT; goto err1; } from_old_alarm_set: spin_lock_irqsave(&alarm_slock, flags); pr_alarm(IO, "alarm %d set %ld.%09ld\n", alarm_type, new_alarm_time.tv_sec, new_alarm_time.tv_nsec); alarm_enabled |= alarm_type_mask; if (alarm_type == ANDROID_ALARM_POWEROFF_WAKEUP) { spin_unlock_irqrestore(&alarm_slock, flags); alarm_set_real_rtc(alarm_type, new_alarm_time); spin_lock_irqsave(&alarm_slock, flags); } spin_unlock_irqrestore(&alarm_slock, flags); alarm_start_range(&alarms[alarm_type], timespec_to_ktime(new_alarm_time), timespec_to_ktime(new_alarm_time)); if (ANDROID_ALARM_BASE_CMD(cmd) != ANDROID_ALARM_SET_AND_WAIT(0) && cmd != ANDROID_ALARM_SET_AND_WAIT_OLD) break; /* fall though */ case ANDROID_ALARM_WAIT: spin_lock_irqsave(&alarm_slock, flags); pr_alarm(IO, "alarm wait\n"); if (!alarm_pending && wait_pending) { wake_unlock(&alarm_wake_lock); wait_pending = 0; } spin_unlock_irqrestore(&alarm_slock, flags); rv = wait_event_interruptible(alarm_wait_queue, alarm_pending); if (rv) goto err1; //AndyPan add if (alarm_pending & pwoff_mask) { //printk("andy alarm_pending &= ~ pwoff_mask =%d \r\n",alarm_pending); alarm_pending &= ~ pwoff_mask; alarm_pending |= deviceup_mask; //printk("andy alarm_pending |= deviceup_mask =%d \r\n",alarm_pending); } //AndyPan add spin_lock_irqsave(&alarm_slock, flags); rv = alarm_pending; wait_pending = 1; alarm_pending = 0; spin_unlock_irqrestore(&alarm_slock, flags); break; case ANDROID_ALARM_SET_RTC: if (copy_from_user(&new_rtc_time, (void __user *)arg, sizeof(new_rtc_time))) { rv = -EFAULT; goto err1; } rv = alarm_set_rtc(new_rtc_time); spin_lock_irqsave(&alarm_slock, flags); alarm_pending |= ANDROID_ALARM_TIME_CHANGE_MASK; wake_up(&alarm_wait_queue); spin_unlock_irqrestore(&alarm_slock, flags); if (rv < 0) goto err1; break; case ANDROID_ALARM_GET_TIME(0): switch (alarm_type) { case ANDROID_ALARM_RTC_WAKEUP: case ANDROID_ALARM_RTC: getnstimeofday(&tmp_time); break; case ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP: case ANDROID_ALARM_ELAPSED_REALTIME: tmp_time = ktime_to_timespec(alarm_get_elapsed_realtime()); break; case ANDROID_ALARM_POWEROFF_WAKEUP: case ANDROID_ALARM_TYPE_COUNT: case ANDROID_ALARM_SYSTEMTIME: ktime_get_ts(&tmp_time); break; } if (copy_to_user((void __user *)arg, &tmp_time, sizeof(tmp_time))) { rv = -EFAULT; goto err1; } break; default: rv = -EINVAL; goto err1; } err1: return rv; }
static void memdump_wake_lock_stop(void) { wake_unlock(&memdump_wake_lock); wake_lock_destroy(&memdump_wake_lock); }