int gpio_event_matrix_func(struct gpio_event_input_devs *input_devs, struct gpio_event_info *info, void **data, int func) { int i; int err; int key_count; int phone_call_status; int fm_radio_status; int irq; static int irq_status = 1; struct gpio_kp *kp; struct gpio_event_matrix_info *mi; mi = container_of(info, struct gpio_event_matrix_info, info); if (func == GPIO_EVENT_FUNC_SUSPEND || func == GPIO_EVENT_FUNC_RESUME) { /* TODO: disable scanning */ if (mi->detect_phone_status == 0) { if (func == GPIO_EVENT_FUNC_SUSPEND) irq_status = 0; else irq_status = 1; } else { phone_call_status = gpio_event_get_phone_call_status() & 0x01; fm_radio_status = gpio_event_get_fm_radio_status() & 0x01; KEY_LOGI("%s: mi->ninputs: %d, func&0x01 = %d, phone_call_status=%d, fm_radio_status=%d\n", __func__, mi->ninputs, func & 0x01, phone_call_status, fm_radio_status); if (irq_status != ((func & 0x01) | phone_call_status | fm_radio_status)) { irq_status = ((func & 0x01) | phone_call_status | fm_radio_status); KEY_LOGI("%s: irq_status %d \n", __func__, irq_status); } else { KEY_LOGI("%s: irq_status %d, did not change\n", __func__, irq_status); return 0; } } for (i = 0; i < mi->ninputs; i++) { irq = gpio_to_irq(mi->input_gpios[i]); err = set_irq_wake(irq, irq_status); if (err) KEY_LOGE("gpiomatrix: set_irq_wake failed ,irq_status %d ,for input irq %d,%d\n", irq_status, i, irq); else KEY_LOGD("%s: set ok,irq_status %d, irq %d = %d\n", __func__, irq_status, i, irq); } return 0; } if (func == GPIO_EVENT_FUNC_INIT) { if (mi->keymap == NULL || mi->input_gpios == NULL || mi->output_gpios == NULL) { err = -ENODEV; KEY_LOGE("gpiomatrix: Incomplete pdata\n"); goto err_invalid_platform_data; } key_count = mi->ninputs * mi->noutputs; *data = kp = kzalloc(sizeof(*kp) + sizeof(kp->keys_pressed[0]) * BITS_TO_LONGS(key_count), GFP_KERNEL); if (kp == NULL) { err = -ENOMEM; KEY_LOGE("gpiomatrix: Failed to allocate private data\n"); goto err_kp_alloc_failed; } kp->input_devs = input_devs; kp->keypad_info = mi; for (i = 0; i < key_count; i++) { unsigned short keyentry = mi->keymap[i]; unsigned short keycode = keyentry & MATRIX_KEY_MASK; unsigned short dev = keyentry >> MATRIX_CODE_BITS; if (dev >= input_devs->count) { KEY_LOGE("gpiomatrix: bad device index %d >= " "%d for key code %d\n", dev, input_devs->count, keycode); err = -EINVAL; goto err_bad_keymap; } if (keycode && keycode <= KEY_MAX) input_set_capability(input_devs->dev[dev], EV_KEY, keycode); } #ifndef CONFIG_ARCH_MSM8X60 if (mi->setup_ninputs_gpio) mi->setup_ninputs_gpio(); #else if (mi->setup_matrix_gpio) mi->setup_matrix_gpio(); #endif for (i = 0; i < mi->noutputs; i++) { err = gpio_request(mi->output_gpios[i], "gpio_kp_out"); if (err) { KEY_LOGE("gpiomatrix: gpio_request failed for " "output %d\n", mi->output_gpios[i]); goto err_request_output_gpio_failed; } if (gpio_cansleep(mi->output_gpios[i])) { KEY_LOGE("gpiomatrix: unsupported output gpio %d," " can sleep\n", mi->output_gpios[i]); err = -EINVAL; goto err_output_gpio_configure_failed; } if (mi->flags & GPIOKPF_DRIVE_INACTIVE) err = gpio_direction_output(mi->output_gpios[i], !(mi->flags & GPIOKPF_ACTIVE_HIGH)); else err = gpio_direction_input(mi->output_gpios[i]); if (err) { KEY_LOGE("gpiomatrix: gpio_configure failed for " "output %d\n", mi->output_gpios[i]); goto err_output_gpio_configure_failed; } } for (i = 0; i < mi->ninputs; i++) { err = gpio_request(mi->input_gpios[i], "gpio_kp_in"); if (err) { KEY_LOGE("gpiomatrix: gpio_request failed for " "input %d\n", mi->input_gpios[i]); goto err_request_input_gpio_failed; } err = gpio_direction_input(mi->input_gpios[i]); if (err) { KEY_LOGE("gpiomatrix: gpio_direction_input failed" " for input %d\n", mi->input_gpios[i]); goto err_gpio_direction_input_failed; } } kp->current_output = mi->noutputs; kp->key_state_changed = 1; #ifndef CONFIG_ARCH_MSM8X60 hrtimer_init(&kp->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); kp->timer.function = gpio_keypad_timer_func; #else km_queue = create_singlethread_workqueue("km_queue"); INIT_WORK(&kp->work, gpio_keypad_timer_func); #endif wake_lock_init(&kp->wake_lock, WAKE_LOCK_SUSPEND, "gpio_kp"); err = gpio_keypad_request_irqs(kp); kp->use_irq = err == 0; #ifndef CONFIG_ARCH_MSM8X60 kp_use_irq = kp->use_irq; #endif KEY_LOGI("GPIO Matrix Keypad Driver: Start keypad matrix for " "%s%s in %s mode\n", input_devs->dev[0]->name, (input_devs->count > 1) ? "..." : "", kp->use_irq ? "interrupt" : "polling"); if (kp->use_irq) wake_lock(&kp->wake_lock); #ifndef CONFIG_ARCH_MSM8X60 hrtimer_start(&kp->timer, ktime_set(0, 0), HRTIMER_MODE_REL); #else queue_work(km_queue, &kp->work); #endif return 0; } err = 0; kp = *data; if (kp->use_irq) for (i = mi->noutputs - 1; i >= 0; i--) free_irq(gpio_to_irq(mi->input_gpios[i]), kp); #ifndef CONFIG_ARCH_MSM8X60 hrtimer_cancel(&kp->timer); #else cancel_work_sync(&kp->work); #endif wake_lock_destroy(&kp->wake_lock); for (i = mi->noutputs - 1; i >= 0; i--) { err_gpio_direction_input_failed: gpio_free(mi->input_gpios[i]); err_request_input_gpio_failed: ; } for (i = mi->noutputs - 1; i >= 0; i--) { err_output_gpio_configure_failed: gpio_free(mi->output_gpios[i]); err_request_output_gpio_failed: ; } err_bad_keymap: kfree(kp); err_kp_alloc_failed: err_invalid_platform_data: return err; }
static int __devinit hym8563_probe(struct i2c_client *client, const struct i2c_device_id *id) { int rc = 0; u8 reg = 0; struct hym8563 *hym8563; struct rtc_device *rtc = NULL; struct rtc_time tm_read, tm = { .tm_wday = 6, .tm_year = 111, .tm_mon = 0, .tm_mday = 1, .tm_hour = 12, .tm_min = 0, .tm_sec = 0, }; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) return -ENODEV; hym8563 = kzalloc(sizeof(struct hym8563), GFP_KERNEL); if (!hym8563) { return -ENOMEM; } gClient = client; hym8563->client = client; hym8563->alarm.enabled = 0; mutex_init(&hym8563->mutex); wake_lock_init(&hym8563->wake_lock, WAKE_LOCK_SUSPEND, "rtc_hym8563"); i2c_set_clientdata(client, hym8563); hym8563_init_device(client); hym8563_enable_count(client, 0); // check power down hym8563_i2c_read_regs(client,RTC_SEC,®,1); if (reg&0x80) { dev_info(&client->dev, "clock/calendar information is no longer guaranteed\n"); hym8563_set_time(client, &tm); } hym8563_read_datetime(client, &tm_read); //read time from hym8563 if(((tm_read.tm_year < 70) | (tm_read.tm_year > 137 )) | (tm_read.tm_mon == -1) | (rtc_valid_tm(&tm_read) != 0)) //if the hym8563 haven't initialized { hym8563_set_time(client, &tm); //initialize the hym8563 } if(gpio_request(client->irq, "rtc gpio")) { dev_err(&client->dev, "gpio request fail\n"); gpio_free(client->irq); goto exit; } hym8563->irq = gpio_to_irq(client->irq); gpio_pull_updown(client->irq,GPIOPullUp); if (request_threaded_irq(hym8563->irq, NULL, hym8563_wakeup_irq, IRQF_TRIGGER_LOW | IRQF_ONESHOT, client->dev.driver->name, hym8563) < 0) { printk("unable to request rtc irq\n"); goto exit; } enable_irq_wake(hym8563->irq); rtc = rtc_device_register(client->name, &client->dev, &hym8563_rtc_ops, THIS_MODULE); if (IS_ERR(rtc)) { rc = PTR_ERR(rtc); rtc = NULL; goto exit; } hym8563->rtc = rtc; return 0; exit: if (rtc) rtc_device_unregister(rtc); if (hym8563) { wake_lock_destroy(&hym8563->wake_lock); kfree(hym8563); } return rc; } static int __devexit hym8563_remove(struct i2c_client *client) { struct hym8563 *hym8563 = i2c_get_clientdata(client); if (hym8563->irq > 0) { mutex_lock(&hym8563->mutex); hym8563->exiting = 1; mutex_unlock(&hym8563->mutex); free_irq(hym8563->irq, hym8563); cancel_work_sync(&hym8563->work); } rtc_device_unregister(hym8563->rtc); wake_lock_destroy(&hym8563->wake_lock); kfree(hym8563); hym8563 = NULL; return 0; } void hym8563_shutdown(struct i2c_client * client) { u8 regs[2]; int ret; //disable clkout regs[0] = 0x00; ret=hym8563_i2c_set_regs(client, RTC_CLKOUT, regs, 1); if(ret<0) printk("rtc shutdown is error\n"); }
static int __devinit max14656_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct device_node *dev_node = client->dev.of_node; struct max14656_chip *chip; int ret = 0; int rc = 0; pr_err("%s:\n", __func__); chip = kzalloc(sizeof(*chip), GFP_KERNEL); if (!chip) return -ENOMEM; /* chip->batt_psy = power_supply_get_by_name("battery"); if (!chip->batt_psy) { pr_err("%s : batt_psy is not yet ready\n", __func__); ret = -EPROBE_DEFER; goto error; } */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { pr_err("%s : i2c_check_functionality fail\n", __func__); return -EIO; } chip->client = client; /* need dts parser */ if (dev_node) { ret = max14656_parse_dt(dev_node, chip); if (ret) { pr_err("failed to parse dt\n"); goto error; } } #ifdef CONFIG_LGE_PM chip->chg_detect_done = 0; chip->chg_type = 0; chip->dcd_timeout = 0; #endif ret = gpio_request_one(chip->int_gpio, GPIOF_DIR_IN, "max14656_int"); if (ret) { pr_err("failed to request int_gpio\n"); goto error; } chip->irq = gpio_to_irq(chip->int_gpio); pr_debug("int_gpio irq#=%d.\n", chip->irq); i2c_set_clientdata(client, NULL); ret = max14656_hw_init(chip); if (ret) { pr_err("max14656_hwinit failed.ret=%d\n", ret); goto err_hw_init; } INIT_DELAYED_WORK(&chip->irq_work, max14656_irq_worker); if (chip->irq) { ret = request_irq(chip->irq, max14656_irq, IRQF_TRIGGER_FALLING, "max14656_irq", chip); if (ret) { pr_err("request_irq %d failed\n", chip->irq); goto err_req_irq; } enable_irq_wake(chip->irq); } schedule_delayed_work(&chip->irq_work, msecs_to_jiffies(2000)); #ifdef CONFIG_LGE_PM chip->detect_psy = max14656_ps; rc = power_supply_register(&chip->client->dev, &chip->detect_psy); if (rc < 0) { pr_err("[2222]batt failed to register rc = %d\n", rc); } #endif pr_info("%s : Done\n", __func__); return 0; err_req_irq: err_hw_init: if (chip->int_gpio) gpio_free(chip->int_gpio); error: kfree(chip); chip = NULL; pr_info("fail to probe\n"); return ret; }
{ gpio_set_value(GPIO9_CHARGE_EN, (flags == PDA_POWER_CHARGE_USB)); } static struct pda_power_pdata power_pdata = { .is_ac_online = is_ac_connected, .is_usb_online = is_usb_connected, .set_charge = mioa701_set_charge, .supplied_to = supplicants, .num_supplicants = ARRAY_SIZE(supplicants), }; static struct resource power_resources[] = { [0] = { .name = "ac", .start = gpio_to_irq(GPIO96_AC_DETECT), .end = gpio_to_irq(GPIO96_AC_DETECT), .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE | IORESOURCE_IRQ_LOWEDGE, }, [1] = { .name = "usb", .start = gpio_to_irq(GPIO13_nUSB_DETECT), .end = gpio_to_irq(GPIO13_nUSB_DETECT), .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE | IORESOURCE_IRQ_LOWEDGE, }, }; static struct platform_device power_dev = { .name = "pda-power",
static void mci_exit(struct device *dev, void *data) { mio_gpio_free(ARRAY_AND_SIZE(mci_gpios)); free_irq(gpio_to_irq(GPIO15_SDIO_INSERT), data); }
static void marxbot_sdhc2_exit(struct device *dev, void *data) { free_irq(gpio_to_irq(SDHC2_CD), data); gpio_free(SDHC2_WP); gpio_free(SDHC2_CD); }
static int mx27ads_sdhc2_init(struct device *dev, irq_handler_t detect_irq, void *data) { return request_irq(gpio_to_irq(IMX_GPIO_NR(2, 7)), detect_irq, IRQF_TRIGGER_RISING, "sdhc2-card-detect", data); }
static void p54spi_power_off(struct p54s_priv *priv) { disable_irq(gpio_to_irq(p54spi_gpio_irq)); gpio_set_value(p54spi_gpio_power, 0); }
static int __devinit p54spi_probe(struct spi_device *spi) { struct p54s_priv *priv = NULL; struct ieee80211_hw *hw; int ret = -EINVAL; hw = p54_init_common(sizeof(*priv)); if (!hw) { dev_err(&spi->dev, "could not alloc ieee80211_hw"); return -ENOMEM; } priv = hw->priv; priv->hw = hw; dev_set_drvdata(&spi->dev, priv); priv->spi = spi; spi->bits_per_word = 16; spi->max_speed_hz = 24000000; ret = spi_setup(spi); if (ret < 0) { dev_err(&priv->spi->dev, "spi_setup failed"); goto err_free_common; } ret = gpio_request(p54spi_gpio_power, "p54spi power"); if (ret < 0) { dev_err(&priv->spi->dev, "power GPIO request failed: %d", ret); goto err_free_common; } ret = gpio_request(p54spi_gpio_irq, "p54spi irq"); if (ret < 0) { dev_err(&priv->spi->dev, "irq GPIO request failed: %d", ret); goto err_free_common; } gpio_direction_output(p54spi_gpio_power, 0); gpio_direction_input(p54spi_gpio_irq); ret = request_irq(gpio_to_irq(p54spi_gpio_irq), p54spi_interrupt, IRQF_DISABLED, "p54spi", priv->spi); if (ret < 0) { dev_err(&priv->spi->dev, "request_irq() failed"); goto err_free_common; } irq_set_irq_type(gpio_to_irq(p54spi_gpio_irq), IRQ_TYPE_EDGE_RISING); disable_irq(gpio_to_irq(p54spi_gpio_irq)); INIT_WORK(&priv->work, p54spi_work); init_completion(&priv->fw_comp); INIT_LIST_HEAD(&priv->tx_pending); mutex_init(&priv->mutex); SET_IEEE80211_DEV(hw, &spi->dev); priv->common.open = p54spi_op_start; priv->common.stop = p54spi_op_stop; priv->common.tx = p54spi_op_tx; ret = p54spi_request_firmware(hw); if (ret < 0) goto err_free_common; ret = p54spi_request_eeprom(hw); if (ret) goto err_free_common; ret = p54_register_common(hw, &priv->spi->dev); if (ret) goto err_free_common; return 0; err_free_common: p54_free_common(priv->hw); return ret; }
static int headsetdet_probe(struct platform_device *pdev) { struct gpio_switch_platform_data *pdata = pdev->dev.platform_data; struct headset_switch_data *switch_data; int ret = 0; struct input_dev *ip_dev; if (!pdata) return -EBUSY; switch_data = kzalloc(sizeof(struct headset_switch_data), GFP_KERNEL); if (!switch_data) return -ENOMEM; switch_data->sdev.name = pdata->name; switch_data->gpio = pdata->gpio; switch_data->name_on = pdata->name_on; switch_data->name_off = pdata->name_off; switch_data->state_on = pdata->state_on; switch_data->state_off = pdata->state_off; switch_data->sdev.print_state = switch_gpio_print_state; switch_data->hook_gpio = 163; #if defined(CONFIG_MACH_LGE_HUB_REV_A) // 20100814 , dmb ant detect [START_LGE] //nothing #else switch_data->dmb_ant_gpio = 164; switch_data->dmb_ant_detected = 0; #endif // 20100814 , dmb ant detect [END_LGE] ret = switch_dev_register(&switch_data->sdev); if (ret < 0) goto err_switch_dev_register; omap_mux_init_gpio(switch_data->gpio, OMAP_PIN_INPUT_PULLDOWN | OMAP_PIN_OFF_WAKEUPENABLE); //20101004 , ear sense wakable setting #if 1 //20101109 , hook key wakable setting omap_mux_init_gpio(switch_data->hook_gpio, OMAP_PIN_INPUT_PULLUP | OMAP_PIN_OFF_WAKEUPENABLE); #endif ret = gpio_request(switch_data->gpio, pdev->name); ret = gpio_request(switch_data->hook_gpio, pdev->name); #if defined(CONFIG_MACH_LGE_HUB_REV_A) // 20100814 , dmb ant detect [START_LGE] //nothing #else ret = gpio_request(switch_data->dmb_ant_gpio, pdev->name); #endif // 20100814 , dmb ant detect [END_LGE] if (ret < 0) goto err_request_gpio; ret = gpio_direction_input(switch_data->gpio); ret = gpio_direction_input(switch_data->hook_gpio); #if defined(CONFIG_MACH_LGE_HUB_REV_A) || defined(CONFIG_MACH_LGE_HUB_REV_B)// 20100814 , dmb ant detect [START_LGE] //nothing #else ret = gpio_direction_input(switch_data->dmb_ant_gpio); #endif // 20100814 , dmb ant detect [END_LGE] if (ret < 0) goto err_set_gpio_input; ip_dev = input_allocate_device(); switch_data->ip_dev = ip_dev; switch_data->ip_dev->name = "Hookkey"; //20100830, , define the input dev name set_bit(EV_SYN, switch_data->ip_dev->evbit); set_bit(EV_KEY, switch_data->ip_dev->evbit); set_bit(KEY_HOOK, switch_data->ip_dev->keybit); //for short pressed hook key ret = input_register_device(switch_data->ip_dev); INIT_WORK(&switch_data->work, headset_det_work); INIT_DELAYED_WORK(&switch_data->delayed_work, type_det_work); INIT_DELAYED_WORK(&switch_data->hook_delayed_work, hook_det_work); switch_data->irq = gpio_to_irq(switch_data->gpio); switch_data->hook_irq = gpio_to_irq(switch_data->hook_gpio); // 20100814 , dmb ant detect [START_LGE] #if defined(CONFIG_MACH_LGE_HUB_REV_A) //nothing #else switch_data->dmb_ant_irq = gpio_to_irq(switch_data->dmb_ant_gpio); // 20100814 , dmb ant gpio [START_LGE] #endif // 20100814 , dmb ant detect [END_LGE] if (switch_data->irq < 0) { ret = switch_data->irq; goto err_detect_irq_num_failed; } #if 1 //20101004 , ear sense wakable setting /* Make the interrupt on wake up OMAP which is in suspend mode */ ret = enable_irq_wake(switch_data->irq); if(ret < 0){ printk(KERN_INFO "[LUCKYJUN77] EAR SENSE 170 wake up source setting failed!\n"); disable_irq_wake(switch_data->irq); return -ENOSYS; } #endif #if 1 //20101109 , hook key wakable setting /* Make the interrupt on wake up OMAP which is in suspend mode */ ret = enable_irq_wake(switch_data->hook_irq); if(ret < 0){ printk(KERN_INFO "[LUCKYJUN77] Hook key 163 wake up source setting failed!\n"); disable_irq_wake(switch_data->hook_irq); return -ENOSYS; } #endif ret = request_irq(switch_data->irq, headset_int_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, pdev->name, switch_data); if (ret < 0) goto err_request_irq; ret = request_irq(switch_data->hook_irq, headset_hook_int_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "headset_hook", switch_data); if (ret < 0) goto err_request_irq; // 20100825 , mic bias LDO control test [START_LGE] #if 1 omap_mux_init_gpio(MIC_BIAS_LDO, OMAP_PIN_OUTPUT); ret = gpio_request(MIC_BIAS_LDO, pdev->name); if(ret < 0) { printk("can't get hub Mic bias LDO enable GPIO\n"); goto err_request_gpio; } #endif // 20100825 , mic bias LDO control test [END_LGE] // 20100814 , dmb ant detect [START_LGE] #if defined(CONFIG_MACH_LGE_HUB_REV_A) //nothing #else ret = request_irq(switch_data->dmb_ant_irq, dmb_ant_int_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "dmb_ant", switch_data); #endif // 20100814 , dmb ant detect [END_LGE] /* Perform initial detection */ headset_sw_data = switch_data; headset_sw_data->is_suspend = 0; //resume headset_det_work(&switch_data->work); // 20100603 , headset suspend/resume [START_LGE] #ifdef CONFIG_HAS_EARLYSUSPEND switch_data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 2; switch_data->early_suspend.suspend = headsetdet_early_suspend; switch_data->early_suspend.resume = headsetdet_late_resume; register_early_suspend(&switch_data->early_suspend); #endif // 20100603 , headset suspend/resume [END_LGE] return 0; err_request_irq: err_detect_irq_num_failed: err_set_gpio_input: gpio_free(switch_data->gpio); err_request_gpio: switch_dev_unregister(&switch_data->sdev); err_switch_dev_register: kfree(switch_data); return ret; }
/* GPIOD: input GPIOs, CF */ ASIC3_GPIOD11_nCIOIS16, ASIC3_GPIOD12_nCWAIT, ASIC3_GPIOD15_nPIOW, }; static struct resource asic3_resources[] = { /* GPIO part */ [0] = { .start = ASIC3_PHYS, .end = ASIC3_PHYS + ASIC3_MAP_SIZE_16BIT - 1, .flags = IORESOURCE_MEM, }, [1] = { .start = gpio_to_irq(GPIO12_HX4700_ASIC3_IRQ), .end = gpio_to_irq(GPIO12_HX4700_ASIC3_IRQ), .flags = IORESOURCE_IRQ, }, /* SD part */ [2] = { .start = ASIC3_SD_PHYS, .end = ASIC3_SD_PHYS + ASIC3_MAP_SIZE_16BIT - 1, .flags = IORESOURCE_MEM, }, [3] = { .start = gpio_to_irq(GPIO66_HX4700_ASIC3_nSDIO_IRQ), .end = gpio_to_irq(GPIO66_HX4700_ASIC3_nSDIO_IRQ), .flags = IORESOURCE_IRQ, }, };
.companion = BCMPMU_DUMMY_CLIENTS, .i2c_companion_info = pmu_i2c_companion_info, .i2c_adapter_id = PMU_DEVICE_I2C_BUSNO, .i2c_pagesize = 256, .bc = BCMPMU_BC_BB_BC12, #ifdef CONFIG_CHARGER_BCMPMU_SPA .flags = BCMPMU_SPA_EN, #endif }; static struct i2c_board_info __initdata bcmpmu_i2c_info[] = { { I2C_BOARD_INFO("bcmpmu59xxx_i2c", PMU_DEVICE_I2C_ADDR), .platform_data = &bcmpmu_i2c_pdata, .irq = gpio_to_irq(PMU_DEVICE_INT_GPIO), }, }; int bcmpmu_get_pmu_mfd_cell(struct mfd_cell **pmu_cell) { *pmu_cell = pmu59xxx_devs; return ARRAY_SIZE(pmu59xxx_devs); } EXPORT_SYMBOL(bcmpmu_get_pmu_mfd_cell); void bcmpmu_set_pullup_reg(void) { u32 val1, val2; val1 = readl(KONA_CHIPREG_VA + CHIPREG_SPARE_CONTROL0_OFFSET);
/* * tpm_st33_i2c_probe initialize the TPM device * @param: client, the i2c_client drescription (TPM I2C description). * @param: id, the i2c_device_id struct. * @return: 0 in case of success. * -1 in other case. */ static int tpm_st33_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int err; u8 intmask; struct tpm_chip *chip; struct st33zp24_platform_data *platform_data; if (client == NULL) { pr_info("%s: i2c client is NULL. Device not accessible.\n", __func__); err = -ENODEV; goto end; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_info(&client->dev, "client not i2c capable\n"); err = -ENODEV; goto end; } chip = tpm_register_hardware(&client->dev, &st_i2c_tpm); if (!chip) { dev_info(&client->dev, "fail chip\n"); err = -ENODEV; goto end; } platform_data = client->dev.platform_data; if (!platform_data) { dev_info(&client->dev, "chip not available\n"); err = -ENODEV; goto _tpm_clean_answer; } platform_data->tpm_i2c_buffer[0] = kmalloc(TPM_BUFSIZE * sizeof(u8), GFP_KERNEL); if (platform_data->tpm_i2c_buffer[0] == NULL) { err = -ENOMEM; goto _tpm_clean_answer; } platform_data->tpm_i2c_buffer[1] = kmalloc(TPM_BUFSIZE * sizeof(u8), GFP_KERNEL); if (platform_data->tpm_i2c_buffer[1] == NULL) { err = -ENOMEM; goto _tpm_clean_response1; } TPM_VPRIV(chip) = client; chip->vendor.timeout_a = msecs_to_jiffies(TIS_SHORT_TIMEOUT); chip->vendor.timeout_b = msecs_to_jiffies(TIS_LONG_TIMEOUT); chip->vendor.timeout_c = msecs_to_jiffies(TIS_SHORT_TIMEOUT); chip->vendor.timeout_d = msecs_to_jiffies(TIS_SHORT_TIMEOUT); chip->vendor.locality = LOCALITY0; if (power_mgt) { err = gpio_request(platform_data->io_lpcpd, "TPM IO_LPCPD"); if (err) goto _gpio_init1; gpio_set_value(platform_data->io_lpcpd, 1); } if (interrupts) { init_completion(&platform_data->irq_detection); if (request_locality(chip) != LOCALITY0) { err = -ENODEV; goto _tpm_clean_response2; } err = gpio_request(platform_data->io_serirq, "TPM IO_SERIRQ"); if (err) goto _gpio_init2; clear_interruption(client); err = request_irq(gpio_to_irq(platform_data->io_serirq), &tpm_ioserirq_handler, IRQF_TRIGGER_HIGH, "TPM SERIRQ management", chip); if (err < 0) { dev_err(chip->dev , "TPM SERIRQ signals %d not available\n", gpio_to_irq(platform_data->io_serirq)); goto _irq_set; } err = I2C_READ_DATA(client, TPM_INT_ENABLE, &intmask, 1); if (err < 0) goto _irq_set; intmask |= TPM_INTF_CMD_READY_INT | TPM_INTF_FIFO_AVALAIBLE_INT | TPM_INTF_WAKE_UP_READY_INT | TPM_INTF_LOCALITY_CHANGE_INT | TPM_INTF_STS_VALID_INT | TPM_INTF_DATA_AVAIL_INT; err = I2C_WRITE_DATA(client, TPM_INT_ENABLE, &intmask, 1); if (err < 0) goto _irq_set; intmask = TPM_GLOBAL_INT_ENABLE; err = I2C_WRITE_DATA(client, (TPM_INT_ENABLE + 3), &intmask, 1); if (err < 0) goto _irq_set; err = I2C_READ_DATA(client, TPM_INT_STATUS, &intmask, 1); if (err < 0) goto _irq_set; chip->vendor.irq = interrupts; tpm_gen_interrupt(chip); } tpm_get_timeouts(chip); tpm_do_selftest(chip); dev_info(chip->dev, "TPM I2C Initialized\n"); return 0; _irq_set: free_irq(gpio_to_irq(platform_data->io_serirq), (void *)chip); _gpio_init2: if (interrupts) gpio_free(platform_data->io_serirq); _gpio_init1: if (power_mgt) gpio_free(platform_data->io_lpcpd); _tpm_clean_response2: kzfree(platform_data->tpm_i2c_buffer[1]); platform_data->tpm_i2c_buffer[1] = NULL; _tpm_clean_response1: kzfree(platform_data->tpm_i2c_buffer[0]); platform_data->tpm_i2c_buffer[0] = NULL; _tpm_clean_answer: tpm_remove_hardware(chip->dev); end: pr_info("TPM I2C initialisation fail\n"); return err; }
/* Ethernet */ DF_nCS1_nCS3, GPIO97_GPIO, }; #define SAAR_ETH_PHYS (0x14000000) static struct resource smc91x_resources[] = { [0] = { .start = (SAAR_ETH_PHYS + 0x300), .end = (SAAR_ETH_PHYS + 0xfffff), .flags = IORESOURCE_MEM, }, [1] = { .start = gpio_to_irq(mfp_to_gpio(MFP_PIN_GPIO97)), .end = gpio_to_irq(mfp_to_gpio(MFP_PIN_GPIO97)), .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE, } }; static struct smc91x_platdata saar_smc91x_info = { .flags = SMC91X_USE_16BIT | SMC91X_NOWAIT | SMC91X_USE_DMA, }; static struct platform_device smc91x_device = { .name = "smc91x", .id = 0, .num_resources = ARRAY_SIZE(smc91x_resources), .resource = smc91x_resources, .dev = {
static int bcm_bt_lpm_acpi_probe(struct platform_device *pdev) { struct acpi_gpio_info info; acpi_handle handle; acpi_integer port; /* * Handle ACPI specific initializations. */ dev_dbg(&pdev->dev, "ACPI specific probe\n"); bt_lpm.gpio_enable_bt = acpi_get_gpio_by_index(&pdev->dev, gpio_enable_bt_acpi_idx, &info); if (!gpio_is_valid(bt_lpm.gpio_enable_bt)) { pr_err("%s: gpio %d for gpio_enable_bt not valid\n", __func__, bt_lpm.gpio_enable_bt); return -EINVAL; } #ifdef LPM_ON bt_lpm.gpio_wake = acpi_get_gpio_by_index(&pdev->dev, gpio_wake_acpi_idx, &info); if (!gpio_is_valid(bt_lpm.gpio_wake)) { pr_err("%s: gpio %d for gpio_wake not valid\n", __func__, bt_lpm.gpio_wake); return -EINVAL; } bt_lpm.gpio_host_wake = acpi_get_gpio_by_index(&pdev->dev, host_wake_acpi_idx, &info); if (!gpio_is_valid(bt_lpm.gpio_host_wake)) { pr_err("%s: gpio %d for gpio_host_wake not valid\n", __func__, bt_lpm.gpio_host_wake); return -EINVAL; } bt_lpm.int_host_wake = gpio_to_irq(bt_lpm.gpio_host_wake); pr_debug("%s: gpio_wake %d, gpio_host_wake %d, int_host_wake %d\n", __func__, bt_lpm.gpio_wake, bt_lpm.gpio_host_wake, bt_lpm.int_host_wake); #endif handle = DEVICE_ACPI_HANDLE(&pdev->dev); if (ACPI_FAILURE(acpi_evaluate_integer(handle, "UART", NULL, &port))) { dev_err(&pdev->dev, "Error evaluating UART port number\n"); /* FIXME - Force port 0 if the information is missing from the * ACPI table. * That will be removed once the ACPI tables will all have been * updated. */ port = 0; } bt_lpm.port = port; pr_debug("%s: UART port %d\n", __func__, bt_lpm.port); return 0; }
static int hi6401_irq_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct device_node *np = dev->of_node; struct hi6401_irq *irq = NULL; enum of_gpio_flags flags; unsigned int virq; int ret = 0; int i; irq = devm_kzalloc(dev, sizeof(*irq), GFP_KERNEL); if (!irq) { dev_err(dev, "cannot allocate hi6401_irq device info\n"); return -ENOMEM; } platform_set_drvdata(pdev, irq); /* get resources */ irq->res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!irq->res) { dev_err(dev, "platform_get_resource err\n"); goto err_exit; } if (!devm_request_mem_region(dev, irq->res->start, resource_size(irq->res), pdev->name)) { dev_err(dev, "cannot claim register memory\n"); goto err_exit; } irq->reg_base_addr = devm_ioremap(dev, irq->res->start, resource_size(irq->res)); if (!irq->reg_base_addr) { dev_err(dev, "cannot map register memory\n"); goto ioremap_err; } /* get pinctrl */ irq->pctrl = devm_pinctrl_get(dev); if (IS_ERR(irq->pctrl)) { dev_err(dev, "could not get pinctrl\n"); goto codec_ssi_get_err; } ret = codec_ssi_iomux_default(irq->pctrl); if (0 != ret) goto codec_ssi_iomux_err; /* get codec ssi clk */ irq->codec_ssi_clk = devm_clk_get(dev, "clk_codecssi"); if (IS_ERR(irq->codec_ssi_clk)) { pr_err("clk_get: codecssi clk not found!\n"); ret = PTR_ERR(irq->codec_ssi_clk); goto codec_ssi_clk_err; } ret = clk_prepare_enable(irq->codec_ssi_clk); if (0 != ret) { pr_err("codec_ssi_clk :clk prepare enable failed !\n"); goto codec_ssi_clk_enable_err; } /* get pmu audio clk */ irq->pmu_audio_clk = devm_clk_get(dev, "clk_pmuaudioclk"); if (IS_ERR(irq->pmu_audio_clk)) { pr_err("_clk_get: pmu_audio_clk not found!\n"); ret = PTR_ERR(irq->pmu_audio_clk); goto pmu_audio_clk_err; } ret = clk_prepare_enable(irq->pmu_audio_clk); if (0 != ret) { pr_err("pmu_audio_clk :clk prepare enable failed !\n"); goto pmu_audio_clk_enable_err; } spin_lock_init(&irq->lock); spin_lock_init(&irq->rw_lock); mutex_init(&irq->sr_mutex); mutex_init(&irq->pll_mutex); wake_lock_init(&irq->wake_lock, WAKE_LOCK_SUSPEND, "hi6401-irq"); irq->dev = dev; /* clear IRQ status */ hi6401_irq_write(irq, HI6401_REG_IRQ_0, 0xFF); hi6401_irq_write(irq, HI6401_REG_IRQ_1, 0xFF); /* mask all irqs */ hi6401_irq_write(irq, HI6401_REG_IRQM_0, 0xFF); hi6401_irq_write(irq, HI6401_REG_IRQM_1, 0xFF); irq->gpio = of_get_gpio_flags(np, 0, &flags); if (0 > irq->gpio) { dev_err(dev, "get gpio flags error\n"); ret = irq->gpio; goto get_gpio_err; } if (!gpio_is_valid(irq->gpio)) { dev_err(dev, "gpio is invalid\n"); ret = -EINVAL; goto get_gpio_err; } ret = gpio_request_one(irq->gpio, GPIOF_IN, "hi6401_irq"); if (0 > ret) { dev_err(dev, "failed to request gpio%d\n", irq->gpio); goto get_gpio_err; } irq->irq = gpio_to_irq(irq->gpio); irq->domain = irq_domain_add_simple(np, HI6401_MAX_IRQS, 0, &hi6401_domain_ops, irq); if (!irq->domain) { dev_err(dev, "irq domain error\n"); ret = -ENODEV; goto gpio_err; } for (i = 0; i < HI6401_MAX_IRQS; i++) { virq = irq_create_mapping(irq->domain, i); if (virq == NO_IRQ) { dev_err(dev, "Failed mapping hwirq\n"); ret = -ENOSPC; goto gpio_err; } irq->irqs[i] = virq; } ret = request_irq(irq->irq, hi6401_irq_handler, IRQF_TRIGGER_LOW | IRQF_NO_SUSPEND, "hi6401_irq", irq); if (0 > ret) { dev_err(dev, "could not claim irq %d\n", ret); ret = -ENODEV; goto gpio_err; } irq->hi6401_irq_delay_wq = create_singlethread_workqueue("hi6401_irq_delay_wq"); if (!(irq->hi6401_irq_delay_wq)) { pr_err("%s(%u) : workqueue create failed", __FUNCTION__,__LINE__); ret = -ENOMEM; goto irq_delay_wq_err; } INIT_DELAYED_WORK(&irq->hi6401_irq_delay_work, hi6401_irq_work_func); irq->pll_delay_wq = create_singlethread_workqueue("pll_delay_wq"); if (!(irq->pll_delay_wq)) { pr_err("%s : pll_delay_wq create failed", __FUNCTION__); ret = -ENOMEM; goto pll_delay_wq_err; } INIT_DELAYED_WORK(&irq->pll_delay_work, hi6401_pll_work_func); g_dump_buf = (char*)kmalloc(sizeof(char)*Hi6401_SIZE_MAX, GFP_KERNEL); if (!g_dump_buf) { pr_err("%s : couldn't malloc buffer.\n",__FUNCTION__); ret = -ENOMEM; goto g_dump_buf_kmalloc_err; } memset(g_dump_buf, 0, Hi6401_SIZE_MAX); /* populate sub nodes */ of_platform_populate(np, of_hi6401_irq_child_match_tbl, NULL, dev); if (!hi6401_client) { hi6401_client = dsm_register_client(&dsm_hi6401); } return 0; g_dump_buf_kmalloc_err: if(irq->pll_delay_wq) { cancel_delayed_work(&irq->pll_delay_work); flush_workqueue(irq->pll_delay_wq); destroy_workqueue(irq->pll_delay_wq); } pll_delay_wq_err: if(irq->hi6401_irq_delay_wq) { cancel_delayed_work(&irq->hi6401_irq_delay_work); flush_workqueue(irq->hi6401_irq_delay_wq); destroy_workqueue(irq->hi6401_irq_delay_wq); } irq_delay_wq_err: free_irq(irq->irq, irq); gpio_err: gpio_free(irq->gpio); get_gpio_err: clk_disable_unprepare(irq->pmu_audio_clk); pmu_audio_clk_enable_err: devm_clk_put(dev, irq->pmu_audio_clk); pmu_audio_clk_err: clk_disable_unprepare(irq->codec_ssi_clk); codec_ssi_clk_enable_err: devm_clk_put(dev, irq->codec_ssi_clk); codec_ssi_clk_err: codec_ssi_iomux_idle(irq->pctrl); codec_ssi_iomux_err: pinctrl_put(irq->pctrl); codec_ssi_get_err: devm_iounmap(dev, irq->reg_base_addr); ioremap_err: devm_release_mem_region(dev, irq->res->start, resource_size(irq->res)); err_exit: devm_kfree(dev, irq); return ret; }
}; static struct i2c_board_info __initdata snapper9260_i2c_devices[] = { { /* IO expander */ I2C_BOARD_INFO("max7312", 0x28), .platform_data = &snapper9260_io_expander_data, }, { /* Audio codec */ I2C_BOARD_INFO("tlv320aic23", 0x1a), }, { /* RTC */ I2C_BOARD_INFO("isl1208", 0x6f), .irq = gpio_to_irq(AT91_PIN_PA31), }, }; static void __init snapper9260_add_device_nand(void) { at91_set_A_periph(AT91_PIN_PC14, 0); sam9_smc_configure(3, &snapper9260_nand_smc_config); at91_add_device_nand(&snapper9260_nand_data); } static void __init snapper9260_board_init(void) { at91_add_device_i2c(snapper9260_i2c_devices, ARRAY_SIZE(snapper9260_i2c_devices)); at91_add_device_serial();
static void dalmore_i2c_init(void) { nfc_board_info.irq = gpio_to_irq(TEGRA_GPIO_PW2); i2c_register_board_info(0, &nfc_board_info, 1); i2c_register_board_info(0, &rt5640_board_info, 1); }
static int __devinit pm8xxx_cradle_probe(struct platform_device *pdev) { int ret; unsigned int hall_pouch_gpio_irq = 0; struct pm8xxx_cradle_platform_data *pdata; if (pdev->dev.of_node) { pdata = devm_kzalloc(&pdev->dev, sizeof(struct pm8xxx_cradle_platform_data), GFP_KERNEL); if (pdata == NULL) { pr_err("%s: no pdata\n", __func__); return -ENOMEM; } pdev->dev.platform_data = pdata; #if defined(CONFIG_S5717) s5717_parse_dt(&pdev->dev, pdata); #else /*CONFIG_BU52061NVX*/ bu52061nvx_parse_dt(&pdev->dev, pdata); #endif } else { pdata = pdev->dev.platform_data; } if (!pdata) { pr_err("%s: no pdata\n", __func__); return -ENOMEM; } cradle = kzalloc(sizeof(*cradle), GFP_KERNEL); if (!cradle) return -ENOMEM; cradle->pdata = pdata; #ifdef CONFIG_MACH_MSM8926_VFP_KR cradle->sdev.name = "folderstatus"; #else cradle->sdev.name = "smartcover"; #endif cradle->sdev.print_name = cradle_print_name; cradle->pouch = 0; spin_lock_init(&cradle->lock); ret = switch_dev_register(&cradle->sdev); if (ret < 0) goto err_switch_dev_register; if (pre_set_flag) { cradle_set_deskdock(pre_set_flag); cradle->state = pre_set_flag; } wake_lock_init(&cradle->wake_lock, WAKE_LOCK_SUSPEND, "hall_ic_wakeups"); INIT_DELAYED_WORK(&cradle->pouch_work, pm8xxx_pouch_work_func); printk("%s : init cradle\n", __func__); /* initialize irq of gpio_hall */ if (cradle->pdata->hallic_pouch_detect_pin > 0) { hall_pouch_gpio_irq = gpio_to_irq(cradle->pdata->hallic_pouch_detect_pin); printk("%s : hall_pouch_gpio_irq = [%d]\n", __func__, hall_pouch_gpio_irq); if (hall_pouch_gpio_irq < 0) { printk("Failed : GPIO TO IRQ \n"); ret = hall_pouch_gpio_irq; goto err_request_irq; } ret = request_irq(hall_pouch_gpio_irq, pm8xxx_pouch_irq_handler, pdata->irq_flags, HALL_IC_DEV_NAME, cradle); if (ret > 0) { printk(KERN_ERR "%s: Can't allocate irq %d, ret %d\n", __func__, hall_pouch_gpio_irq, ret); goto err_request_irq; } if (enable_irq_wake(hall_pouch_gpio_irq) == 0) printk("%s :enable_irq_wake Enable(1)\n",__func__); else printk("%s :enable_irq_wake failed(1)\n",__func__); } printk("%s : pdata->irq_flags = [%d]\n", __func__,(int)pdata->irq_flags); printk("%s :boot_cradle_det_func START\n",__func__); boot_cradle_det_func(); ret = device_create_file(&pdev->dev, &cradle_sensing_attr); if (ret) goto err_request_irq; if (cradle->pdata->hallic_pouch_detect_pin > 0) { ret = device_create_file(&pdev->dev, &cradle_pouch_attr); if (ret) goto err_request_irq; } platform_set_drvdata(pdev, cradle); return 0; err_request_irq: if (hall_pouch_gpio_irq) free_irq(hall_pouch_gpio_irq, 0); err_switch_dev_register: switch_dev_unregister(&cradle->sdev); kfree(cradle); return ret; }
* pull up resistors are missing. */ .irq = IRQ_GPIO(99), }, { /* ITS400 Sensor board only */ .type = "tmp175", .addr = 0x4A, .irq = IRQ_GPIO(96), }, }; static struct i2c_board_info __initdata stargate2_pwr_i2c_board_info[] = { { .type = "da9030", .addr = 0x49, .platform_data = &stargate2_da9030_pdata, .irq = gpio_to_irq(1), }, }; static struct pxa2xx_spi_master pxa_ssp_master_0_info = { .num_chipselect = 1, }; static struct pxa2xx_spi_master pxa_ssp_master_1_info = { .num_chipselect = 1, }; static struct pxa2xx_spi_master pxa_ssp_master_2_info = { .num_chipselect = 1, };
static void mx27ads_sdhc2_exit(struct device *dev, void *data) { free_irq(gpio_to_irq(IMX_GPIO_NR(2, 7)), data); }
static int sdhci_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct sdhci_host *host; struct resource *iomem; struct spear_sdhci *sdhci; int ret; iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!iomem) { ret = -ENOMEM; dev_dbg(&pdev->dev, "memory resource not defined\n"); goto err; } if (!devm_request_mem_region(&pdev->dev, iomem->start, resource_size(iomem), "spear-sdhci")) { ret = -EBUSY; dev_dbg(&pdev->dev, "cannot request region\n"); goto err; } sdhci = devm_kzalloc(&pdev->dev, sizeof(*sdhci), GFP_KERNEL); if (!sdhci) { ret = -ENOMEM; dev_dbg(&pdev->dev, "cannot allocate memory for sdhci\n"); goto err; } /* clk enable */ sdhci->clk = clk_get(&pdev->dev, NULL); if (IS_ERR(sdhci->clk)) { ret = PTR_ERR(sdhci->clk); dev_dbg(&pdev->dev, "Error getting clock\n"); goto err; } ret = clk_prepare_enable(sdhci->clk); if (ret) { dev_dbg(&pdev->dev, "Error enabling clock\n"); goto put_clk; } ret = clk_set_rate(sdhci->clk, 50000000); if (ret) dev_dbg(&pdev->dev, "Error setting desired clk, clk=%lu\n", clk_get_rate(sdhci->clk)); if (np) { sdhci->data = sdhci_probe_config_dt(pdev); if (IS_ERR(sdhci->data)) { dev_err(&pdev->dev, "DT: Failed to get pdata\n"); return -ENODEV; } } else { sdhci->data = dev_get_platdata(&pdev->dev); } pdev->dev.platform_data = sdhci; if (pdev->dev.parent) host = sdhci_alloc_host(pdev->dev.parent, 0); else host = sdhci_alloc_host(&pdev->dev, 0); if (IS_ERR(host)) { ret = PTR_ERR(host); dev_dbg(&pdev->dev, "error allocating host\n"); goto disable_clk; } host->hw_name = "sdhci"; host->ops = &sdhci_pltfm_ops; host->irq = platform_get_irq(pdev, 0); host->quirks = SDHCI_QUIRK_BROKEN_ADMA; host->ioaddr = devm_ioremap(&pdev->dev, iomem->start, resource_size(iomem)); if (!host->ioaddr) { ret = -ENOMEM; dev_dbg(&pdev->dev, "failed to remap registers\n"); goto free_host; } ret = sdhci_add_host(host); if (ret) { dev_dbg(&pdev->dev, "error adding host\n"); goto free_host; } platform_set_drvdata(pdev, host); /* * It is optional to use GPIOs for sdhci Power control & sdhci card * interrupt detection. If sdhci->data is NULL, then use original sdhci * lines otherwise GPIO lines. * If GPIO is selected for power control, then power should be disabled * after card removal and should be enabled when card insertion * interrupt occurs */ if (!sdhci->data) return 0; if (sdhci->data->card_power_gpio >= 0) { int val = 0; ret = devm_gpio_request(&pdev->dev, sdhci->data->card_power_gpio, "sdhci"); if (ret < 0) { dev_dbg(&pdev->dev, "gpio request fail: %d\n", sdhci->data->card_power_gpio); goto set_drvdata; } if (sdhci->data->power_always_enb) val = sdhci->data->power_active_high; else val = !sdhci->data->power_active_high; ret = gpio_direction_output(sdhci->data->card_power_gpio, val); if (ret) { dev_dbg(&pdev->dev, "gpio set direction fail: %d\n", sdhci->data->card_power_gpio); goto set_drvdata; } } if (sdhci->data->card_int_gpio >= 0) { ret = devm_gpio_request(&pdev->dev, sdhci->data->card_int_gpio, "sdhci"); if (ret < 0) { dev_dbg(&pdev->dev, "gpio request fail: %d\n", sdhci->data->card_int_gpio); goto set_drvdata; } ret = gpio_direction_input(sdhci->data->card_int_gpio); if (ret) { dev_dbg(&pdev->dev, "gpio set direction fail: %d\n", sdhci->data->card_int_gpio); goto set_drvdata; } ret = devm_request_irq(&pdev->dev, gpio_to_irq(sdhci->data->card_int_gpio), sdhci_gpio_irq, IRQF_TRIGGER_LOW, mmc_hostname(host->mmc), pdev); if (ret) { dev_dbg(&pdev->dev, "gpio request irq fail: %d\n", sdhci->data->card_int_gpio); goto set_drvdata; } } return 0; set_drvdata: platform_set_drvdata(pdev, NULL); sdhci_remove_host(host, 1); free_host: sdhci_free_host(host); disable_clk: clk_disable_unprepare(sdhci->clk); put_clk: clk_put(sdhci->clk); err: dev_err(&pdev->dev, "spear-sdhci probe failed: %d\n", ret); return ret; }
static void gsm_exit(void) { free_irq(gpio_to_irq(GPIO25_GSM_MOD_ON_STATE), NULL); mio_gpio_free(ARRAY_AND_SIZE(gsm_gpios)); }
/* ==========================================================================*/ static void __init ambarella_init_filbert(void) { int i; struct ambarella_spi_platform_info *spi2_pdata; ambarella_init_machine("Filbert"); platform_add_devices(ambarella_devices, ARRAY_SIZE(ambarella_devices)); for (i = 0; i < ARRAY_SIZE(ambarella_devices); i++) { device_set_wakeup_capable(&ambarella_devices[i]->dev, 1); device_set_wakeup_enable(&ambarella_devices[i]->dev, 0); } /* config board */ ambarella_board_generic.power_detect.irq_gpio = GPIO(135); ambarella_board_generic.power_detect.irq_line = gpio_to_irq(135); ambarella_board_generic.power_detect.irq_type = IRQF_TRIGGER_RISING; ambarella_board_generic.power_detect.irq_gpio_val = GPIO_LOW; ambarella_board_generic.power_detect.irq_gpio_mode = GPIO_FUNC_SW_INPUT; /* config LCD */ ambarella_board_generic.lcd_backlight.gpio_id = GPIO(85); ambarella_board_generic.lcd_backlight.active_level = GPIO_HIGH; ambarella_board_generic.lcd_backlight.active_delay = 1; ambarella_board_generic.lcd_spi_hw.bus_id = 2; ambarella_board_generic.lcd_spi_hw.cs_id = 4; /* config audio */ ambarella_board_generic.audio_reset.gpio_id = GPIO(12); ambarella_board_generic.audio_reset.active_level = GPIO_LOW; /* Config Eth0 */ ambarella_eth0_platform_info.mii_reset.gpio_id = GPIO(124); /* Config Eth1 */ ambarella_eth1_platform_info.mii_reset.gpio_id = GPIO(125); /* Config Vin */ ambarella_board_generic.vin0_reset.gpio_id = GPIO(127); ambarella_board_generic.vin0_reset.active_level = GPIO_LOW; ambarella_board_generic.vin0_reset.active_delay = 200; /* Config SD */ fio_default_owner = SELECT_FIO_SDIO; ambarella_platform_sd_controller0.max_blk_mask = SD_BLK_SZ_512KB; ambarella_platform_sd_controller0.slot[1].ext_power.gpio_id = GPIO(54); ambarella_platform_sd_controller0.slot[1].ext_power.active_level = GPIO_HIGH; ambarella_platform_sd_controller0.slot[1].ext_power.active_delay = 300; ambarella_platform_sd_controller0.slot[1].gpio_cd.irq_gpio = GPIO(SMIO_44); ambarella_platform_sd_controller0.slot[1].gpio_cd.irq_line = gpio_to_irq(SMIO_44); ambarella_platform_sd_controller0.slot[1].gpio_cd.irq_type = IRQ_TYPE_EDGE_BOTH; ambarella_platform_sd_controller0.slot[1].gpio_wp.gpio_id = GPIO(SMIO_45); spi2_pdata = (struct ambarella_spi_platform_info *)ambarella_spi2.dev.platform_data; spi2_pdata->cs_num = 7; spi2_pdata->cs_pins[7] = -1; spi_register_board_info(ambarella_spi_devices, ARRAY_SIZE(ambarella_spi_devices)); #if defined(CONFIG_TOUCH_AMBARELLA_TM1510) ambarella_tm1510_board_info.irq = ambarella_board_generic.touch_panel_irq.irq_line; ambarella_tm1510_board_info.flags = 0; i2c_register_board_info(0, &ambarella_tm1510_board_info, 1); #endif i2c_register_board_info(0, ambarella_board_vin_infos, ARRAY_SIZE(ambarella_board_vin_infos)); #if (IDC_SUPPORT_PIN_MUXING_FOR_HDMI == 1) i2c_register_board_info(0, &ambarella_board_hdmi_info, 1); #else i2c_register_board_info(1, &ambarella_board_hdmi_info, 1); #endif platform_device_register(&filbert_board_input); }
/* * This function is called when the module is loaded */ static int __init sample_init_module(void) { /* * Register device */ int ret; ret = register_chrdev(module_major, module_name, &sample_fops); if (ret < 0) { printk(KERN_INFO "%s: registering device %s with major %d failed with %d\n", __func__, module_name, module_major, module_major ); return(ret); } else { printk(KERN_INFO "%s: registering device %s with major %d\n", __func__, module_name, module_major ); /* * Reserve gpios */ if( gpio_request( TRIGGER, module_name ) ) // request pin D7 (trigger) { printk( KERN_INFO "%s: %s unable to get TRIG gpio\n", module_name, __func__ ); ret = -EBUSY; return(ret); } if( gpio_request( ECHO, module_name ) ) // request pin D8 (echo) { printk( KERN_INFO "%s: %s unable to get ECHO gpio\n", module_name, __func__ ); ret = -EBUSY; return(ret); } if( gpio_request( LED, module_name ) ) // request user LED GPIO { printk( KERN_INFO "%s: %s unable to get LED gpio\n", module_name, __func__ ); ret = -EBUSY; return(ret); } /* * Set gpios directions */ if( gpio_direction_output( TRIGGER, 0 ) < 0 ) // Set pin D7 (trigger) as output with default value 0 { printk( KERN_INFO "%s: %s unable to set TRIG gpio as output\n", module_name, __func__ ); ret = -EBUSY; return(ret); } if( gpio_direction_input( ECHO ) < 0 ) // Set pin D8 (echo) as input { printk( KERN_INFO "%s: %s unable to set ECHO gpio as input\n", module_name, __func__ ); ret = -EBUSY; return(ret); } if( gpio_direction_output( LED, 0 ) < 0 ) // Set LED gpio as output with default value 0 { printk( KERN_INFO "%s: %s unable to set LED gpio as output\n", module_name, __func__ ); ret = -EBUSY; return(ret); } // assign handler to ECHO pin IRQ if( request_irq( gpio_to_irq( ECHO ), // IRQ of pin D8 (irq_handler_t) echo_handler, // ISR (callback) IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING , // sensitive to either edge module_name, NULL ) < 0 ) { printk( KERN_INFO "%s: %s unable to register gpio irq\n", module_name, __func__ ); ret = -EBUSY; return( ret ); } /* create the 2 needed workqueues */ t_wq = create_workqueue( "Trigger wq" ); if( t_wq ) { INIT_WORK( (struct work_struct *)&trigger_work, trigger_wq_function ); } led_wq = create_workqueue( "LED wq" ); if( led_wq ) { INIT_WORK( (struct work_struct *)&led_work, led_wq_function ); } } return(ret); }
static int rk610_hdmi_i2c_probe(struct i2c_client *client,const struct i2c_device_id *id) { int rc = 0; struct hdmi *hdmi = NULL; struct rkdisplay_platform_data *hdmi_data = client->dev.platform_data; rk610_hdmi = kzalloc(sizeof(struct rk610_hdmi_pdata), GFP_KERNEL); if(!rk610_hdmi) { dev_err(&client->dev, "no memory for state\n"); goto err_kzalloc_rk610_hdmi; } rk610_hdmi->client = client; if(hdmi_data) hdmi = hdmi_register(&client->dev, &rk610_hdmi_ops, hdmi_data->video_source, hdmi_data->property); else hdmi = hdmi_register(&client->dev, &rk610_hdmi_ops, DISPLAY_SOURCE_LCDC0, DISPLAY_MAIN); if(hdmi == NULL) { dev_err(&client->dev, "fail to register hdmi\n"); goto err_hdmi_register; } hdmi->support_r2y = 1; rk610_hdmi->hdmi = hdmi; hdmi_set_privdata(hdmi, rk610_hdmi); i2c_set_clientdata(client, rk610_hdmi); { #ifdef HDMI_USE_IRQ // hdmi_changed(hdmi, 0); INIT_WORK(&rk610_hdmi->irq_work, rk610_irq_work_func); if((rc = gpio_request(client->irq, "hdmi gpio")) < 0) { dev_err(&client->dev, "fail to request gpio %d\n", client->irq); goto err_request_gpio; } rk610_hdmi->irq = gpio_to_irq(client->irq); rk610_hdmi->gpio = client->irq; gpio_pull_updown(client->irq,GPIOPullUp); gpio_direction_input(client->irq); if((rc = request_irq(rk610_hdmi->irq, rk610_irq,IRQF_TRIGGER_RISING,NULL,hdmi)) < 0) { dev_err(&client->dev, "fail to request hdmi irq\n"); goto err_request_irq; } #else HDMI_task(hdmi); queue_delayed_work(hdmi->workqueue, &hdmi->delay_work, 200); #endif hdmi_enable(hdmi); dev_info(&client->dev, "rk610 hdmi i2c probe ok\n"); } return 0; err_request_irq: gpio_free(client->irq); err_request_gpio: hdmi_unregister(hdmi); err_hdmi_register: kfree(rk610_hdmi); rk610_hdmi = NULL; err_kzalloc_rk610_hdmi: hdmi = NULL; dev_err(&client->dev, "rk610 hdmi probe error\n"); return rc; }
"main-battery", "backup-battery", }; static struct pda_power_pdata collie_power_data = { .init = collie_power_init, .is_ac_online = collie_power_ac_online, .exit = collie_power_exit, .supplied_to = collie_ac_supplied_to, .num_supplicants = ARRAY_SIZE(collie_ac_supplied_to), }; static struct resource collie_power_resource[] = { { .name = "ac", .start = gpio_to_irq(COLLIE_GPIO_AC_IN), .end = gpio_to_irq(COLLIE_GPIO_AC_IN), .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE | IORESOURCE_IRQ_LOWEDGE, }, }; static struct platform_device collie_power_device = { .name = "pda-power", .id = -1, .dev.platform_data = &collie_power_data, .resource = collie_power_resource, .num_resources = ARRAY_SIZE(collie_power_resource), };
/*! * This function initializes the driver in terms of memory of the soundcard * and some basic HW clock settings. * * @return 0 on success, -1 otherwise. */ static int __init usi_modem_ioctrl_probe(struct platform_device *pdev) { int grc, irq = 0; dbg("%s, %s\n", __func__, "entry"); #ifdef USI_MODEM_USBEN /* MODEM_USBEN */ grc = gpio_request(USI_MODEM_USBEN, "modem-usben"); if (grc) goto err_gpio_usben_req; grc = gpio_direction_output(USI_MODEM_USBEN, 1); if (grc) goto err_gpio_usben_dir; #endif #ifdef USI_MODEM_APReady /* MODEM_APReady */ grc = gpio_request(USI_MODEM_APReady, "modem-apready"); if (grc) goto err_gpio_apready_req; grc = gpio_direction_output(USI_MODEM_APReady, 1); if (grc) goto err_gpio_apready_dir; #endif #ifdef USI_MODEM_POWERKEY /* MODEM_POWERKEY */ grc = gpio_request(USI_MODEM_POWERKEY, "modem-powerkey"); if (grc) goto err_gpio_powerkey_req; grc = gpio_direction_output(USI_MODEM_POWERKEY, 0); if (grc) goto err_gpio_powerkey_dir; #endif #ifdef USI_MODEM_UARTEN /* MODEM_UARTEN */ grc = gpio_request(USI_MODEM_UARTEN, "modem-uarten"); if (grc) goto err_gpio_uarten_req; grc = gpio_direction_output(USI_MODEM_UARTEN, 1); if (grc) goto err_gpio_uarten_dir; #endif #ifdef USI_MODEM_APWAKE /* MODEM_APWAKE */ grc = gpio_request(USI_MODEM_APWAKE, "modem-apawake"); if (grc) { goto err_gpio_apwake_req; } gpio_direction_input(USI_MODEM_APWAKE); irq = gpio_to_irq(USI_MODEM_APWAKE); if(irq < 0) { gpio_free(USI_MODEM_APWAKE); printk("failed to request modem-apawake\n"); } grc = request_irq(irq, detect_irq_handler, IRQ_BB_WAKEUP_AP_TRIGGER | IRQF_DISABLED | IRQF_SHARED, "modem-apawake", NULL); if (grc < 0) { printk("%s: request_irq(%d) failed\n", __func__, irq); gpio_free(USI_MODEM_APWAKE); goto err_gpio_apwake_dir; } enable_irq_wake(irq); wake_lock_init(&modem_wakelock, WAKE_LOCK_SUSPEND, "modem-apawake"); #endif /* Check Modem exist */ modem_exist(); /* Register character device */ init_chrdev(&(pdev->dev)); return 0; #ifdef USI_MODEM_POWERKEY err_gpio_powerkey_dir: printk(KERN_ERR "%s: USI_MODEM_POWERKEY gpio(%d) setting failed\n", __func__, USI_MODEM_POWERKEY); gpio_free(USI_MODEM_POWERKEY); err_gpio_powerkey_req: printk(KERN_ERR "%s: USI_MODEM_POWERKEY gpio(%d) request failed\n", __func__, USI_MODEM_POWERKEY); #endif #ifdef USI_MODEM_UARTEN err_gpio_uarten_dir: printk(KERN_ERR "%s: USI_MODEM_UARTEN gpio(%d) setting failed\n", __func__, USI_MODEM_UARTEN); gpio_free(USI_MODEM_UARTEN); err_gpio_uarten_req: printk(KERN_ERR "%s: USI_MODEM_UARTEN gpio(%d) request failed\n", __func__, USI_MODEM_UARTEN); #endif #ifdef USI_MODEM_USBEN err_gpio_usben_dir: printk(KERN_ERR "%s: USI_MODEM_USBEN gpio(%d) setting failed\n", __func__, USI_MODEM_USBEN); gpio_free(USI_MODEM_USBEN); err_gpio_usben_req: printk(KERN_ERR "%s: USI_MODEM_USBEN gpio(%d) request failed\n", __func__, USI_MODEM_USBEN); #endif #ifdef USI_MODEM_APReady err_gpio_apready_dir: printk(KERN_ERR "%s: USI_MODEM_APReady gpio(%d) setting failed\n", __func__, USI_MODEM_APReady); gpio_free(USI_MODEM_APReady); err_gpio_apready_req: printk(KERN_ERR "%s: USI_MODEM_APReady gpio(%d) request failed\n", __func__, USI_MODEM_APReady); #endif #ifdef USI_MODEM_APWAKE err_gpio_apwake_dir: printk(KERN_ERR "%s: USI_MODEM_APWAKE gpio(%d) setting failed\n", __func__, USI_MODEM_APWAKE); gpio_free(USI_MODEM_APWAKE); err_gpio_apwake_req: printk(KERN_ERR "%s: USI_MODEM_APWAKE gpio(%d) request failed\n", __func__, USI_MODEM_APWAKE); #endif return grc; }
static int __init hs_probe(struct platform_device *pdev) { int result = 0; mic.hsmajor = 0; mic.headset_state = 0; mic.hsbtime.tv.sec = 0; mic.hsbtime.tv.nsec = 0; mic.headset_pd = NULL; mic.check_count = 0; #ifdef CONFIG_SWITCH result = hs_switchinit(&mic); if (result < 0) return result; #endif result = hs_inputdev(&mic); if (result < 0) goto err; result = register_chrdev(mic.hsmajor, "BrcmHeadset", &hs_fops); if(result < 0) goto err1; else if(result > 0 && (mic.hsmajor == 0)) /* this is for dynamic major */ mic.hsmajor = result; wake_lock_init(&mic.det_wake_lock, WAKE_LOCK_SUSPEND, "sec_jack_det"); INIT_DELAYED_WORK(&(mic.imsi_work), getIMSI_work_func); /* check if platform data is defined for a particular board variant */ if (pdev->dev.platform_data) { mic.headset_pd = pdev->dev.platform_data; KEY_PRESS_THRESHOLD = mic.headset_pd->key_press_threshold; KEY_3POLE_THRESHOLD = mic.headset_pd->key_3pole_threshold; KEY1_THRESHOLD_L = mic.headset_pd->key1_threshold_l; KEY1_THRESHOLD_U = mic.headset_pd->key1_threshold_u; KEY2_THRESHOLD_L = mic.headset_pd->key2_threshold_l; KEY2_THRESHOLD_U = mic.headset_pd->key2_threshold_u; KEY3_THRESHOLD_L = mic.headset_pd->key3_threshold_l; KEY3_THRESHOLD_U = mic.headset_pd->key3_threshold_u; if (mic.headset_pd->hsgpio == 0) mic.hsirq = mic.headset_pd->hsirq; else { setup_timer(&mic.timer, gpio_jack_timer, (unsigned long)&mic); // timer register. if (gpio_request(mic.headset_pd->hsgpio, "headset detect") < 0) { printk("%s: Could not reserve headset signal GPIO!\n", __func__); goto err2; } gpio_direction_input(mic.headset_pd->hsgpio); bcm_gpio_set_db_val(mic.headset_pd->hsgpio, 0x7); mic.hsirq = gpio_to_irq(mic.headset_pd->hsgpio); } mic.hsbirq = mic.headset_pd->hsbirq; } else { mic.hsirq = platform_get_irq(pdev, 0); mic.hsbirq = platform_get_irq(pdev, 1); } printk("%s: HS irq %d\n", __func__, mic.hsirq); printk("%s: HSB irq %d\n", __func__, mic.hsbirq); result = request_irq(mic.hsbirq, hs_buttonisr, IRQF_NO_SUSPEND, "BrcmHeadsetButton", (void *) NULL); mic.hsbst = DISABLE; if(result < 0) goto err2; result = request_irq(mic.hsirq, hs_isr,(IRQF_DISABLED | IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING | IRQF_NO_SUSPEND), "BrcmHeadset", &mic); if(result < 0) { free_irq(mic.hsbirq, &mic); goto err2; } printk("%s: BrcmHeadset: module inserted >>>> . Major number is = %d\n", __func__, mic.hsmajor); /* Set the ANACR2 bit for mic power down */ board_sysconfig(SYSCFG_AUXMIC, SYSCFG_INIT); board_sysconfig(SYSCFG_HEADSET, SYSCFG_INIT); /*Fix the audio path is wrong when headset already plugged in the device then boot device case.*/ if (mic.headset_pd->hsgpio != 0) { mic.headset_pd->check_hs_state(&mic.headset_state); printk("%s: headset_state:%d\n", __func__, mic.headset_state); set_irq_type(mic.hsirq, (mic.headset_state) ? IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING); schedule_work(&(mic.switch_data.work)); schedule_delayed_work(&(mic.imsi_work), GET_IMSI_REF_TIME); } return 0; err2: unregister_chrdev(mic.hsmajor,"BrcmHeadset"); if(mic.headset_pd->hsgpio) del_timer_sync(&mic.timer); err1: hs_unreginputdev(&mic); err: hs_unregsysfs(&mic); return result; }
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; #ifndef CONFIG_ARCH_MSM8X60 err = request_irq(irq, gpio_keypad_irq_handler, request_flags, "gpio_kp", kp); if (err) { KEY_LOGE("gpiomatrix: request_irq failed for input %d, " "irq %d\n", mi->input_gpios[i], irq); goto err_request_irq_failed; } #else err = request_any_context_irq(irq, gpio_keypad_irq_handler, request_flags, "gpio_kp", kp); if (err < 0) { KEY_LOGE("gpiomatrix: request_irq failed for input %d, " "irq %d, err %d\n", mi->input_gpios[i], irq, err); goto err_request_irq_failed; } #endif err = set_irq_wake(irq, 1); if (err) { KEY_LOGE("gpiomatrix: set_irq_wake failed for input %d, " "irq %d\n", mi->input_gpios[i], irq); } 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; }