int __init buzz_init_mmc(unsigned int sys_rev) { uint32_t id; wifi_status_cb = NULL; sdslot_vreg_enabled = 0; printk(KERN_INFO "%s\n", __func__); /* initial WIFI_SHUTDOWN */ id = PCOM_GPIO_CFG(BUZZ_GPIO_WIFI_EN, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA), msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &id, 0); msm_add_sdcc(1, &buzz_wifi_data, 0, 0); if (opt_disable_sdcard) { printk(KERN_INFO "buzz: SD-Card interface disabled\n"); goto done; } vreg_sdslot = vreg_get(0, "gp6"); if (IS_ERR(vreg_sdslot)) return PTR_ERR(vreg_sdslot); set_irq_wake(MSM_GPIO_TO_INT(BUZZ_GPIO_SDMC_CD_N), 1); msm_add_sdcc(2, &buzz_sdslot_data, MSM_GPIO_TO_INT(BUZZ_GPIO_SDMC_CD_N), IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE); done: return 0; }
int sapphire_init_gpio(void) { int i; if (!machine_is_sapphire()) return 0; DBG("%d,%d\r\n",SAPPHIRE_INT_START, SAPPHIRE_INT_END); DBG("NR_MSM_IRQS=%d, NR_GPIO_IRQS=%d\r\n", NR_MSM_IRQS, NR_GPIO_IRQS); for(i = SAPPHIRE_INT_START; i <= SAPPHIRE_INT_END; i++) { set_irq_chip(i, &sapphire_gpio_irq_chip); set_irq_handler(i, handle_edge_irq); set_irq_flags(i, IRQF_VALID); } register_gpio_chip(&sapphire_gpio_chip); register_gpio_chip(&sapphire_h2w_gpio_chip); /*setup CPLD INT connecting to SOC's gpio 17 */ set_irq_type(MSM_GPIO_TO_INT(17), IRQF_TRIGGER_HIGH); set_irq_chained_handler(MSM_GPIO_TO_INT(17), sapphire_gpio_irq_handler); set_irq_wake(MSM_GPIO_TO_INT(17), 1); if(sysdev_class_register(&sapphire_sysdev_class) == 0) sysdev_register(&sapphire_irq_device); return 0; }
static int __init msm_serial_probe(struct platform_device *pdev) { struct msm_port *msm_port; struct resource *resource; struct uart_port *port; #ifdef CONFIG_SERIAL_MSM_RX_WAKEUP struct msm_serial_platform_data *pdata = pdev->dev.platform_data; #endif if (unlikely(pdev->id < 0 || pdev->id >= UART_NR)) return -ENXIO; printk(KERN_INFO "msm_serial: detected port #%d\n", pdev->id); port = get_port_from_line(pdev->id); port->dev = &pdev->dev; msm_port = UART_TO_MSM(port); msm_port->clk = clk_get(&pdev->dev, "uart_clk"); if (unlikely(IS_ERR(msm_port->clk))) return PTR_ERR(msm_port->clk); port->uartclk = clk_get_rate(msm_port->clk); resource = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (unlikely(!resource)) return -ENXIO; port->mapbase = resource->start; port->irq = platform_get_irq(pdev, 0); if (unlikely(port->irq < 0)) return -ENXIO; platform_set_drvdata(pdev, port); if (unlikely(set_irq_wake(port->irq, 1))) return -ENXIO; #ifdef CONFIG_SERIAL_MSM_RX_WAKEUP if (pdata == NULL) msm_port->wakeup.irq = -1; else { msm_port->wakeup.irq = pdata->wakeup_irq; msm_port->wakeup.ignore = 1; msm_port->wakeup.inject_rx = pdata->inject_rx_on_wakeup; msm_port->wakeup.rx_to_inject = pdata->rx_to_inject; if (unlikely(msm_port->wakeup.irq <= 0)) return -EINVAL; } #endif #ifdef CONFIG_SERIAL_MSM_CLOCK_CONTROL msm_port->clk_state = MSM_CLK_PORT_OFF; hrtimer_init(&msm_port->clk_off_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); msm_port->clk_off_timer.function = msm_serial_clock_off; msm_port->clk_off_delay = ktime_set(0, 1000000); /* 1 ms */ #endif return uart_add_one_port(&msm_uart_driver, port); }
int bcmsdh_register_oob_intr(void *dhdp) { int error = 0; SDLX_MSG(("%s Enter\n", __func__)); sdhcinfo->oob_flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL | IORESOURCE_IRQ_SHAREABLE; dev_set_drvdata(sdhcinfo->dev, dhdp); if (!sdhcinfo->oob_irq_registered) { SDLX_MSG(("%s IRQ=%d Type=%X\n", __func__, (int)sdhcinfo->oob_irq, (int)sdhcinfo->oob_flags)); /* Refer to customer Host IRQ docs about proper irqflags definition */ error = request_irq(sdhcinfo->oob_irq, wlan_oob_irq, sdhcinfo->oob_flags, "bcmsdh_sdmmc", NULL); if (error) return -ENODEV; set_irq_wake(sdhcinfo->oob_irq, 1); sdhcinfo->oob_irq_registered = true; } return 0; }
int __init desirec_init_mmc(unsigned int sys_rev) { wifi_status_cb = NULL; sdslot_vreg_enabled = 0; vreg_wifi_osc = vreg_get(0, "gp4"); if (IS_ERR(vreg_wifi_osc)) return PTR_ERR(vreg_wifi_osc); vreg_set_level(vreg_wifi_osc, 1800); msm_add_sdcc(1, &desirec_wifi_data, 0, 0); /* r porting 29: change func*/ if (opt_disable_sdcard) { printk(KERN_INFO "desirec: SD-Card interface disabled\n"); goto done; } vreg_sdslot = vreg_get(0, "gp6"); if (IS_ERR(vreg_sdslot)) return PTR_ERR(vreg_sdslot); set_irq_wake(MSM_GPIO_TO_INT(DESIREC_GPIO_SDMC_CD_N), 1); msm_add_sdcc(2, &desirec_sdslot_data, MSM_GPIO_TO_INT(DESIREC_GPIO_SDMC_CD_N), IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE); /* r porting 29 */ done: return 0; }
int gp2a_off(struct gp2a_data *gp2a, int type) { u8 value; int err = 0; gprintk("gp2a_off(%d)\n",type); if(type == PROXIMITY || type == ALL) { #if USE_INTERRUPT gprintk("disable irq for proximity \n"); #if !defined(CONFIG_MACH_RANT3) set_irq_wake(gp2a->irq, 0); #endif disable_irq_nosync(gp2a ->irq); #endif // SSD : Software shutdown function ( 0:shutdown mode, 1:opteration mode ) value = 0x02; // VCON enable, SSD disable err = opt_i2c_write((u8)(REGS_OPMOD),&value); } #ifdef LIGHT_SENSOR_ENABLED if(type ==LIGHT) { gprintk("[LIGHT_SENSOR] timer cancel for light sensor\n"); hrtimer_cancel(&gp2a->timer); /* In case light sensor is off, set the default backlight level */ //lcdc_set_backlight_autobrightness(app_bl_level); light_enable = OFF; } #endif return err; }
int bluetooth_enable_irq(int enable, struct platform_device *pdev) { int ret; if (enable) { set_irq_type(host_wake_irq , IRQ_TYPE_EDGE_RISING); ret = request_irq(host_wake_irq , bt_host_wake_isr, 0, pdev->name, NULL); if (ret < 0) return ret; set_irq_wake(host_wake_irq, 1); } else { set_irq_wake(host_wake_irq, 0); free_irq(host_wake_irq, NULL); } return ret; }
static int __init msm_mpm_init(void) { unsigned int irq = MSM_MPM_IPC_IRQ; int rc; bitmap_set(msm_mpm_gic_irqs_mask, 0, NR_MSM_IRQS - 1); bitmap_set(msm_mpm_gpio_irqs_mask, NR_MSM_IRQS, MSM_MPM_NR_APPS_IRQS - 1); rc = request_irq(irq, msm_mpm_irq, IRQF_TRIGGER_RISING, "mpm_drv", msm_mpm_irq); if (rc) { pr_err("%s: failed to request irq %u: %d\n", __func__, irq, rc); goto init_bail; } rc = set_irq_wake(irq, 1); if (rc) { pr_err("%s: failed to set wakeup irq %u: %d\n", __func__, irq, rc); goto init_free_bail; } return 0; init_free_bail: free_irq(irq, msm_mpm_irq); init_bail: return rc; }
static int bcm_bt_lpm_probe(struct platform_device *pdev) { int irq; int ret; struct bcm_bt_lpm_platform_data *pdata = pdev->dev.platform_data; if (bt_lpm.request_clock_off_locked != NULL) { printk(KERN_ERR "Cannot register two bcm_bt_lpm drivers\n"); return -EINVAL; } bt_lpm.gpio_wake = pdata->gpio_wake; bt_lpm.gpio_host_wake = pdata->gpio_host_wake; bt_lpm.request_clock_off_locked = pdata->request_clock_off_locked; bt_lpm.request_clock_on_locked = pdata->request_clock_on_locked; hrtimer_init(&bt_lpm.enter_lpm_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); bt_lpm.enter_lpm_delay = ktime_set(1, 0); /* 1 sec */ bt_lpm.enter_lpm_timer.function = enter_lpm; gpio_set_value(bt_lpm.gpio_wake, 0); bt_lpm.host_wake = 0; irq = gpio_to_irq(bt_lpm.gpio_host_wake); ret = request_irq(irq, host_wake_isr, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "bt host_wake", NULL); if (ret) return ret; ret = set_irq_wake(irq, 1); if (ret) return ret; return 0; }
static uint32_t msm_sdcc_setup_power(struct device *dv, unsigned int vdd) { int rc = 0; struct platform_device *pdev; static int first_setup = 1; pdev = container_of(dv, struct platform_device, dev); rc = msm_sdcc_setup_gpio(pdev->id, !!vdd); if (rc) goto out; rc = msm_sdcc_setup_vreg(pdev->id, !!vdd); /* if first called related to sdcc1, * irq should be registered as wakeup source * [email protected], 2010-02-19 */ if (vdd && first_setup) { struct mmc_platform_data *pdata = pdev->dev.platform_data; if (pdev->id == 1) { first_setup = 0; set_irq_wake(pdata->status_irq, 1); } } out: return rc; }
/********************************************************** ** Function: Jack detection-in gpio configuration function ** Parameter: none ** Return value: if sucess, then returns 0 ** ************************************************************/ static int jack_config_gpio() { int ret; printk("HEADSET: Config Jack-in detection gpio\n"); tegra_gpio_enable(JACK_GPIO); ret = gpio_request(JACK_GPIO, "h2w_detect"); ret = gpio_direction_input(JACK_GPIO); hs_data->irq = gpio_to_irq(JACK_GPIO); ret = request_irq(hs_data->irq, detect_irq_handler, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "h2w_detect", NULL); ret = set_irq_wake(hs_data->irq, 1); if (gpio_get_value(JACK_GPIO) == 0){ jack_alive = true; insert_headset(); }else { jack_alive = false; remove_headset(); } return 0; }
/** * Stops the Sleep-Mode Protocol on the Host. */ static void dhd_disable_hwakeup(void) { if (set_irq_wake(dhd_wifi_sleep->host_wake_irq, 0)) DHD_ERROR(("Couldn't disable hostwake IRQ wakeup mode\n")); }
static int mpr084_driver_register(struct mpr084_data *data) { struct input_dev *idev; int ret = 0; if (data->kpirq) { ret = request_irq(data->kpirq, mpr084_keypadirq, IRQF_TRIGGER_FALLING, DRIVER_NAME, data); if (!ret) { init_completion(&data->kpirq_completion); set_irq_wake(data->kpirq, 1); } else { printk(KERN_ERR "%s: cannot grab irq %d\n", __func__, data->kpirq); } } idev = input_allocate_device(); data->idev = idev; input_set_drvdata(idev, data); idev->name = DRIVER_NAME; idev->open = mpr084_idev_open; idev->close = mpr084_idev_close; if (!ret) ret = input_register_device(idev); return ret; }
void hPlatform_freeInterrupt(void *tnet_drv) { TWlanDrvIfObj *drv = tnet_drv; set_irq_wake(drv->irq, 0); free_irq(drv->irq, drv); gpio_free(WLAN_EN); }
static int adp5587_remove(struct i2c_client *client) { struct adp5587_data *client_data = i2c_get_clientdata(client); set_irq_wake(client->irq, 0); free_irq(client->irq, client_data); input_unregister_device(client_data->input_dev); kfree(client_data); return 0; }
static int gpio_keypad_request_irqs(struct gpio_kp *kp) { int i; int err; unsigned int irq; unsigned long request_flags; struct gpio_event_matrix_info *mi = kp->keypad_info; switch (mi->flags & (GPIOKPF_ACTIVE_HIGH|GPIOKPF_LEVEL_TRIGGERED_IRQ)) { default: request_flags = IRQF_TRIGGER_FALLING; break; case GPIOKPF_ACTIVE_HIGH: request_flags = IRQF_TRIGGER_RISING; break; case GPIOKPF_LEVEL_TRIGGERED_IRQ: request_flags = IRQF_TRIGGER_LOW; break; case GPIOKPF_LEVEL_TRIGGERED_IRQ | GPIOKPF_ACTIVE_HIGH: request_flags = IRQF_TRIGGER_HIGH; break; } for (i = 0; i < mi->ninputs; i++) { err = irq = gpio_to_irq(mi->input_gpios[i]); if (err < 0) goto err_gpio_get_irq_num_failed; err = request_irq(irq, gpio_keypad_irq_handler, request_flags, "gpio_kp", kp); if (err) { pr_err("gpiomatrix: request_irq failed for input %d, " "irq %d\n", mi->input_gpios[i], irq); goto err_request_irq_failed; } #ifndef CONFIG_ZTE_PLATFORM err = set_irq_wake(irq, 1); if (err) { pr_err("gpiomatrix: set_irq_wake failed for input %d, " "irq %d\n", mi->input_gpios[i], irq); } #endif disable_irq(irq); if (kp->disabled_irq) { kp->disabled_irq = 0; enable_irq(irq); } } return 0; for (i = mi->noutputs - 1; i >= 0; i--) { free_irq(gpio_to_irq(mi->input_gpios[i]), kp); err_request_irq_failed: err_gpio_get_irq_num_failed: ; } return err; }
static int gpio_keypad_request_irqs(struct gpio_kp *kp) { int i; int err; unsigned int irq; unsigned long request_flags; struct gpio_event_matrix_info *mi = kp->keypad_info; unsigned long flags; switch (mi->flags & (GPIOKPF_ACTIVE_HIGH|GPIOKPF_LEVEL_TRIGGERED_IRQ)) { default: request_flags = IRQF_TRIGGER_FALLING; break; case GPIOKPF_ACTIVE_HIGH: request_flags = IRQF_TRIGGER_RISING; break; case GPIOKPF_LEVEL_TRIGGERED_IRQ: request_flags = IRQF_TRIGGER_LOW; break; case GPIOKPF_LEVEL_TRIGGERED_IRQ | GPIOKPF_ACTIVE_HIGH: request_flags = IRQF_TRIGGER_HIGH; break; } start_to_setup_irq = 1; for (i = 0; i < mi->ninputs; i++) { err = irq = gpio_to_irq(mi->input_gpios[i]); if (err < 0) goto err_gpio_get_irq_num_failed; irq_disable = 0; err = request_irq(irq, gpio_keypad_irq_handler, request_flags, "gpio_kp", kp); if (err) { pr_err("gpiomatrix: request_irq failed for input %d, " "irq %d\n", mi->input_gpios[i], irq); goto err_request_irq_failed; } err = set_irq_wake(irq, 1); if (err) { pr_err("gpiomatrix: set_irq_wake failed for input %d, " "irq %d\n", mi->input_gpios[i], irq); } spin_lock_irqsave(&gpio_keypad_lock,flags); if(irq_disable == 0) disable_irq(irq); spin_unlock_irqrestore(&gpio_keypad_lock,flags); } start_to_setup_irq = 0; return 0; for (i = mi->ninputs - 1; i >= 0; i--) { free_irq(gpio_to_irq(mi->input_gpios[i]), kp); err_request_irq_failed: err_gpio_get_irq_num_failed: ; } return err; }
void bcmsdh_unregister_oob_intr(void) { SDLX_MSG(("%s: Enter\n", __func__)); set_irq_wake(sdhcinfo->oob_irq, 0); disable_irq(sdhcinfo->oob_irq); /* just in case.. */ free_irq(sdhcinfo->oob_irq, NULL); sdhcinfo->oob_irq_registered = false; }
/***************************************************************************************** * * function : gp2a_on * description : This function is power-on function for optical sensor. * * int type : Sensor type. Two values is available (PROXIMITY,LIGHT). * it support power-on function separately. * * */ int gp2a_on(struct gp2a_data *gp2a, int type) { u8 value; int err = 0; #ifdef LIGHT_SENSOR_ENABLED ktime_t light_polling_time; #endif gprintk("gp2a_on(%d)\n",type); gprintk("gp2a power on voltage up \n"); if(type == PROXIMITY) { gprintk("[PROXIMITY] go nomal mode : power on \n"); // ASD : Select switch for analog sleep function ( 0:ineffective, 1:effective ) // OCON[1:0] : Select switches for enabling/disabling VOUT terminal // ( 00:enable, 11:force to go High, 10:forcr to go Low ) value = 0x18; // 11:force to go High err = opt_i2c_write((u8)(REGS_CON),&value); if(err < 0) return err; #if defined(CONFIG_MACH_RANT3) value = 0x2F; // HYSD enable #else value = 0x40; // HYSD enable #endif err = opt_i2c_write((u8)(REGS_HYS),&value); if(err < 0) return err; // VCON : VOUT terminal output method control ( 0:normal mode, 1:interrupt mode ) // SSD : Software shutdown function ( 0:shutdown mode, 1:opteration mode ) value = 0x03; // VCON enable, SSD enable err = opt_i2c_write((u8)(REGS_OPMOD),&value); if(err < 0) return err; #if USE_INTERRUPT gprintk("enable irq for proximity\n"); enable_irq(gp2a ->irq); #if !defined(CONFIG_MACH_RANT3) set_irq_wake(gp2a->irq, 1); #endif #endif // OCON[1:0] : Select switches for enabling/disabling VOUT terminal // ( 00:enable, 11:force to go High, 10:forcr to go Low ) value = 0x00; // 00:enable err = opt_i2c_write((u8)(REGS_CON),&value); } #ifdef LIGHT_SENSOR_ENABLED if(type == LIGHT) { gprintk(KERN_INFO "[LIGHT_SENSOR] timer start for light sensor\n"); //hrtimer_start(&gp2a->timer,ktime_set(light_init_period/2,0),HRTIMER_MODE_REL); hrtimer_start(&gp2a->timer,ktime_set(0,500000000),HRTIMER_MODE_REL); light_enable = ON; } #endif return err; }
int __init x3proto_gpio_setup(void) { int ilsel; int ret, i; ilsel = ilsel_enable(ILSEL_KEY); if (unlikely(ilsel < 0)) return ilsel; ret = gpiochip_add(&x3proto_gpio_chip); if (unlikely(ret)) goto err_gpio; for (i = 0; i < NR_BASEBOARD_GPIOS; i++) { unsigned long flags; int irq = create_irq(); if (unlikely(irq < 0)) { ret = -EINVAL; goto err_irq; } spin_lock_irqsave(&x3proto_gpio_lock, flags); x3proto_gpio_irq_map[i] = irq; set_irq_chip_and_handler_name(irq, &dummy_irq_chip, handle_simple_irq, "gpio"); spin_unlock_irqrestore(&x3proto_gpio_lock, flags); } pr_info("registering '%s' support, handling GPIOs %u -> %u, " "bound to IRQ %u\n", x3proto_gpio_chip.label, x3proto_gpio_chip.base, x3proto_gpio_chip.base + x3proto_gpio_chip.ngpio, ilsel); set_irq_chained_handler(ilsel, x3proto_gpio_irq_handler); set_irq_wake(ilsel, 1); return 0; err_irq: for (; i >= 0; --i) if (x3proto_gpio_irq_map[i]) destroy_irq(x3proto_gpio_irq_map[i]); ret = gpiochip_remove(&x3proto_gpio_chip); if (unlikely(ret)) pr_err("Failed deregistering GPIO\n"); err_gpio: synchronize_irq(ilsel); ilsel_disable(ILSEL_KEY); return ret; }
static void keypad_volumnkey_wake_ctrl(void) { int err; if( sleep_volumnkey_awake == OFF) { if( sleep_volumnkey_awake_state == ON ) { err = set_irq_wake(gpio_to_irq(VOLUMN_UP_KEYSENSE), OFF); if (err) { pr_err("volumnkey_wake: set_irq_wake failed for input %d, " "err %d\n", VOLUMN_UP_KEYSENSE, err); } err = set_irq_wake(gpio_to_irq(VOLUMN_DN_KEYSENSE), OFF); if (err) { pr_err("volumnkey_wake: set_irq_wake failed for input %d, " "err %d\n", VOLUMN_UP_KEYSENSE, err); } sleep_volumnkey_awake_state = OFF; } } else { if( sleep_volumnkey_awake_state == OFF ) { err = set_irq_wake(gpio_to_irq(VOLUMN_UP_KEYSENSE), ON); if (err) { pr_err("volumnkey_wake: set_irq_wake failed for input %d, " "err %d\n", VOLUMN_UP_KEYSENSE, err); } err = set_irq_wake(gpio_to_irq(VOLUMN_DN_KEYSENSE), ON); if (err) { pr_err("volumnkey_wake: set_irq_wake failed for input %d, " "err %d\n", VOLUMN_UP_KEYSENSE, err); } sleep_volumnkey_awake_state = ON; } } }
void hPlatform_freeInterrupt( void *tnet_drv ) { TWlanDrvIfObj *drv = tnet_drv; if (drv->irq == 0) return; set_irq_wake(drv->irq, 0); free_irq(drv->irq, drv); }
static void insert_headset(void) { unsigned long irq_flags; int jpole; H2W_DBG(""); #ifdef CONFIG_LGE_AUDIO_HEADSET_PROTECT gpio_set_value(hi->gpio_mic_bias_en, 1); msleep(100); #endif jpole = gpio_get_value(hi->gpio_jpole); if(jpole) // 3pole { hi->ignore_btn = 1; H2W_DBG("insert_headset_no-mic-headset \n"); switch_set_state(&hi->sdev, LGE_NO_MIC_HEADSET); //kiwone, 2009.12.24 , to fix bug //no mic headset insert->no mic headset eject->4pole headset insert->button key do not work. /* Enable button irq */ local_irq_save(irq_flags); enable_irq(hi->irq_btn); set_irq_wake(hi->irq_btn, 1); local_irq_restore(irq_flags); hi->debounce_time = ktime_set(0, 20000000); /* 20 ms */ hi->unplug_debounce_time = ktime_set(0, 100000000); // add eklee gpio_set_value(hi->gpio_mic_bias_en, 0); } else { // 4pole hi->ignore_btn =0; H2W_DBG("insert_headset_headset \n"); switch_set_state(&hi->sdev, LGE_HEADSET); /* Enable button irq */ local_irq_save(irq_flags); enable_irq(hi->irq_btn); set_irq_wake(hi->irq_btn, 1); local_irq_restore(irq_flags); hi->debounce_time = ktime_set(0, 20000000); /* 20 ms */ hi->unplug_debounce_time = ktime_set(0, 100000000); // add eklee } }
int __init vision_init_mmc(unsigned int sys_rev) { uint32_t id; wifi_status_cb = NULL; /*sdslot_vreg_enabled = 0;*/ printk(KERN_INFO "vision: %s\n", __func__); /* SDC2: MoviNAND */ /* register_msm_irq_mask(INT_SDC2_0); register_msm_irq_mask(INT_SDC2_1); */ config_gpio_table(movinand_on_gpio_table, ARRAY_SIZE(movinand_on_gpio_table)); #if 0 msm_add_sdcc(2, &vision_movinand_data, 0, 0); #endif /* initial WIFI_SHUTDOWN# */ id = PCOM_GPIO_CFG(VISION_GPIO_WIFI_SHUTDOWN_N, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA), msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &id, 0); gpio_set_value(VISION_GPIO_WIFI_SHUTDOWN_N, 0); msm_add_sdcc(3, &vision_wifi_data); #if 0 register_msm_irq_mask(INT_SDC4_0); register_msm_irq_mask(INT_SDC4_1); #endif #if 0 if (opt_disable_sdcard) { printk(KERN_INFO "vision: SD-Card interface disabled\n"); goto done; } vreg_sdslot = vreg_get(0, "gp10"); if (IS_ERR(vreg_sdslot)) return PTR_ERR(vreg_sdslot); set_irq_wake(MSM_GPIO_TO_INT(VISION_SDMC_CD_N_TO_SYS), 1); msm_add_sdcc(4, &vision_sdslot_data, MSM_GPIO_TO_INT(VISION_SDMC_CD_N_TO_SYS), IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE); done: #endif /* reset eMMC for write protection test */ gpio_set_value(VISION_GPIO_EMMC_RST, 0); /* this should not work!!! */ udelay(100); gpio_set_value(VISION_GPIO_EMMC_RST, 1); return 0; }
int __init mahimahi_init_mmc(unsigned int sys_rev, unsigned debug_uart) { uint32_t id; printk("%s()+\n", __func__); /* initial WIFI_SHUTDOWN# */ id = PCOM_GPIO_CFG(MAHIMAHI_GPIO_WIFI_SHUTDOWN_N, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA), msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &id, 0); msm_add_sdcc(1, &mahimahi_wifi_data, 0, 0); if (debug_uart) { pr_info("%s: sdcard disabled due to debug uart\n", __func__); goto done; } if (opt_disable_sdcard) { pr_info("%s: sdcard disabled on cmdline\n", __func__); goto done; } sdslot_vreg_enabled = 0; if (is_cdma_version(sys_rev)) { /* In the CDMA version, sdslot is supplied by a gpio. */ int rc = gpio_request(MAHIMAHI_CDMA_SD_2V85_EN, "sdslot_en"); if (rc < 0) { pr_err("%s: gpio_request(%d) failed: %d\n", __func__, MAHIMAHI_CDMA_SD_2V85_EN, rc); return rc; } mahimahi_sdslot_data.translate_vdd = mahimahi_cdma_sdslot_switchvdd; } else { /* in UMTS version, sdslot is supplied by pmic */ sdslot_vreg = vreg_get(0, "gp6"); if (IS_ERR(sdslot_vreg)) return PTR_ERR(sdslot_vreg); } if (system_rev > 0) msm_add_sdcc(2, &mahimahi_sdslot_data, 0, 0); else { mahimahi_sdslot_data.status = mahimahi_sdslot_status_rev0; mahimahi_sdslot_data.register_status_notify = NULL; set_irq_wake(MSM_GPIO_TO_INT(MAHIMAHI_GPIO_SDMC_CD_REV0_N), 1); msm_add_sdcc(2, &mahimahi_sdslot_data, MSM_GPIO_TO_INT(MAHIMAHI_GPIO_SDMC_CD_REV0_N), IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE); } done: printk("%s()-\n", __func__); return 0; }
static void bma250_release(struct input_dev *dev) { int rc; struct driver_data *dd = input_get_drvdata(dev); rc = set_irq_wake(dd->ic_dev->irq, 0); if (rc) dev_err(&dd->ic_dev->dev, "%s: set_irq_wake failed with error %d\n", __func__, rc); free_irq(dd->ic_dev->irq, &dd->ic_dev->dev); }
int __init bravo_init_mmc(unsigned int sys_rev) { uint32_t id; struct cnf_driver *microp_sdcard_detect; wifi_status_cb = NULL; printk(KERN_INFO "%s()+\n", __func__); /* initial WIFI_SHUTDOWN# */ id = PCOM_GPIO_CFG(127, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA), msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &id, 0); gpio_set_value(127, 0); msm_add_sdcc(1, &bravo_wifi_data, 0, 0); if (opt_disable_sdcard) { pr_info("%s: sdcard disabled on cmdline\n", __func__); goto done; } sdslot_vreg_enabled = 0; sdslot_vreg = vreg_get(0, "gp6"); if (IS_ERR(sdslot_vreg)) return PTR_ERR(sdslot_vreg); if (bravo_sd_gpio()) { set_irq_wake(MSM_GPIO_TO_INT(BRAVO_GPIO_SDMC_CD_N), 1); msm_add_sdcc(2, &bravo_sdslot_data, MSM_GPIO_TO_INT(BRAVO_GPIO_SDMC_CD_N), IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE); } else { microp_sdcard_detect = kzalloc(sizeof(struct cnf_driver), GFP_KERNEL); if (microp_sdcard_detect) { microp_sdcard_detect->name = "sdcard_detect"; microp_sdcard_detect->func = (void *) µp_check_status; } else { printk(KERN_ERR "%s: Alloc SD callback func error\n", __func__); goto done; } cnf_driver_register(microp_sdcard_detect); msm_add_sdcc(2, &bravo_sdslot_data, 0, 0); } done: printk(KERN_INFO "%s()-\n", __func__); return 0; }
void check_hook_key_state_work_func(struct work_struct *work) { int hook_key_status = 0; int rc = 0; unsigned long irq_flags; HEADSET_DBG(""); if ( HSD_HEADSET != g_headset_type ) { HEADSET_INFO("Headset remove!! or may ear phone noise !!"); return; } hook_key_status = gpio_get_value(headset_data.hook_gpio); if ( 1 == hook_key_status ) { button_pressed(); atomic_set(&headset_data.is_button_press, 1); rc = set_irq_type(headset_data.hook_irq, IRQF_TRIGGER_LOW); if (rc) HEADSET_ERR( "change hook key detection type as low fail!!"); } else { if ( 1 == atomic_read(&headset_data.is_button_press)) { button_released(); atomic_set(&headset_data.is_button_press, 0); rc = set_irq_type(headset_data.hook_irq, IRQF_TRIGGER_HIGH); HEADSET_DBG("Hook Key release change hook key detection type as high"); if (rc) HEADSET_ERR("change hook key detection type as high fail!!"); } } if ( HSD_IRQ_DISABLE == headset_data.hook_irq_status) { local_irq_save(irq_flags); enable_irq(headset_data.hook_irq); headset_data.hook_irq_status = HSD_IRQ_ENABLE; set_irq_wake(headset_data.hook_irq, 1); local_irq_restore(irq_flags); } }
static int __init msm_init_gpio(void) { int i; for (i = NR_MSM_IRQS; i < NR_MSM_IRQS + NR_GPIO_IRQS; i++) { set_irq_chip(i, &msm_gpio_irq_chip); set_irq_handler(i, handle_edge_irq); set_irq_flags(i, IRQF_VALID); } for (i = 0; i < ARRAY_SIZE(msm_gpio_chips); i++) { writel(0, msm_gpio_chips[i].regs.int_en); register_gpio_chip(&msm_gpio_chips[i].chip); } set_irq_chained_handler(INT_GPIO_GROUP1, msm_gpio_irq_handler); set_irq_chained_handler(INT_GPIO_GROUP2, msm_gpio_irq_handler); set_irq_wake(INT_GPIO_GROUP1, 1); set_irq_wake(INT_GPIO_GROUP2, 2); return 0; }
struct pm_irq_chip * pm8xxx_irq_init(struct device *dev, const struct pm8xxx_irq_platform_data *pdata) { struct pm_irq_chip *chip; int devirq, rc; unsigned int pmirq; if (!pdata) { pr_err("No platform data\n"); return ERR_PTR(-EINVAL); } devirq = pdata->devirq; if (devirq < 0) { pr_err("missing devirq\n"); rc = devirq; return ERR_PTR(-EINVAL); } chip = kzalloc(sizeof(struct pm_irq_chip) + sizeof(u8) * pdata->irq_cdata.nirqs, GFP_KERNEL); if (!chip) { pr_err("Cannot alloc pm_irq_chip struct\n"); return ERR_PTR(-EINVAL); } chip->dev = dev; chip->devirq = devirq; chip->irq_base = pdata->irq_base; chip->num_irqs = pdata->irq_cdata.nirqs; chip->num_blocks = DIV_ROUND_UP(chip->num_irqs, 8); chip->num_masters = DIV_ROUND_UP(chip->num_blocks, 8); spin_lock_init(&chip->pm_irq_lock); for (pmirq = 0; pmirq < chip->num_irqs; pmirq++) { irq_set_chip_and_handler(chip->irq_base + pmirq, &pm8xxx_irq_chip, handle_level_irq); irq_set_chip_data(chip->irq_base + pmirq, chip); #ifdef CONFIG_ARM set_irq_flags(chip->irq_base + pmirq, IRQF_VALID); #else irq_set_noprobe(chip->irq_base + pmirq); #endif } irq_set_irq_type(devirq, pdata->irq_trigger_flag); irq_set_handler_data(devirq, chip); irq_set_chained_handler(devirq, pm8xxx_irq_handler); set_irq_wake(devirq, 1); return chip; }