static void __exit minnow_gpio_module_exit(void) { if (minnow_lvds_detect()) gpio_free_array(expansion_aux_gpios, ARRAY_SIZE(expansion_aux_gpios)); gpio_free_array(expansion_gpios, ARRAY_SIZE(expansion_gpios)); }
static void vpac270_pcmcia_hw_shutdown(struct soc_pcmcia_socket *skt) { if (skt->nr == 0) gpio_free_array(vpac270_pcmcia_gpios, ARRAY_SIZE(vpac270_pcmcia_gpios)); else gpio_free_array(vpac270_cf_gpios, ARRAY_SIZE(vpac270_cf_gpios)); }
int msm_camera_request_gpio_table(struct msm_camera_sensor_info *sinfo, int gpio_en) { int rc = 0; struct msm_camera_gpio_conf *gpio_conf = sinfo->sensor_platform_info->gpio_conf; if (!gpio_conf->gpio_no_mux) { if (gpio_conf->cam_gpio_req_tbl == NULL || gpio_conf->cam_gpio_common_tbl == NULL) { pr_err("%s: NULL camera gpio table\n", __func__); return -EFAULT; } } if (gpio_conf->gpio_no_mux) config_gpio_table(gpio_conf); if (gpio_en) { if (!gpio_conf->gpio_no_mux && !gpio_ref_count) { if (gpio_conf->cam_gpiomux_conf_tbl != NULL) { msm_gpiomux_install( (struct msm_gpiomux_config *) gpio_conf->cam_gpiomux_conf_tbl, gpio_conf->cam_gpiomux_conf_tbl_size); } rc = gpio_request_array(gpio_conf->cam_gpio_common_tbl, gpio_conf->cam_gpio_common_tbl_size); if (rc < 0) { pr_err("%s common gpio request failed\n" , __func__); return rc; } } gpio_ref_count++; if (gpio_conf->cam_gpio_req_tbl_size) { rc = gpio_request_array(gpio_conf->cam_gpio_req_tbl, gpio_conf->cam_gpio_req_tbl_size); if (rc < 0) { pr_err("%s camera gpio" "request failed\n", __func__); gpio_free_array(gpio_conf->cam_gpio_common_tbl, gpio_conf->cam_gpio_common_tbl_size); return rc; } } } else { gpio_ref_count--; gpio_free_array(gpio_conf->cam_gpio_req_tbl, gpio_conf->cam_gpio_req_tbl_size); if (!gpio_conf->gpio_no_mux && !gpio_ref_count) gpio_free_array(gpio_conf->cam_gpio_common_tbl, gpio_conf->cam_gpio_common_tbl_size); } return rc; }
static int __init sg2_pcmcia_init(void) { int ret; if (!machine_is_stargate2()) return -ENODEV; sg2_pcmcia_device = platform_device_alloc("pxa2xx-pcmcia", -1); if (!sg2_pcmcia_device) return -ENOMEM; ret = gpio_request_array(sg2_pcmcia_gpios, ARRAY_SIZE(sg2_pcmcia_gpios)); if (ret) goto error_put_platform_device; ret = platform_device_add_data(sg2_pcmcia_device, &sg2_pcmcia_ops, sizeof(sg2_pcmcia_ops)); if (ret) goto error_free_gpios; ret = platform_device_add(sg2_pcmcia_device); if (ret) goto error_free_gpios; return 0; error_free_gpios: gpio_free_array(sg2_pcmcia_gpios, ARRAY_SIZE(sg2_pcmcia_gpios)); error_put_platform_device: platform_device_put(sg2_pcmcia_device); return ret; }
static int __init minnow_gpio_module_init(void) { int err; err = -ENODEV; if (!minnow_detect()) goto out; /* Auxillary Expansion GPIOs */ if (!minnow_lvds_detect()) { pr_debug("LVDS_DETECT not asserted, configuring Aux GPIO lines\n"); err = gpio_request_array(expansion_aux_gpios, ARRAY_SIZE(expansion_aux_gpios)); if (err) { pr_err("Failed to request expansion aux GPIO lines\n"); goto out; } } else { pr_debug("LVDS_DETECT asserted, ignoring aux GPIO lines\n"); } /* Expansion GPIOs */ err = gpio_request_array(expansion_gpios, ARRAY_SIZE(expansion_gpios)); if (err) { pr_err("Failed to request expansion GPIO lines\n"); if (minnow_lvds_detect()) gpio_free_array(expansion_aux_gpios, ARRAY_SIZE(expansion_aux_gpios)); goto out; } out: return err; }
static int vision_spi_mmc_init(struct device *pdev, irqreturn_t (*func)(int, void *), void *pdata) { int err; err = gpio_request_array(vision_spi_mmc_gpios, ARRAY_SIZE(vision_spi_mmc_gpios)); if (err) return err; err = gpio_set_debounce(VISION_SPI_MMC_CD, 1); if (err) goto exit_err; err = request_irq(gpio_to_irq(VISION_SPI_MMC_CD), func, IRQ_TYPE_EDGE_BOTH, "mmc_spi:cd", pdata); if (err) goto exit_err; return 0; exit_err: gpio_free_array(vision_spi_mmc_gpios, ARRAY_SIZE(vision_spi_mmc_gpios)); return err; }
int msm_camera_request_gpio_table(struct gpio *gpio_tbl, uint8_t size, int gpio_en) { int rc = 0, i = 0; if (!gpio_tbl || !size) { pr_err("%s:%d invalid gpio_tbl %p / size %d\n", __func__, __LINE__, gpio_tbl, size); return -EINVAL; } for (i = 0; i < size; i++) { CDBG("%s:%d i %d, gpio %d dir %ld\n", __func__, __LINE__, i, gpio_tbl[i].gpio, gpio_tbl[i].flags); } if (gpio_en) { rc = gpio_request_array(gpio_tbl, size); if (rc < 0) { pr_err("%s:%d camera gpio request failed\n", __func__, __LINE__); return rc; } } else { gpio_free_array(gpio_tbl, size); } return rc; }
int msm_camera_request_gpio_table(struct gpio *gpio_tbl, uint8_t size, int gpio_en) { int rc = 0, i = 0, err = 0; if (!gpio_tbl || !size) { pr_err("%s:%d invalid gpio_tbl %p / size %d\n", __func__, __LINE__, gpio_tbl, size); return -EINVAL; } for (i = 0; i < size; i++) { CDBG("%s:%d i %d, gpio %d dir %ld\n", __func__, __LINE__, i, gpio_tbl[i].gpio, gpio_tbl[i].flags); } if (gpio_en) { for (i = 0; i < size; i++) { err = gpio_request_one(gpio_tbl[i].gpio, gpio_tbl[i].flags, gpio_tbl[i].label); if (err) { /* * After GPIO request fails, contine to * apply new gpios, outout a error message * for driver bringup debug */ pr_err("%s:%d gpio %d:%s request fails\n", __func__, __LINE__, gpio_tbl[i].gpio, gpio_tbl[i].label); } } } else { gpio_free_array(gpio_tbl, size); } return rc; }
static int __init qi_lb60_init(void) { int ret; qi_lb60_snd_device = platform_device_alloc("soc-audio", -1); if (!qi_lb60_snd_device) return -ENOMEM; ret = gpio_request_array(qi_lb60_gpios, ARRAY_SIZE(qi_lb60_gpios)); if (ret) { pr_err("qi_lb60 snd: Failed to request gpios: %d\n", ret); goto err_device_put; } platform_set_drvdata(qi_lb60_snd_device, &qi_lb60); ret = platform_device_add(qi_lb60_snd_device); if (ret) { pr_err("qi_lb60 snd: Failed to add snd soc device: %d\n", ret); goto err_unset_pdata; } return 0; err_unset_pdata: platform_set_drvdata(qi_lb60_snd_device, NULL); /*err_gpio_free_array:*/ gpio_free_array(qi_lb60_gpios, ARRAY_SIZE(qi_lb60_gpios)); err_device_put: platform_device_put(qi_lb60_snd_device); return ret; }
void ev3_output_port_unregister(struct lego_port_device *port) { struct ev3_output_port_data *data; /* port can be null if disabled via module parameter */ if (!port) return; data = container_of(port, struct ev3_output_port_data, out_port); pwm_disable(data->pwm); pwm_put(data->pwm); hrtimer_cancel(&data->timer); cancel_work_sync(&data->change_uevent_work); cancel_work_sync(&data->work); if (data->motor) ev3_output_port_unregister_motor(&data->work); if (port->mode == EV3_OUTPUT_PORT_MODE_RAW) ev3_output_port_disable_raw_mode(data); lego_port_unregister(&data->out_port); ev3_output_port_float(data); gpio_free_array(data->gpio, ARRAY_SIZE(data->gpio)); put_legoev3_analog(data->analog); dev_set_drvdata(&port->dev, NULL); kfree(data); }
static int mx31_3ds_sdhc1_init(struct device *dev, irq_handler_t detect_irq, void *data) { int ret; ret = gpio_request_array(mx31_3ds_sdhc1_gpios, ARRAY_SIZE(mx31_3ds_sdhc1_gpios)); if (ret) { pr_warning("Unable to request the SD/MMC GPIOs.\n"); return ret; } ret = request_irq(IOMUX_TO_IRQ(MX31_PIN_GPIO3_1), detect_irq, IRQF_DISABLED | IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "sdhc1-detect", data); if (ret) { pr_warning("Unable to request the SD/MMC card-detect IRQ.\n"); goto gpio_free; } return 0; gpio_free: gpio_free_array(mx31_3ds_sdhc1_gpios, ARRAY_SIZE(mx31_3ds_sdhc1_gpios)); return ret; }
static __devinit int palmld_pata_probe(struct platform_device *pdev) { struct ata_host *host; struct ata_port *ap; void __iomem *mem; int ret; /* allocate host */ host = ata_host_alloc(&pdev->dev, 1); if (!host) { ret = -ENOMEM; goto err1; } /* remap drive's physical memory address */ mem = devm_ioremap(&pdev->dev, PALMLD_IDE_PHYS, 0x1000); if (!mem) { ret = -ENOMEM; goto err1; } /* request and activate power GPIO, IRQ GPIO */ ret = gpio_request_array(palmld_hdd_gpios, ARRAY_SIZE(palmld_hdd_gpios)); if (ret) goto err1; /* reset the drive */ gpio_set_value(GPIO_NR_PALMLD_IDE_RESET, 0); msleep(30); gpio_set_value(GPIO_NR_PALMLD_IDE_RESET, 1); msleep(30); /* setup the ata port */ ap = host->ports[0]; ap->ops = &palmld_port_ops; ap->pio_mask = ATA_PIO4; ap->flags |= ATA_FLAG_PIO_POLLING; /* memory mapping voodoo */ ap->ioaddr.cmd_addr = mem + 0x10; ap->ioaddr.altstatus_addr = mem + 0xe; ap->ioaddr.ctl_addr = mem + 0xe; /* start the port */ ata_sff_std_ports(&ap->ioaddr); /* activate host */ ret = ata_host_activate(host, 0, NULL, IRQF_TRIGGER_RISING, &palmld_sht); if (ret) goto err2; return ret; err2: gpio_free_array(palmld_hdd_gpios, ARRAY_SIZE(palmld_hdd_gpios)); err1: return ret; }
/** * gpio_pmodoled_init_gpio - Initialize GPIO for ZED Onboard OLED * @dev - gpio_pmodoled_device * * Initializes OLED GPIO Control Pins. * It returns 0, if the gpio pins are successfully * initialized, or a negative value if there is an error. */ static int gpio_pmodoled_init_gpio(struct gpio_pmodoled_device *dev) { struct gpio gpio_pmodoled_ctrl[] = { {dev->iVBAT, GPIOF_OUT_INIT_HIGH, "OLED VBat"}, {dev->iVDD, GPIOF_OUT_INIT_HIGH, "OLED VDD"}, {dev->iRES, GPIOF_OUT_INIT_HIGH, "OLED_RESET"}, {dev->iDC, GPIOF_OUT_INIT_HIGH, "OLED_D/C"}, }; int status; int i; for (i = 0; i < ARRAY_SIZE(gpio_pmodoled_ctrl); i++) { status = gpio_is_valid(gpio_pmodoled_ctrl[i].gpio); if (!status) { dev_err(&dev->spi->dev, "!! gpio_is_valid for GPIO %d, %s FAILED!, status: %d\n", gpio_pmodoled_ctrl[i].gpio, gpio_pmodoled_ctrl[i].label, status); goto gpio_invalid; } } status = gpio_request_array(gpio_pmodoled_ctrl, ARRAY_SIZE(gpio_pmodoled_ctrl)); if (status) { dev_err(&dev->spi->dev, "!! gpio_request_array FAILED!\n"); dev_err(&dev->spi->dev, " status is: %d\n", status); gpio_free_array(gpio_pmodoled_ctrl, 4); goto gpio_invalid; } gpio_invalid: return status; }
static void __init cm_t35_init_display(void) { int err; spi_register_board_info(cm_t35_lcd_spi_board_info, ARRAY_SIZE(cm_t35_lcd_spi_board_info)); err = gpio_request_array(cm_t35_dss_gpios, ARRAY_SIZE(cm_t35_dss_gpios)); if (err) { pr_err("CM-T35: failed to request DSS control GPIOs\n"); return; } gpio_export(CM_T35_LCD_EN_GPIO, 0); gpio_export(CM_T35_LCD_BL_GPIO, 0); gpio_export(CM_T35_DVI_EN_GPIO, 0); msleep(50); gpio_set_value(CM_T35_LCD_EN_GPIO, 1); err = omap_display_init(&cm_t35_dss_data); if (err) { pr_err("CM-T35: failed to register DSS device\n"); gpio_free_array(cm_t35_dss_gpios, ARRAY_SIZE(cm_t35_dss_gpios)); } }
static void wm1250_ev1_free(struct i2c_client *i2c) { struct wm1250_priv *wm1250 = dev_get_drvdata(&i2c->dev); if (wm1250) gpio_free_array(wm1250->gpios, ARRAY_SIZE(wm1250->gpios)); }
static void __init omap3_beagle_init_rev(void) { int ret; u16 beagle_rev = 0; omap_mux_init_gpio(171, OMAP_PIN_INPUT_PULLUP); omap_mux_init_gpio(172, OMAP_PIN_INPUT_PULLUP); omap_mux_init_gpio(173, OMAP_PIN_INPUT_PULLUP); ret = gpio_request_array(omap3_beagle_rev_gpios, ARRAY_SIZE(omap3_beagle_rev_gpios)); if (ret < 0) { printk(KERN_ERR "Unable to get revision detection GPIO pins\n"); omap3_beagle_version = OMAP3BEAGLE_BOARD_UNKN; return; } beagle_rev = gpio_get_value(171) | (gpio_get_value(172) << 1) | (gpio_get_value(173) << 2); gpio_free_array(omap3_beagle_rev_gpios, ARRAY_SIZE(omap3_beagle_rev_gpios)); switch (beagle_rev) { case 7: printk(KERN_INFO "OMAP3 Beagle Rev: Ax/Bx\n"); omap3_beagle_version = OMAP3BEAGLE_BOARD_AXBX; beagle_config.mmc1_gpio_wp = 29; beagle_config.reset_gpio = 170; beagle_config.usr_button_gpio = 7; break; case 6: printk(KERN_INFO "OMAP3 Beagle Rev: C1/C2/C3\n"); omap3_beagle_version = OMAP3BEAGLE_BOARD_C1_3; beagle_config.mmc1_gpio_wp = 23; beagle_config.reset_gpio = 170; beagle_config.usr_button_gpio = 7; break; case 5: printk(KERN_INFO "OMAP3 Beagle Rev: C4\n"); omap3_beagle_version = OMAP3BEAGLE_BOARD_C4; beagle_config.mmc1_gpio_wp = 23; beagle_config.reset_gpio = 170; beagle_config.usr_button_gpio = 7; break; case 0: printk(KERN_INFO "OMAP3 Beagle Rev: xM Ax/Bx\n"); omap3_beagle_version = OMAP3BEAGLE_BOARD_XM; beagle_config.usb_pwr_level = GPIOF_OUT_INIT_HIGH; break; case 2: printk(KERN_INFO "OMAP3 Beagle Rev: xM C\n"); omap3_beagle_version = OMAP3BEAGLE_BOARD_XMC; break; default: printk(KERN_INFO "OMAP3 Beagle Rev: unknown %hd\n", beagle_rev); omap3_beagle_version = OMAP3BEAGLE_BOARD_UNKN; } }
static int hx4700_audio_remove(struct platform_device *pdev) { gpio_set_value(GPIO92_HX4700_HP_DRIVER, 0); gpio_set_value(GPIO107_HX4700_SPK_nSD, 0); gpio_free_array(hx4700_audio_gpios, ARRAY_SIZE(hx4700_audio_gpios)); return 0; }
static int e750_remove(struct platform_device *pdev) { struct snd_soc_card *card = platform_get_drvdata(pdev); gpio_free_array(e750_audio_gpios, ARRAY_SIZE(e750_audio_gpios)); snd_soc_unregister_card(card); return 0; }
// Exit of the module static void __exit tphonekp_exit(void) { int i; // Unregister and free the input device input_unregister_device(input); input_free_device(input); printk(KERN_NOTICE "toxphone: freeing GPIO"); // Free irqs and GPIOs for(i=0 ; i<NB_ROWS ; i++) { free_irq(irq_pin[i], &gpio_rows[i]); } gpio_free_array(gpio_col, NB_COLUMN); gpio_free_array(gpio_rows, NB_ROWS); printk(KERN_NOTICE "toxphone: keypad driver exit"); }
static int hummingbird_touch_release_resources(struct device *dev) { regulator_put(hummingbird_touch_vdd); regulator_put(hummingbird_touch_power); gpio_free_array(hummingbird_touch_gpios, ARRAY_SIZE(hummingbird_touch_gpios)); return 0; }
static int mmi_factory_remove(struct platform_device *pdev) { struct mmi_factory_info *info = platform_get_drvdata(pdev); if (info) gpio_free_array(info->list, info->num_gpios); return 0; }
static void __exit neo1973_exit(void) { platform_device_unregister(neo1973_snd_device); if (machine_is_neo1973_gta02()) { gpio_free_array(neo1973_gta02_gpios, ARRAY_SIZE(neo1973_gta02_gpios)); } }
static int baseband_xmm_power_driver_remove(struct platform_device *device) { int i; struct baseband_power_platform_data *data = (struct baseband_power_platform_data *) device->dev.platform_data; struct device *dev = &device->dev; pr_debug("%s\n", __func__); /* check for platform data */ if (!data) return 0; usb_unregister_notify(&usb_xmm_nb); /* free work structure */ kfree(baseband_xmm_power_work); baseband_xmm_power_work = (struct baseband_xmm_power_work_t *) 0; /* free baseband irq(s) */ if (modem_flash && modem_pm) { free_irq(gpio_to_irq(baseband_power_driver_data ->modem.xmm.ipc_ap_wake), NULL); } /* free baseband gpio(s) */ gpio_free_array(tegra_baseband_gpios, ARRAY_SIZE(tegra_baseband_gpios)); /* disable regulator LDO7 for hsic power*/ regulator_disable(reg_grouper_hsic); regulator_put(reg_grouper_hsic); reg_grouper_hsic = NULL; /* destroy wake lock */ wake_lock_destroy(&wakelock); wake_lock_destroy(&modem_recovery_wakelock); /* delete device file */ /* device_remove_file(dev, &dev_attr_xmm_onoff); */ for (i = 0; i < (ARRAY_SIZE(xmm_device_attr) - 1); i++) { device_remove_file(dev, &xmm_device_attr[i]); } /* unregister usb host controller */ if (data->hsic_unregister && (!register_hsic_device)) { register_hsic_device = true; data->hsic_unregister(data->modem.xmm.hsic_device); }else pr_err("%s: hsic_unregister is missing\n", __func__); return 0; }
/** @brief The LKM cleanup function * Similar to the initialization function, it is static. The __exit macro notifies that if this * code is used for a built-in driver (not a LKM) that this function is not required. */ static void __exit ebbButton_exit(void) { printk(KERN_INFO "EBB Button: The button was pressed %d times\n", numberPresses); kobject_put(ebb_kobj); // clean up -- remove the kobject sysfs entry free_irq(irqNumber, NULL); // Free the IRQ number, no *dev_id required in this case // free inputs gpio_free_array(btn_gpios, ARRAY_SIZE(btn_gpios)); printk(KERN_INFO "EBB Button: Goodbye from the EBB Button LKM!\n"); }
static int __devexit hx4700_audio_remove(struct platform_device *pdev) { snd_soc_jack_free_gpios(&hs_jack, 1, &hs_jack_gpio); snd_soc_unregister_card(&snd_soc_card_hx4700); gpio_set_value(GPIO92_HX4700_HP_DRIVER, 0); gpio_set_value(GPIO107_HX4700_SPK_nSD, 0); gpio_free_array(hx4700_audio_gpios, ARRAY_SIZE(hx4700_audio_gpios)); return 0; }
static void tlc5947_exit(void) { if(tlc5947_cdev) { cdev_del(tlc5947_cdev); } if(tlc5947_major_number > -1) { unregister_chrdev_region(tlc5947_numbers, tlc5947_minor_count); } if((tlc5947[0].gpio == tlc5947_data) && (tlc5947[1].gpio == tlc5947_clock) && (tlc5947[2].gpio == tlc5947_latch)) { gpio_free_array(tlc5947, TLC5947_GPIOS); } }
static inline void __init palmz72_cam_gpio_init(void) { int ret; ret = gpio_request_array(ARRAY_AND_SIZE(palmz72_camera_gpios)); if (!ret) gpio_free_array(ARRAY_AND_SIZE(palmz72_camera_gpios)); else printk(KERN_ERR "Camera GPIO init failed!\n"); return; }
static __devexit int palmld_pata_remove(struct platform_device *dev) { struct ata_host *host = platform_get_drvdata(dev); ata_host_detach(host); /* power down the HDD */ gpio_set_value(GPIO_NR_PALMLD_IDE_PWEN, 0); gpio_free_array(palmld_hdd_gpios, ARRAY_SIZE(palmld_hdd_gpios)); return 0; }
static void uc_msp430_exit(void) { D(KERN_INFO, "exit.\n"); gpio_set_value(UC_MSP430_RED_GPIO, 1); gpio_set_value(UC_MSP430_GREEN_GPIO, 0); free_irq(uc_msp430_irq_addr, (void*) uc_msp430_driver); gpio_free_array(uc_msp430_gpio_array, ARRAY_SIZE(uc_msp430_gpio_array)); D(KERN_INFO "exited.\n"); }
/* * Module exit function */ static void __exit gpiomod_exit(void) { int i; printk(KERN_INFO "%s\n", __func__); // turn all LEDs off for(i = 0; i < ARRAY_SIZE(leds); i++) { gpio_set_value(leds[i].gpio, 0); } // unregister all GPIOs gpio_free_array(leds, ARRAY_SIZE(leds)); }