static int i2c_camera_power(struct device *dev, int on) { int res, ret = 0; pr_debug("%s: %s the camera\n", __func__, on ? "ENABLE" : "DISABLE"); res = devm_gpio_request(dev, camera_power_pin, "ov2640_power"); if (res < 0) { printk("can't request ov2640_power pin\n"); return -1; } res = devm_gpio_request(dev, camera_reset_pin, "ov2640_reset"); if (res < 0) { printk("can't request ov2640_reset pin\n"); devm_gpio_free(dev, camera_power_pin); return -1; } /* enable or disable the camera */ res = gpio_direction_output(camera_power_pin, !on); if (res < 0) { printk("can't request output direction for ov2640_power pin\n"); ret = -1; goto out; } if (!on) goto out; /* If enabled, give a reset impulse */ res = gpio_direction_output(camera_reset_pin, 0); if (res < 0) { printk("can't request output direction for ov2640_reset pin\n"); ret = -1; goto out; } msleep(20); res = gpio_direction_output(camera_reset_pin, 1); if (res < 0) { printk("can't request output direction for ov2640_reset pin\n"); ret = -1; goto out; } msleep(100); out: devm_gpio_free(dev, camera_reset_pin); devm_gpio_free(dev, camera_power_pin); return ret; }
static void poweroff_seq(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev); if (apb->init_disabled || apb->state == ARCHE_PLATFORM_STATE_OFF) return; if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING && gpio_is_valid(apb->spi_en_gpio)) devm_gpio_free(dev, apb->spi_en_gpio); /* disable the clock */ if (gpio_is_valid(apb->clk_en_gpio)) gpio_set_value(apb->clk_en_gpio, 0); if (!IS_ERR(apb->vcore) && regulator_is_enabled(apb->vcore) > 0) regulator_disable(apb->vcore); if (!IS_ERR(apb->vio) && regulator_is_enabled(apb->vio) > 0) regulator_disable(apb->vio); /* As part of exit, put APB back in reset state */ assert_reset(apb->resetn_gpio); apb->state = ARCHE_PLATFORM_STATE_OFF; /* TODO: May have to send an event to SVC about this exit */ }
static int standby_boot_seq(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev); if (apb->init_disabled) return 0; /* Even if it is in OFF state, then we do not want to change the state */ if (apb->state == ARCHE_PLATFORM_STATE_STANDBY || apb->state == ARCHE_PLATFORM_STATE_OFF) return 0; if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING && gpio_is_valid(apb->spi_en_gpio)) devm_gpio_free(dev, apb->spi_en_gpio); /* * As per WDM spec, do nothing * * Pasted from WDM spec, * - A falling edge on POWEROFF_L is detected (a) * - WDM enters standby mode, but no output signals are changed */ /* TODO: POWEROFF_L is input to WDM module */ apb->state = ARCHE_PLATFORM_STATE_STANDBY; return 0; }
static int sdhci_acpi_add_own_cd(struct device *dev, int gpio, struct mmc_host *mmc) { unsigned long flags; int err, irq; if (gpio < 0) { err = gpio; goto out; } err = devm_gpio_request_one(dev, gpio, GPIOF_DIR_IN, "sd_cd"); if (err) goto out; irq = gpio_to_irq(gpio); if (irq < 0) { err = irq; goto out_free; } flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING; err = devm_request_irq(dev, irq, sdhci_acpi_sd_cd, flags, "sd_cd", mmc); if (err) goto out_free; return 0; out_free: devm_gpio_free(dev, gpio); out: dev_warn(dev, "failed to setup card detect wake up\n"); return err; }
static void __exit tgpio_exit(void) { struct private_data *p = dev_get_drvdata(&device); devm_gpio_free(&device, p->gpio_num); del_timer(&p->timeout); device_remove_file(&device, &dev_attr_timer_timeout); device_unregister(&device); }
static int mcuio_dio_probe(struct mcuio_device *mdev) { struct mcuio_shld_i2c_info *i; int cnt; int ret; struct mcuio_shld_data *data; dev_dbg(&mdev->dev, "%s entered\n", __func__); data = devm_kzalloc(&mdev->dev, sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; dev_set_drvdata(&mdev->dev, data); /* Apply module_param values to platform_data when needed */ pca9555_plat.gpio_base = pca9555_base; data->i2c_adap = mcuio_get_i2c_adapter(mdev); if (!data->i2c_adap) { dev_err(&mdev->dev, "error setting up i2c adapter\n"); return -ENODEV; } data->i2c_info = i2c_lst; data->i2c_cnt = ARRAY_SIZE(i2c_lst); /* Register all devices in Digital IO shield */ for (cnt = 0; cnt < data->i2c_cnt; cnt++) { i = &data->i2c_info[cnt]; i->info.addr = *i->paddr; /* HACK this is needed to enable pullup */ ret = devm_gpio_request_one(&mdev->dev, i->gpio_irq, GPIOF_DIR_IN, "digitalio-shield"); if (ret < 0) return ret; gpio_direction_output(i->gpio_irq, 1); gpio_direction_input(i->gpio_irq); devm_gpio_free(&mdev->dev, i->gpio_irq); i->info.irq = (i->gpio_irq >= 0) ? gpio_to_irq(i->gpio_irq) : 0; i->i2c_client = i2c_new_device(data->i2c_adap, &i->info); if (!i->i2c_client) dev_err(&mdev->dev, "i2c_new_device %s failed\n", i->info.type); } dev_dbg(&mdev->dev, "%s returns ok\n", __func__); return 0; }
static int de1soc_audio_remove(struct platform_device *pdev) { struct snd_soc_card *card = platform_get_drvdata(pdev); if (gpio_is_valid(i2c_mux_gpio)) devm_gpio_free(&pdev->dev, i2c_mux_gpio); snd_soc_unregister_card(card); return 0; }
/** * mmc_gpio_free_ro - free the write-protection gpio * @host: mmc host * * It's provided only for cases that client drivers need to manually free * up the write-protection gpio requested by mmc_gpio_request_ro(). */ void mmc_gpio_free_ro(struct mmc_host *host) { struct mmc_gpio *ctx = host->slot.handler_priv; int gpio; if (!ctx || !gpio_is_valid(ctx->ro_gpio)) return; gpio = ctx->ro_gpio; ctx->ro_gpio = -EINVAL; devm_gpio_free(&host->class_dev, gpio); }
/** * mmc_gpio_free_ro - free the write-protection gpio * @host: mmc host * * It's provided only for cases that client drivers need to manually free * up the write-protection gpio requested by mmc_gpio_request_ro(). */ void mmc_gpio_free_ro(struct mmc_host *host) { struct mmc_gpio *ctx = host->slot.handler_priv; int gpio; if (!ctx || !ctx->ro_gpio) return; gpio = desc_to_gpio(ctx->ro_gpio); ctx->ro_gpio = NULL; devm_gpio_free(&host->class_dev, gpio); }
/* * Note: Please do not modify the below sequence, as it is as per the spec */ static int coldboot_seq(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev); int ret; if (apb->init_disabled || apb->state == ARCHE_PLATFORM_STATE_ACTIVE) return 0; /* Hold APB in reset state */ assert_reset(apb->resetn_gpio); if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING && gpio_is_valid(apb->spi_en_gpio)) devm_gpio_free(dev, apb->spi_en_gpio); /* Enable power to APB */ if (!IS_ERR(apb->vcore)) { ret = regulator_enable(apb->vcore); if (ret) { dev_err(dev, "failed to enable core regulator\n"); return ret; } } if (!IS_ERR(apb->vio)) { ret = regulator_enable(apb->vio); if (ret) { dev_err(dev, "failed to enable IO regulator\n"); return ret; } } apb_bootret_deassert(dev); /* On DB3 clock was not mandatory */ if (gpio_is_valid(apb->clk_en_gpio)) gpio_set_value(apb->clk_en_gpio, 1); usleep_range(100, 200); /* deassert reset to APB : Active-low signal */ deassert_reset(apb->resetn_gpio); apb->state = ARCHE_PLATFORM_STATE_ACTIVE; return 0; }
/** * mmc_gpio_free_cd - free the card-detection gpio * @host: mmc host * * It's provided only for cases that client drivers need to manually free * up the card-detection gpio requested by mmc_gpio_request_cd(). */ void mmc_gpio_free_cd(struct mmc_host *host) { struct mmc_gpio *ctx = host->slot.handler_priv; int gpio; if (!ctx || !gpio_is_valid(ctx->cd_gpio)) return; if (host->slot.cd_irq >= 0) { devm_free_irq(&host->class_dev, host->slot.cd_irq, host); host->slot.cd_irq = -EINVAL; } gpio = ctx->cd_gpio; ctx->cd_gpio = -EINVAL; devm_gpio_free(&host->class_dev, gpio); }
static int hinge_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct hinge_data *data = NULL; struct hinge_platform_data *pdata; int err = 0; int value; int retries; int bootcfg_value, reset_value; int gpio_init_flags; dev_info(&client->dev, "%s: enter\n", __func__); #if 0 if (client->addr != HINGE_SLAVE_ADDRESS) { dev_err(&client->dev, "Unexpected slave address 0x%02x\n", client->addr); err = -EINVAL; goto error_1; } #endif pdata = client->dev.platform_data; if (!pdata) { dev_err(&client->dev, "Missing platform data.\n"); err = -EINVAL; goto error_1; } data = kzalloc(sizeof(struct hinge_data), GFP_KERNEL); if (!data) { err = -ENOMEM; goto error_1; } i2c_set_clientdata(client, data); data->dev = &client->dev; data->idev = input_allocate_device(); CHECK_ERROR(!data->idev, error_2, "Failed to allocate input device!\n"); data->idev->name = HINGE_NAME "-keys"; data->idev->phys = HINGE_NAME "-keys/input0"; data->idev->id.bustype = BUS_I2C; data->idev->dev.parent = &client->dev; set_bit(EV_KEY, data->idev->evbit); set_bit(KEY_CAMERA, data->idev->keybit); set_bit(KEY_CAMERA_FOCUS, data->idev->keybit); set_bit(EV_SW, data->idev->evbit); set_bit(SW_RFKILL_ALL, data->idev->swbit); err = input_register_device(data->idev); CHECK_ERROR(err, error_3, "Failed to register input device: %d\n", err); wake_lock_init(&data->wakelock, WAKE_LOCK_SUSPEND, "hinge_wakelock"); dev_info(&client->dev, "Defined GPIOs\n"); dev_info(&client->dev, "reset_gpio: %d\n", pdata->reset_gpio); dev_info(&client->dev, "bootcfg_gpio: %d\n", pdata->bootcfg_gpio); dev_info(&client->dev, "preview_gpio: %d\n", pdata->irq_preview_gpio); dev_info(&client->dev, "photo_gpio: %d\n", pdata->irq_photo_gpio); dev_info(&client->dev, "hinge_gpio: %d\n", pdata->irq_hinge_gpio); err = -EINVAL; CHECK_ERROR(pdata->irq_hinge_gpio == -1, error_4, "hinge_gpio is not defined\n"); data->irq_hinge = gpio_to_irq(pdata->irq_hinge_gpio); CHECK_ERROR(pdata->irq_photo_gpio == -1, error_4, "photo_gpio is not defined\n"); data->irq_photo = gpio_to_irq(pdata->irq_photo_gpio); CHECK_ERROR(pdata->irq_preview_gpio == -1, error_4, "preview_gpio is not defined\n"); data->irq_preview = gpio_to_irq(pdata->irq_preview_gpio); data->irq_hinge = gpio_to_irq(pdata->irq_hinge_gpio); data->irq_photo = gpio_to_irq(pdata->irq_photo_gpio); data->irq_preview = gpio_to_irq(pdata->irq_preview_gpio); data->hinge_gpio = pdata->irq_hinge_gpio; data->photo_gpio = pdata->irq_photo_gpio; data->preview_gpio = pdata->irq_preview_gpio; data->bootcfg_gpio = pdata->bootcfg_gpio; data->reset_gpio = pdata->reset_gpio; data->active_polarity = pdata->active_polarity; dev_info(&client->dev, "active_polarity=%d\n", data->active_polarity); /* reset and bootcfg initial config depends on polarity */ gpio_init_flags = data->active_polarity ? GPIOF_OUT_INIT_LOW : GPIOF_OUT_INIT_HIGH; err = -EINVAL; CHECK_ERROR(data->bootcfg_gpio == -1, error_4, "bootcfg_gpio is not defined\n"); err = devm_gpio_request_one(data->dev, data->bootcfg_gpio, gpio_init_flags, "mcu_bootcfg0"); CHECK_ERROR(err, error_4, "Failed to request bootcfg gpio (%d): %d\n", data->bootcfg_gpio, err); err = -EINVAL; CHECK_ERROR(data->reset_gpio == -1, error_5, "reset_gpio is not defined\n"); err = devm_gpio_request_one(data->dev, data->reset_gpio, gpio_init_flags, "mcu_reset"); CHECK_ERROR(err, error_5, "Failed to request reset gpio (%d): %d\n", data->reset_gpio, err); err = -EINVAL; CHECK_ERROR(data->hinge_gpio == -1, error_6, "hinge_gpio is not defined\n"); err = devm_gpio_request_one(data->dev, data->hinge_gpio, GPIOF_IN, "mcu_hinge"); CHECK_ERROR(err, error_6, "Failed to request hinge gpio (%d): %d\n", data->hinge_gpio, err); err = -EINVAL; CHECK_ERROR(data->photo_gpio == -1, error_7, "photo_gpio is not defined\n"); err = devm_gpio_request_one(data->dev, data->photo_gpio, GPIOF_IN, "mcu_photo"); CHECK_ERROR(err, error_7, "Failed to request photo gpio (%d): %d\n", data->photo_gpio, err); err = -EINVAL; CHECK_ERROR(data->preview_gpio == -1, error_8, "preview_gpio is not defined\n"); err = devm_gpio_request_one(data->dev, data->preview_gpio, GPIOF_IN, "mcu_preview"); CHECK_ERROR(err, error_8, "Failed to request preview gpio (%d): %d\n", data->preview_gpio, err); err = request_threaded_irq(data->irq_hinge, NULL, hinge_irq_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT | IRQF_NO_SUSPEND, HINGE_NAME "-hinge", data); CHECK_ERROR(err, error_9, "Failed to register hinge irq %d (gpio %d): %d\n", data->irq_hinge, pdata->irq_hinge_gpio, err); err = request_threaded_irq(data->irq_photo, NULL, hinge_irq_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT | IRQF_NO_SUSPEND, HINGE_NAME "-photo", data); CHECK_ERROR(err, error_10, "Failed to register photo irq %d (gpio %d): %d\n", data->irq_photo, pdata->irq_photo_gpio, err); err = request_threaded_irq(data->irq_preview, NULL, hinge_irq_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT | IRQF_NO_SUSPEND, HINGE_NAME "-preview", data); CHECK_ERROR(err, error_11, "Failed to register preview irq %d (gpio %d): %d\n", data->irq_preview, pdata->irq_preview_gpio, err); err = sysfs_create_group(&data->dev->kobj, &hinge_attr_group); CHECK_ERROR(err, error_12, "Failed to create sysfs nodes: %d\n", err); /* read initial values of bootcfg and reset */ bootcfg_value = hinge_get_bootcfg(data); reset_value = hinge_get_reset(data); dev_warn(&client->dev, "Initial values: bootcfg=%d reset=%d\n", bootcfg_value, reset_value); retries = 10; do { hinge_determine_status(data); } while (data->mcu_status == MCU_STATUS_ERROR && retries--); /* if the MCU still can't be reached, try resetting it between attempts */ hinge_set_bootcfg(data, false); retries = 5; while (data->mcu_status == MCU_STATUS_ERROR && retries--) { hinge_set_reset(data, true); usleep_range(10000, 10500); hinge_set_reset(data, false); usleep_range(10000, 10500); hinge_determine_status(data); } if (data->mcu_status == MCU_STATUS_RESET) { dev_info(data->dev, "MCU in reset at boot\n"); /* make sure the MCU is not left in reset */ retries = 10; do { hinge_set_bootcfg(data, false); hinge_set_reset(data, false); usleep_range(10000, 10500); hinge_determine_status(data); } while ((data->mcu_status == MCU_STATUS_RESET || data->mcu_status == MCU_STATUS_ERROR) && retries--); if (data->mcu_status == MCU_STATUS_RESET) dev_err(data->dev, "Failed to take the MCU out of reset\n"); } if (data->mcu_status == MCU_STATUS_BOOTLOADER) { dev_info(data->dev, "MCU in bootloader at boot\n"); hinge_bl_jumpstart(data); usleep_range(10000, 10500); hinge_determine_status(data); if (data->mcu_status != MCU_STATUS_RUNNING) dev_err(data->dev, "Failed to jumpstart the MCU\n"); } if (data->mcu_status == MCU_STATUS_RUNNING) { err = hinge_read_reg(data, REG_FIRMWARE_REVISION, &value); if (err) dev_warn(&client->dev, "WARNING: Failed to read MCU firmware revision: %d\n", err); else dev_info(&client->dev, "Firmware revision is %08x\n", value); /* dump programmed thresholds */ hinge_read_reg(data, REG_HALL_HINGE_CLOSED, &value); dev_info(data->dev, "hinge_closed=%08x\n", value); hinge_read_reg(data, REG_HALL_HINGE_OPENED, &value); dev_info(data->dev, "hinge_opened=%08x\n", value); hinge_read_reg(data, REG_HALL_PREVIEW_PRESSED, &value); dev_info(data->dev, "preview_pressed=%08x\n", value); hinge_read_reg(data, REG_HALL_PREVIEW_RELEASED, &value); dev_info(data->dev, "preview_released=%08x\n", value); hinge_read_reg(data, REG_HALL_PHOTO_PRESSED, &value); dev_info(data->dev, "photo_pressed=%08x\n", value); hinge_read_reg(data, REG_HALL_PHOTO_RELEASED, &value); dev_info(data->dev, "photo_released=%08x\n", value); /* send initial hinge state event */ handle_hinge_event(data, true); } else if (data->mcu_status == MCU_STATUS_ERROR) { dev_info(data->dev, "MCU in unknown state at boot, holding it in reset for safety.\n"); hinge_set_bootcfg(data, false); hinge_set_reset(data, true); } dev_info(&client->dev, "%s: exit\n", __func__); return 0; /* error_13: sysfs_remove_group(&data->dev->kobj, &hinge_attr_group); */ error_12: free_irq(data->irq_preview, data); error_11: free_irq(data->irq_photo, data); error_10: free_irq(data->irq_hinge, data); error_9: devm_gpio_free(data->dev, data->preview_gpio); error_8: devm_gpio_free(data->dev, data->photo_gpio); error_7: devm_gpio_free(data->dev, data->hinge_gpio); error_6: devm_gpio_free(data->dev, data->reset_gpio); error_5: devm_gpio_free(data->dev, data->bootcfg_gpio); error_4: input_unregister_device(data->idev); error_3: input_free_device(data->idev); error_2: i2c_set_clientdata(client, NULL); wake_lock_destroy(&data->wakelock); kfree(data); error_1: dev_info(&client->dev, "%s: error: %d\n", __func__, err); return err; }