static ssize_t apds990x_store_enable_ps_sensor(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct i2c_client *client = to_i2c_client(dev); struct apds990x_data *data = i2c_get_clientdata(client); unsigned long val = simple_strtoul(buf, NULL, 10); unsigned long flags; printk("%s: enable ps senosr ( %ld)\n", __func__, val); if ((val != 0) && (val != 1)) { printk("%s:store unvalid value=%ld\n", __func__, val); return count; } if(val == 1) { //turn on p sensor if (data->enable_ps_sensor==0) { data->enable_ps_sensor= 1; apds990x_set_enable(client,0); /* Power Off */ apds990x_set_atime(client, 0xf6); /* 27.2ms */ apds990x_set_ptime(client, 0xff); /* 2.72ms */ apds990x_set_ppcount(client, 8); /* 8-pulse */ apds990x_set_control(client, data->control); /* 100mA, IR-diode, 1X PGAIN, 1X AGAIN */ apds990x_set_pilt(client, 0); // init threshold for proximity apds990x_set_piht(client, APDS990x_PS_DETECTION_THRESHOLD); data->ps_threshold = APDS990x_PS_DETECTION_THRESHOLD; data->ps_hysteresis_threshold = APDS990x_PS_HSYTERESIS_THRESHOLD; apds990x_set_ailt( client, 0); apds990x_set_aiht( client, 0xffff); apds990x_set_pers(client, 0x33); /* 3 persistence */ if (data->enable_als_sensor==0) { /* we need this polling timer routine for sunlight canellation */ spin_lock_irqsave(&data->update_lock.wait_lock, flags); /* * If work is already scheduled then subsequent schedules will not * change the scheduled time that's why we have to cancel it first. */ __cancel_delayed_work(&data->als_dwork); schedule_delayed_work(&data->als_dwork, msecs_to_jiffies(data->als_poll_delay)); // 100ms spin_unlock_irqrestore(&data->update_lock.wait_lock, flags); } apds990x_set_enable(client, 0x27); /* only enable PS interrupt */ } } else { //turn off p sensor - kk 25 Apr 2011 we can't turn off the entire sensor, the light sensor may be needed by HAL data->enable_ps_sensor = 0; if (data->enable_als_sensor) { // reconfigute light sensor setting apds990x_set_enable(client,0); /* Power Off */ apds990x_set_atime(client, data->als_atime); /* previous als poll delay */ apds990x_set_ailt( client, 0); apds990x_set_aiht( client, 0xffff); apds990x_set_control(client, data->control); /* 100mA, IR-diode, 1X PGAIN, 1X AGAIN */ apds990x_set_pers(client, 0x33); /* 3 persistence */ apds990x_set_enable(client, 0x3); /* only enable light sensor */ spin_lock_irqsave(&data->update_lock.wait_lock, flags); /* * If work is already scheduled then subsequent schedules will not * change the scheduled time that's why we have to cancel it first. */ __cancel_delayed_work(&data->als_dwork); schedule_delayed_work(&data->als_dwork, msecs_to_jiffies(data->als_poll_delay)); // 100ms spin_unlock_irqrestore(&data->update_lock.wait_lock, flags); } else { apds990x_set_enable(client, 0); spin_lock_irqsave(&data->update_lock.wait_lock, flags); /* * If work is already scheduled then subsequent schedules will not * change the scheduled time that's why we have to cancel it first. */ __cancel_delayed_work(&data->als_dwork); spin_unlock_irqrestore(&data->update_lock.wait_lock, flags); } } return count; }
static int omapbmi_slot_probe(struct platform_device *pdev) { struct bmi_slot *slot; struct resource *irq_pres, *irq_stat; struct omap_bmi_platform_data* slot_pdata; int ret; printk(KERN_INFO "Buglabs 2.0 BUG Slots Driver...\n"); irq_pres = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!irq_pres) { dev_err(&pdev->dev, "No presence irq resource...\n"); return -ENODEV; } irq_stat = platform_get_resource(pdev, IORESOURCE_IRQ, 1); if (!irq_stat) { dev_err(&pdev->dev, "No status irq resource...\n"); return -ENODEV; } slot = kzalloc(sizeof(struct bmi_slot), GFP_KERNEL); if (!slot) { ret = -ENOMEM; goto err_release; } //Request slot enable gpios ret = gpio_request(IOEXP_START + 15, "slot0 buf"); ret = gpio_request(IOEXP_START + 16, "slot0 en"); ret = gpio_request(IOEXP_START + 22, "slot1 buf"); ret = gpio_request(IOEXP_START + 17, "slot1 en"); ret = gpio_request(IOEXP_START + 6, "slot2 buf"); ret = gpio_request(IOEXP_START + 18, "slot2 en"); ret = gpio_request(IOEXP_START + 7, "slot3 buf"); ret = gpio_request(IOEXP_START + 19, "slot3 en"); ret = gpio_request(irq_stat->start, "BMI SINT"); if (ret) { printk(KERN_ERR "slots_bug: GPIO %d request failed...\n",irq_stat->start); goto err_release; } ret = gpio_request(irq_pres->start, "BMI PINT"); if (ret) { gpio_free(irq_stat->start); printk(KERN_ERR "slots_bug: GPIO %d request failed...\n",irq_pres->start); goto err_release; } ret = gpio_direction_input(irq_pres->start); gpio_set_debounce(irq_pres->start, 7936); slot_pdata = pdev->dev.platform_data; omapbmi_slot_gpio_req(slot_pdata->gpios); slot->slot_data = (void*)slot_pdata->gpios; slot->present_irq = gpio_to_irq(irq_pres->start); slot->status_irq = gpio_to_irq(irq_stat->start); slot->owner = THIS_MODULE; slot->name = "omap_bug_slot"; slot->slotdev.parent = &pdev->dev; slot->actions = &bl_actions; slot->spi_bus_num = 1; slot->spi_cs = slot_pdata->spi_cs; slot->adap = i2c_get_adapter(slot_pdata->i2c_bus_no); if (!slot->adap) { printk(KERN_ERR "slots_bug: i2c adapter NULL...\n"); goto gpio_release; } ret = bmi_add_slot(slot); if (ret) { printk(KERN_ERR "slots_bug: Trouble instantiating slot...%d\n", ret); goto gpio_release; } // disable_irq_nosync(slot->present_irq); schedule_delayed_work(&slot->work, msecs_to_jiffies(1000)); return 0; gpio_release: gpio_free(irq_stat->start); gpio_free(irq_pres->start); err_release: kfree(slot->slot_data); kfree(slot); return ret; }
// Pantech Earjack Probe Function static int __devinit pantech_earjack_probe(struct platform_device *pdev) { int rc = 0; int err = 0; struct input_dev *ipdev; dbg_func_in(); irq_state = 0; // Alloc Devices earjack = kzalloc(sizeof(struct pantech_earjack), GFP_KERNEL); if (!earjack) return -ENOMEM; earjack->sdev.name = "h2w"; earjack->sdev.print_name = msm_headset_print_name; rc = switch_dev_register(&earjack->sdev); if (rc) goto err_switch_dev_register; ipdev = input_allocate_device(); if (!ipdev) { rc = -ENOMEM; goto err_alloc_input_dev; } input_set_drvdata(ipdev, earjack); // Init Status Flags earjack->ipdev = ipdev; earjack->car_kit = 0; earjack->type=EARJACK_STATE_OFF; earjack->remotekey_pressed = 0; earjack->remotekey_index = 0; // Initialize Work Queue INIT_DELAYED_WORK(&earjack_work,earjack_detect_func); // INIT WORK INIT_DELAYED_WORK(&remotekey_work,remotekey_detect_func); // Get Power Source #if defined(CONFIG_MIC_BIAS_1_8V) err = 0; #else hs_jack_l8 = regulator_get(NULL, "8058_l8"); regulator_set_voltage(hs_jack_l8,2700000,2700000); dbg("regulator_enable hs_jack_l8 value => %d\n",err); #endif // Initialize Wakelocks wake_lock_init(&earjack_wake_lock, WAKE_LOCK_SUSPEND, "earjack_wake_lock_init"); wake_lock_init(&remotekey_wake_lock, WAKE_LOCK_SUSPEND, "remotekey_wake_lock_init"); // Setup GPIO's gpio_request(EARJACK_DET, "earjack_det"); gpio_request(REMOTEKEY_DET, "remotekey_det"); gpio_tlmm_config(GPIO_CFG(EARJACK_DET, 0, GPIO_CFG_INPUT,GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE); rc = request_irq(gpio_to_irq(EARJACK_DET), Earjack_Det_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "earjack_det-irq", earjack); // Warning: REMOTEKEY_DET using default gpio config. //gpio_tlmm_config(GPIO_CFG(REMOTEKEY_DET, 0, GPIO_CFG_INPUT,GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE); irq_set_irq_wake(gpio_to_irq(EARJACK_DET), 1); irq_set_irq_wake(gpio_to_irq(REMOTEKEY_DET), 1); // Init Input Device //pz1946 merge for wired long key #ifdef CONFIG_MACH_MSM8X60_PRESTO ipdev->name = DRIVER_NAME; ipdev->id.vendor = 0; ipdev->id.product = 0; ipdev->id.version = 0; #else ipdev->id.vendor = 0x0001; ipdev->id.product = 1; ipdev->id.version = 1; #endif input_set_capability(ipdev, EV_KEY, KEY_MEDIA); input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP); input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN); input_set_capability(ipdev, EV_KEY, KEY_POWER); input_set_capability(ipdev, EV_KEY, KEY_END); input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT); input_set_capability(ipdev, EV_SW, SW_MICROPHONE_INSERT); rc = input_register_device(ipdev); if (rc) { dev_err(&ipdev->dev, "hs_probe: input_register_device rc=%d\n", rc); goto err_reg_input_dev; } platform_set_drvdata(pdev, earjack); rc = sysfs_create_group(&pdev->dev.kobj, &dev_attr_grp); if (rc) { dev_err(&ipdev->dev, "hs_probe: sysfs_create_group rc=%d\n", rc); goto err_earjack_init; } // Scehdule earjack_detect_func for initial detect disable_irq_detect(); //disable_irq_nosync(gpio_to_irq(EARJACK_DET)); wake_lock(&earjack_wake_lock); disable_irq_nosync(gpio_to_irq(REMOTEKEY_DET)); schedule_delayed_work(&earjack_work,10); // after 100ms dbg_func_out(); return 0; err_earjack_init: err_reg_input_dev: input_unregister_device(ipdev); ipdev = NULL; err_alloc_input_dev: input_free_device(ipdev); err_switch_dev_register: kfree(earjack); return 0; }
static int my3126_interrupt_enable(struct cphy *cphy) { schedule_delayed_work(&cphy->phy_update, HZ/30); t1_tpi_read(cphy->adapter, A_ELMER0_GPO, &cphy->elmer_gpo); return 0; }
static int fsa9480_codec_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct fsa9480_state *state; struct device *dev = &client->dev; u8 pData; DEBUG_FSA9480("[FSA9480] %s\n", __func__); s3c_gpio_cfgpin(GPIO_USB_SCL_28V, S3C_GPIO_OUTPUT); s3c_gpio_setpull(GPIO_USB_SCL_28V, S3C_GPIO_PULL_NONE); s3c_gpio_cfgpin(GPIO_USB_SDA_28V, S3C_GPIO_OUTPUT); s3c_gpio_setpull(GPIO_USB_SDA_28V, S3C_GPIO_PULL_NONE); s3c_gpio_cfgpin(GPIO_UART_SEL, S3C_GPIO_OUTPUT ); s3c_gpio_setpull(GPIO_UART_SEL, S3C_GPIO_PULL_NONE); if (device_create_file(switch_dev, &dev_attr_uart_sel) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_uart_sel.attr.name); if (device_create_file(switch_dev, &dev_attr_usb_sel) < 0) DEBUG_FSA9480("[FSA9480]Failed to create device file(%s)!\n", dev_attr_usb_sel.attr.name); if (device_create_file(switch_dev, &dev_attr_usb_state) < 0) DEBUG_FSA9480("[FSA9480]Failed to create device file(%s)!\n", dev_attr_usb_state.attr.name); #if 1 if (device_create_file(switch_dev, &dev_attr_DMport) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_DMport.attr.name); if (device_create_file(switch_dev, &dev_attr_DMlog) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_DMlog.attr.name); #endif if (device_create_file(switch_dev, &dev_attr_UsbMenuSel) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_UsbMenuSel.attr.name); if (device_create_file(switch_dev, &dev_attr_AskOnMenuSel) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_AskOnMenuSel.attr.name); if (device_create_file(switch_dev, &dev_attr_Mtp) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_Mtp.attr.name); if (device_create_file(switch_dev, &dev_attr_SwitchingInitValue) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_SwitchingInitValue.attr.name); if (device_create_file(switch_dev, &dev_attr_FactoryResetValue) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_FactoryResetValue.attr.name); if (device_create_file(switch_dev, &dev_attr_AskOnStatus) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_AskOnStatus.attr.name); if (device_create_file(switch_dev, &dev_attr_MtpInitStatusSel) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_MtpInitStatusSel.attr.name); if (device_create_file(switch_dev, &dev_attr_AskInitStatusSel) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_AskInitStatusSel.attr.name); if (device_create_file(switch_dev, &dev_attr_tethering) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_tethering.attr.name); if (device_create_file(switch_dev, &dev_attr_dock) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_dock.attr.name); init_waitqueue_head(&usb_detect_waitq); INIT_WORK(&fsa9480_work, FSA9480_ReadIntRegister); fsa9480_workqueue = create_singlethread_workqueue("fsa9480_workqueue"); state = kzalloc(sizeof(struct fsa9480_state), GFP_KERNEL); if(!state) { dev_err(dev, "%s: failed to create fsa9480_state\n", __func__); return -ENOMEM; } indicator_dev.name = DRIVER_NAME; indicator_dev.print_name = print_switch_name; indicator_dev.print_state = print_switch_state; switch_dev_register(&indicator_dev); state->client = client; fsa9480_i2c_client = client; i2c_set_clientdata(client, state); if(!fsa9480_i2c_client) { dev_err(dev, "%s: failed to create fsa9480_i2c_client\n", __func__); return -ENODEV; } /*clear interrupt mask register*/ fsa9480_read(fsa9480_i2c_client, REGISTER_CONTROL, &pData); fsa9480_write(fsa9480_i2c_client, REGISTER_CONTROL, pData & ~INT_MASK); fsa9480_interrupt_init(); fsa9480_chip_init(); INIT_DELAYED_WORK(&micorusb_init_work, connectivity_switching_init); schedule_delayed_work(&micorusb_init_work, msecs_to_jiffies(200)); return 0; }
DECLARE_DVFS_WORK_FUNC(SET, PEN) { struct input_booster *data = (struct input_booster *)booster_data; struct booster_dvfs *dvfs = data->dvfses[BOOSTER_DEVICE_PEN]; if (!dvfs || !dvfs->initialized) { dev_err(data->dev, "%s: Dvfs is not initialized\n", __func__); return; } mutex_lock(&dvfs->lock); if (!dvfs->level) { dev_err(data->dev, "%s : Skip to set booster due to level 0\n", __func__); goto out; } switch (booster_mode) { case BOOSTER_MODE_ON: cancel_delayed_work(&dvfs->dvfs_off_work); cancel_delayed_work(&dvfs->dvfs_chg_work); switch (dvfs->level) { case BOOSTER_LEVEL1: case BOOSTER_LEVEL2: set_qos(&dvfs->cpu_qos, PM_QOS_CPU_FREQ_MIN, dvfs->freqs[BOOSTER_LEVEL1].cpu_freq); set_qos(&dvfs->mif_qos, PM_QOS_BUS_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL1].mif_freq); set_qos(&dvfs->int_qos, PM_QOS_DEVICE_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL1].int_freq); break; case BOOSTER_LEVEL3: set_qos(&dvfs->cpu_qos, PM_QOS_CPU_FREQ_MIN, dvfs->freqs[BOOSTER_LEVEL3].cpu_freq); set_qos(&dvfs->mif_qos, PM_QOS_BUS_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL3].mif_freq); set_qos(&dvfs->int_qos, PM_QOS_DEVICE_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL3].int_freq); break; case BOOSTER_LEVEL9: set_qos(&dvfs->cpu_qos, PM_QOS_CPU_FREQ_MIN, dvfs->freqs[BOOSTER_LEVEL9].cpu_freq); set_qos(&dvfs->mif_qos, PM_QOS_BUS_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL9].mif_freq); set_qos(&dvfs->int_qos, PM_QOS_DEVICE_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL9].int_freq); break; default: dev_err(data->dev, "%s : Undefined type passed[%d]\n", __func__, dvfs->level); break; } DVFS_DEV_DBG(DBG_DVFS, data->dev, "%s : DVFS ON [level %d]\n", __func__, dvfs->level); if (dvfs->level == BOOSTER_LEVEL9) schedule_delayed_work(&dvfs->dvfs_chg_work, msecs_to_jiffies(BOOSTER_DEBUG_HEAD_TIME)); else schedule_delayed_work(&dvfs->dvfs_chg_work, msecs_to_jiffies(dvfs->times[dvfs->level].head_time)); dvfs->lock_status = true; break; case BOOSTER_MODE_OFF: if (dvfs->lock_status) schedule_delayed_work(&dvfs->dvfs_off_work, msecs_to_jiffies(dvfs->times[dvfs->level].tail_time)); break; case BOOSTER_MODE_FORCE_OFF: if (dvfs->lock_status) { cancel_delayed_work(&dvfs->dvfs_chg_work); cancel_delayed_work(&dvfs->dvfs_off_work); schedule_work(&dvfs->dvfs_off_work.work); } break; default: break; } out: mutex_unlock(&dvfs->lock); return; }
static void micveth_clientpoll(struct work_struct *work) { micveth_info_t *veth_info; uint32_t transRingHi; uint32_t transRingLo; uint32_t scratch14 = 0; uint32_t scratch15 = 0; int bd; static int enter = 0; if (enter == 0) { printk("micveth is polling\n"); enter = 1; } mutex_lock(&micveth.lv_state_mutex); if (micveth.lv_pollstate == CLIENT_POLL_STOPPING) { micveth.lv_pollstate = CLIENT_POLL_STOPPED; mutex_unlock(&micveth.lv_state_mutex); wake_up(&micveth.lv_wq); return; } // Check for state changes for each board in the system for (bd = 0; bd < micveth.lv_num_clients; bd++) { veth_info = &micveth.lv_info[bd]; // Do not poll boards that have not had the interface started. if (veth_info->vi_state == VETH_STATE_INITIALIZED) { break; } #ifdef NO_SRATCHREGREAD_AFTER_CONNECT if(veth_info->vi_state != VETH_STATE_LINKUP) { #endif scratch14 = readl(veth_info->vi_scratch14); scratch15 = readl(veth_info->vi_scratch15); #ifdef NO_SRATCHREGREAD_AFTER_CONNECT } #endif if (veth_info->vi_state == VETH_STATE_LINKUP) { if (scratch14 == MICVETH_LINK_DOWN_MAGIC) { veth_info->vi_state = VETH_STATE_LINKDOWN; } } else if (veth_info->vi_state == VETH_STATE_LINKDOWN) { if (scratch14 == MICVETH_LINK_UP_MAGIC) { // Write the transfer ring address. transRingHi = (uint32_t)(veth_info->vi_ring.phys >> 32); transRingLo = (uint32_t)(veth_info->vi_ring.phys & 0xffffffff); writel(transRingLo, veth_info->vi_scratch14); writel(transRingHi, veth_info->vi_scratch15); veth_info->vi_state = VETH_STATE_LINKUP; printk("MIC virtual ethernet up for board %d\n", bd); #ifdef MIC_IS_EMULATION printk("Card wrote Magic: It must be UP!\n"); #endif if (mic_vnet_mode == VNET_MODE_POLL) { schedule_delayed_work(&veth_info->vi_poll, msecs_to_jiffies(MICVETH_POLL_TIMER_DELAY)); } micveth.lv_num_links_remaining--; } #ifdef MIC_IS_EMULATION else if (scratch14) { printk("---> 0x%x \n", scratch14); writel(0x0, veth_info->vi_scratch14); } #endif }
long mdm_modem_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { int status, ret = 0; if (_IOC_TYPE(cmd) != CHARM_CODE) { pr_err("%s: invalid ioctl code\n", __func__); return -EINVAL; } pr_debug("%s: Entering ioctl cmd = %d\n", __func__, _IOC_NR(cmd)); switch (cmd) { case WAKE_CHARM: pr_info("%s: Powering on mdm\n", __func__); mdm_drv->ops->power_on_mdm_cb(mdm_drv); break; case CHECK_FOR_BOOT: if (gpio_get_value(mdm_drv->mdm2ap_status_gpio) == 0) put_user(1, (unsigned long __user *) arg); else put_user(0, (unsigned long __user *) arg); break; case NORMAL_BOOT_DONE: pr_debug("%s: check if mdm is booted up\n", __func__); get_user(status, (unsigned long __user *) arg); if (status) { pr_debug("%s: normal boot failed\n", __func__); mdm_drv->mdm_boot_status = -EIO; } else { pr_info("%s: normal boot done\n", __func__); mdm_drv->mdm_boot_status = 0; } mdm_drv->mdm_ready = 1; if (mdm_drv->ops->normal_boot_done_cb != NULL) mdm_drv->ops->normal_boot_done_cb(mdm_drv); if (!first_boot) complete(&mdm_boot); else first_boot = 0; /* If successful, start a timer to check that the mdm2ap_status * gpio goes high. */ if (!status && gpio_get_value(mdm_drv->mdm2ap_status_gpio) == 0) schedule_delayed_work(&mdm2ap_status_check_work, msecs_to_jiffies(MDM2AP_STATUS_TIMEOUT_MS)); break; case RAM_DUMP_DONE: pr_debug("%s: mdm done collecting RAM dumps\n", __func__); get_user(status, (unsigned long __user *) arg); if (status) mdm_drv->mdm_ram_dump_status = -EIO; else { pr_info("%s: ramdump collection completed\n", __func__); mdm_drv->mdm_ram_dump_status = 0; } complete(&mdm_ram_dumps); break; case WAIT_FOR_RESTART: pr_debug("%s: wait for mdm to need images reloaded\n", __func__); ret = wait_for_completion_interruptible(&mdm_needs_reload); if (!ret) put_user(mdm_drv->boot_type, (unsigned long __user *) arg); INIT_COMPLETION(mdm_needs_reload); break; case GET_DLOAD_STATUS: pr_debug("getting status of mdm2ap_errfatal_gpio\n"); if (gpio_get_value(mdm_drv->mdm2ap_errfatal_gpio) == 1 && !mdm_drv->mdm_ready) put_user(1, (unsigned long __user *) arg); else put_user(0, (unsigned long __user *) arg); break; case IMAGE_UPGRADE: pr_debug("%s Image upgrade ioctl recieved\n", __func__); if (mdm_drv->pdata->image_upgrade_supported && mdm_drv->ops->image_upgrade_cb) { get_user(status, (unsigned long __user *) arg); mdm_drv->ops->image_upgrade_cb(mdm_drv, status); } else pr_debug("%s Image upgrade not supported\n", __func__); break; case SHUTDOWN_CHARM: if (!mdm_drv->pdata->send_shdn) break; mdm_drv->mdm_ready = 0; if (mdm_debug_mask & MDM_DEBUG_MASK_SHDN_LOG) pr_info("Sending shutdown request to mdm\n"); ret = sysmon_send_shutdown(SYSMON_SS_EXT_MODEM); if (ret) pr_err("%s: Graceful shutdown of the external modem failed, ret = %d\n", __func__, ret); break; default: pr_err("%s: invalid ioctl cmd = %d\n", __func__, _IOC_NR(cmd)); ret = -EINVAL; break; } return ret; }
void musb_port_reset(struct musb *musb, bool do_reset) { u8 power; void __iomem *mbase = musb->mregs; if (musb->xceiv->otg->state == OTG_STATE_B_IDLE) { musb_dbg(musb, "HNP: Returning from HNP; no hub reset from b_idle"); musb->port1_status &= ~USB_PORT_STAT_RESET; return; } if (!is_host_active(musb)) return; /* NOTE: caller guarantees it will turn off the reset when * the appropriate amount of time has passed */ power = musb_readb(mbase, MUSB_POWER); if (do_reset) { /* * If RESUME is set, we must make sure it stays minimum 20 ms. * Then we must clear RESUME and wait a bit to let musb start * generating SOFs. If we don't do this, OPT HS A 6.8 tests * fail with "Error! Did not receive an SOF before suspend * detected". */ if (power & MUSB_POWER_RESUME) { long remain = (unsigned long) musb->rh_timer - jiffies; if (musb->rh_timer > 0 && remain > 0) { /* take into account the minimum delay after resume */ schedule_delayed_work( &musb->deassert_reset_work, remain); return; } musb_writeb(mbase, MUSB_POWER, power & ~MUSB_POWER_RESUME); /* Give the core 1 ms to clear MUSB_POWER_RESUME */ schedule_delayed_work(&musb->deassert_reset_work, msecs_to_jiffies(1)); return; } power &= 0xf0; musb_writeb(mbase, MUSB_POWER, power | MUSB_POWER_RESET); musb->port1_status |= USB_PORT_STAT_RESET; musb->port1_status &= ~USB_PORT_STAT_ENABLE; schedule_delayed_work(&musb->deassert_reset_work, msecs_to_jiffies(50)); } else { musb_dbg(musb, "root port reset stopped"); musb_platform_pre_root_reset_end(musb); musb_writeb(mbase, MUSB_POWER, power & ~MUSB_POWER_RESET); musb_platform_post_root_reset_end(musb); power = musb_readb(mbase, MUSB_POWER); if (power & MUSB_POWER_HSMODE) { musb_dbg(musb, "high-speed device connected"); musb->port1_status |= USB_PORT_STAT_HIGH_SPEED; } musb->port1_status &= ~USB_PORT_STAT_RESET; musb->port1_status |= USB_PORT_STAT_ENABLE | (USB_PORT_STAT_C_RESET << 16) | (USB_PORT_STAT_C_ENABLE << 16); usb_hcd_poll_rh_status(musb->hcd); musb->vbuserr_retry = VBUSERR_RETRY_COUNT; } }
void tsensor_late_init(void) { int i = 0,ret=0; efuse_trim_init(); for(i=0; i<gstTempPrtInfo.num; i++) { printk(KERN_INFO "sensor%d type : %d.\n",i,gstTempPrtInfo.sensor_config[i].sensor_type); printk(KERN_INFO "sensor%d sel : %d.\n",i,gstTempPrtInfo.sensor_config[i].sel); printk(KERN_INFO "sensor%d lag_value : %d.\n",i,gstTempPrtInfo.sensor_config[i].lag_value); gstTempPrtInfo.sensor_config[i].lag_cfg_value= (gstTempPrtInfo.sensor_config[i].lag_value*255/200); printk(KERN_INFO "sensor%d thres_value : %d.\n",i,gstTempPrtInfo.sensor_config[i].thres_value); printk(KERN_INFO "sensor%d reset_value : %d.\n",i,gstTempPrtInfo.sensor_config[i].reset_value); printk(KERN_INFO "sensor%d alarm_cnt : %d.\n",i,gstTempPrtInfo.sensor_config[i].alarm_cnt); printk(KERN_INFO "sensor%d recover_cnt : %d.\n",i,gstTempPrtInfo.sensor_config[i].recover_cnt); switch(gstTempPrtInfo.sensor_config[i].sensor_type) { case TSENSOR_TYPE_ACPU_CLUSTER0: gstTempPrtInfo.sensor_config[i].thres_cfg_value = \ ((gstTempPrtInfo.sensor_config[i].thres_value + 60 + efuse_trim_data.remote_acpu_c0)*255/200); gstTempPrtInfo.sensor_config[i].thres_cfg_value = \ (gstTempPrtInfo.sensor_config[i].thres_cfg_value>254)?254:gstTempPrtInfo.sensor_config[i].thres_cfg_value; gstTempPrtInfo.sensor_config[i].reset_cfg_value = \ ((gstTempPrtInfo.sensor_config[i].reset_value + 60 + efuse_trim_data.remote_acpu_c0)*255/200); gstTempPrtInfo.sensor_config[i].reset_cfg_value = \ (gstTempPrtInfo.sensor_config[i].reset_cfg_value>254)?254:gstTempPrtInfo.sensor_config[i].reset_cfg_value; break; case TSENSOR_TYPE_ACPU_CLUSTER1: gstTempPrtInfo.sensor_config[i].thres_cfg_value = \ ((gstTempPrtInfo.sensor_config[i].thres_value + 60 + efuse_trim_data.remote_acpu_c1)*255/200); gstTempPrtInfo.sensor_config[i].thres_cfg_value = \ (gstTempPrtInfo.sensor_config[i].thres_cfg_value>254)?254:gstTempPrtInfo.sensor_config[i].thres_cfg_value; gstTempPrtInfo.sensor_config[i].reset_cfg_value = \ ((gstTempPrtInfo.sensor_config[i].reset_value + 60 + efuse_trim_data.remote_acpu_c1)*255/200); gstTempPrtInfo.sensor_config[i].reset_cfg_value = \ (gstTempPrtInfo.sensor_config[i].reset_cfg_value>254)?254:gstTempPrtInfo.sensor_config[i].reset_cfg_value; break; case TSENSOR_TYPE_GPU: gstTempPrtInfo.sensor_config[i].thres_cfg_value = \ ((gstTempPrtInfo.sensor_config[i].thres_value + 60 + efuse_trim_data.remote_gpu)*255/200); gstTempPrtInfo.sensor_config[i].thres_cfg_value = \ (gstTempPrtInfo.sensor_config[i].thres_cfg_value>254)?254:gstTempPrtInfo.sensor_config[i].thres_cfg_value; gstTempPrtInfo.sensor_config[i].reset_cfg_value = \ ((gstTempPrtInfo.sensor_config[i].reset_value + 60 + efuse_trim_data.remote_gpu)*255/200); gstTempPrtInfo.sensor_config[i].reset_cfg_value = \ (gstTempPrtInfo.sensor_config[i].reset_cfg_value>254)?254:gstTempPrtInfo.sensor_config[i].reset_cfg_value; break; case TSENSOR_TYPE_LOCAL: gstTempPrtInfo.sensor_config[i].thres_cfg_value = \ ((gstTempPrtInfo.sensor_config[i].thres_value + 60 + efuse_trim_data.local)*255/200); gstTempPrtInfo.sensor_config[i].thres_cfg_value = \ (gstTempPrtInfo.sensor_config[i].thres_cfg_value>254)?254:gstTempPrtInfo.sensor_config[i].thres_cfg_value; gstTempPrtInfo.sensor_config[i].reset_cfg_value = \ ((gstTempPrtInfo.sensor_config[i].reset_value + 60 + efuse_trim_data.local)*255/200); gstTempPrtInfo.sensor_config[i].reset_cfg_value = \ (gstTempPrtInfo.sensor_config[i].reset_cfg_value>254)?254:gstTempPrtInfo.sensor_config[i].reset_cfg_value; break; default: break; } gstTempPrtInfo.sensor_config[i].thres_cfg_value |= 0x0FFFFFF00; gstTempPrtInfo.sensor_config[i].temp_t0 = gstTempPrtInfo.sensor_config[i].thres_value; } ret = request_irq(IRQ_TSENSOR0,tsensor_irq, IRQF_DISABLED,"Tsensor-irq",(void*)&gstTempPrtInfo); if (ret) { pr_err("%s,%d request_irq failed!\n", __func__, __LINE__); return; } /*hw init*/ tsensor_config_set(tsensor_get_index_by_type(TSENSOR_TYPE_LOCAL)); /*Tsensor0温度检测中断清除寄存器。clr irq*/ TSENSOR_REG_WRITE(SOC_PERI_SCTRL_SC_TEMP0_INT_CLR_ADDR(0), SOC_PERI_SCTRL_SC_TEMP0_INT_CLR_temp0_int_clr_START, SOC_PERI_SCTRL_SC_TEMP0_INT_CLR_temp0_int_clr_END, 0x01); /*Tsensor0温度检测中断屏蔽寄存器。enable irq*/ TSENSOR_REG_WRITE(SOC_PERI_SCTRL_SC_TEMP0_INT_EN_ADDR(0), SOC_PERI_SCTRL_SC_TEMP0_INT_EN_temp0_int_en_START, SOC_PERI_SCTRL_SC_TEMP0_INT_EN_temp0_int_en_END, 0x01); gstTempPrtInfo.init_flag = TSENSOR_INIT_OK; pr_info("Tsensor late init ok.\n"); /* HKADC BUSINESS -s */ INIT_DELAYED_WORK(&tsensor_debug_work, hw_tsensor_debug_work); schedule_delayed_work(&tsensor_debug_work, msecs_to_jiffies(60*1000));// 60s /* HKADC BUSINESS -e */ return; }
static int lge_hsd_probe(struct platform_device *pdev) { int ret = 0; struct fsa8008_platform_data *pdata = pdev->dev.platform_data; struct hsd_info *hi; HSD_DBG("lge_hsd_probe"); hi = kzalloc(sizeof(struct hsd_info), GFP_KERNEL); if (NULL == hi) { HSD_ERR("Failed to allloate headset per device info\n"); return -ENOMEM; } hi->key_code = pdata->key_code; platform_set_drvdata(pdev, hi); atomic_set(&hi->btn_state, 0); atomic_set(&hi->is_3_pole_or_not, 1); hi->gpio_detect = pdata->gpio_detect; hi->gpio_mic_en = pdata->gpio_mic_en; hi->gpio_jpole = pdata->gpio_jpole; hi->gpio_key = pdata->gpio_key; hi->set_headset_mic_bias = pdata->set_headset_mic_bias; hi->latency_for_detection = pdata->latency_for_detection; #ifdef CONFIG_LGE_AUDIO_FSA8008_MODIFY hi->latency_for_key = FSA8008_KEY_PRESS_DLY_MS; hi->gpio_key_cnt = 0; INIT_DELAYED_WORK(&hi->work_for_insert, insert_headset); INIT_DELAYED_WORK(&hi->work_for_remove, remove_headset); INIT_DELAYED_WORK(&hi->work_for_key_det_enable, button_enable); #else hi->latency_for_key = 200 /* milli */ * HZ / 1000; /* convert milli to jiffies */ INIT_DELAYED_WORK(&hi->work, detect_work); #endif mutex_init(&hi->mutex_lock); INIT_DELAYED_WORK(&hi->work_for_key_pressed, button_pressed); INIT_DELAYED_WORK(&hi->work_for_key_released, button_released); /* initialize gpio_detect */ ret = gpio_request(hi->gpio_detect, "gpio_detect"); if (ret < 0) { HSD_ERR("Failed to configure gpio%d (gpio_detect) gpio_request\n", hi->gpio_detect); goto error_01; } ret = gpio_direction_input(hi->gpio_detect); if (ret < 0) { HSD_ERR("Failed to configure gpio%d (gpio_detect) gpio_direction_input\n", hi->gpio_detect); goto error_02; } /* initialize gpio_jpole */ ret = gpio_request(hi->gpio_jpole, "gpio_jpole"); if (ret < 0) { HSD_ERR("Failed to configure gpio%d (gpio_jpole) gpio_request\n", hi->gpio_jpole); goto error_02; } ret = gpio_direction_input(hi->gpio_jpole); if (ret < 0) { HSD_ERR("Failed to configure gpio%d (gpio_jpole) gpio_direction_input\n", hi->gpio_jpole); goto error_03; } /* initialize gpio_key */ ret = gpio_request(hi->gpio_key, "gpio_key"); if (ret < 0) { HSD_ERR("Failed to configure gpio%d (gpio_key) gpio_request\n", hi->gpio_key); goto error_03; } ret = gpio_direction_input(hi->gpio_key); if (ret < 0) { HSD_ERR("Failed to configure gpio%d (gpio_key) gpio_direction_input\n", hi->gpio_key); goto error_04; } /* initialize gpio_mic_en */ ret = gpio_request(hi->gpio_mic_en, "gpio_mic_en"); if (ret < 0) { HSD_ERR("Failed to configure gpio%d (gpio_mic_en) gpio_request\n", hi->gpio_mic_en); goto error_04; } ret = gpio_direction_output(hi->gpio_mic_en, 0); if (ret < 0) { HSD_ERR("Failed to configure gpio%d (gpio_mic_en) gpio_direction_output\n", hi->gpio_mic_en); goto error_05; } /* initialize irq of gpio_jpole */ hi->irq_detect = gpio_to_irq(hi->gpio_detect); HSD_DBG("hi->irq_detect = %d\n", hi->irq_detect); if (hi->irq_detect < 0) { HSD_ERR("Failed to get interrupt number\n"); ret = hi->irq_detect; goto error_05; } //LGE_START, MYUNGWON.KIM, When Sleep IRQ Doesn't work ret = request_threaded_irq(hi->irq_detect, NULL, gpio_irq_handler, IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING|IRQF_NO_SUSPEND, pdev->name, hi); //LGE_END, MYUNGWON.KIM if (ret) { HSD_ERR("failed to request button irq"); goto error_05; } ret = irq_set_irq_wake(hi->irq_detect, 1); if (ret < 0) { HSD_ERR("Failed to set irq_detect interrupt wake\n"); goto error_06; } /* initialize irq of gpio_key */ hi->irq_key = gpio_to_irq(hi->gpio_key); HSD_DBG("hi->irq_key = %d\n", hi->irq_key); if (hi->irq_key < 0) { HSD_ERR("Failed to get interrupt number\n"); ret = hi->irq_key; goto error_06; } //LGE_START, MYUNGWON.KIM, When Sleep IRQ Doesn't work ret = request_threaded_irq(hi->irq_key, NULL, button_irq_handler, IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING|IRQF_NO_SUSPEND, pdev->name, hi); //LGE_END, MYUNGWON.KIM if (ret) { HSD_ERR("failed to request button irq"); goto error_06; } disable_irq(hi->irq_key); ret = irq_set_irq_wake(hi->irq_key, 1); if (ret < 0) { HSD_ERR("Failed to set irq_key interrupt wake\n"); goto error_07; } /* initialize switch device */ hi->sdev.name = pdata->switch_name; hi->sdev.print_state = lge_hsd_print_state; hi->sdev.print_name = lge_hsd_print_name; ret = switch_dev_register(&hi->sdev); if (ret < 0) { HSD_ERR("Failed to register switch device\n"); goto error_07; } /* initialize input device */ hi->input = input_allocate_device(); if (!hi->input) { HSD_ERR("Failed to allocate input device\n"); ret = -ENOMEM; goto error_08; } hi->input->name = pdata->keypad_name; hi->input->id.vendor = 0x0001; hi->input->id.product = 1; hi->input->id.version = 1; /*input_set_capability(hi->input, EV_SW, SW_HEADPHONE_INSERT);*/ set_bit(EV_SYN, hi->input->evbit); set_bit(EV_KEY, hi->input->evbit); set_bit(EV_SW, hi->input->evbit); set_bit(hi->key_code, hi->input->keybit); set_bit(SW_HEADPHONE_INSERT, hi->input->swbit); set_bit(SW_MICROPHONE_INSERT, hi->input->swbit); ret = input_register_device(hi->input); if (ret) { HSD_ERR("Failed to register input device\n"); goto error_09; } #ifdef CONFIG_LGE_AUDIO_FSA8008_MODIFY if (gpio_get_value_cansleep(hi->gpio_detect) == EARJACK_INSERTED) { queue_delayed_work(local_fsa8008_workqueue, &(hi->work_for_insert), 0); /* to detect in initialization with eacjack insertion */ } #else if (!gpio_get_value_cansleep(hi->gpio_detect)) #ifdef CONFIG_FSA8008_USE_LOCAL_WORK_QUEUE queue_delayed_work(local_fsa8008_workqueue, &(hi->work), 0); /* to detect in initialization with eacjack insertion */ #else schedule_delayed_work(&(hi->work), 0); /* to detect in initialization with eacjack insertion */ #endif #endif #ifdef AT_TEST_GPKD err = device_create_file(&pdev->dev, &dev_attr_hookkeylog); #endif return ret; error_09: input_free_device(hi->input); error_08: switch_dev_unregister(&hi->sdev); error_07: free_irq(hi->irq_key, 0); error_06: free_irq(hi->irq_detect, 0); error_05: gpio_free(hi->gpio_mic_en); error_04: gpio_free(hi->gpio_key); error_03: gpio_free(hi->gpio_jpole); error_02: gpio_free(hi->gpio_detect); error_01: mutex_destroy(&hi->mutex_lock); kfree(hi); return ret; }
static void hw_tsensor_debug_work(void) { hkadc_tsensor_debug_show(); schedule_delayed_work(&tsensor_debug_work, msecs_to_jiffies(60*1000));// 60s }
/***************************************************************************** 函 数 名 : tsensor_temp_check 功能描述 : tsensor温度检测保护函数 输入参数 : 无 输出参数 : 无 返 回 值 : 无 调用函数 : 被调函数 : 修改历史 : 1.日 期 : 2013年5月6日 作 者 : 刘龙 00217270 修改内容 : 新生成函数 修改历史 : 1.日 期 : 2014年5月26日 作 者 : 王欢 w00251051 修改内容 : V8R1修改 *****************************************************************************/ void tsensor_monitor_work_fn(struct work_struct *work) { int tempvalue = 0; int ret = TSENSOR_ERR; unsigned int index = 0; index = tsensor_get_index_by_type(TSENSOR_TYPE_LOCAL); ret = tsensor_temp_read_by_index(index, &tempvalue); if(TSENSOR_OK != ret) { pr_err("%s,%d tsensor_temp_read_by_index err\n", __func__, __LINE__); schedule_delayed_work(&tsensor_gov->tsensor_monitor_work,0); return; } pr_err("%s,%d temp_t0:%d tempvalue: %d\n", __func__, __LINE__, gstTempPrtInfo.sensor_config[index].temp_t0,tempvalue); if(tempvalue >= gstTempPrtInfo.sensor_config[index].thres_value) { gstTempPrtInfo.temp_prt_vote |= BIT(TSENSOR_TYPE_LOCAL); tsensor_gov->warning_count++; if(gstTempPrtInfo.temp_offset_benchmark<=(tempvalue-gstTempPrtInfo.sensor_config[index].temp_t0)) { acpufreq_limit_level_regulator(&gstTempPrtInfo,FREQ_DOWN); gstTempPrtInfo.sensor_config[index].temp_t0 = tempvalue; pr_err("acpufreq regulator FREQ_DOWN.\n"); } } else if (tempvalue >= (gstTempPrtInfo.sensor_config[index].thres_value - gstTempPrtInfo.sensor_config[index].lag_value)) { if(gstTempPrtInfo.temp_offset_benchmark<=(gstTempPrtInfo.sensor_config[index].temp_t0 - tempvalue)) { acpufreq_limit_level_regulator(&gstTempPrtInfo,FREQ_UP); gstTempPrtInfo.temp_prt_vote |= BIT(TSENSOR_TYPE_LOCAL); gstTempPrtInfo.sensor_config[index].temp_t0 = tempvalue; pr_err("acpufreq regulator FREQ_UP.\n"); } } else { pwrctrl_acpu_freq_limit_max(gstTempPrtInfo.acpu_freq_limit_table[0], LOCK_FREQ_OFF); gstTempPrtInfo.cur_acpu_freq_index = 0; gstTempPrtInfo.sensor_config[index].temp_t0 = tempvalue; gstTempPrtInfo.temp_prt_vote &= ~(BIT(TSENSOR_TYPE_LOCAL)); pr_err("acpu acpufreq_limit OFF.\n"); } index = tsensor_get_index_by_type(TSENSOR_TYPE_GPU); if(tempvalue>= gstTempPrtInfo.sensor_config[index].thres_value) { unsigned int cur_gpu_freq_index = gstTempPrtInfo.cur_gpu_freq_index; cur_gpu_freq_index++; if(cur_gpu_freq_index < gstTempPrtInfo.gpu_freq_limit_num) { gstTempPrtInfo.cur_gpu_freq_index = cur_gpu_freq_index; } pmqos_gpu_dfs_limit_max(LOCK_FREQ_ON,gstTempPrtInfo.gpu_freq_limit_table[gstTempPrtInfo.cur_gpu_freq_index]); gstTempPrtInfo.temp_prt_vote |= BIT(TSENSOR_TYPE_GPU); pr_err("gpufreq limit ON: %dM.\n", gstTempPrtInfo.gpu_freq_limit_table[gstTempPrtInfo.cur_gpu_freq_index]); } else if (tempvalue < gstTempPrtInfo.sensor_config[index].thres_value - gstTempPrtInfo.sensor_config[index].lag_value) { pmqos_gpu_dfs_limit_max(LOCK_FREQ_OFF, gstTempPrtInfo.gpu_freq_limit_table[0]); gstTempPrtInfo.cur_gpu_freq_index = 0; gstTempPrtInfo.temp_prt_vote &= ~(BIT(TSENSOR_TYPE_GPU)); pr_err("gpufreq limit OFF .\n"); } if(gstTempPrtInfo.temp_prt_vote) { schedule_delayed_work(&tsensor_gov->tsensor_monitor_work,msecs_to_jiffies(tsensor_gov->average_period)); } else { /*Tsensor0温度检测中断屏蔽寄存器。*/ TSENSOR_REG_WRITE(SOC_PERI_SCTRL_SC_TEMP0_INT_EN_ADDR(0), SOC_PERI_SCTRL_SC_TEMP0_INT_EN_temp0_int_en_START, SOC_PERI_SCTRL_SC_TEMP0_INT_EN_temp0_int_en_END, 0x01); } }
static ssize_t apds990x_store_enable_als_sensor(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct i2c_client *client = to_i2c_client(dev); struct apds990x_data *data = i2c_get_clientdata(client); unsigned long val = simple_strtoul(buf, NULL, 10); unsigned long flags; printk("%s: enable als sensor ( %ld)\n", __func__, val); if ((val != 0) && (val != 1)) { printk("%s: enable als sensor=%ld\n", __func__, val); return count; } if(val == 1) { //turn on light sensor if (data->enable_als_sensor==0) { data->enable_als_sensor = 1; apds990x_set_enable(client,0); /* Power Off */ apds990x_set_atime(client, data->als_atime); /* 100.64ms */ apds990x_set_ailt( client, 0); apds990x_set_aiht( client, 0xffff); apds990x_set_control(client, data->control); /* 100mA, IR-diode, 1X PGAIN, 1X AGAIN */ apds990x_set_pers(client, 0x33); /* 3 persistence */ if (data->enable_ps_sensor) { apds990x_set_ptime(client, 0xff); /* 2.72ms */ apds990x_set_ppcount(client, 8); /* 8-pulse */ apds990x_set_enable(client, 0x27); /* if prox sensor was activated previously */ } else { apds990x_set_enable(client, 0x3); /* only enable light sensor */ } spin_lock_irqsave(&data->update_lock.wait_lock, flags); /* * If work is already scheduled then subsequent schedules will not * change the scheduled time that's why we have to cancel it first. */ __cancel_delayed_work(&data->als_dwork); schedule_delayed_work(&data->als_dwork, msecs_to_jiffies(data->als_poll_delay)); spin_unlock_irqrestore(&data->update_lock.wait_lock, flags); } } else { //turn off light sensor // what if the p sensor is active? data->enable_als_sensor = 0; if (data->enable_ps_sensor) { apds990x_set_enable(client,0); /* Power Off */ apds990x_set_atime(client, 0xf6); /* 27.2ms */ apds990x_set_ptime(client, 0xff); /* 2.72ms */ apds990x_set_ppcount(client, 8); /* 8-pulse */ apds990x_set_control(client, data->control); /* 100mA, IR-diode, 1X PGAIN, 1X AGAIN */ //apds990x_set_piht(client, 0); //apds990x_set_piht(client, APDS990x_PS_DETECTION_THRESHOLD); apds990x_set_ailt( client, 0); apds990x_set_aiht( client, 0xffff); apds990x_set_pers(client, 0x33); /* 3 persistence */ apds990x_set_enable(client, 0x27); /* only enable prox sensor with interrupt */ } else { apds990x_set_enable(client, 0); } spin_lock_irqsave(&data->update_lock.wait_lock, flags); /* * If work is already scheduled then subsequent schedules will not * change the scheduled time that's why we have to cancel it first. */ __cancel_delayed_work(&data->als_dwork); spin_unlock_irqrestore(&data->update_lock.wait_lock, flags); } return count; }
static void flip_cover_work(struct work_struct *work) { struct gpio_keys_drvdata *ddata = container_of(work, struct gpio_keys_drvdata, flip_cover_dwork.work); #if !defined (CONFIG_SEC_MILLET_PROJECT) || !defined (CONFIG_SEC_T8_PROJECT) int comp_val[2]={0}; #else int comp_val[3]={0}; #endif comp_val[0] = gpio_get_value(ddata->gpio_flip_cover); #if !defined (CONFIG_SEC_MILLET_PROJECT) || !defined (CONFIG_SEC_T8_PROJECT) mdelay(30); #else mdelay(10); #endif comp_val[1] = gpio_get_value(ddata->gpio_flip_cover); #if defined (CONFIG_SEC_MILLET_PROJECT) || defined (CONFIG_SEC_T8_PROJECT) mdelay(10); comp_val[2] = gpio_get_value(ddata->gpio_flip_cover); #endif #if !defined (CONFIG_SEC_MILLET_PROJECT) || !defined (CONFIG_SEC_T8_PROJECT) if (comp_val[0] == comp_val[1]) { #else if ((comp_val[0] == comp_val[1]) && (comp_val[0] == comp_val[2])) { #endif if (ddata->flip_code == SW_LID) ddata->flip_cover = !gpio_get_value(ddata->gpio_flip_cover); else ddata->flip_cover = gpio_get_value(ddata->gpio_flip_cover); printk(KERN_DEBUG "[keys] %s : %d code 0x%x\n", __func__, ddata->flip_cover, ddata->flip_code); input_report_switch(ddata->input, ddata->flip_code, ddata->flip_cover); input_sync(ddata->input); if (ddata->flip_cover != flip_status_before) { #if defined(CONFIG_DUAL_LCD) samsung_switching_lcd(ddata->flip_cover); samsung_switching_tsp(ddata->flip_cover); samsung_switching_tkey(ddata->flip_cover); samsung_switching_ssp(ddata->flip_cover); #endif } flip_status_before = ddata->flip_cover; } else { printk(KERN_DEBUG "%s : Value is not same!\n", __func__); } } #else // CONFIG_SEC_FACTORY static void flip_cover_work(struct work_struct *work) { struct gpio_keys_drvdata *ddata = container_of(work, struct gpio_keys_drvdata, flip_cover_dwork.work); if (ddata->flip_code == SW_LID) ddata->flip_cover = !gpio_get_value(ddata->gpio_flip_cover); else ddata->flip_cover = gpio_get_value(ddata->gpio_flip_cover); printk(KERN_DEBUG "[keys] %s : %d code 0x%x\n", __func__, ddata->flip_cover, ddata->flip_code); input_report_switch(ddata->input, ddata->flip_code, ddata->flip_cover); input_sync(ddata->input); if (ddata->flip_cover != flip_status_before) { #if defined(CONFIG_DUAL_LCD) samsung_switching_lcd(ddata->flip_cover); samsung_switching_tsp(ddata->flip_cover); samsung_switching_tkey(ddata->flip_cover); samsung_switching_ssp(ddata->flip_cover); #endif } flip_status_before = ddata->flip_cover; } #endif // CONFIG_SEC_FACTORY #if defined (CONFIG_SEC_MILLET_PROJECT) || defined (CONFIG_SEC_T8_PROJECT) static irqreturn_t flip_cover_detect(int irq, void *dev_id) { struct gpio_keys_drvdata *ddata = dev_id; #define HALL_COMPARISONS 6 int comp_val[HALL_COMPARISONS]={0}; int i; comp_val[0] = gpio_get_value(ddata->gpio_flip_cover); if(comp_val[0]) { wake_lock_timeout(&ddata->flip_wake_lock, HZ * 5 / 100); /* 50ms */ } else { wake_unlock(&ddata->flip_wake_lock); } pr_info("[keys] %s flip_status : %d (%s)\n", __func__, comp_val[0], comp_val[0]?"on":"off"); for(i=1;i<HALL_COMPARISONS;i++){ mdelay(6); comp_val[i] = gpio_get_value(ddata->gpio_flip_cover); if(comp_val[i]!=comp_val[0]){ pr_err("%s : Value is not same!\n", __func__); goto out; } } ddata->flip_cover = comp_val[0]; pr_info("[keys] hall ic reported value: %d (%s)\n", ddata->flip_cover, ddata->flip_cover?"on":"off"); input_report_switch(ddata->input, SW_FLIP, ddata->flip_cover); input_sync(ddata->input); out: return IRQ_HANDLED; } #else static irqreturn_t flip_cover_detect(int irq, void *dev_id) { bool flip_status; struct gpio_keys_drvdata *ddata = dev_id; #ifdef CONFIG_SENSORS_HALL_IRQ_CTRL bool debounce_status; #endif #ifdef CONFIG_SENSORS_HALL_DEBOUNCE int DTIME_IRQ, DTIME_WAKE; /* Set Debounce time for HALL IC IRQ(wake_lock / IRQ recheck) * ON : 140ms / 70ms * OFF : 50ms / 10ms */ DTIME_IRQ = ddata->debounce_set ? (HZ*7/100) : (HZ*1/100); DTIME_WAKE = ddata->debounce_set ? (HZ*14/100) : (HZ*5/100); #endif if (ddata->flip_code == SW_LID) flip_status = !gpio_get_value(ddata->gpio_flip_cover); else flip_status = gpio_get_value(ddata->gpio_flip_cover); cancel_delayed_work_sync(&ddata->flip_cover_dwork); #ifdef CONFIG_SENSORS_HALL_DEBOUNCE printk(KERN_DEBUG "[keys] %s flip_satatus : %d, IRQt : %d, WAKEt : %d\n", __func__, flip_status, DTIME_IRQ, DTIME_WAKE); if(flip_status) { wake_lock_timeout(&ddata->flip_wake_lock, HZ * DTIME_WAKE); schedule_delayed_work(&ddata->flip_cover_dwork, DTIME_IRQ); } else { wake_unlock(&ddata->flip_wake_lock); wake_lock_timeout(&ddata->flip_wake_lock, HZ * DTIME_WAKE); schedule_delayed_work(&ddata->flip_cover_dwork, DTIME_IRQ); } #else /* CONFIG_SENSORS_HALL_DEBOUNCE */ printk(KERN_DEBUG "[keys] %s flip_satatus : %d\n", __func__, flip_status); if(flip_status) { wake_lock_timeout(&ddata->flip_wake_lock, HZ * 5 / 100); /* 50ms */ schedule_delayed_work(&ddata->flip_cover_dwork, HZ * 1 / 100); /* 10ms */ } else { #ifdef CONFIG_SENSORS_HALL_IRQ_CTRL if (ddata->gsm_area) { mdelay(7); debounce_status = gpio_get_value(ddata->gpio_flip_cover); if (debounce_status != flip_status) { printk(KERN_DEBUG "[keys] %s filp ignore IRQ\n", __func__); return IRQ_HANDLED; } } #endif /* CONFIG_SENSORS_HALL_IRQ_CTRL */ wake_unlock(&ddata->flip_wake_lock); schedule_delayed_work(&ddata->flip_cover_dwork, 0); } #endif /* CONFIG_SENSORS_HALL_DEBOUNCE */ return IRQ_HANDLED; }
int musb_port_suspend(struct musb *musb, bool do_suspend) { struct usb_otg *otg = musb->xceiv->otg; u8 power; void __iomem *mbase = musb->mregs; if (!is_host_active(musb)) return 0; /* NOTE: this doesn't necessarily put PHY into low power mode, * turning off its clock; that's a function of PHY integration and * MUSB_POWER_ENSUSPEND. PHY may need a clock (sigh) to detect * SE0 changing to connect (J) or wakeup (K) states. */ power = musb_readb(mbase, MUSB_POWER); if (do_suspend) { int retries = 10000; if (power & MUSB_POWER_RESUME) return -EBUSY; if (!(power & MUSB_POWER_SUSPENDM)) { power |= MUSB_POWER_SUSPENDM; musb_writeb(mbase, MUSB_POWER, power); /* Needed for OPT A tests */ power = musb_readb(mbase, MUSB_POWER); while (power & MUSB_POWER_SUSPENDM) { power = musb_readb(mbase, MUSB_POWER); if (retries-- < 1) break; } } musb_dbg(musb, "Root port suspended, power %02x", power); musb->port1_status |= USB_PORT_STAT_SUSPEND; switch (musb->xceiv->otg->state) { case OTG_STATE_A_HOST: musb->xceiv->otg->state = OTG_STATE_A_SUSPEND; musb->is_active = otg->host->b_hnp_enable; if (musb->is_active) mod_timer(&musb->otg_timer, jiffies + msecs_to_jiffies( OTG_TIME_A_AIDL_BDIS)); musb_platform_try_idle(musb, 0); break; case OTG_STATE_B_HOST: musb->xceiv->otg->state = OTG_STATE_B_WAIT_ACON; musb->is_active = otg->host->b_hnp_enable; musb_platform_try_idle(musb, 0); break; default: musb_dbg(musb, "bogus rh suspend? %s", usb_otg_state_string(musb->xceiv->otg->state)); } } else if (power & MUSB_POWER_SUSPENDM) { power &= ~MUSB_POWER_SUSPENDM; power |= MUSB_POWER_RESUME; musb_writeb(mbase, MUSB_POWER, power); musb_dbg(musb, "Root port resuming, power %02x", power); musb->port1_status |= MUSB_PORT_STAT_RESUME; schedule_delayed_work(&musb->finish_resume_work, msecs_to_jiffies(USB_RESUME_TIMEOUT)); } return 0; }
DECLARE_DVFS_WORK_FUNC(SET, TOUCH) { struct input_booster *data = (struct input_booster *)booster_data; struct booster_dvfs *dvfs = data->dvfses[BOOSTER_DEVICE_TOUCH]; if (!dvfs || !dvfs->initialized) { dev_err(data->dev, "%s: Dvfs is not initialized\n", __func__); return; } mutex_lock(&dvfs->lock); if (!dvfs->level) { dev_err(data->dev, "%s : Skip to set booster due to level 0\n", __func__); goto out; } switch (booster_mode) { case BOOSTER_MODE_ON: cancel_delayed_work(&dvfs->dvfs_off_work); cancel_delayed_work(&dvfs->dvfs_chg_work); switch (dvfs->level) { case BOOSTER_LEVEL1: case BOOSTER_LEVEL2: SET_HMP(data, BOOSTER_DEVICE_TOUCH, dvfs->freqs[BOOSTER_LEVEL1].hmp_boost); set_qos(&dvfs->kfc_qos, PM_QOS_KFC_FREQ_MIN, dvfs->freqs[BOOSTER_LEVEL1].kfc_freq); set_qos(&dvfs->int_qos, PM_QOS_DEVICE_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL1].int_freq); set_qos(&dvfs->cpu_qos, PM_QOS_CPU_FREQ_MIN, dvfs->freqs[BOOSTER_LEVEL1].cpu_freq); set_qos(&dvfs->mif_qos, PM_QOS_BUS_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL1].mif_freq); break; case BOOSTER_LEVEL3: set_qos(&dvfs->kfc_qos, PM_QOS_KFC_FREQ_MIN, dvfs->freqs[BOOSTER_LEVEL3].kfc_freq); set_qos(&dvfs->int_qos, PM_QOS_DEVICE_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL3].int_freq); set_qos(&dvfs->mif_qos, PM_QOS_BUS_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL3].mif_freq); remove_qos(&dvfs->cpu_qos); SET_HMP(data, BOOSTER_DEVICE_TOUCH, dvfs->freqs[BOOSTER_LEVEL3].hmp_boost); break; case BOOSTER_LEVEL4: set_qos(&dvfs->kfc_qos, PM_QOS_KFC_FREQ_MIN, dvfs->freqs[BOOSTER_LEVEL4].kfc_freq); set_qos(&dvfs->int_qos, PM_QOS_DEVICE_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL4].int_freq); set_qos(&dvfs->mif_qos, PM_QOS_BUS_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL4].mif_freq); remove_qos(&dvfs->cpu_qos); SET_HMP(data, BOOSTER_DEVICE_TOUCH, dvfs->freqs[BOOSTER_LEVEL4].hmp_boost); break; case BOOSTER_LEVEL5: SET_HMP(data, BOOSTER_DEVICE_TOUCH, dvfs->freqs[BOOSTER_LEVEL5].hmp_boost); set_qos(&dvfs->kfc_qos, PM_QOS_KFC_FREQ_MIN, dvfs->freqs[BOOSTER_LEVEL5].kfc_freq); set_qos(&dvfs->int_qos, PM_QOS_DEVICE_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL5].int_freq); set_qos(&dvfs->mif_qos, PM_QOS_BUS_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL5].mif_freq); break; case BOOSTER_LEVEL9: SET_HMP(data, BOOSTER_DEVICE_TOUCH, dvfs->freqs[BOOSTER_LEVEL9].hmp_boost); set_qos(&dvfs->kfc_qos, PM_QOS_KFC_FREQ_MIN, dvfs->freqs[BOOSTER_LEVEL9].kfc_freq); set_qos(&dvfs->int_qos, PM_QOS_DEVICE_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL9].int_freq); set_qos(&dvfs->cpu_qos, PM_QOS_CPU_FREQ_MIN, dvfs->freqs[BOOSTER_LEVEL9].cpu_freq); set_qos(&dvfs->mif_qos, PM_QOS_BUS_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL9].mif_freq); break; default: dev_err(data->dev, "%s : Undefined type passed[%d]\n", __func__, dvfs->level); break; } if (dvfs->times[dvfs->level].phase_time) { schedule_delayed_work(&dvfs->dvfs_chg_work, msecs_to_jiffies(dvfs->times[dvfs->level].phase_time)); if (dvfs->phase_excuted) dvfs->phase_excuted = false; } else { schedule_delayed_work(&dvfs->dvfs_chg_work, msecs_to_jiffies(dvfs->times[dvfs->level].head_time)); } dvfs->lock_status = true; DVFS_DEV_DBG(DBG_DVFS, data->dev, "%s : DVFS ON [level %d][start time [%d]]\n", __func__, dvfs->level, dvfs->times[dvfs->level].phase_time ?: dvfs->times[dvfs->level].head_time); break; case BOOSTER_MODE_OFF: if (dvfs->lock_status) schedule_delayed_work(&dvfs->dvfs_off_work, msecs_to_jiffies(dvfs->times[dvfs->level].tail_time)); break; case BOOSTER_MODE_FORCE_OFF: if (dvfs->lock_status) { cancel_delayed_work(&dvfs->dvfs_chg_work); cancel_delayed_work(&dvfs->dvfs_off_work); schedule_work(&dvfs->dvfs_off_work.work); } break; default: break; } out: mutex_unlock(&dvfs->lock); return; }
static int check_keyboard_dock(struct sec_keyboard_callbacks *cb, bool val) { struct sec_keyboard_drvdata *data = container_of(cb, struct sec_keyboard_drvdata, callbacks); int try_cnt = 0; int max_cnt = 14; if (NULL == data->serio) return 0; if (!val) data->dockconnected = false; else { cancel_delayed_work_sync(&data->power_dwork); /* wakeup by keyboard dock */ if (data->pre_connected) { if (UNKOWN_KEYLAYOUT != data->pre_kl) { data->kl = data->pre_kl; data->acc_power(3, true); printk(KERN_DEBUG "[Keyboard] kl : %d\n", data->pre_kl); return 1; } } else data->pre_kl = UNKOWN_KEYLAYOUT; data->pre_connected = true; /* to prevent the over current issue */ data->acc_power(0, false); if (data->check_uart_path) data->check_uart_path(true); msleep(200); data->acc_power(3, true); /* try to get handshake data */ for (try_cnt = 0; try_cnt < max_cnt; try_cnt++) { msleep(50); if (data->kl != UNKOWN_KEYLAYOUT) { data->dockconnected = true; break; } if (gpio_get_value(data->acc_int_gpio)) { printk(KERN_DEBUG "[Keyboard] acc is disconnected.\n"); break; } } } if (data->dockconnected) return 1; else { if (data->pre_connected) { data->dockconnected = false; schedule_delayed_work(&data->power_dwork, HZ/2); data->kl = UNKOWN_KEYLAYOUT; release_all_keys(data); } return 0; } }
/* Touch */ DECLARE_DVFS_DELAYED_WORK_FUNC(CHG, TOUCH) { struct booster_dvfs *dvfs = container_of(work, struct booster_dvfs, dvfs_chg_work.work); struct input_booster *data = dev_get_drvdata(dvfs->parent_dev); mutex_lock(&dvfs->lock); if (!dvfs->times[dvfs->level].phase_time) dvfs->phase_excuted = false; switch (dvfs->level) { case BOOSTER_LEVEL0: case BOOSTER_LEVEL1: case BOOSTER_LEVEL3: remove_qos(&dvfs->cpu_qos); remove_qos(&dvfs->kfc_qos); remove_qos(&dvfs->mif_qos); remove_qos(&dvfs->int_qos); SET_HMP(data, BOOSTER_DEVICE_TOUCH, false); dvfs->lock_status = false; DVFS_DEV_DBG(DBG_DVFS, data->dev, "%s : DVFS OFF\n", __func__); break; case BOOSTER_LEVEL2: set_qos(&dvfs->kfc_qos, PM_QOS_KFC_FREQ_MIN, dvfs->freqs[BOOSTER_LEVEL2].kfc_freq); set_qos(&dvfs->int_qos, PM_QOS_DEVICE_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL2].int_freq); set_qos(&dvfs->mif_qos, PM_QOS_BUS_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL2].mif_freq); remove_qos(&dvfs->cpu_qos); SET_HMP(data, BOOSTER_DEVICE_TOUCH, false); DVFS_DEV_DBG(DBG_DVFS, data->dev, "%s : DVFS CHANGED [level %d]\n", __func__, dvfs->level); break; case BOOSTER_LEVEL4: DVFS_DEV_DBG(DBG_DVFS, data->dev, "%s : DVFS CHANGED [level %d]\n", __func__, dvfs->level); break; case BOOSTER_LEVEL5: if (dvfs->phase_excuted) { remove_qos(&dvfs->cpu_qos); remove_qos(&dvfs->kfc_qos); remove_qos(&dvfs->mif_qos); remove_qos(&dvfs->int_qos); SET_HMP(data, BOOSTER_DEVICE_TOUCH, false); dvfs->lock_status = false; dvfs->phase_excuted = false; DVFS_DEV_DBG(DBG_DVFS, data->dev, "%s : DVFS OFF\n", __func__); } else { set_qos(&dvfs->cpu_qos, PM_QOS_CPU_FREQ_MIN, dvfs->freqs[BOOSTER_LEVEL5].cpu_freq); schedule_delayed_work(&dvfs->dvfs_chg_work, msecs_to_jiffies(dvfs->times[BOOSTER_LEVEL5].head_time - dvfs->times[BOOSTER_LEVEL5].phase_time)); dvfs->phase_excuted = true; DVFS_DEV_DBG(DBG_DVFS, data->dev, "%s : DVFS CHANGED [level %d, start time[%d]]\n", __func__, dvfs->level, dvfs->times[BOOSTER_LEVEL5].head_time - dvfs->times[BOOSTER_LEVEL5].phase_time); } break; case BOOSTER_LEVEL9: SET_HMP(data, BOOSTER_DEVICE_TOUCH, dvfs->freqs[BOOSTER_LEVEL9_CHG].hmp_boost); set_qos(&dvfs->kfc_qos, PM_QOS_KFC_FREQ_MIN, dvfs->freqs[BOOSTER_LEVEL9_CHG].kfc_freq); set_qos(&dvfs->int_qos, PM_QOS_DEVICE_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL9_CHG].int_freq); set_qos(&dvfs->cpu_qos, PM_QOS_CPU_FREQ_MIN, dvfs->freqs[BOOSTER_LEVEL9_CHG].cpu_freq); set_qos(&dvfs->mif_qos, PM_QOS_BUS_THROUGHPUT, dvfs->freqs[BOOSTER_LEVEL9_CHG].mif_freq); DVFS_DEV_DBG(DBG_DVFS, data->dev, "%s : DVFS CHANGED [level %d]\n", __func__, dvfs->level); break; default: dev_err(data->dev, "%s : Undefined type passed[%d]\n", __func__, dvfs->level); break; } if (!dvfs->lock_status) dvfs->phase_excuted = false; mutex_unlock(&dvfs->lock); }
static void sec_keyboard_process_data(struct work_struct *work) { struct sec_keyboard_drvdata *data = container_of(work, struct sec_keyboard_drvdata, handledata_dwork.work); bool press; unsigned int keycode; unsigned char scan_code = data->scan_code; /* keyboard driver need the contry code*/ if (data->kl == UNKOWN_KEYLAYOUT) { switch (scan_code) { case US_KEYBOARD: data->kl = US_KEYLAYOUT; data->keycode[49] = KEY_BACKSLASH; /* for the wakeup state*/ data->pre_kl = data->kl; printk(KERN_DEBUG "[Keyboard] US keyboard is attacted.\n"); break; case UK_KEYBOARD: data->kl = UK_KEYLAYOUT; data->keycode[49] = KEY_NUMERIC_POUND; /* for the wakeup state*/ data->pre_kl = data->kl; printk(KERN_DEBUG "[Keyboard] UK keyboard is attacted.\n"); break; default: printk(KERN_DEBUG "[Keyboard] Unkown layout : %x\n", scan_code); break; } } else { switch (scan_code) { case 0x0: release_all_keys(data); break; case 0xca: /* Caps lock on */ case 0xcb: /* Caps lock off */ case 0xeb: /* US keyboard */ case 0xec: /* UK keyboard */ break; /* Ignore */ case 0x45: case 0x48: data->remap_key = scan_code; data->pressed[scan_code] = true; schedule_delayed_work(&data->remap_dwork, HZ/3); break; case 0xc5: case 0xc8: keycode = (scan_code & 0x7f); data->pressed[keycode] = false; if (0 == data->remap_key) { input_report_key(data->input_dev, data->keycode[keycode], 0); input_sync(data->input_dev); } else { cancel_delayed_work_sync(&data->remap_dwork); if (0x48 == keycode) keycode = KEY_NEXTSONG; else keycode = KEY_PREVIOUSSONG; input_report_key(data->input_dev, keycode, 1); input_report_key(data->input_dev, keycode, 0); input_sync(data->input_dev); } break; default: keycode = (scan_code & 0x7f); press = ((scan_code & 0x80) != 0x80); if (keycode >= KEYBOARD_MIN || keycode <= KEYBOARD_MAX) { data->pressed[keycode] = press; input_report_key(data->input_dev, data->keycode[keycode], press); input_sync(data->input_dev); } break; } } }
/* boost switching logic: * - boost_working means that freq is already set to high value * - boost_scheduled means that job is scheduled to turn boost either on or off * - boost_required is a flag for scheduled job telling it what to do with boost * * if we are in APE_50_OPP, skip boost * if we are in APE_100_OPP and util>boost_up_thresh, shedule boost if its not on or - if its on and scheduled to be turned off - cancel that schedule * if boost is scheduled and not yet working and util < util_high_to_low, then cancel scheduled boost * if boost is on and util < boost_down_thresh, schedule boost to be turned off */ void mali_utilization_function(struct work_struct *ptr) { /*By default, platform start with 50% APE OPP and 25% DDR OPP*/ static u32 has_requested_low = 1; MALI_DEBUG_PRINT(5, ("MALI GPU utilization: %u\n", mali_last_utilization)); mutex_lock(&mali_boost_lock); if ((!boost_required && !boost_working && !boost_scheduled) || !boost_enable) { // consider power saving mode (APE_50_OPP) only if we're not on boost if (mali_last_utilization > mali_utilization_low_to_high) { if (has_requested_low) { MALI_DEBUG_PRINT(5, ("MALI GPU utilization: %u SIGNAL_HIGH\n", mali_last_utilization)); /*Request 100% APE_OPP.*/ prcmu_qos_update_requirement(PRCMU_QOS_APE_OPP, "mali", PRCMU_QOS_MAX_VALUE); /* * Since the utilization values will be reported higher * if DDR_OPP is lowered, we also request 100% DDR_OPP. */ prcmu_qos_update_requirement(PRCMU_QOS_DDR_OPP, "mali", PRCMU_QOS_MAX_VALUE); has_requested_low = 0; mutex_unlock(&mali_boost_lock); return; //After we switch to APE_100_OPP we want to measure utilization once again before entering boost logic } } else { if (mali_last_utilization < mali_utilization_high_to_low) { if (!has_requested_low) { /*Remove APE_OPP and DDR_OPP requests*/ prcmu_qos_update_requirement(PRCMU_QOS_DDR_OPP, "mali", PRCMU_QOS_DEFAULT_VALUE); prcmu_qos_update_requirement(PRCMU_QOS_APE_OPP, "mali", PRCMU_QOS_DEFAULT_VALUE); MALI_DEBUG_PRINT(5, ("MALI GPU utilization: %u SIGNAL_LOW\n", mali_last_utilization)); has_requested_low = 1; } } } } if (!has_requested_low && boost_enable) { // consider boost only if we are in APE_100_OPP mode if (!boost_required && mali_last_utilization > boost_upthreshold) { boost_required = true; if (!boost_scheduled) { //schedule job to turn boost on boost_scheduled = true; schedule_delayed_work(&mali_boost_delayedwork, msecs_to_jiffies(boost_delay)); } else { //cancel job meant to turn boost off boost_scheduled = false; cancel_delayed_work(&mali_boost_delayedwork); } } else if (boost_required && !boost_working && mali_last_utilization < boost_downthreshold) { boost_required = false; if (boost_scheduled) { //if it's not working yet, but is scheduled to be turned on, than cancel scheduled job cancel_delayed_work(&mali_boost_delayedwork); boost_scheduled = false; } } else if (boost_working && mali_last_utilization < boost_downthreshold) { boost_required = false; if (!boost_scheduled) { // if boost is on and isn't yet scheduled to be turned off then schedule it boost_scheduled = true; schedule_delayed_work(&mali_boost_delayedwork, msecs_to_jiffies(boost_delay)); } } } mutex_unlock(&mali_boost_lock); }
static int netvsc_probe(struct hv_device *dev, const struct hv_vmbus_device_id *dev_id) { struct net_device *net = NULL; struct net_device_context *net_device_ctx; struct netvsc_device_info device_info; struct netvsc_device *nvdev; int ret; u32 max_needed_headroom; net = alloc_etherdev_mq(sizeof(struct net_device_context), num_online_cpus()); if (!net) return -ENOMEM; max_needed_headroom = sizeof(struct hv_netvsc_packet) + RNDIS_AND_PPI_SIZE; netif_carrier_off(net); net_device_ctx = netdev_priv(net); net_device_ctx->device_ctx = dev; hv_set_drvdata(dev, net); INIT_DELAYED_WORK(&net_device_ctx->dwork, netvsc_link_change); INIT_WORK(&net_device_ctx->work, do_set_multicast); net->netdev_ops = &device_ops; net->hw_features = NETIF_F_RXCSUM | NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO; net->features = NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_SG | NETIF_F_RXCSUM | NETIF_F_IP_CSUM | NETIF_F_TSO; net->ethtool_ops = ðtool_ops; SET_NETDEV_DEV(net, &dev->device); /* * Request additional head room in the skb. * We will use this space to build the rndis * heaser and other state we need to maintain. */ net->needed_headroom = max_needed_headroom; /* Notify the netvsc driver of the new device */ device_info.ring_size = ring_size; ret = rndis_filter_device_add(dev, &device_info); if (ret != 0) { netdev_err(net, "unable to add netvsc device (ret %d)\n", ret); free_netdev(net); hv_set_drvdata(dev, NULL); return ret; } memcpy(net->dev_addr, device_info.mac_adr, ETH_ALEN); nvdev = hv_get_drvdata(dev); netif_set_real_num_tx_queues(net, nvdev->num_chn); netif_set_real_num_rx_queues(net, nvdev->num_chn); ret = register_netdev(net); if (ret != 0) { pr_err("Unable to register netdev.\n"); rndis_filter_device_remove(dev); free_netdev(net); } else { schedule_delayed_work(&net_device_ctx->dwork, 0); } return ret; }
void connectivity_switching_init(struct work_struct *ignored) { int usb_sel,uart_sel,samsung_kies_sel,ums_sel,mtp_sel,vtp_sel,askon_sel; int lpm_mode_check = charging_mode_get(); if (sec_get_param_value){ sec_get_param_value(__SWITCH_SEL, &switch_sel); cancel_delayed_work(&micorusb_init_work); } else{ schedule_delayed_work(&micorusb_init_work, msecs_to_jiffies(200)); return; } if(BOOTUP){ BOOTUP = 0; otg_phy_init(); //USB Power on after boot up. } printk("[FSA9480]connectivity_switching_init = switch_sel : 0x%x\n",switch_sel); usb_sel = switch_sel & (int)(USB_SEL_MASK); uart_sel = (switch_sel & (int)(UART_SEL_MASK)) >> 1; samsung_kies_sel = (switch_sel & (int)(USB_SAMSUNG_KIES_MASK)) >> 2; ums_sel = (switch_sel & (int)(USB_UMS_MASK)) >> 3; mtp_sel = (switch_sel & (int)(USB_MTP_MASK)) >> 4; #if !defined(CONFIG_ARIES_NTT) // disable tethering xmoondash vtp_sel = (switch_sel & (int)(USB_VTP_MASK)) >> 5; #endif askon_sel = (switch_sel & (int)(USB_ASKON_MASK)) >> 6; if((switch_sel == 0x1) || (factoryresetstatus == 0xAE)){ PathSelStore(AP_USB_MODE); Ap_Cp_Switch_Config(AP_USB_MODE); usb_switching_value_update(SWITCH_PDA); PathSelStore(CP_UART_MODE); Ap_Cp_Switch_Config(CP_UART_MODE); uart_switching_value_update(SWITCH_MODEM); } else{ if(usb_sel) { Ap_Cp_Switch_Config(AP_USB_MODE); usb_switching_value_update(SWITCH_PDA); } else { if(MicroJigUARTOffStatus){ Ap_Cp_Switch_Config(AP_USB_MODE); } else { Ap_Cp_Switch_Config(CP_USB_MODE); usb_switching_value_update(SWITCH_MODEM); } } if(uart_sel) { Ap_Cp_Switch_Config(AP_UART_MODE); uart_switching_value_update(SWITCH_PDA); } else { Ap_Cp_Switch_Config(CP_UART_MODE); uart_switching_value_update(SWITCH_MODEM); } } /*Turn off usb power when LPM mode*/ if(lpm_mode_check) otg_phy_off(); switching_value_update(); if((switch_sel == 1) || (factoryresetstatus == 0xAE)){ usb_switch_select(USBSTATUS_SAMSUNG_KIES); mtp_mode_on = 0; // ap_usb_power_on(0); UsbMenuSelStore(0); } else{ if(usb_sel){ if(samsung_kies_sel){ usb_switch_select(USBSTATUS_SAMSUNG_KIES); /*USB Power off till MTP Appl launching*/ mtp_mode_on = 0; // ap_usb_power_on(0); } else if(mtp_sel){ usb_switch_select(USBSTATUS_MTPONLY); /*USB Power off till MTP Appl launching*/ mtp_mode_on = 1; ap_usb_power_on(0); } else if(ums_sel){ usb_switch_select(USBSTATUS_UMS); } #if !defined(CONFIG_ARIES_NTT) // disable tethering xmoondash else if(vtp_sel){ usb_switch_select(USBSTATUS_VTP); } #endif else if(askon_sel){ usb_switch_select(USBSTATUS_ASKON); } } } if(!FSA9480_Get_USB_Status()) { s3c_usb_cable(1); mdelay(5); s3c_usb_cable(0); } printk("[FSA9480]connectivity_switching_init = switch_sel : 0x%x\n",switch_sel); microusb_uart_status(1); connectivity_switching_init_state=1; }
static int compass_akm_set_mode(struct i2c_client *client, char mode) { struct sensor_private_data* sensor = (struct sensor_private_data *)i2c_get_clientdata(this_client); int result = 0; switch(mode) { case AK8975_MODE_SNG_MEASURE: case AK8975_MODE_SELF_TEST: case AK8975_MODE_FUSE_ACCESS: if(sensor->status_cur == SENSOR_OFF) { if(sensor->pdata->irq_enable) { //DBG("%s:enable irq=%d\n",__func__,client->irq); //enable_irq(client->irq); } else { schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms)); } sensor->status_cur = SENSOR_ON; } break; case AK8975_MODE_POWERDOWN: if(sensor->status_cur == SENSOR_ON) { if(sensor->pdata->irq_enable) { //DBG("%s:disable irq=%d\n",__func__,client->irq); //disable_irq_nosync(client->irq);//disable irq } else cancel_delayed_work_sync(&sensor->delaywork); sensor->status_cur = SENSOR_OFF; } break; } switch(mode) { case AK8975_MODE_SNG_MEASURE: result = sensor_write_reg(client, sensor->ops->ctrl_reg, AK8975_MODE_SNG_MEASURE); if(result) printk("%s:i2c error,mode=%d\n",__func__,mode); break; case AK8975_MODE_SELF_TEST: result = sensor_write_reg(client, sensor->ops->ctrl_reg, AK8975_MODE_SELF_TEST); if(result) printk("%s:i2c error,mode=%d\n",__func__,mode); break; case AK8975_MODE_FUSE_ACCESS: result = sensor_write_reg(client, sensor->ops->ctrl_reg, AK8975_MODE_FUSE_ACCESS); if(result) printk("%s:i2c error,mode=%d\n",__func__,mode); break; case AK8975_MODE_POWERDOWN: /* Set powerdown mode */ result = sensor_write_reg(client, sensor->ops->ctrl_reg, AK8975_MODE_POWERDOWN); if(result) printk("%s:i2c error,mode=%d\n",__func__,mode); udelay(100); break; default: printk("%s: Unknown mode(%d)", __func__, mode); result = -EINVAL; break; } DBG("%s:mode=%d\n",__func__,mode); return result; }
/* * Check if the die sensor is cooling down. If it's higher than * t_hot since the last throttle then throttle it again. * OMAP junction temperature could stay for a long time in an * unacceptable temperature range. The idea here is to check after * t_hot->throttle the system really came below t_hot else re-throttle * and keep doing till it's under t_hot temp range. */ static void throttle_delayed_work_fn(struct work_struct *work) { int curr; struct omap_temp_sensor *temp_sensor = container_of(work, struct omap_temp_sensor, throttle_work.work); curr = omap_read_current_temp(temp_sensor); #ifdef CONFIG_OMAP_TEMP_CONTROL if (curr >= temp_limit || curr < 0) { #else if (curr >= BGAP_THRESHOLD_T_HOT || curr < 0) { #endif pr_warn("%s: OMAP temp read %d exceeds the threshold\n", __func__, curr); omap_thermal_throttle(); schedule_delayed_work(&temp_sensor->throttle_work, msecs_to_jiffies(THROTTLE_DELAY_MS)); } else { schedule_delayed_work(&temp_sensor->throttle_work, msecs_to_jiffies(THROTTLE_DELAY_MS)); } } static irqreturn_t omap_tshut_irq_handler(int irq, void *data) { struct omap_temp_sensor *temp_sensor = (struct omap_temp_sensor *)data; /* Need to handle thermal mgmt in bootloader * to avoid restart again at kernel level */ if (temp_sensor->is_efuse_valid) { pr_emerg("%s: Thermal shutdown reached rebooting device\n", __func__); kernel_restart(NULL); } else { pr_err("%s:Invalid EFUSE, Non-trimmed BGAP\n", __func__); } return IRQ_HANDLED; } static irqreturn_t omap_talert_irq_handler(int irq, void *data) { struct omap_temp_sensor *temp_sensor = (struct omap_temp_sensor *)data; int t_hot, t_cold, temp_offset; t_hot = omap_temp_sensor_readl(temp_sensor, BGAP_STATUS_OFFSET) & OMAP4_HOT_FLAG_MASK; t_cold = omap_temp_sensor_readl(temp_sensor, BGAP_STATUS_OFFSET) & OMAP4_COLD_FLAG_MASK; temp_offset = omap_temp_sensor_readl(temp_sensor, BGAP_CTRL_OFFSET); if (t_hot) { omap_thermal_throttle(); schedule_delayed_work(&temp_sensor->throttle_work, msecs_to_jiffies(THROTTLE_DELAY_MS)); temp_offset &= ~(OMAP4_MASK_HOT_MASK); temp_offset |= OMAP4_MASK_COLD_MASK; } else if (t_cold) { cancel_delayed_work_sync(&temp_sensor->throttle_work); omap_thermal_unthrottle(); temp_offset &= ~(OMAP4_MASK_COLD_MASK); temp_offset |= OMAP4_MASK_HOT_MASK; } omap_temp_sensor_writel(temp_sensor, temp_offset, BGAP_CTRL_OFFSET); return IRQ_HANDLED; } static int __devinit omap_temp_sensor_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct omap_temp_sensor_pdata *pdata = pdev->dev.platform_data; struct omap_temp_sensor *temp_sensor; struct resource *mem; int ret = 0, val; if (!pdata) { dev_err(dev, "%s: platform data missing\n", __func__); return -EINVAL; } temp_sensor = kzalloc(sizeof(struct omap_temp_sensor), GFP_KERNEL); if (!temp_sensor) return -ENOMEM; spin_lock_init(&temp_sensor->lock); mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mem) { dev_err(dev, "%s:no mem resource\n", __func__); ret = -EINVAL; goto plat_res_err; } temp_sensor->irq = platform_get_irq_byname(pdev, "thermal_alert"); if (temp_sensor->irq < 0) { dev_err(dev, "%s:Cannot get thermal alert irq\n", __func__); ret = -EINVAL; goto get_irq_err; } ret = gpio_request_one(OMAP_TSHUT_GPIO, GPIOF_DIR_IN, "thermal_shutdown"); if (ret) { dev_err(dev, "%s: Could not get tshut_gpio\n", __func__); goto tshut_gpio_req_err; } temp_sensor->tshut_irq = gpio_to_irq(OMAP_TSHUT_GPIO); if (temp_sensor->tshut_irq < 0) { dev_err(dev, "%s:Cannot get thermal shutdown irq\n", __func__); ret = -EINVAL; goto get_tshut_irq_err; } temp_sensor->phy_base = pdata->offset; temp_sensor->pdev = pdev; temp_sensor->dev = dev; pm_runtime_enable(dev); pm_runtime_irq_safe(dev); /* * check if the efuse has a non-zero value if not * it is an untrimmed sample and the temperatures * may not be accurate */ if (omap_readl(OMAP4_CTRL_MODULE_CORE + OMAP4_CTRL_MODULE_CORE_STD_FUSE_OPP_BGAP)) temp_sensor->is_efuse_valid = 1; temp_sensor->clock = clk_get(&temp_sensor->pdev->dev, "fck"); if (IS_ERR(temp_sensor->clock)) { ret = PTR_ERR(temp_sensor->clock); pr_err("%s:Unable to get fclk: %d\n", __func__, ret); ret = -EINVAL; goto clk_get_err; } /* Init delayed work for throttle decision */ INIT_DELAYED_WORK(&temp_sensor->throttle_work, throttle_delayed_work_fn); platform_set_drvdata(pdev, temp_sensor); ret = omap_temp_sensor_enable(temp_sensor); if (ret) { dev_err(dev, "%s:Cannot enable temp sensor\n", __func__); goto sensor_enable_err; } omap_enable_continuous_mode(temp_sensor); omap_configure_temp_sensor_thresholds(temp_sensor); /* 1 ms */ omap_configure_temp_sensor_counter(temp_sensor, 1); /* Wait till the first conversion is done wait for at least 1ms */ mdelay(2); /* Read the temperature once due to hw issue*/ omap_read_current_temp(temp_sensor); /* Set 2 seconds time as default counter */ omap_configure_temp_sensor_counter(temp_sensor, temp_sensor->clk_rate * 2); ret = request_threaded_irq(temp_sensor->irq, NULL, omap_talert_irq_handler, IRQF_TRIGGER_RISING | IRQF_ONESHOT, "temp_sensor", (void *)temp_sensor); if (ret) { dev_err(dev, "Request threaded irq failed.\n"); goto req_irq_err; } ret = request_threaded_irq(temp_sensor->tshut_irq, NULL, omap_tshut_irq_handler, IRQF_TRIGGER_RISING | IRQF_ONESHOT, "tshut", (void *)temp_sensor); if (ret) { dev_err(dev, "Request threaded irq failed for TSHUT.\n"); goto tshut_irq_req_err; } ret = sysfs_create_group(&pdev->dev.kobj, &omap_temp_sensor_group); if (ret) { dev_err(&pdev->dev, "could not create sysfs files\n"); goto sysfs_create_err; } /* unmask the T_COLD and unmask T_HOT at init */ val = omap_temp_sensor_readl(temp_sensor, BGAP_CTRL_OFFSET); val |= OMAP4_MASK_COLD_MASK; val |= OMAP4_MASK_HOT_MASK; omap_temp_sensor_writel(temp_sensor, val, BGAP_CTRL_OFFSET); dev_info(dev, "%s probed", pdata->name); temp_sensor_pm = temp_sensor; #ifdef CONFIG_OMAP_TEMP_CONTROL ctrl_sensor = temp_sensor; tempcontrol_registerlimit(temp_limit); #endif return 0; sysfs_create_err: free_irq(temp_sensor->tshut_irq, temp_sensor); cancel_delayed_work_sync(&temp_sensor->throttle_work); tshut_irq_req_err: free_irq(temp_sensor->irq, temp_sensor); req_irq_err: platform_set_drvdata(pdev, NULL); omap_temp_sensor_disable(temp_sensor); sensor_enable_err: clk_put(temp_sensor->clock); clk_get_err: pm_runtime_disable(dev); get_tshut_irq_err: gpio_free(OMAP_TSHUT_GPIO); tshut_gpio_req_err: get_irq_err: plat_res_err: kfree(temp_sensor); return ret; } static int __devexit omap_temp_sensor_remove(struct platform_device *pdev) { struct omap_temp_sensor *temp_sensor = platform_get_drvdata(pdev); sysfs_remove_group(&pdev->dev.kobj, &omap_temp_sensor_group); cancel_delayed_work_sync(&temp_sensor->throttle_work); omap_temp_sensor_disable(temp_sensor); clk_put(temp_sensor->clock); platform_set_drvdata(pdev, NULL); if (temp_sensor->irq) free_irq(temp_sensor->irq, temp_sensor); if (temp_sensor->tshut_irq) free_irq(temp_sensor->tshut_irq, temp_sensor); kfree(temp_sensor); return 0; } #ifdef CONFIG_PM static void omap_temp_sensor_save_ctxt(struct omap_temp_sensor *temp_sensor) { temp_sensor_context.temp_sensor_ctrl = omap_temp_sensor_readl(temp_sensor, TEMP_SENSOR_CTRL_OFFSET); temp_sensor_context.bg_ctrl = omap_temp_sensor_readl(temp_sensor, BGAP_CTRL_OFFSET); temp_sensor_context.bg_counter = omap_temp_sensor_readl(temp_sensor, BGAP_COUNTER_OFFSET); temp_sensor_context.bg_threshold = omap_temp_sensor_readl(temp_sensor, BGAP_THRESHOLD_OFFSET); temp_sensor_context.temp_sensor_tshut_threshold = omap_temp_sensor_readl(temp_sensor, BGAP_TSHUT_OFFSET); }
/* Remote-control poll function - called every dib->rc_query_interval ms to see * whether the remote control has received anything. * * TODO: Fix the repeat rate of the input device. */ static void dvb_usb_read_remote_control(struct work_struct *work) { struct dvb_usb_device *d = container_of(work, struct dvb_usb_device, rc_query_work.work); u32 event; int state; /* TODO: need a lock here. We can simply skip checking for the remote control if we're busy. */ /* when the parameter has been set to 1 via sysfs while the driver was running */ if (dvb_usb_disable_rc_polling) return; if (d->props.rc_query(d,&event,&state)) { err("error while querying for an remote control event."); goto schedule; } switch (state) { case REMOTE_NO_KEY_PRESSED: break; case REMOTE_KEY_PRESSED: deb_rc("key pressed\n"); d->last_event = event; case REMOTE_KEY_REPEAT: deb_rc("key repeated\n"); input_event(d->rc_input_dev, EV_KEY, event, 1); input_event(d->rc_input_dev, EV_KEY, d->last_event, 0); input_sync(d->rc_input_dev); break; default: break; } /* improved repeat handling ??? switch (state) { case REMOTE_NO_KEY_PRESSED: deb_rc("NO KEY PRESSED\n"); if (d->last_state != REMOTE_NO_KEY_PRESSED) { deb_rc("releasing event %d\n",d->last_event); input_event(d->rc_input_dev, EV_KEY, d->last_event, 0); input_sync(d->rc_input_dev); } d->last_state = REMOTE_NO_KEY_PRESSED; d->last_event = 0; break; case REMOTE_KEY_PRESSED: deb_rc("KEY PRESSED\n"); deb_rc("pressing event %d\n",event); input_event(d->rc_input_dev, EV_KEY, event, 1); input_sync(d->rc_input_dev); d->last_event = event; d->last_state = REMOTE_KEY_PRESSED; break; case REMOTE_KEY_REPEAT: deb_rc("KEY_REPEAT\n"); if (d->last_state != REMOTE_NO_KEY_PRESSED) { deb_rc("repeating event %d\n",d->last_event); input_event(d->rc_input_dev, EV_KEY, d->last_event, 2); input_sync(d->rc_input_dev); d->last_state = REMOTE_KEY_REPEAT; } default: break; } */ schedule: schedule_delayed_work(&d->rc_query_work,msecs_to_jiffies(d->props.rc_interval)); }
static void pil_proxy_unvote(struct pil_device *pil, unsigned long timeout) { if (pil->desc->ops->proxy_unvote) schedule_delayed_work(&pil->proxy, msecs_to_jiffies(timeout)); }
static int __devinit gpio_keys_probe(struct platform_device *pdev) { const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; struct gpio_keys_drvdata *ddata; struct gpio_keys_button *button = NULL; struct gpio_button_data *bdata = NULL; struct device *dev = &pdev->dev; struct gpio_keys_platform_data alt_pdata; struct input_dev *input; int i, error; int wakeup = 0; int ret; struct device *sec_key; #ifdef CONFIG_SEC_PATEK_PROJECT struct device *sec_keypad; struct device *sec_flip; #endif if (!pdata) { error = gpio_keys_get_devtree_pdata(dev, &alt_pdata); if (error) return error; pdata = &alt_pdata; } ddata = kzalloc(sizeof(struct gpio_keys_drvdata) + pdata->nbuttons * sizeof(struct gpio_button_data), GFP_KERNEL); input = input_allocate_device(); if (!ddata || !input) { dev_err(dev, "failed to allocate state\n"); error = -ENOMEM; goto fail1; } ddata->input = input; ddata->n_buttons = pdata->nbuttons; ddata->enable = pdata->enable; ddata->disable = pdata->disable; #ifdef CONFIG_SENSORS_HALL_DEBOUNCE ddata->debounce_set = pdata->debounce_set; #endif #ifdef CONFIG_SENSORS_HALL #if defined (CONFIG_SEC_MILLET_PROJECT) || defined (CONFIG_SEC_BERLUTI_PROJECT)\ || defined (CONFIG_SEC_MATISSE_PROJECT) || defined (CONFIG_SEC_ATLANTIC_PROJECT)\ || defined (CONFIG_SEC_MEGA2_PROJECT) || defined (CONFIG_SEC_T8_PROJECT) || defined (CONFIG_SEC_T10_PROJECT) || defined(CONFIG_SEC_HESTIA_PROJECT) ret = gpio_request(pdata->gpio_flip_cover,"HALL"); if(ret) printk(KERN_CRIT "[HALL IC] gpio Request FAIL\n"); else { gpio_tlmm_config(GPIO_CFG(pdata->gpio_flip_cover,0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL,GPIO_CFG_2MA),GPIO_CFG_DISABLE); } #endif ddata->gpio_flip_cover = pdata->gpio_flip_cover; ddata->flip_code = pdata->flip_code; ddata->irq_flip_cover = gpio_to_irq(ddata->gpio_flip_cover); wake_lock_init(&ddata->flip_wake_lock, WAKE_LOCK_SUSPEND, "flip_wake_lock"); flip_status_before = -1; #endif mutex_init(&ddata->disable_lock); #ifdef CONFIG_SENSORS_HALL_IRQ_CTRL mutex_init(&ddata->irq_lock); #endif platform_set_drvdata(pdev, ddata); input_set_drvdata(input, ddata); input->name = pdata->name ? : pdev->name; input->phys = "gpio-keys/input0"; input->dev.parent = &pdev->dev; #ifdef CONFIG_SENSORS_HALL if(ddata->gpio_flip_cover != 0) { input->evbit[0] |= BIT_MASK(EV_SW); input_set_capability(input, EV_SW, ddata->flip_code); } #endif #ifdef CONFIG_SENSORS_HALL_IRQ_CTRL ddata->gsm_area = false; ddata->cover_state = false; ddata->workaround_set = pdata->workaround_set; drv_data = ddata; #endif #ifdef CONFIG_SENSORS_HALL_DEBOUNCE ddata->debounce_set = false; #endif input->open = gpio_keys_open; input->close = gpio_keys_close; input->id.bustype = BUS_HOST; input->id.vendor = 0x0001; input->id.product = 0x0001; input->id.version = 0x0100; /* Enable auto repeat feature of Linux input subsystem */ if (pdata->rep) __set_bit(EV_REP, input->evbit); for (i = 0; i < pdata->nbuttons; i++) { button = &pdata->buttons[i]; bdata = &ddata->data[i]; error = gpio_keys_setup_key(pdev, input, bdata, button); if (error) goto fail2; #ifdef KEY_BOOSTER error = gpio_key_init_dvfs(bdata); if (error < 0) { dev_err(dev, "Fail get dvfs level for touch booster\n"); goto fail2; } #endif if (button->wakeup) wakeup = 1; } error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group); if (error) { dev_err(dev, "Unable to export keys/switches, error: %d\n", error); goto fail2; } error = input_register_device(input); if (error) { dev_err(dev, "Unable to register input device, error: %d\n", error); goto fail3; } /* get current state of buttons that are connected to GPIOs */ for (i = 0; i < pdata->nbuttons; i++) { bdata = &ddata->data[i]; if (gpio_is_valid(bdata->button->gpio)) gpio_keys_gpio_report_event(bdata); } input_sync(input); sec_key = device_create(sec_class, NULL, 0, NULL, "sec_key"); if (IS_ERR(sec_key)) pr_err("Failed to create device(sec_key)!\n"); #ifdef CONFIG_SEC_PATEK_PROJECT sec_keypad=device_create(sec_class, NULL, 0, NULL, "sec_keypad"); if (device_create_file(sec_keypad, &dev_attr_brightness) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_brightness.attr.name); sec_flip = device_create(sec_class, NULL, 0, NULL, "sec_flip"); if (device_create_file(sec_flip, &dev_attr_flipStatus) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_flipStatus.attr.name); #endif ret = device_create_file(sec_key, &dev_attr_sec_key_pressed); if (ret) { pr_err("Failed to create device file in sysfs entries(%s)!\n", dev_attr_sec_key_pressed.attr.name); } #if defined(CONFIG_SEC_S_PROJECT) ret = device_create_file(sec_key, &dev_attr_sec_key_pressed_code); if (ret) { pr_err("Failed to create device file in sysfs entries(%s)!\n", dev_attr_sec_key_pressed_code.attr.name); } #endif #ifdef CONFIG_SENSORS_HALL_IRQ_CTRL if(ddata->gpio_flip_cover != 0) { ret = device_create_file(sec_key, &dev_attr_hall_irq_ctrl); if (ret < 0) { pr_err("Failed to create device file(%s)!, error: %d\n", dev_attr_hall_irq_ctrl.attr.name, ret); } } #endif #if defined(CONFIG_SENSORS_HALL) if(ddata->gpio_flip_cover != 0) { ret = device_create_file(sec_key, &dev_attr_hall_detect); if (ret < 0) { pr_err("Failed to create device file(%s)!, error: %d\n", dev_attr_hall_detect.attr.name, ret); } } #if defined(CONFIG_SENSORS_HALL_DEBOUNCE) if(ddata->gpio_flip_cover != 0) { ret = device_create_file(sec_key, &dev_attr_hall_irq_ctrl); if (ret < 0) { pr_err("Failed to create device file(%s)!, error: %d\n", dev_attr_hall_irq_ctrl.attr.name, ret); } } #endif #if defined (CONFIG_SEC_MILLET_PROJECT) || defined (CONFIG_SEC_BERLUTI_PROJECT) || defined (CONFIG_SEC_T8_PROJECT) if (!lvs1_1p8) { lvs1_1p8 = regulator_get(dev, "8226_lvs1"); if(!lvs1_1p8) printk(KERN_CRIT "%s: regulator_get for 8226_lvs1 failed\n", __func__); else { ret = regulator_enable(lvs1_1p8); if (ret){ regulator_put(lvs1_1p8); printk(KERN_CRIT "%s: Failed to enable regulator lvs1_1p8.\n",__func__); } } } #endif #endif #ifdef CONFIG_USE_VM_KEYBOARD_REJECT reject_keyboard_specific_key = false; ret = device_create_file(sec_key, &dev_attr_reject_key_comb); if (ret < 0) { pr_err("Failed to create device file(%s), error: %d\n", dev_attr_reject_key_comb.attr.name, ret); } #endif ret = device_create_file(sec_key, &dev_attr_wakeup_keys); if (ret < 0) { pr_err("Failed to create device file(%s), error: %d\n", dev_attr_wakeup_keys.attr.name, ret); } dev_set_drvdata(sec_key, ddata); device_init_wakeup(&pdev->dev, wakeup); #if defined(CONFIG_SEC_PATEK_PROJECT) keypadled_powerset(&pdev->dev); dev_set_drvdata(sec_flip, ddata); #endif #ifdef PERIODIC_CHECK_GPIOS INIT_DELAYED_WORK_DEFERRABLE(&g_gpio_check_work, sec_gpiocheck_work); schedule_delayed_work(&g_gpio_check_work, msecs_to_jiffies(0)); #endif return 0; fail3: sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group); fail2: while (--i >= 0) gpio_remove_key(&ddata->data[i]); platform_set_drvdata(pdev, NULL); #ifdef CONFIG_SENSORS_HALL wake_lock_destroy(&ddata->flip_wake_lock); #endif fail1: input_free_device(input); kfree(ddata); /* If we have no platform_data, we allocated buttons dynamically. */ if (!pdev->dev.platform_data) kfree(pdata->buttons); return error; }
static void earjack_detect_func( struct work_struct *test_earjack) { int err; struct pm8xxx_mpp_config_data pantech_presto_earjack_adc = { .type = PM8XXX_MPP_TYPE_D_INPUT, .level = PM8058_MPP_DIG_LEVEL_S3, .control = PM8XXX_MPP_DIN_TO_INT, }; dbg_func_in(); dbg("currnet earjack->type: "); switch(earjack->type){ case EARJACK_STATE_OFF : { dbg_without_label("EARJACK_STATE_OFF\n"); if(EARJACK_INSERTED){ earjack->type = EARJACK_STATE_CHECK; #if defined(CONFIG_MIC_BIAS_1_8V) #else err=regulator_is_enabled(hs_jack_l8); if(err<=0) err = regulator_enable(hs_jack_l8); #endif //defined(CONFIG_MACH_MSM8X60_PRESTO) pm8xxx_mpp_config(PM8058_MPP_PM_TO_SYS(2), &pantech_presto_earjack_adc); //pm8058_mpp_config_digital_in(XOADC_MPP_3,PM8058_MPP_DIG_LEVEL_S3, PM_MPP_DIN_TO_INT); schedule_delayed_work(&earjack_work, 5); //50ms // return without enable IRQ, wake_unlock. return; } break; } case EARJACK_STATE_CHECK : { dbg_without_label("EARJACK_STATE_CHECK\n"); if(EARJACK_INSERTED) { // 3pole if(!is_4pole_earjack()){ dbg("3pole headset inserted.\n"); earjack->type= EARJACK_STATE_ON_3POLE_CHECK; earjack->mic_on = 0; earjack->hs_on = 1; input_report_switch(earjack->ipdev, SW_HEADPHONE_INSERT,earjack->hs_on); switch_set_state(&earjack->sdev, switch_state()); schedule_delayed_work(&earjack_work, 60); // check if 4pole 600ms // return without enable IRQ, wake_unlock. return; } //4pole else { dbg("4pole headset inserted.\n"); earjack->type= EARJACK_STATE_ON; err=request_threaded_irq(gpio_to_irq(REMOTEKEY_DET),NULL,Remotekey_Det_handler,IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "remote_det-irq", earjack); if(err) dbg("request_threaded_irq failed\n"); earjack->mic_on = 1; earjack->hs_on = 1; input_report_switch(earjack->ipdev, SW_MICROPHONE_INSERT,earjack->mic_on); //TODO: NO USE? input_report_switch(earjack->ipdev, SW_HEADPHONE_INSERT,earjack->hs_on); switch_set_state(&earjack->sdev, switch_state()); } } else // if EARJACK_RELEASED { earjack->type = EARJACK_STATE_OFF; dbg("earjack_type: -> EARJACK_STATE_OFF"); } break; // case EARJACK_STATE_CHECK } case EARJACK_STATE_ON_3POLE_CHECK : { // CHECKING IF 4POLE EARJACK IS INSERTIND? dbg_without_label("EARJACK_STATE_ON_3POLE_CHECK\n"); if(EARJACK_INSERTED){ earjack->type= EARJACK_STATE_ON; if(!is_4pole_earjack()){ dbg("3pole earjack insert.\n"); #if defined(CONFIG_MIC_BIAS_1_8V) #else err=regulator_is_enabled(hs_jack_l8); dbg("regulator_is_enabled(hs_jack_l8) value => %d\n",err); if(err>0) regulator_disable(hs_jack_l8); #endif //defined(CONFIG_MACH_MSM8X60_PRESTO) } else { dbg("4pole earjack insert.\n"); earjack->mic_on =1; input_report_switch(earjack->ipdev, SW_MICROPHONE_INSERT,earjack->mic_on); switch_set_state(&earjack->sdev, switch_state()); err=request_threaded_irq(gpio_to_irq(REMOTEKEY_DET),NULL,Remotekey_Det_handler,IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "remote_det-irq", earjack); if(err) dbg("request_threaded_irq failed\n"); } } else{ #if defined(CONFIG_MIC_BIAS_1_8V) #else err=regulator_is_enabled(hs_jack_l8); dbg("regulator_is_enabled(hs_jack_l8) value => %d\n",err); if(err>0) regulator_disable(hs_jack_l8); #endif// defined(CONFIG_MACH_MSM8X60_PRESTO) earjack->type = EARJACK_STATE_OFF; earjack->hs_on=0; input_report_switch(earjack->ipdev, SW_HEADPHONE_INSERT,earjack->hs_on); switch_set_state(&earjack->sdev, switch_state()); } break; } case EARJACK_STATE_ON: { dbg_without_label("EARJACK_STATE_ON\n"); if(EARJACK_RELEASED){ earjack->type = EARJACK_STATE_OFF; // if 4pole if (earjack->mic_on) { earjack->mic_on = 0; input_report_switch(earjack->ipdev, SW_MICROPHONE_INSERT,earjack->mic_on); // free remote key irq and turn off mic power. free_irq(gpio_to_irq(REMOTEKEY_DET), earjack); #if defined(CONFIG_MIC_BIAS_1_8V) #else err=regulator_is_enabled(hs_jack_l8); dbg("regulator_is_enabled(hs_jack_l8) value => %d\n",err); if(err>0){ regulator_disable(hs_jack_l8); } #endif //defined(CONFIG_MACH_MSM8X60_PRESTO) // release remote key if pressed if(earjack->remotekey_pressed){ earjack->remotekey_pressed = 0; if (earjack->remotekey_index != 0) input_report_key(earjack->ipdev, remotekey_type[earjack->remotekey_index].key_index, earjack->remotekey_pressed); dbg("remote key: %s : %d->%d \n", remotekey_type[earjack->remotekey_index].key_name, !earjack->remotekey_pressed, earjack->remotekey_pressed); input_sync(earjack->ipdev); } dbg("earjack_release \n"); } earjack->hs_on = 0; input_report_switch(earjack->ipdev, SW_HEADPHONE_INSERT,earjack->hs_on); switch_set_state(&earjack->sdev, switch_state()); } break; } default : dbg("earjack_detect_func default.\n"); } enable_irq_detect(); //enable_irq(gpio_to_irq(EARJACK_DET)); wake_unlock(&earjack_wake_lock); dbg_func_out(); return; }
void hv_kvp_onchannelcallback(void *context) { struct vmbus_channel *channel = context; u32 recvlen; u64 requestid; struct hv_kvp_msg *kvp_msg; struct icmsg_hdr *icmsghdrp; struct icmsg_negotiate *negop = NULL; int util_fw_version; int kvp_srv_version; if (kvp_transaction.state > HVUTIL_READY) return; vmbus_recvpacket(channel, recv_buffer, PAGE_SIZE * 4, &recvlen, &requestid); if (recvlen > 0) { icmsghdrp = (struct icmsg_hdr *)&recv_buffer[ sizeof(struct vmbuspipe_hdr)]; if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) { /* * Based on the host, select appropriate * framework and service versions we will * negotiate. */ switch (vmbus_proto_version) { case (VERSION_WS2008): util_fw_version = UTIL_WS2K8_FW_VERSION; kvp_srv_version = WS2008_SRV_VERSION; break; case (VERSION_WIN7): util_fw_version = UTIL_FW_VERSION; kvp_srv_version = WIN7_SRV_VERSION; break; default: util_fw_version = UTIL_FW_VERSION; kvp_srv_version = WIN8_SRV_VERSION; } vmbus_prep_negotiate_resp(icmsghdrp, negop, recv_buffer, util_fw_version, kvp_srv_version); } else { kvp_msg = (struct hv_kvp_msg *)&recv_buffer[ sizeof(struct vmbuspipe_hdr) + sizeof(struct icmsg_hdr)]; /* * Stash away this global state for completing the * transaction; note transactions are serialized. */ kvp_transaction.recv_len = recvlen; kvp_transaction.recv_channel = channel; kvp_transaction.recv_req_id = requestid; kvp_transaction.kvp_msg = kvp_msg; if (kvp_transaction.state < HVUTIL_READY) { /* Userspace is not registered yet */ kvp_respond_to_host(NULL, HV_E_FAIL); return; } kvp_transaction.state = HVUTIL_HOSTMSG_RECEIVED; /* * Get the information from the * user-mode component. * component. This transaction will be * completed when we get the value from * the user-mode component. * Set a timeout to deal with * user-mode not responding. */ schedule_work(&kvp_sendkey_work); schedule_delayed_work(&kvp_timeout_work, HV_UTIL_TIMEOUT * HZ); return; } icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION | ICMSGHDRFLAG_RESPONSE; vmbus_sendpacket(channel, recv_buffer, recvlen, requestid, VM_PKT_DATA_INBAND, 0); } }