static int __devinit z2_batt_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; int props = 1; /* POWER_SUPPLY_PROP_PRESENT */ struct z2_charger *charger; struct z2_battery_info *info = client->dev.platform_data; if (info == NULL) { dev_err(&client->dev, "Please set platform device platform_data" " to a valid z2_battery_info pointer!\n"); return -EINVAL; } charger = kzalloc(sizeof(*charger), GFP_KERNEL); if (charger == NULL) return -ENOMEM; charger->bat_status = POWER_SUPPLY_STATUS_UNKNOWN; charger->info = info; charger->client = client; i2c_set_clientdata(client, charger); mutex_init(&charger->work_lock); if (info->charge_gpio >= 0 && gpio_is_valid(info->charge_gpio)) { ret = gpio_request(info->charge_gpio, "BATT CHRG"); if (ret) goto err; ret = gpio_direction_input(info->charge_gpio); if (ret) goto err2; set_irq_type(gpio_to_irq(info->charge_gpio), IRQ_TYPE_EDGE_BOTH); ret = request_irq(gpio_to_irq(info->charge_gpio), z2_charge_switch_irq, IRQF_DISABLED, "AC Detect", charger); if (ret) goto err3; } ret = z2_batt_ps_init(charger, props); if (ret) goto err3; INIT_WORK(&charger->bat_work, z2_batt_work); ret = power_supply_register(&client->dev, &charger->batt_ps); if (ret) goto err4; schedule_work(&charger->bat_work); return 0; err4: kfree(charger->batt_ps.properties); err3: if (info->charge_gpio >= 0 && gpio_is_valid(info->charge_gpio)) free_irq(gpio_to_irq(info->charge_gpio), charger); err2: if (info->charge_gpio >= 0 && gpio_is_valid(info->charge_gpio)) gpio_free(info->charge_gpio); err: kfree(charger); return ret; }
static int nxp_nci_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct nxp_nci_i2c_phy *phy; struct nxp_nci_nfc_platform_data *pdata; int r; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { nfc_err(&client->dev, "Need I2C_FUNC_I2C\n"); r = -ENODEV; goto probe_exit; } phy = devm_kzalloc(&client->dev, sizeof(struct nxp_nci_i2c_phy), GFP_KERNEL); if (!phy) { r = -ENOMEM; goto probe_exit; } phy->i2c_dev = client; i2c_set_clientdata(client, phy); pdata = client->dev.platform_data; if (!pdata && client->dev.of_node) { r = nxp_nci_i2c_parse_devtree(client); if (r < 0) { nfc_err(&client->dev, "Failed to get DT data\n"); goto probe_exit; } } else if (pdata) { phy->gpio_en = pdata->gpio_en; phy->gpio_fw = pdata->gpio_fw; } else if (ACPI_HANDLE(&client->dev)) { r = nxp_nci_i2c_acpi_config(phy); if (r < 0) goto probe_exit; goto nci_probe; } else { nfc_err(&client->dev, "No platform data\n"); r = -EINVAL; goto probe_exit; } r = devm_gpio_request_one(&phy->i2c_dev->dev, phy->gpio_en, GPIOF_OUT_INIT_LOW, "nxp_nci_en"); if (r < 0) goto probe_exit; r = devm_gpio_request_one(&phy->i2c_dev->dev, phy->gpio_fw, GPIOF_OUT_INIT_LOW, "nxp_nci_fw"); if (r < 0) goto probe_exit; nci_probe: r = nxp_nci_probe(phy, &client->dev, &i2c_phy_ops, NXP_NCI_I2C_MAX_PAYLOAD, &phy->ndev); if (r < 0) goto probe_exit; r = request_threaded_irq(client->irq, NULL, nxp_nci_i2c_irq_thread_fn, IRQF_TRIGGER_RISING | IRQF_ONESHOT, NXP_NCI_I2C_DRIVER_NAME, phy); if (r < 0) nfc_err(&client->dev, "Unable to register IRQ handler\n"); probe_exit: return r; }
static int __devinit smb349_probe(struct i2c_client *client, const struct i2c_device_id *id) { const struct smb349_platform_data *pdata; struct smb349_struct *smb349_chg; int ret = 0; pdata = client->dev.platform_data; if (pdata == NULL) { dev_err(&client->dev, "%s no platform data\n", __func__); ret = -EINVAL; goto out; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { ret = -EIO; goto out; } smb349_chg = kzalloc(sizeof(*smb349_chg), GFP_KERNEL); if (!smb349_chg) { ret = -ENOMEM; goto out; } smb349_chg->client = client; smb349_chg->chg_current_ma = pdata->chg_current_ma; ret = gpio_request(pdata->chg_susp_gpio, "smb349_suspend"); if (ret) { dev_err(&client->dev, "%s gpio_request failed for %d ret=%d\n", __func__, pdata->chg_susp_gpio, ret); goto free_smb349_chg; } smb349_chg->chg_susp_gpio = pdata->chg_susp_gpio; ret = gpio_request(pdata->en_n_gpio, "smb349_charger_enable"); if (ret) { dev_err(&client->dev, "%s gpio_request failed for %d ret=%d\n", __func__, pdata->en_n_gpio, ret); goto chg_susp_gpio_fail; } smb349_chg->en_n_gpio = pdata->en_n_gpio; i2c_set_clientdata(client, smb349_chg); ret = smb349_hwinit(smb349_chg); if (ret) goto free_smb349_chg; ret = smb349_init_ext_chg(smb349_chg); if (ret) goto chg_en_gpio_fail; the_smb349_chg = smb349_chg; spin_lock_init(&smb349_chg->lock); create_debugfs_entries(smb349_chg); INIT_WORK(&smb349_chg->chg_work, chg_worker); pr_info("OK connector present = %d\n", smb349_chg->present); return 0; chg_en_gpio_fail: gpio_free(smb349_chg->en_n_gpio); chg_susp_gpio_fail: gpio_free(smb349_chg->chg_susp_gpio); free_smb349_chg: kfree(smb349_chg); out: return ret; }
static int tc3589x_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct tc3589x_platform_data *pdata = i2c->dev.platform_data; struct device_node *np = i2c->dev.of_node; struct tc3589x *tc3589x; int ret; if (!pdata) { if (np) { pdata = devm_kzalloc(&i2c->dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) return -ENOMEM; ret = tc3589x_of_probe(np, pdata); if (ret) return ret; } else { dev_err(&i2c->dev, "No platform data or DT found\n"); return -EINVAL; } } if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK)) return -EIO; tc3589x = kzalloc(sizeof(struct tc3589x), GFP_KERNEL); if (!tc3589x) return -ENOMEM; mutex_init(&tc3589x->lock); tc3589x->dev = &i2c->dev; tc3589x->i2c = i2c; tc3589x->pdata = pdata; tc3589x->irq_base = pdata->irq_base; tc3589x->num_gpio = id->driver_data; i2c_set_clientdata(i2c, tc3589x); ret = tc3589x_chip_init(tc3589x); if (ret) goto out_free; ret = tc3589x_irq_init(tc3589x, np); if (ret) goto out_free; ret = request_threaded_irq(tc3589x->i2c->irq, NULL, tc3589x_irq, IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "tc3589x", tc3589x); if (ret) { dev_err(tc3589x->dev, "failed to request IRQ: %d\n", ret); goto out_free; } ret = tc3589x_device_init(tc3589x); if (ret) { dev_err(tc3589x->dev, "failed to add child devices\n"); goto out_freeirq; } return 0; out_freeirq: free_irq(tc3589x->i2c->irq, tc3589x); out_free: kfree(tc3589x); return ret; }
static int __devinit qt1070_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct qt1070_data *data; struct input_dev *input; int i; int err; err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE); if (!err) { dev_err(&client->dev, "%s adapter not supported\n", dev_driver_string(&client->adapter->dev)); return -ENODEV; } /* Identify the qt1070 chip */ if (!qt1070_identify(client)) return -ENODEV; data = kzalloc(sizeof(struct qt1070_data), GFP_KERNEL); input = input_allocate_device(); if (!data || !input) { dev_err(&client->dev, "insufficient memory\n"); err = -ENOMEM; goto err_free_mem; } data->client = client; data->input = input; data->irq = client->irq; input->name = "AT42QT1070 QTouch Sensor"; input->dev.parent = &client->dev; input->id.bustype = BUS_I2C; /* Add the keycode */ input->keycode = data->keycodes; input->keycodesize = sizeof(data->keycodes[0]); input->keycodemax = ARRAY_SIZE(qt1070_key2code); __set_bit(EV_KEY, input->evbit); for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) { data->keycodes[i] = qt1070_key2code[i]; __set_bit(qt1070_key2code[i], input->keybit); } /* Calibrate device */ qt1070_write(client, CALIBRATE_CMD, 1); msleep(QT1070_CAL_TIME); /* Soft reset */ qt1070_write(client, RESET, 1); msleep(QT1070_RESET_TIME); /* Apply the interrupt */ if (!client->irq) { dev_err(&client->dev, "please assign the irq to this device\n"); goto err_free_mem; } err = request_threaded_irq(client->irq, NULL, qt1070_interrupt, IRQF_TRIGGER_NONE, client->dev.driver->name, data); if (err) { dev_err(&client->dev, "fail to request irq\n"); goto err_free_mem; } /* Register the input device */ err = input_register_device(data->input); if (err) { dev_err(&client->dev, "Failed to register input device\n"); goto err_free_irq; } i2c_set_clientdata(client, data); /* Read to clear the chang line */ qt1070_read(client, DET_STATUS); return 0; err_free_irq: free_irq(client->irq, data); err_free_mem: input_free_device(input); kfree(data); return err; }
static int smb347_probe(struct i2c_client *client, const struct i2c_device_id *id) { static char *battery[] = { "smb347-battery" }; const struct smb347_charger_platform_data *pdata; struct device *dev = &client->dev; struct smb347_charger *smb; int ret; pdata = dev->platform_data; if (!pdata) return -EINVAL; if (!pdata->use_mains && !pdata->use_usb) return -EINVAL; smb = devm_kzalloc(dev, sizeof(*smb), GFP_KERNEL); if (!smb) return -ENOMEM; i2c_set_clientdata(client, smb); mutex_init(&smb->lock); smb->client = client; smb->pdata = pdata; ret = smb347_hw_init(smb); if (ret < 0) return ret; smb->mains.name = "smb347-mains"; smb->mains.type = POWER_SUPPLY_TYPE_MAINS; smb->mains.get_property = smb347_mains_get_property; smb->mains.properties = smb347_mains_properties; smb->mains.num_properties = ARRAY_SIZE(smb347_mains_properties); smb->mains.supplied_to = battery; smb->mains.num_supplicants = ARRAY_SIZE(battery); smb->usb.name = "smb347-usb"; smb->usb.type = POWER_SUPPLY_TYPE_USB; smb->usb.get_property = smb347_usb_get_property; smb->usb.properties = smb347_usb_properties; smb->usb.num_properties = ARRAY_SIZE(smb347_usb_properties); smb->usb.supplied_to = battery; smb->usb.num_supplicants = ARRAY_SIZE(battery); smb->battery.name = "smb347-battery"; smb->battery.type = POWER_SUPPLY_TYPE_BATTERY; smb->battery.get_property = smb347_battery_get_property; smb->battery.properties = smb347_battery_properties; smb->battery.num_properties = ARRAY_SIZE(smb347_battery_properties); ret = power_supply_register(dev, &smb->mains); if (ret < 0) return ret; ret = power_supply_register(dev, &smb->usb); if (ret < 0) { power_supply_unregister(&smb->mains); return ret; } ret = power_supply_register(dev, &smb->battery); if (ret < 0) { power_supply_unregister(&smb->usb); power_supply_unregister(&smb->mains); return ret; } if (pdata->irq_gpio >= 0) { ret = smb347_irq_init(smb); if (ret < 0) { dev_warn(dev, "failed to initialize IRQ: %d\n", ret); dev_warn(dev, "disabling IRQ support\n"); } } smb->dentry = debugfs_create_file("smb347-regs", S_IRUSR, NULL, smb, &smb347_debugfs_fops); return 0; }
static int yas_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct yas_state *st; struct iio_dev *indio_dev; int ret, i; int position; pr_err("%s : PROBE START\n", __func__); this_client = i2c; indio_dev = iio_device_alloc(sizeof(*st)); if (!indio_dev) { ret = -ENOMEM; goto error_ret; } i2c_set_clientdata(i2c, indio_dev); indio_dev->name = YAS_MAG_NAME; indio_dev->dev.parent = &i2c->dev; indio_dev->info = &yas_info; indio_dev->channels = yas_channels; indio_dev->num_channels = ARRAY_SIZE(yas_channels); indio_dev->modes = INDIO_DIRECT_MODE; st = iio_priv(indio_dev); st->client = i2c; st->sampling_frequency = 20; st->mag.callback.device_open = yas_device_open; st->mag.callback.device_close = yas_device_close; st->mag.callback.device_read = yas_device_read; st->mag.callback.device_write = yas_device_write; st->mag.callback.usleep = yas_usleep; st->mag.callback.current_time = yas_current_time; INIT_DELAYED_WORK(&st->work, yas_work_func); mutex_init(&st->lock); #ifdef CONFIG_HAS_EARLYSUSPEND st->sus.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; st->sus.suspend = yas_early_suspend; st->sus.resume = yas_late_resume; register_early_suspend(&st->sus); #endif for (i = 0; i < 3; i++) st->compass_data[i] = 0; ret = yas_probe_buffer(indio_dev); if (ret) goto error_free_dev; ret = yas_probe_trigger(indio_dev); if (ret) goto error_remove_buffer; ret = iio_device_register(indio_dev); if (ret) goto error_remove_trigger; ret = yas_mag_driver_init(&st->mag); if (ret < 0) { ret = -EFAULT; goto error_unregister_iio; } ret = st->mag.init(); if (ret < 0) { ret = -EFAULT; goto error_unregister_iio; } ret = yas_parse_dt(&i2c->dev, st); if(!ret){ position = st->position; ret = st->mag.set_position(position); pr_info("[SENSOR] set_position (%d)\n", position); } spin_lock_init(&st->spin_lock); ret = sensors_register(factory_dev, indio_dev, mag_sensor_attrs, MODULE_NAME_MAG); if (ret < 0) { pr_err("%s: cound not register mag sensor device(%d).\n", __func__, ret); goto err_mag_sensor_register_failed; } pr_err("%s : PROBE END\n", __func__); return 0; err_mag_sensor_register_failed: error_unregister_iio: iio_device_unregister(indio_dev); error_remove_trigger: yas_remove_trigger(indio_dev); error_remove_buffer: yas_remove_buffer(indio_dev); error_free_dev: #ifdef CONFIG_HAS_EARLYSUSPEND unregister_early_suspend(&st->sus); #endif iio_device_free(indio_dev); error_ret: i2c_set_clientdata(i2c, NULL); this_client = NULL; return ret; }
static int __devinit rmi_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct rmi_phys_device *rmi_phys; struct rmi_i2c_data *data; struct rmi_device_platform_data *pdata = client->dev.platform_data; int error; if (!pdata) { printk( "ITUCH : Device(%s) no platform data\n", dev_name( &client->dev ) ); return -EINVAL; } printk( "ITUCH : Probing %s at %#02x (IRQ %d)\n", pdata->sensor_name ? pdata->sensor_name : "-no name-", client->addr, pdata->attn_gpio ); error = i2c_check_functionality(client->adapter, I2C_FUNC_I2C); if (!error) { printk( "ITUCH : Device(%s) i2c_check_functionality error(%d)\n", dev_name( &client->dev ), error ); return error; } rmi_phys = kzalloc(sizeof(struct rmi_phys_device), GFP_KERNEL); if (!rmi_phys) return -ENOMEM; data = kzalloc(sizeof(struct rmi_i2c_data), GFP_KERNEL); if (!data) { error = -ENOMEM; goto err_phys; } if( gpio_request( pdata->reset_gpio, "RMI4_RESET" ) ) printk( "ITUCH : Unable to request gpio%d\n", pdata->reset_gpio ); reset_touch( pdata ); data->enabled = true; /* We plan to come up enabled. */ data->irq = gpio_to_irq(pdata->attn_gpio); if (pdata->level_triggered) { data->irq_flags = IRQF_ONESHOT | ((pdata->attn_polarity == RMI_ATTN_ACTIVE_HIGH) ? IRQF_TRIGGER_HIGH : IRQF_TRIGGER_LOW); } else { data->irq_flags = (pdata->attn_polarity == RMI_ATTN_ACTIVE_HIGH) ? IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING; } data->phys = rmi_phys; rmi_phys->data = data; rmi_phys->dev = &client->dev; rmi_phys->write = rmi_i2c_write; rmi_phys->write_block = rmi_i2c_write_block; rmi_phys->read = rmi_i2c_read; rmi_phys->read_block = rmi_i2c_read_block; rmi_phys->enable_device = enable_device; rmi_phys->disable_device = disable_device; rmi_phys->info.proto = phys_proto_name; mutex_init(&data->page_mutex); /* Setting the page to zero will (a) make sure the PSR is in a * known state, and (b) make sure we can talk to the device. */ error = rmi_set_page(rmi_phys, 0); if (error) { printk( "ITUCH : Device(%s) failed to set page select to 0\n", dev_name( &client->dev ) ); goto err_data; } if (pdata->gpio_config) { error = pdata->gpio_config(pdata->gpio_data, true); if (error < 0) { printk( "ITUCH : Device(%s) failed to setup irq%d\n", dev_name( &client->dev ), pdata->attn_gpio ); goto err_data; } } error = rmi_register_phys_device(rmi_phys); if (error) { printk( "ITUCH : Device(%s) failed to register physical driver at 0x%.2X\n", dev_name( &client->dev ), client->addr ); goto err_gpio; } i2c_set_clientdata(client, rmi_phys); if (pdata->attn_gpio > 0) { error = acquire_attn_irq(data); if (error < 0) { printk( "ITUCH : Device(%s) request_threaded_irq(IRQ%d) failed\n", dev_name( &client->dev ), pdata->attn_gpio ); goto err_unregister; } } #if defined(CONFIG_RMI4_DEV) error = gpio_export(pdata->attn_gpio, false); if (error) { printk( "ITUCH : Device(%s) failed to export ATTN gpio\n", dev_name( &client->dev ) ); error = 0; } else { error = gpio_export_link(&(rmi_phys->rmi_dev->dev), "attn", pdata->attn_gpio); if (error) { printk( "ITUCH : Device(%s) failed to symlink ATTN gpio\n", dev_name( &rmi_phys->rmi_dev->dev ) ); error = 0; } else { printk( "ITUCH : Device(%s) exported GPIO-%d\n", dev_name( &rmi_phys->rmi_dev->dev ), pdata->attn_gpio ); } } #endif /* CONFIG_RMI4_DEV */ printk( "ITUCH : Device(%s) registered rmi i2c driver at 0x%.2X\n", dev_name( &client->dev ), client->addr ); return 0; err_unregister: rmi_unregister_phys_device(rmi_phys); err_gpio: if (pdata->gpio_config) pdata->gpio_config(pdata->gpio_data, false); err_data: kfree(data); err_phys: kfree(rmi_phys); return error; }
static int __devinit max8649_regulator_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct max8649_platform_data *pdata = client->dev.platform_data; struct max8649_regulator_info *info = NULL; unsigned char data; int id1, id2; int ret; info = kzalloc(sizeof(struct max8649_regulator_info), GFP_KERNEL); if (!info) { dev_err(&client->dev, "No enough memory\n"); return -ENOMEM; } info->i2c = client; info->dev = &client->dev; mutex_init(&info->io_lock); i2c_set_clientdata(client, info); info->mode = pdata->mode; switch (info->mode) { case 0: info->vol_reg = MAX8649_MODE0; break; case 1: info->vol_reg = MAX8649_MODE1; break; case 2: info->vol_reg = MAX8649_MODE2; break; case 3: info->vol_reg = MAX8649_MODE3; break; default: break; } id1 = max8649_reg_read(info->i2c, MAX8649_CHIP_ID1); if (id1 < 0) { dev_err(info->dev, "Failed to detect ID1 of MAX8649:%d\n", id1); ret = id1; goto out; } id2 = max8649_reg_read(info->i2c, MAX8649_CHIP_ID2); if (id2 < 0) { dev_err(info->dev, "Failed to detect ID2 of MAX8649:%d\n", id2); ret = id2; goto out; } switch (id2) { case MAX8649S_CHIP_ID2_VAL: dev_info(info->dev, "Detected MAX8649S (ID: 0x%02x%02x)\n", id1, id2); info->dcdc_vmin = MAX8649S_DCDC_VMIN; info->dcdc_vmax = MAX8649S_DCDC_VMAX; break; case MAX8952_CHIP_ID2_VAL: dev_info(info->dev, "Detected MAX8952 (ID: 0x%02x%02x)\n", id1, id2); info->dcdc_vmin = MAX8952_DCDC_VMIN; info->dcdc_vmax = MAX8952_DCDC_VMAX; break; case MAX8649_CHIP_ID2_VAL: dev_info(info->dev, "Detected MAX8649 (ID: 0x%02x%02x)\n", id1, id2); info->dcdc_vmin = MAX8649_DCDC_VMIN; info->dcdc_vmax = MAX8649_DCDC_VMAX; break; default: dev_info(info->dev, "Detected Unknown (ID: 0x%02x%02x)" " - defaulting to max8649 settings\n", id1, id2); info->dcdc_vmin = MAX8649_DCDC_VMIN; info->dcdc_vmax = MAX8649_DCDC_VMAX; break; } /* enable VID0 & VID1 */ max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_VID_MASK, 0); /* enable/disable external clock synchronization */ info->extclk = pdata->extclk; data = (info->extclk) ? MAX8649_SYNC_EXTCLK : 0; max8649_set_bits(info->i2c, info->vol_reg, MAX8649_SYNC_EXTCLK, data); if (info->extclk) { /* set external clock frequency */ info->extclk_freq = pdata->extclk_freq; max8649_set_bits(info->i2c, MAX8649_SYNC, MAX8649_EXT_MASK, info->extclk_freq << 6); } if (pdata->ramp_timing) { info->ramp_timing = pdata->ramp_timing; max8649_set_bits(info->i2c, MAX8649_RAMP, MAX8649_RAMP_MASK, info->ramp_timing << 5); } info->ramp_down = pdata->ramp_down; if (info->ramp_down) { max8649_set_bits(info->i2c, MAX8649_RAMP, MAX8649_RAMP_DOWN, MAX8649_RAMP_DOWN); } info->regulator = regulator_register(&dcdc_desc, &client->dev, pdata->regulator, info); if (IS_ERR(info->regulator)) { dev_err(info->dev, "failed to register regulator %s\n", dcdc_desc.name); ret = PTR_ERR(info->regulator); goto out; } dev_info(info->dev, "Max8649 regulator device is detected.\n"); return 0; out: kfree(info); return ret; }
static int wacom_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct wacom_i2c *wac_i2c; struct wacom_g5_platform_data *pdata = client->dev.platform_data; int i, ret; i = ret = 0; printk(KERN_DEBUG "[E-PEN]:%s:\n", __func__); wacom_is_pressed = 0; /*Check I2C functionality*/ if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) goto err3; /*Obtain kernel memory space for wacom i2c*/ wac_i2c = kzalloc(sizeof(struct wacom_i2c), GFP_KERNEL); wac_i2c->wac_feature = &wacom_feature_EMR; /*Initializing for semaphor*/ mutex_init(&wac_i2c->lock); /*Register platform data*/ wac_i2c->wac_pdata = client->dev.platform_data; /*Register callbacks*/ wac_i2c->callbacks.check_prox = wacom_check_emr_prox; if (wac_i2c->wac_pdata->register_cb) wac_i2c->wac_pdata->register_cb(&wac_i2c->callbacks); /*Register wacom i2c to input device*/ wac_i2c->input_dev = input_allocate_device(); if (wac_i2c == NULL || wac_i2c->input_dev == NULL) goto fail; wacom_i2c_set_input_values(client, wac_i2c, wac_i2c->input_dev); wac_i2c->client = client; wac_i2c->irq = client->irq; /*Change below if irq is needed*/ wac_i2c->irq_flag = 1; #ifdef CONFIG_HAS_EARLYSUSPEND wac_i2c->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; wac_i2c->early_suspend.suspend = wacom_i2c_early_suspend; wac_i2c->early_suspend.resume = wacom_i2c_late_resume; register_early_suspend(&wac_i2c->early_suspend); #endif /*Init Featreus by hw rev*/ if( get_hw_rev() >= HWREV_PEN_PITCH4P4 ) { printk("[E-PEN] Wacom driver is working for 4.4mm pitch pad.\n"); /* Firmware Feature */ Firmware_version_of_file = Firmware_version_of_file_44; Binary = Binary_44; } else { printk("[E-PEN] Wacom driver is working for 4.8mm pitch pad.\n"); /* Firmware Feature */ Firmware_version_of_file = Firmware_version_of_file_48; Binary = Binary_48; } init_offset_tables(); INIT_WORK(&wac_i2c->update_work, update_work_func); INIT_DELAYED_WORK(&wac_i2c->resume_work, wacom_i2c_resume_work); /* Reset IC */ gpio_set_value(GPIO_PEN_RESET, 0); msleep(200); gpio_set_value(GPIO_PEN_RESET, 1); msleep(200); ret = wacom_i2c_query(wac_i2c); if( ret < 0 ) epen_reset_result = false; else epen_reset_result = true; input_set_abs_params(wac_i2c->input_dev, ABS_X, pdata->min_x, pdata->max_x, 4, 0); input_set_abs_params(wac_i2c->input_dev, ABS_Y, pdata->min_y, pdata->max_y, 4, 0); input_set_abs_params(wac_i2c->input_dev, ABS_PRESSURE, pdata->min_pressure, pdata->max_pressure, 0, 0); input_set_drvdata(wac_i2c->input_dev, wac_i2c); /*Set client data*/ i2c_set_clientdata(client, wac_i2c); /*Before registering input device, data in each input_dev must be set*/ if (input_register_device(wac_i2c->input_dev)) goto err2; g_client = client; /* if(wac_i2c->irq_flag) */ /* disable_irq(wac_i2c->irq); */ sec_epen= device_create(sec_class, NULL, 0, NULL, "sec_epen"); dev_set_drvdata(sec_epen, wac_i2c); if (IS_ERR(sec_epen)) printk(KERN_ERR "Failed to create device(sec_epen)!\n"); if (device_create_file(sec_epen, &dev_attr_epen_firm_update)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_firm_update.attr.name); if (device_create_file(sec_epen, &dev_attr_epen_firm_update_status)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_firm_update_status.attr.name); if (device_create_file(sec_epen, &dev_attr_epen_firm_version)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_firm_version.attr.name); if (device_create_file(sec_epen, &dev_attr_epen_rotation)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_rotation.attr.name); if (device_create_file(sec_epen, &dev_attr_epen_hand)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_hand.attr.name); if (device_create_file(sec_epen, &dev_attr_epen_reset)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_reset.attr.name); if (device_create_file(sec_epen, &dev_attr_epen_reset_result)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_reset_result.attr.name); /*Request IRQ*/ if (wac_i2c->irq_flag) { ret = request_threaded_irq(wac_i2c->irq, NULL, wacom_interrupt, IRQF_DISABLED|IRQF_TRIGGER_RISING|IRQF_ONESHOT, wac_i2c->name, wac_i2c); if (ret < 0) goto err1; } /* firmware update */ printk(KERN_NOTICE "[E-PEN] wacom fw ver : 0x%x, new fw ver : 0x%x\n", wac_i2c->wac_feature->fw_version, Firmware_version_of_file); if( wac_i2c->wac_feature->fw_version < Firmware_version_of_file ) { #if defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L) printk("[E-PEN] %s\n", __func__); disable_irq(wac_i2c->irq); printk(KERN_NOTICE "[E-PEN]: INIT_FIRMWARE_FLASH is enabled.\n"); ret = wacom_i2c_flash(wac_i2c); msleep(800); printk(KERN_ERR "[E-PEN]: flashed.(%d)\n", ret); wacom_i2c_query(wac_i2c); enable_irq(wac_i2c->irq); #else schedule_work(&wac_i2c->update_work); #endif } return 0; err3: printk(KERN_ERR "[E-PEN]: No I2C functionality found\n"); return -ENODEV; err2: printk(KERN_ERR "[E-PEN]: err2 occured\n"); input_free_device(wac_i2c->input_dev); return -EIO; err1: printk(KERN_ERR "[E-PEN]: err1 occured(num:%d)\n", ret); input_free_device(wac_i2c->input_dev); wac_i2c->input_dev = NULL; return -EIO; fail: printk(KERN_ERR "[E-PEN]: fail occured\n"); return -ENOMEM; }
static int __devinit gp2a_probe(struct i2c_client *client, const struct i2c_device_id *id) { const struct gp2a_platform_data *pdata = client->dev.platform_data; struct gp2a_data *dt; int error; if (!pdata) return -EINVAL; if (pdata->hw_setup) { error = pdata->hw_setup(client); if (error < 0) return error; } error = gpio_request_one(pdata->vout_gpio, GPIOF_IN, GP2A_I2C_NAME); if (error) goto err_hw_shutdown; dt = kzalloc(sizeof(struct gp2a_data), GFP_KERNEL); if (!dt) { error = -ENOMEM; goto err_free_gpio; } dt->pdata = pdata; dt->i2c_client = client; error = gp2a_initialize(dt); if (error < 0) goto err_free_mem; dt->input = input_allocate_device(); if (!dt->input) { error = -ENOMEM; goto err_free_mem; } input_set_drvdata(dt->input, dt); dt->input->open = gp2a_device_open; dt->input->close = gp2a_device_close; dt->input->name = GP2A_I2C_NAME; dt->input->id.bustype = BUS_I2C; dt->input->dev.parent = &client->dev; input_set_capability(dt->input, EV_SW, SW_FRONT_PROXIMITY); error = request_threaded_irq(client->irq, NULL, gp2a_irq, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, GP2A_I2C_NAME, dt); if (error) { dev_err(&client->dev, "irq request failed\n"); goto err_free_input_dev; } error = input_register_device(dt->input); if (error) { dev_err(&client->dev, "device registration failed\n"); goto err_free_irq; } device_init_wakeup(&client->dev, pdata->wakeup); i2c_set_clientdata(client, dt); return 0; err_free_irq: free_irq(client->irq, dt); err_free_input_dev: input_free_device(dt->input); err_free_mem: kfree(dt); err_free_gpio: gpio_free(pdata->vout_gpio); err_hw_shutdown: if (pdata->hw_shutdown) pdata->hw_shutdown(client); return error; }
static int __devinit rt5033_mfd_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { int ret = 0; u8 data = 0; rt5033_mfd_chip_t *chip; rt5033_mfd_platform_data_t *pdata = i2c->dev.platform_data; pr_info("%s : RT5033 MFD Driver start probe\n", __func__); chip = kzalloc(sizeof(*chip), GFP_KERNEL); if (chip == NULL) { dev_err(chip->dev, "Memory is not enough.\n"); ret = -ENOMEM; goto err_mfd_nomem; } ret = i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_I2C_BLOCK); if (!ret) { ret = i2c_get_functionality(i2c->adapter); dev_err(chip->dev, "I2C functionality is not supported.\n"); ret = -ENOSYS; goto err_i2cfunc_not_support; } chip->dev = &i2c->dev; chip->i2c_client = i2c; chip->pdata = pdata; pdata->irq_base = irq_alloc_descs(-1, 0, RT5033_IRQS_NR, -1); if (pdata->irq_base < 0) { pr_err("%s:%s irq_alloc_descs Fail! ret(%d)\n", "rt5033-mfd", __func__, pdata->irq_base); ret = -EINVAL; goto irq_base_err; } else { chip->irq_base = pdata->irq_base; } i2c_set_clientdata(i2c, chip); mutex_init(&chip->io_lock); wake_lock_init(&(chip->irq_wake_lock), WAKE_LOCK_SUSPEND, "rt5033mfd_wakelock"); ret = rt5033_clr_bits(i2c, 0x47, 1<<3); pr_info("Diable MANUAL RESET (%d)\n", ret); ret = rt5033_init_irq(chip); if (ret < 0) { dev_err(chip->dev, "Error : can't initialize RT5033 MFD irq\n"); goto err_init_irq; } #ifdef CONFIG_REGULATOR_RT5033 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(3,6,0)) ret = mfd_add_devices(chip->dev, 0, &rt5033_regulator_devs[0], ARRAY_SIZE(rt5033_regulator_devs), NULL, chip->irq_base, NULL); #else ret = mfd_add_devices(chip->dev, 0, &rt5033_regulator_devs[0], ARRAY_SIZE(rt5033_regulator_devs), NULL, chip->irq_base); #endif if (ret < 0) { dev_err(chip->dev, "Error : can't add regulator\n"); goto err_add_regulator_devs; } #endif /*CONFIG_REGULATOR_RT5033*/ #ifdef CONFIG_FLED_RT5033 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(3,6,0)) ret = mfd_add_devices(chip->dev, 0, &rt5033_fled_devs[0], ARRAY_SIZE(rt5033_fled_devs), NULL, chip->irq_base, NULL); #else ret = mfd_add_devices(chip->dev, 0, &rt5033_fled_devs[0], ARRAY_SIZE(rt5033_fled_devs), NULL, chip->irq_base); #endif if (ret < 0) { dev_err(chip->dev,"Failed : add FlashLED devices"); goto err_add_fled_devs; } #endif /*CONFIG_FLED_RT5033*/ #ifdef CONFIG_CHARGER_RT5033 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(3,6,0)) ret = mfd_add_devices(chip->dev, 0, &rt5033_charger_devs[0], ARRAY_SIZE(rt5033_charger_devs), NULL, chip->irq_base, NULL); #else ret = mfd_add_devices(chip->dev, 0, &rt5033_charger_devs[0], ARRAY_SIZE(rt5033_charger_devs), NULL, chip->irq_base); #endif if (ret<0) { dev_err(chip->dev, "Failed : add charger devices\n"); goto err_add_chg_devs; } #endif /*CONFIG_CHARGER_RT5033*/ pr_info("%s : RT5033 MFD Driver Fin probe\n", __func__); return ret; #ifdef CONFIG_CHARGER_RT5033 err_add_chg_devs: #endif /*CONFIG_CHARGER_RT5033*/ #ifdef CONFIG_FLED_RT5033 err_add_fled_devs: #endif /*CONFIG_FLED_RT5033*/ mfd_remove_devices(chip->dev); #ifdef CONFIG_REGULATOR_RT5033 err_add_regulator_devs: #endif /*CONFIG_REGULATOR_RT5033*/ err_init_irq: wake_lock_destroy(&(chip->irq_wake_lock)); mutex_destroy(&chip->io_lock); kfree(chip); irq_base_err: err_mfd_nomem: err_i2cfunc_not_support: return ret; }
static int lsm303dlh_m_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct lsm303dlh_m_data *data; int err = 0; data = kzalloc(sizeof(struct lsm303dlh_m_data), GFP_KERNEL); if (!data) { dev_err(&client->dev, "memory allocation failed\n"); err = -ENOMEM; goto exit; } /* check for valid platform data */ if (!client->dev.platform_data) { dev_err(&client->dev, "Invalid platform data\n"); err = -ENOMEM; goto exit1; } data->pdata = client->dev.platform_data; data->mode = SLEEP_MODE; data->config = NORMAL_CFG; data->range = RANGE_1_3G; data->rate = RATE_00_75; data->device_status = DEVICE_OFF; data->client = client; i2c_set_clientdata(client, data); data->regulator = regulator_get(&client->dev, "vdd"); if (IS_ERR(data->regulator)) { err = PTR_ERR(data->regulator); dev_err(&client->dev, "failed to get regulator = %d\n", err); goto exit1; } /* Enable regulator */ lsm303dlh_m_enable(data); lsm303dlh_m_setup(client); mutex_init(&data->lock); data->indio_dev = iio_allocate_device(0); if (!data->indio_dev) { dev_err(&client->dev, "iio allocation failed\n"); err = -ENOMEM; goto exit2; } data->indio_dev->info = &lsmdlh303m_info; data->indio_dev->dev.parent = &client->dev; data->indio_dev->dev_data = (void *)data; data->indio_dev->modes = INDIO_DIRECT_MODE; err = iio_device_register(data->indio_dev); if (err) goto exit3; #ifdef CONFIG_HAS_EARLYSUSPEND data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; data->early_suspend.suspend = lsm303dlh_m_early_suspend; data->early_suspend.resume = lsm303dlh_m_late_resume; register_early_suspend(&data->early_suspend); #endif /* Disable regulator */ lsm303dlh_m_disable(data); return 0; exit3: iio_free_device(data->indio_dev); exit2: lsm303dlh_m_disable(data); regulator_put(data->regulator); exit1: kfree(data); exit: return err; }
static int summit_smb347_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct summit_smb347_info *info; int ret = 0; #ifdef SUMMIT_SMB347_DEBUG int i = 0; #endif int error = 0; unsigned char value = 0xff; info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) { return -ENOMEM; } client->addr = SUMMIT_SMB347_I2C_ADDRESS; i2c_set_clientdata(client, info); info->client = client; info->charger.name = "summit_smb347_ac"; info->charger.type = POWER_SUPPLY_TYPE_MAINS; info->charger.get_property = smb347_get_ac_property; info->charger.properties = smb347_charger_props; info->charger.num_properties = ARRAY_SIZE(smb347_charger_props); info->usb.name = "summit_smb347_usb"; info->usb.type = POWER_SUPPLY_TYPE_USB; info->usb.get_property = smb347_get_usb_property; info->usb.properties = smb347_usb_props; info->usb.num_properties = ARRAY_SIZE(smb347_usb_props); info->battery.name = "summit_smb347_battery"; info->battery.type = POWER_SUPPLY_TYPE_BATTERY; info->battery.get_property = smb347_get_battery_property; info->battery.properties = smb347_battery_props; info->battery.num_properties = ARRAY_SIZE(smb347_battery_props); ret = power_supply_register(&client->dev, &info->charger); if (ret) { dev_err(&client->dev, "failed: power supply register\n"); i2c_set_clientdata(client, NULL); kfree(info); return ret; } ret = power_supply_register(&client->dev, &info->usb); if (ret) { dev_err(&client->dev, "failed: power supply register\n"); i2c_set_clientdata(client, NULL); kfree(info); return ret; } ret = power_supply_register(&client->dev, &info->battery); if (ret) { dev_err(&client->dev, "failed: battery power supply register\n"); i2c_set_clientdata(client, NULL); kfree(info); return ret; } summit_smb347_i2c_client = info->client; summit_smb347_i2c_client->addr = SUMMIT_SMB347_I2C_ADDRESS; if (summit_smb347_read_id(&summit_smb347_id_reg) < 0) return -ENODEV; printk(KERN_INFO "Summit SMB347 detected, chip_id=0x%x\n", summit_smb347_id_reg); ret = request_irq(summit_smb347_i2c_client->irq, summit_smb347_irq, IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING, "summit_smb347", NULL); if (ret != 0) { printk(KERN_ERR "Failed to request IRQ %d: %d\n", summit_smb347_i2c_client->irq, ret); } summit_smb347_init_registers(); #ifdef SUMMIT_SMB347_DEBUG for (i = 0; i <= 0xE; i++) { ret = summit_smb347_i2c_read(i, &value); printk(KERN_INFO "summit_smb347: reg=%d, value=0x%x\n", i, value); } for (i = 0x30; i <= 0x3F; i++) { ret = summit_smb347_i2c_read(i, &value); printk(KERN_INFO "summit_smb347: reg=%d, value=0x%x\n", i, value); } #endif error = sysdev_class_register(&smb347_reg_sysclass); if (!error) error = sysdev_register(&device_smb347_reg); if (!error) error = sysdev_create_file(&device_smb347_reg, &attr_smb347_reg); error = sysdev_class_register(&smb347_register_sysclass); if (!error) error = sysdev_register(&device_smb347_register); if (!error) error = sysdev_create_file(&device_smb347_register, &attr_smb347_register); /* Initialize workqueue */ summit_smb347_charger_workqueue = create_singlethread_workqueue("smb347_charger"); INIT_DELAYED_WORK(&summit_smb347_charger_work, summit_smb347_worker); queue_delayed_work(summit_smb347_charger_workqueue, &summit_smb347_charger_work, msecs_to_jiffies(10000)); return 0; }
static int cyttsp4_i2c_probe(struct i2c_client *client, const struct i2c_device_id *i2c_id) { struct cyttsp4_i2c *ts_i2c; struct device *dev = &client->dev; char const *adap_id = dev_get_platdata(dev); char const *id; int rc; dev_info(dev, "%s: Starting %s probe...\n", __func__, CYTTSP4_I2C_NAME); dev_dbg(dev, "%s: debug on\n", __func__); dev_vdbg(dev, "%s: verbose debug on\n", __func__); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(dev, "%s: fail check I2C functionality\n", __func__); rc = -EIO; goto error_alloc_data_failed; } ts_i2c = kzalloc(sizeof(struct cyttsp4_i2c), GFP_KERNEL); if (ts_i2c == NULL) { dev_err(dev, "%s: Error, kzalloc.\n", __func__); rc = -ENOMEM; goto error_alloc_data_failed; } mutex_init(&ts_i2c->lock); ts_i2c->client = client; client->dev.bus = &i2c_bus_type; i2c_set_clientdata(client, ts_i2c); dev_set_drvdata(&client->dev, ts_i2c); if (adap_id) id = adap_id; else id = CYTTSP4_I2C_NAME; dev_dbg(dev, "%s: add adap='%s' (CYTTSP4_I2C_NAME=%s)\n", __func__, id, CYTTSP4_I2C_NAME); pm_runtime_enable(&client->dev); rc = cyttsp4_add_adapter(id, &ops, dev); if (rc) { dev_err(dev, "%s: Error on probe %s\n", __func__, CYTTSP4_I2C_NAME); goto add_adapter_err; } dev_info(dev, "%s: Successful probe %s\n", __func__, CYTTSP4_I2C_NAME); return 0; add_adapter_err: pm_runtime_disable(&client->dev); dev_set_drvdata(&client->dev, NULL); i2c_set_clientdata(client, NULL); kfree(ts_i2c); error_alloc_data_failed: return rc; }
static int bebot_base_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct bebot_base_device *base; struct senseact_poll_device *senseact_poll; struct senseact_device *senseact; int rc; if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_I2C_BLOCK)) return -ENODEV; base = kzalloc(sizeof(struct bebot_base_device), GFP_KERNEL); if (!base) { dev_err(&client->dev, "not enough memory for bebot_base device\n"); rc = -ENOMEM; goto exit; } /* set speed to 0 */ rc = i2c_smbus_write_i2c_block_data(client, SETSPEED_REG, SETSPEED_COUNT, base->speed); if (rc < 0) goto exit_kfree; base->client = client; senseact_poll = senseact_allocate_poll_device(); if (!senseact_poll) { dev_err(&client->dev, "not enough memory for senseact poll device\n"); rc = -ENOMEM; goto exit_kfree; } base->senseact_poll = senseact_poll; /* set senseact poll device handler */ senseact_poll->poll = bebot_base_poll; senseact_poll->poll_interval = 250; /* set senseact device handler */ senseact = senseact_poll->senseact; senseact->name = client->name; snprintf(base->addr, sizeof(base->addr), "%01d-%04x", client->adapter->nr, client->addr); senseact->addr = base->addr; senseact->dev.parent = &client->dev; senseact->pass = bebot_base_pass; senseact_set_drvdata(senseact, base); senseact_set_capabilities(senseact, SENSEACT_TYPE_SPEED, 4); senseact_set_capabilities(senseact, SENSEACT_TYPE_INCREMENT, 2); senseact_set_capabilities(senseact, SENSEACT_TYPE_POSITION, 2); senseact_set_capability(senseact, SENSEACT_TYPE_ANGLE); rc = senseact_register_poll_device(senseact_poll); if (rc) { dev_err(&client->dev, "could not register senseact poll device\n"); goto exit_free_poll; } i2c_set_clientdata(client, base); return 0; exit_free_poll: senseact_free_poll_device(senseact_poll); exit_kfree: kfree(base); exit: return rc; }
static int cs42l52_i2c_probe(struct i2c_client *i2c_client, const struct i2c_device_id *id) { struct cs42l52_private *cs42l52; struct cs42l52_platform_data *pdata = dev_get_platdata(&i2c_client->dev); int ret; unsigned int devid = 0; unsigned int reg; u32 val32; cs42l52 = devm_kzalloc(&i2c_client->dev, sizeof(struct cs42l52_private), GFP_KERNEL); if (cs42l52 == NULL) return -ENOMEM; cs42l52->dev = &i2c_client->dev; cs42l52->regmap = devm_regmap_init_i2c(i2c_client, &cs42l52_regmap); if (IS_ERR(cs42l52->regmap)) { ret = PTR_ERR(cs42l52->regmap); dev_err(&i2c_client->dev, "regmap_init() failed: %d\n", ret); return ret; } if (pdata) { cs42l52->pdata = *pdata; } else { pdata = devm_kzalloc(&i2c_client->dev, sizeof(struct cs42l52_platform_data), GFP_KERNEL); if (!pdata) { dev_err(&i2c_client->dev, "could not allocate pdata\n"); return -ENOMEM; } if (i2c_client->dev.of_node) { if (of_property_read_bool(i2c_client->dev.of_node, "cirrus,mica-differential-cfg")) pdata->mica_diff_cfg = true; if (of_property_read_bool(i2c_client->dev.of_node, "cirrus,micb-differential-cfg")) pdata->micb_diff_cfg = true; if (of_property_read_u32(i2c_client->dev.of_node, "cirrus,micbias-lvl", &val32) >= 0) pdata->micbias_lvl = val32; if (of_property_read_u32(i2c_client->dev.of_node, "cirrus,chgfreq-divisor", &val32) >= 0) pdata->chgfreq = val32; pdata->reset_gpio = of_get_named_gpio(i2c_client->dev.of_node, "cirrus,reset-gpio", 0); } cs42l52->pdata = *pdata; } if (cs42l52->pdata.reset_gpio) { ret = devm_gpio_request_one(&i2c_client->dev, cs42l52->pdata.reset_gpio, GPIOF_OUT_INIT_HIGH, "CS42L52 /RST"); if (ret < 0) { dev_err(&i2c_client->dev, "Failed to request /RST %d: %d\n", cs42l52->pdata.reset_gpio, ret); return ret; } gpio_set_value_cansleep(cs42l52->pdata.reset_gpio, 0); gpio_set_value_cansleep(cs42l52->pdata.reset_gpio, 1); } i2c_set_clientdata(i2c_client, cs42l52); ret = regmap_register_patch(cs42l52->regmap, cs42l52_threshold_patch, ARRAY_SIZE(cs42l52_threshold_patch)); if (ret != 0) dev_warn(cs42l52->dev, "Failed to apply regmap patch: %d\n", ret); ret = regmap_read(cs42l52->regmap, CS42L52_CHIP, ®); devid = reg & CS42L52_CHIP_ID_MASK; if (devid != CS42L52_CHIP_ID) { ret = -ENODEV; dev_err(&i2c_client->dev, "CS42L52 Device ID (%X). Expected %X\n", devid, CS42L52_CHIP_ID); return ret; } dev_info(&i2c_client->dev, "Cirrus Logic CS42L52, Revision: %02X\n", reg & CS42L52_CHIP_REV_MASK); /* Set Platform Data */ if (cs42l52->pdata.mica_diff_cfg) regmap_update_bits(cs42l52->regmap, CS42L52_MICA_CTL, CS42L52_MIC_CTL_TYPE_MASK, cs42l52->pdata.mica_diff_cfg << CS42L52_MIC_CTL_TYPE_SHIFT); if (cs42l52->pdata.micb_diff_cfg) regmap_update_bits(cs42l52->regmap, CS42L52_MICB_CTL, CS42L52_MIC_CTL_TYPE_MASK, cs42l52->pdata.micb_diff_cfg << CS42L52_MIC_CTL_TYPE_SHIFT); if (cs42l52->pdata.chgfreq) regmap_update_bits(cs42l52->regmap, CS42L52_CHARGE_PUMP, CS42L52_CHARGE_PUMP_MASK, cs42l52->pdata.chgfreq << CS42L52_CHARGE_PUMP_SHIFT); if (cs42l52->pdata.micbias_lvl) regmap_update_bits(cs42l52->regmap, CS42L52_IFACE_CTL2, CS42L52_IFACE_CTL2_BIAS_LVL, cs42l52->pdata.micbias_lvl); ret = snd_soc_register_codec(&i2c_client->dev, &soc_codec_dev_cs42l52, &cs42l52_dai, 1); if (ret < 0) return ret; return 0; }
/** * stkxxx_probe() - initialize the I2C client * @client: client to initialize * @id: I2C device ID */ static int stkxxx_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct stkxxx *ts; int err = 0; ts = kzalloc(sizeof(struct stkxxx), GFP_KERNEL); if (!ts) { err = -ENOMEM; goto fail; } ts->client = client; stkxxx_reset(ts); if (stkxxx_register_input(ts) < 0) { dev_err(&client->dev, "register input fail!\n"); goto fail; } /* setup platform-specific hooks */ ts->pdata = client->dev.platform_data; if (!ts->pdata || !ts->pdata->init_irq || !ts->pdata->get_irq_level) { dev_err(&client->dev, "no platform-specific callbacks " "provided\n"); err = -ENXIO; goto fail; } if (ts->pdata->init_irq) { err = ts->pdata->init_irq(); if (err < 0) { dev_err(&client->dev, "failed to initialize IRQ#%d: " "%d\n", client->irq, err); goto fail; } } spin_lock_init(&ts->lock); #ifdef TS_DELAY_WORK INIT_DELAYED_WORK(&ts->work, stkxxx_work); #else hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); ts->timer.function = stkxxx_timer; INIT_WORK(&ts->work, stkxxx_work); ts->workqueue = create_singlethread_workqueue("stkxxx"); if (ts->workqueue == NULL) { dev_err(&client->dev, "can't create work queue\n"); err = -ENOMEM; goto fail; } printk("work create: %x\n", ts->workqueue); #endif ts->pendown = 0; ts->touching_num = 0; ts->pre_touching_num = 0; err = request_irq(client->irq, stkxxx_interrupt, IRQF_TRIGGER_FALLING, client->dev.driver->name, client); if (err) { dev_err(&client->dev, "failed to request IRQ#%d: %d\n", client->irq, err); goto fail_irq; } i2c_set_clientdata(client, ts); // INIT_DELAYED_WORK(&ts->cal_work, stkxxx_cal_work); // schedule_delayed_work(&ts->cal_work, 20*HZ); err = 0; goto out; fail_irq: free_irq(client->irq, client); fail: if (ts) { input_free_device(ts->input); kfree(ts); } i2c_set_clientdata(client, NULL); out: printk("stkxxx touch screen driver ok\n"); return err; }
int mpu_probe(struct i2c_client *client, const struct i2c_device_id *devid) { struct mpu_platform_data *pdata; struct mpu_private_data *mpu; struct mldl_cfg *mldl_cfg; int res = 0; int ii = 0; dev_info(&client->adapter->dev, "%s: %d\n", __func__, ii++); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { res = -ENODEV; goto out_check_functionality_failed; } mpu = kzalloc(sizeof(struct mpu_private_data), GFP_KERNEL); if (!mpu) { res = -ENOMEM; goto out_alloc_data_failed; } mldl_cfg = &mpu->mldl_cfg; mldl_cfg->mpu_ram = &mpu->mpu_ram; mldl_cfg->mpu_gyro_cfg = &mpu->mpu_gyro_cfg; mldl_cfg->mpu_offsets = &mpu->mpu_offsets; mldl_cfg->mpu_chip_info = &mpu->mpu_chip_info; mldl_cfg->inv_mpu_cfg = &mpu->inv_mpu_cfg; mldl_cfg->inv_mpu_state = &mpu->inv_mpu_state; mldl_cfg->mpu_ram->length = MPU_MEM_NUM_RAM_BANKS * MPU_MEM_BANK_SIZE; mldl_cfg->mpu_ram->ram = kzalloc(mldl_cfg->mpu_ram->length, GFP_KERNEL); if (!mldl_cfg->mpu_ram->ram) { res = -ENOMEM; goto out_alloc_ram_failed; } mpu_private_data = mpu; i2c_set_clientdata(client, mpu); mpu->client = client; init_waitqueue_head(&mpu->mpu_event_wait); mutex_init(&mpu->mutex); init_completion(&mpu->completion); mpu->response_timeout = 60; /* Seconds */ mpu->timeout.function = mpu_pm_timeout; mpu->timeout.data = (u_long) mpu; init_timer(&mpu->timeout); mpu->nb.notifier_call = mpu_pm_notifier_callback; mpu->nb.priority = 0; res = register_pm_notifier(&mpu->nb); if (res) { dev_err(&client->adapter->dev, "Unable to register pm_notifier %d\n", res); goto out_register_pm_notifier_failed; } pdata = (struct mpu_platform_data *)client->dev.platform_data; if (!pdata) { dev_WARN(&client->adapter->dev, "Missing platform data for mpu\n"); } mldl_cfg->pdata = pdata; mldl_cfg->mpu_chip_info->addr = client->addr; res = inv_mpu_open(&mpu->mldl_cfg, client->adapter, NULL, NULL, NULL); if (res) { dev_err(&client->adapter->dev, "Unable to open %s %d\n", MPU_NAME, res); res = -ENODEV; goto out_whoami_failed; } mpu->dev.minor = MISC_DYNAMIC_MINOR; mpu->dev.name = "mpu"; mpu->dev.fops = &mpu_fops; res = misc_register(&mpu->dev); if (res < 0) { dev_err(&client->adapter->dev, "ERROR: misc_register returned %d\n", res); goto out_misc_register_failed; } if (client->irq) { dev_info(&client->adapter->dev, "Installing irq using %d\n", client->irq); res = mpuirq_init(client, mldl_cfg); if (res) goto out_mpuirq_failed; } else { dev_WARN(&client->adapter->dev, "Missing %s IRQ\n", MPU_NAME); } return res; out_mpuirq_failed: misc_deregister(&mpu->dev); out_misc_register_failed: inv_mpu_close(&mpu->mldl_cfg, client->adapter, NULL, NULL, NULL); out_whoami_failed: unregister_pm_notifier(&mpu->nb); out_register_pm_notifier_failed: kfree(mldl_cfg->mpu_ram->ram); mpu_private_data = NULL; out_alloc_ram_failed: kfree(mpu); out_alloc_data_failed: out_check_functionality_failed: dev_err(&client->adapter->dev, "%s failed %d\n", __func__, res); return res; }
static int ds278x_battery_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct ds278x_platform_data *pdata = client->dev.platform_data; struct ds278x_info *info; int ret; int num; /* * ds2786 should have the sense resistor value set * in the platform data */ if (id->driver_data == DS2786 && !pdata) { dev_err(&client->dev, "missing platform data for ds2786\n"); return -EINVAL; } /* Get an ID for this battery */ ret = idr_pre_get(&battery_id, GFP_KERNEL); if (ret == 0) { ret = -ENOMEM; goto fail_id; } mutex_lock(&battery_lock); ret = idr_get_new(&battery_id, client, &num); mutex_unlock(&battery_lock); if (ret < 0) goto fail_id; info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) { ret = -ENOMEM; goto fail_info; } info->battery.name = kasprintf(GFP_KERNEL, "%s-%d", client->name, num); if (!info->battery.name) { ret = -ENOMEM; goto fail_name; } if (id->driver_data == DS2786) info->rsns = pdata->rsns; i2c_set_clientdata(client, info); info->client = client; info->id = num; info->ops = &ds278x_ops[id->driver_data]; ds278x_power_supply_init(&info->battery); ret = power_supply_register(&client->dev, &info->battery); if (ret) { dev_err(&client->dev, "failed to register battery\n"); goto fail_register; } return 0; fail_register: kfree(info->battery.name); fail_name: kfree(info); fail_info: mutex_lock(&battery_lock); idr_remove(&battery_id, num); mutex_unlock(&battery_lock); fail_id: return ret; }
static int msp430_probe(struct i2c_client *client, const struct i2c_device_id *id) { int i; int ret = 0; char rec_buf = 0; struct msp430_data *data; struct _batt_func batt_func = {0}; acer_smem_flag_t *acer_smem_flag; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s: i2c_check_functionality failed!\n", __func__); ret = -EIO; goto exit_i2c_check_failed; } data = kzalloc(sizeof(struct msp430_data), GFP_KERNEL); if (data == NULL) { pr_err("%s: no memory for driver data\n", __func__); ret = -ENOMEM; goto exit_kzalloc_failed; } i2c_set_clientdata(client, data); data->client = client; data->is_mcu_ready = 0; data->led_buf[0] = 0; data->led_buf[1] = 0; data->led_buf[2] = 0; data->batt_info.cap_percent = 255; data->is_first_read_cap_after_resume = 1; priv_data = data; acer_smem_flag = (acer_smem_flag_t *)(smem_alloc(SMEM_ID_VENDOR0, sizeof(acer_smem_flag_t))); if (acer_smem_flag == NULL) { pr_err("%s:alloc acer_smem_flag failed!\n", __func__); data->hw_ver = ACER_HW_VERSION_INVALID; } else data->hw_ver = acer_smem_flag->acer_hw_version; mutex_init(&data->gauge_mutex); mutex_init(&data->mutex); mutex_init(&data->i2c_mutex); INIT_WORK(&data->work, msp430_work_func); init_waitqueue_head(&data->gauge_wait); wake_lock_init(&data->cap_zero_wlock, WAKE_LOCK_SUSPEND, "batt_zero(full)_lock"); wake_lock_init(&data->mcu_update_wlock, WAKE_LOCK_SUSPEND, "mcu_update_lock"); setup_timer(&data->avg_timer, avg_timer_expired, 0); INIT_WORK(&data->avg_work, avg_timer_work); /* connect with battery driver */ batt_func.get_battery_info = _get_battery_info; register_bat_func(&batt_func); if (data && batt_func.battery_isr_hander) data->battery_isr_hander = batt_func.battery_isr_hander; else pr_err("%s:register battery function(battery_isr_hander) error!\n", __func__); if (data && batt_func.get_charger_type) data->get_charger_type = batt_func.get_charger_type; else pr_err("%s:register battery function(get_charger_type) error!\n", __func__); /* Input register */ data->input = input_allocate_device(); if (!data->input) { pr_err("%s: input_allocate_device failed!\n", __func__); ret = -ENOMEM; goto exit_input_allocate_failed; } data->input->name = "a5-msp430-keypad"; data->keymap_size = ARRAY_SIZE(msp430_keymap); for (i = 1; i < data->keymap_size; i++) input_set_capability(data->input, EV_KEY, msp430_keymap[i]); ret = input_register_device(data->input); if (ret) { pr_err("%s input_register_device failed!\n", __func__); goto exit_input_register_failed; } /* Link interrupt routine with the irq */ if (client->irq) { ret = request_irq(client->irq, msp430_interrupt, IRQF_TRIGGER_RISING, MSP430_DRIVER_NAME, data); if (ret < 0) { pr_err("%s: request_irq failed!\n", __func__); goto exit_irq_request_failed; } else enable_irq_wake(client->irq); } /* Read MCU Version */ ret = reg_read(client, REG_SYSTEM_VERSION, &rec_buf); if (ret < 0) { ret = -EIO; goto exit_read_failed; } pr_info("MCU msp430 Version = %d\n", rec_buf); data->version = rec_buf; if (data->version > 0x18) data->led_buf[0] = SYS_MODE_RESERVED; else data->led_buf[0] = SYS_MODE_NORMAL; if (data->hw_ver != ACER_HW_VERSION_INVALID) update_mcu_delayed(14000); /*version=0xff means firmware is broken, *it should be fixed by update_mcu_delayed*/ if (data->version != 0xff) { mcu_hw_config(client, data->version); data->is_mcu_ready = 1; battery_info_change(); mod_timer(&data->avg_timer, jiffies + msecs_to_jiffies(POLLING_TIME - 5000)); } #ifdef CONFIG_HAS_EARLYSUSPEND data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN; data->early_suspend.suspend = msp430_early_suspend; data->early_suspend.resume = msp430_late_resume; register_early_suspend(&data->early_suspend); #endif return 0; exit_read_failed: free_irq(client->irq, &data); exit_irq_request_failed: input_unregister_device(data->input); exit_input_register_failed: input_free_device(data->input); exit_input_allocate_failed: kfree(data); exit_kzalloc_failed: exit_i2c_check_failed: return ret; }
static int yas_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct yas_state *st; struct iio_dev *indio_dev; int ret, i; u8 temp; pr_info("[SENSOR]: %s - Probe Start!\n", __func__); this_client = client; /* Check if the device is there or not. */ ret = yas_device_read(YAS_TYPE_MAG, REG_DIDR, &temp, 1); if (ret < 0) { ret = -ENODEV; goto error_check_dev; } indio_dev = iio_device_alloc(sizeof(*st)); if (!indio_dev) { ret = -ENOMEM; goto error_ret; } st = iio_priv(indio_dev); i2c_set_clientdata(client, indio_dev); st->client = client; /* IIO device init */ indio_dev->name = "magnetic_sensor"; indio_dev->channels = yas_channels; indio_dev->num_channels = ARRAY_SIZE(yas_channels); indio_dev->dev.parent = &client->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &yas_info; st->sampling_frequency = 20; st->mag.callback.device_open = yas_device_open; st->mag.callback.device_close = yas_device_close; st->mag.callback.device_read = yas_device_read; st->mag.callback.device_write = yas_device_write; st->mag.callback.usleep = yas_usleep; st->mag.callback.current_time = yas_current_time; INIT_DELAYED_WORK(&st->work, yas_work_func); mutex_init(&st->lock); #ifdef CONFIG_HAS_EARLYSUSPEND st->sus.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; st->sus.suspend = yas_early_suspend; st->sus.resume = yas_late_resume; register_early_suspend(&st->sus); #endif for (i = 0; i < 3; i++) st->compass_data[i] = 0; ret = yas_probe_buffer(indio_dev); if (ret) goto error_free_dev; ret = yas_probe_trigger(indio_dev); if (ret) goto error_remove_buffer; ret = iio_device_register(indio_dev); if (ret) goto error_remove_trigger; ret = yas_mag_driver_init(&st->mag); if (ret < 0) { ret = -EFAULT; goto error_unregister_iio; } ret = st->mag.init(); if (ret < 0) { ret = -EFAULT; goto error_unregister_iio; } ret = yas_parse_dt(st, &client->dev); if (ret < 0) { pr_err("%s of_node error\n", __func__); ret = -ENODEV; goto error_of_node; } ret= st->mag.set_position(st->chip_pos); if (ret < 0) { ret = -EFAULT; goto error_of_node; } spin_lock_init(&st->spin_lock); ret = sensors_register(st->factory_dev, st, mag_sensor_attrs, MODULE_NAME); if (ret < 0) { pr_err("[SENSOR] %s: cound not register mag device(%d).\n", __func__, ret); goto err_mag_sensor_register_failed; } pr_info("[SENSOR]: %s - Probe done!\n", __func__); return 0; err_mag_sensor_register_failed: error_of_node: error_unregister_iio: iio_device_unregister(indio_dev); error_remove_trigger: yas_remove_trigger(indio_dev); error_remove_buffer: yas_remove_buffer(indio_dev); error_free_dev: #ifdef CONFIG_HAS_EARLYSUSPEND unregister_early_suspend(&st->sus); #endif i2c_set_clientdata(client, NULL); error_ret: error_check_dev: this_client = NULL; pr_err("[SENSOR]: %s - Probe fail!\n", __func__); return ret; }
static int pn547_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; int err; int addr; char tmp[4] = {0x20, 0x00, 0x01, 0x01}; int addrcnt; struct pn547_i2c_platform_data *platform_data; struct pn547_dev *pn547_dev; if (client->dev.of_node) { platform_data = devm_kzalloc(&client->dev, sizeof(struct pn547_i2c_platform_data), GFP_KERNEL); if (!platform_data) { dev_err(&client->dev, "Failed to allocate memory\n"); return -ENOMEM; } err = pn547_parse_dt(&client->dev, platform_data); if (err) return err; } else { platform_data = client->dev.platform_data; } if (platform_data == NULL) { pr_err("%s : nfc probe fail\n", __func__); return -ENODEV; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s : need I2C_FUNC_I2C\n", __func__); return -ENODEV; } ret = gpio_request(platform_data->irq_gpio, "nfc_int"); if (ret) return -ENODEV; ret = gpio_request(platform_data->ven_gpio, "nfc_ven"); if (ret) goto err_ven; ret = gpio_request(platform_data->firm_gpio, "nfc_firm"); if (ret) goto err_firm; #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST ret = gpio_request(platform_data->clk_req_gpio, "nfc_clk_req"); if (ret) goto err_clk_req; #endif pn547_dev = kzalloc(sizeof(*pn547_dev), GFP_KERNEL); if (pn547_dev == NULL) { dev_err(&client->dev, "failed to allocate memory for module data\n"); ret = -ENOMEM; goto err_exit; } #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST pn547_dev->nfc_clock = msm_xo_get(MSM_XO_TCXO_A1, "nfc"); if (IS_ERR(pn547_dev->nfc_clock)) { ret = PTR_ERR(pn547_dev->nfc_clock); printk(KERN_ERR "%s: Couldn't get TCXO_A1 vote for NFC (%d)\n", __func__, ret); ret = -ENODEV; goto err_get_clock; } pn547_dev->clock_state = false; #endif #ifdef CONFIG_NFC_PN547_PMC8974_CLK_REQ pn547_dev->nfc_clk = clk_get(&client->dev, "nfc_clk"); if (IS_ERR(pn547_dev->nfc_clk)) { ret = PTR_ERR(pn547_dev->nfc_clk); printk(KERN_ERR "%s: Couldn't get D1 (%d)\n", __func__, ret); } else { if (clk_prepare_enable(pn547_dev->nfc_clk)) printk(KERN_ERR "%s: Couldn't prepare D1\n", __func__); } #endif pr_info("%s : IRQ num %d\n", __func__, client->irq); pn547_dev->irq_gpio = platform_data->irq_gpio; pn547_dev->ven_gpio = platform_data->ven_gpio; pn547_dev->firm_gpio = platform_data->firm_gpio; pn547_dev->conf_gpio = platform_data->conf_gpio; #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST pn547_dev->clk_req_gpio = platform_data->clk_req_gpio; pn547_dev->clk_req_irq = platform_data->clk_req_irq; #endif pn547_dev->client = client; /* init mutex and queues */ init_waitqueue_head(&pn547_dev->read_wq); mutex_init(&pn547_dev->read_mutex); pn547_dev->pn547_device.minor = MISC_DYNAMIC_MINOR; #ifdef CONFIG_NFC_PN547 pn547_dev->pn547_device.name = "pn547"; #else pn547_dev->pn547_device.name = "pn544"; #endif pn547_dev->pn547_device.fops = &pn547_dev_fops; ret = misc_register(&pn547_dev->pn547_device); if (ret) { pr_err("%s : misc_register failed\n", __FILE__); goto err_misc_register; } /* request irq. the irq is set whenever the chip has data available * for reading. it is cleared when all data has been read. */ pr_info("%s : requesting IRQ %d\n", __func__, client->irq); gpio_direction_input(pn547_dev->irq_gpio); gpio_direction_output(pn547_dev->ven_gpio, 0); gpio_direction_output(pn547_dev->firm_gpio, 0); #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST gpio_direction_input(pn547_dev->clk_req_gpio); #endif i2c_set_clientdata(client, pn547_dev); wake_lock_init(&pn547_dev->nfc_wake_lock, WAKE_LOCK_SUSPEND, "nfc_wake_lock"); #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST pn547_dev->wq_clock = create_singlethread_workqueue("nfc_wq"); if (!pn547_dev->wq_clock) { ret = -ENOMEM; pr_err("%s: could not create workqueue\n", __func__); goto err_create_workqueue; } INIT_WORK(&pn547_dev->work_nfc_clock, nfc_work_func_clock); #endif ret = request_irq(client->irq, pn547_dev_irq_handler, IRQF_TRIGGER_RISING, "pn547", pn547_dev); if (ret) { dev_err(&client->dev, "request_irq failed\n"); goto err_request_irq_failed; } disable_irq_nosync(pn547_dev->client->irq); atomic_set(&pn547_dev->irq_enabled, 0); #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST ret = request_irq(pn547_dev->clk_req_irq, pn547_dev_clk_req_irq_handler, IRQF_SHARED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING , "pn547_clk_req", pn547_dev); if (ret) { dev_err(&client->dev, "request_irq(clk_req) failed\n"); goto err_request_irq_failed; } enable_irq_wake(pn547_dev->clk_req_irq); #endif gpio_set_value(pn547_dev->ven_gpio, 1); usleep_range(10000, 11000); for (addr = 0x28; addr < 0x2C; addr++) { client->addr = addr; addrcnt = 2; do { ret = i2c_master_send(client, tmp, 4); if (ret > 0) { pr_info("%s : i2c addr=0x%X\n", __func__, client->addr); break; } msleep(20); } while (addrcnt--); if (ret > 0) break; } gpio_set_value(pn547_dev->ven_gpio, 0); if (ret < 0) { pr_err("%s : fail to get i2c addr\n", __func__); goto err_request_irq_failed; } pr_info("%s : success\n", __func__); return 0; err_request_irq_failed: #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST err_create_workqueue: #endif misc_deregister(&pn547_dev->pn547_device); wake_lock_destroy(&pn547_dev->nfc_wake_lock); err_misc_register: mutex_destroy(&pn547_dev->read_mutex); #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST msm_xo_put(pn547_dev->nfc_clock); err_get_clock: #endif kfree(pn547_dev); err_exit: #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST gpio_free(platform_data->clk_req_gpio); err_clk_req: #endif gpio_free(platform_data->firm_gpio); err_firm: gpio_free(platform_data->ven_gpio); err_ven: gpio_free(platform_data->irq_gpio); pr_err("[pn547] pn547_probe fail!\n"); return ret; }
static int sec_pmic_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct sec_pmic_platform_data *pdata = i2c->dev.platform_data; struct sec_pmic_dev *sec_pmic; int ret = 0; if (!pdata) { dev_err(&i2c->dev, "No platform data found\n"); return -EIO; } sec_pmic = devm_kzalloc(&i2c->dev, sizeof(struct sec_pmic_dev), GFP_KERNEL); if (sec_pmic == NULL) return -ENOMEM; i2c_set_clientdata(i2c, sec_pmic); sec_pmic->dev = &i2c->dev; sec_pmic->i2c = i2c; sec_pmic->irq = i2c->irq; sec_pmic->type = id->driver_data; if (pdata) { sec_pmic->device_type = pdata->device_type; sec_pmic->ono = pdata->ono; sec_pmic->irq_base = pdata->irq_base; sec_pmic->wakeup = pdata->wakeup; } sec_pmic->regmap = regmap_init_i2c(i2c, &sec_regmap_config); if (IS_ERR(sec_pmic->regmap)) { ret = PTR_ERR(sec_pmic->regmap); dev_err(&i2c->dev, "Failed to allocate register map: %d\n", ret); goto err4; } mutex_init(&sec_pmic->iolock); sec_pmic->rtc = i2c_new_dummy(i2c->adapter, RTC_I2C_ADDR); if (IS_ERR(sec_pmic->rtc)) { ret = PTR_ERR(sec_pmic->rtc); dev_err(&i2c->dev, "Address %02x unavailable\n", RTC_I2C_ADDR); goto err3; } i2c_set_clientdata(sec_pmic->rtc, sec_pmic); sec_pmic->rtc_regmap = regmap_init_i2c(sec_pmic->rtc, &sec_regmap_config); if (IS_ERR(sec_pmic->rtc_regmap)) { ret = PTR_ERR(sec_pmic->rtc_regmap); dev_err(&sec_pmic->rtc->dev, "Failed to allocate register map: %d\n", ret); goto err2; } if (pdata && pdata->cfg_pmic_irq) pdata->cfg_pmic_irq(); sec_irq_init(sec_pmic); pm_runtime_set_active(sec_pmic->dev); switch (sec_pmic->device_type) { case S5M8751X: ret = mfd_add_devices(sec_pmic->dev, -1, s5m8751_devs, ARRAY_SIZE(s5m8751_devs), NULL, 0); break; case S5M8763X: ret = mfd_add_devices(sec_pmic->dev, -1, s5m8763_devs, ARRAY_SIZE(s5m8763_devs), NULL, 0); break; case S5M8767X: ret = mfd_add_devices(sec_pmic->dev, -1, s5m8767_devs, ARRAY_SIZE(s5m8767_devs), NULL, 0); break; case S2MPS11X: ret = mfd_add_devices(sec_pmic->dev, -1, s2mps11_devs, ARRAY_SIZE(s2mps11_devs), NULL, 0); break; default: /* If this happens the probe function is problem */ BUG(); } if (ret < 0) goto err1; return ret; err1: sec_irq_exit(sec_pmic); regmap_exit(sec_pmic->rtc_regmap); err2: i2c_unregister_device(sec_pmic->rtc); err3: regmap_exit(sec_pmic->regmap); err4: return ret; }
static int cw_bat_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct cw_bat_platform_data *pdata = client->dev.platform_data; struct cw_battery *cw_bat; int ret; int loop = 0; printk("\ncw2015/cw2013 driver v1.2 probe start, battery_type_id is %d\n", battery_type_id); cw_bat = kzalloc(sizeof(struct cw_battery), GFP_KERNEL); if (!cw_bat) { dev_err(&cw_bat->client->dev, "fail to allocate memory\n"); return -ENOMEM; } if (client->dev.of_node) { pdata = devm_kzalloc(&client->dev, sizeof(struct cw_bat_platform_data), GFP_KERNEL); if (!pdata) { dev_err(&client->dev, "GTP Failed to allocate memory for pdata\n"); return -ENOMEM; } ret = cw_bat_parse_dt(&client->dev, pdata); if (ret) return ret; } else { pdata = client->dev.platform_data; } if (!pdata) { dev_err(&client->dev, "Invalid pdata\n"); return -EINVAL; } if (battery_type_id == 0) { pdata->cw_bat_config_info = config_info_desai ; } else if (battery_type_id == 1) { pdata->cw_bat_config_info = config_info_feimaotui ; } else if (battery_type_id == 2) { pdata->cw_bat_config_info = config_info_guanyu ; } else if (battery_type_id == 3) { pdata->cw_bat_config_info = config_info_xinwangda; } else { pdata->cw_bat_config_info = config_info; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "I2C not supported\n"); return -ENODEV; } cw_bat->client = client; i2c_set_clientdata(client, cw_bat); cw_bat->plat_data = pdata; ret = cw_check_ic(cw_bat); while ((loop++ < 5) && (ret != 0)) { pr_debug(" check ret is %d, loop is %d \n" , ret, loop); ret = cw_check_ic(cw_bat); } if (ret != 0) { pr_debug(" wc_check_ic fail , return ENODEV \n"); return -ENODEV; } ret = cw_init(cw_bat); while ((loop++ < 2000) && (ret != 0)) { ret = cw_init(cw_bat); } if (ret) { return ret; } cw_bat->rk_bat.name = "rk-bat"; cw_bat->rk_bat.type = POWER_SUPPLY_TYPE_BATTERY; cw_bat->rk_bat.properties = rk_battery_properties; cw_bat->rk_bat.num_properties = ARRAY_SIZE(rk_battery_properties); cw_bat->rk_bat.get_property = rk_battery_get_property; ret = power_supply_register(&client->dev, &cw_bat->rk_bat); if (ret < 0) { dev_err(&cw_bat->client->dev, "power supply register rk_bat error\n"); printk("rk_bat_register_fail\n"); goto rk_bat_register_fail; } cw_bat->charger_mode = 0; cw_bat->capacity = 0; cw_bat->voltage = 0; cw_bat->status = 0; cw_bat->time_to_empty = 0; cw_bat->bat_change = 0; cw_update_time_member_capacity_change(cw_bat); cw_update_time_member_charge_start(cw_bat); cw_bat->battery_workqueue = create_singlethread_workqueue("rk_battery"); INIT_DELAYED_WORK(&cw_bat->battery_delay_work, cw_bat_work); queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(10)); #ifdef BAT_LOW_INTERRUPT ret = cw_bat_regulator_configure(cw_bat, true); if (ret < 0) { dev_err(&client->dev, "%s Failed to configure regulators\n", __func__); goto err_reg_configure; } ret = cw_bat_power_on(cw_bat, true); if (ret < 0) { dev_err(&client->dev, "%s Failed to power on\n", __func__); goto err_power_device; } ret = cw_bat_pinctrl_init(cw_bat); if (!ret && cw_bat->ts_pinctrl) { ret = pinctrl_select_state(cw_bat->ts_pinctrl, cw_bat->pinctrl_state_active); if (ret < 0) goto err_pinctrl_select; } ret = cw_bat_gpio_configure(cw_bat, true); if (ret < 0) { dev_err(&client->dev, "%s Failed to configure gpios\n", __func__); goto err_gpio_config; } INIT_DELAYED_WORK(&cw_bat->bat_low_wakeup_work, bat_low_detect_do_wakeup); wake_lock_init(&bat_low_wakelock, WAKE_LOCK_SUSPEND, "bat_low_detect"); cw_bat->client->irq = gpio_to_irq(pdata->bat_low_pin); ret = request_threaded_irq(client->irq, NULL, bat_low_detect_irq_handler, pdata->irq_flags, "bat_low_detect", cw_bat); if (ret) { dev_err(&client->dev, "request irq failed\n"); gpio_free(cw_bat->plat_data->bat_low_pin); } /*Chaman add for charger detect*/ charge_psy = power_supply_get_by_name("usb"); err_gpio_config: if (cw_bat->ts_pinctrl) { ret = cw_bat_pinctrl_select(cw_bat, false); if (ret < 0) pr_err("Cannot get idle pinctrl state\n"); } err_pinctrl_select: if (cw_bat->ts_pinctrl) { pinctrl_put(cw_bat->ts_pinctrl); } err_power_device: cw_bat_power_on(cw_bat, false); err_reg_configure: cw_bat_regulator_configure(cw_bat, false); #endif printk("\ncw2015/cw2013 driver v1.2 probe sucess\n"); return 0; rk_bat_register_fail: dev_dbg(&cw_bat->client->dev, "cw2015/cw2013 driver v1.2 probe error!!!!\n"); return ret; }
static int __devinit ami306_probe(struct i2c_client *client, const struct i2c_device_id * devid) { int err = 0; struct ami306_i2c_data *data; struct ecom_platform_data* ecom_pdata; if (AMI306_DEBUG_FUNC_TRACE & ami306_debug_mask) AMID("motion start....!\n"); if(!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { AMIE("adapter can NOT support I2C_FUNC_I2C.\n"); return -ENODEV; } if (!(data = kmalloc(sizeof(struct ami306_i2c_data), GFP_KERNEL))) { err = -ENOMEM; goto exit; } memset(data, 0, sizeof(struct ami306_i2c_data)); data->client = client; i2c_set_clientdata(client, data); ami306_i2c_client = client; ecom_pdata = ami306_i2c_client->dev.platform_data; ecom_pdata->power(1); #if defined(CONFIG_HAS_EARLYSUSPEND) ami306_sensor_early_suspend.suspend = ami306_early_suspend; ami306_sensor_early_suspend.resume = ami306_late_resume; register_early_suspend(&ami306_sensor_early_suspend); atomic_set(&ami306_report_enabled, 1); #endif err=Identify_AMI_Chipset(); if (err != 0) { //get ami306_data.chipset printk(KERN_INFO "Failed to identify AMI_Chipset!\n"); goto exit_kfree; } AMI306_Chipset_Init(AMI306_FORCE_MODE, ami306_data.chipset); // default is Force State dev_info(&client->dev, "%s operating mode\n", ami306_data.mode? "force" : "normal"); printk(KERN_INFO "Register input device!\n"); err = ami306_input_init(data); if(err) goto exit_kfree; //register misc device:ami306 err = misc_register(&ami306_device); if (err) { AMIE("ami306_device register failed\n"); goto exit_misc_ami306_device_register_failed; } //register misc device:ami306daemon err = misc_register(&ami306daemon_device); if (err) { AMIE("ami306daemon_device register failed\n"); goto exit_misc_ami306daemon_device_register_failed; } //register misc device:ami306hal err = misc_register(&ami306hal_device); if (err) { AMIE("ami306hal_device register failed\n"); goto exit_misc_ami306hal_device_register_failed; } /* Register sysfs hooks */ err = sysfs_create_group(&client->dev.kobj, &ami306_attribute_group); if (err) { AMIE("ami306 sysfs register failed\n"); goto exit_sysfs_create_group_failed; } printk(KERN_INFO "[jaekyung83.lee] ami306 probe"); return 0; exit_sysfs_create_group_failed: sysfs_remove_group(&client->dev.kobj, &ami306_attribute_group); exit_misc_ami306hal_device_register_failed: misc_deregister(&ami306daemon_device); exit_misc_ami306daemon_device_register_failed: misc_deregister(&ami306_device); exit_misc_ami306_device_register_failed: input_unregister_device(data->input_dev); input_free_device(data->input_dev); exit_kfree: kfree(data); exit: return err; }
static int da9150_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct da9150 *da9150; struct da9150_pdata *pdata = dev_get_platdata(&client->dev); int qif_addr; int ret; da9150 = devm_kzalloc(&client->dev, sizeof(*da9150), GFP_KERNEL); if (!da9150) return -ENOMEM; da9150->dev = &client->dev; da9150->irq = client->irq; i2c_set_clientdata(client, da9150); da9150->regmap = devm_regmap_init_i2c(client, &da9150_regmap_config); if (IS_ERR(da9150->regmap)) { ret = PTR_ERR(da9150->regmap); dev_err(da9150->dev, "Failed to allocate register map: %d\n", ret); return ret; } /* Setup secondary I2C interface for QIF access */ qif_addr = da9150_reg_read(da9150, DA9150_CORE2WIRE_CTRL_A); qif_addr = (qif_addr & DA9150_CORE_BASE_ADDR_MASK) >> 1; qif_addr |= DA9150_QIF_I2C_ADDR_LSB; da9150->core_qif = i2c_new_dummy(client->adapter, qif_addr); if (!da9150->core_qif) { dev_err(da9150->dev, "Failed to attach QIF client\n"); return -ENODEV; } i2c_set_clientdata(da9150->core_qif, da9150); if (pdata) { da9150->irq_base = pdata->irq_base; da9150_devs[DA9150_FG_IDX].platform_data = pdata->fg_pdata; da9150_devs[DA9150_FG_IDX].pdata_size = sizeof(struct da9150_fg_pdata); } else { da9150->irq_base = -1; } ret = regmap_add_irq_chip(da9150->regmap, da9150->irq, IRQF_TRIGGER_LOW | IRQF_ONESHOT, da9150->irq_base, &da9150_regmap_irq_chip, &da9150->regmap_irq_data); if (ret) { dev_err(da9150->dev, "Failed to add regmap irq chip: %d\n", ret); goto regmap_irq_fail; } da9150->irq_base = regmap_irq_chip_get_base(da9150->regmap_irq_data); enable_irq_wake(da9150->irq); ret = mfd_add_devices(da9150->dev, -1, da9150_devs, ARRAY_SIZE(da9150_devs), NULL, da9150->irq_base, NULL); if (ret) { dev_err(da9150->dev, "Failed to add child devices: %d\n", ret); goto mfd_fail; } return 0; mfd_fail: regmap_del_irq_chip(da9150->irq, da9150->regmap_irq_data); regmap_irq_fail: i2c_unregister_device(da9150->core_qif); return ret; }
static int __devinit isl9519q_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct isl_platform_data *pdata; struct isl9519q_struct *isl_chg; int ret; ret = 0; pdata = client->dev.platform_data; pr_debug("\n"); if (pdata == NULL) { dev_err(&client->dev, "%s no platform data\n", __func__); ret = -EINVAL; goto out; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA)) { ret = -EIO; goto out; } isl_chg = kzalloc(sizeof(*isl_chg), GFP_KERNEL); if (!isl_chg) { ret = -ENOMEM; goto out; } spin_lock_init(&isl_chg->lock); INIT_DELAYED_WORK(&isl_chg->charge_work, isl9519q_worker); isl_chg->client = client; isl_chg->chgcurrent = pdata->chgcurrent; isl_chg->term_current = pdata->term_current; isl_chg->input_current = pdata->input_current; isl_chg->max_system_voltage = pdata->max_system_voltage; isl_chg->min_system_voltage = pdata->min_system_voltage; isl_chg->valid_n_gpio = pdata->valid_n_gpio; isl_chg->chgcurrent &= ~0x7F; isl_chg->input_current &= ~0x7F; isl_chg->notify_by_pmic = (client->irq == 0); i2c_set_clientdata(client, isl_chg); if (pdata->chg_detection_config) { ret = pdata->chg_detection_config(); if (ret) { dev_err(&client->dev, "%s valid config failed ret=%d\n", __func__, ret); goto free_isl_chg; } } isl_chg->max_system_voltage &= MAX_VOLTAGE_REG_MASK; isl_chg->min_system_voltage &= MIN_VOLTAGE_REG_MASK; if (isl_chg->max_system_voltage == 0) isl_chg->max_system_voltage = DEFAULT_MAX_VOLTAGE_REG_VALUE; if (isl_chg->min_system_voltage == 0) isl_chg->min_system_voltage = DEFAULT_MIN_VOLTAGE_REG_VALUE; ret = isl9519q_hwinit(isl_chg); if (ret) goto free_isl_chg; if (isl_chg->notify_by_pmic) ret = isl9519q_init_ext_chg(isl_chg); else ret = isl9519q_init_adapter(isl_chg); if (ret) goto free_isl_chg; the_isl_chg = isl_chg; create_debugfs_entries(isl_chg); pr_info("OK.\n"); return 0; free_isl_chg: kfree(isl_chg); out: return ret; }
static int anx7808_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct anx7808_data *anx7808; struct anx7808_platform_data *pdata; struct device_node *dev_node = client->dev.of_node; struct msm_hdmi_sp_ops *hdmi_sp_ops = NULL; int ret = 0; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) { pr_err("i2c bus does not support anx7808\n"); ret = -ENODEV; goto exit; } anx7808 = kzalloc(sizeof(struct anx7808_data), GFP_KERNEL); if (!anx7808) { pr_err("failed to allocate driver data\n"); ret = -ENOMEM; goto exit; } anx7808->client = client; i2c_set_clientdata(client, anx7808); if (dev_node) { ret = anx7808_parse_dt(dev_node, anx7808); if (ret) { pr_err("failed to parse dt\n"); goto err0; } } else { pdata = client->dev.platform_data; if (pdata == NULL) { pr_err("no platform data.\n"); goto err0; } anx7808->gpio_p_dwn = pdata->gpio_p_dwn; anx7808->gpio_reset = pdata->gpio_reset; anx7808->gpio_int = pdata->gpio_int; anx7808->gpio_cbl_det = pdata->gpio_cbl_det; anx7808->vdd10_name = pdata->vdd10_name; anx7808->vdd10_name = pdata->avdd33_name; } /* initialize hdmi_sp_ops */ hdmi_sp_ops = devm_kzalloc(&client->dev, sizeof(struct msm_hdmi_sp_ops), GFP_KERNEL); if (!hdmi_sp_ops) { pr_err("alloc hdmi sp ops failed\n"); goto err0; } if (anx7808->hdmi_pdev) { ret = msm_hdmi_register_sp(anx7808->hdmi_pdev, hdmi_sp_ops); if (ret) { pr_err("register with hdmi_failed\n"); goto err0; } } anx7808->hdmi_sp_ops = hdmi_sp_ops; the_chip = anx7808; mutex_init(&anx7808->lock); init_completion(&init_aux_ch_completion); ret = anx7808_init_gpio(anx7808); if (ret) { pr_err("failed to initialize gpio\n"); goto err0; } INIT_DELAYED_WORK(&anx7808->work, anx7808_work_func); anx7808->workqueue = create_singlethread_workqueue("anx7808_work"); if (!anx7808->workqueue) { pr_err("failed to create work queue\n"); ret = -ENOMEM; goto err1; } ret = anx7808_avdd_3p3_power(anx7808, true); if (ret) goto err2; ret = anx7808_vdd_1p0_power(anx7808, false); if (ret) goto err3; ret = anx7808_system_init(); if (ret) { pr_err("failed to initialize anx7808\n"); goto err4; } client->irq = gpio_to_irq(anx7808->gpio_cbl_det); if (client->irq < 0) { pr_err("failed to get gpio irq\n"); goto err4; } wake_lock_init(&anx7808->slimport_lock, WAKE_LOCK_SUSPEND, "slimport_wake_lock"); ret = request_threaded_irq(client->irq, NULL, anx7808_cbl_det_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "anx7808", anx7808); if (ret < 0) { pr_err("failed to request irq\n"); goto err5; } disable_irq(client->irq); ret = enable_irq_wake(client->irq); if (ret < 0) { pr_err("interrupt wake enable fail\n"); goto err6; } anx7808_setup_video_mode_lut(); anx7808_get_usb_clk(client); return 0; err6: free_irq(client->irq, anx7808); err5: wake_lock_destroy(&anx7808->slimport_lock); err4: if (!anx7808->vdd_reg) regulator_put(anx7808->vdd_reg); err3: if (!anx7808->avdd_reg) regulator_put(anx7808->avdd_reg); err2: destroy_workqueue(anx7808->workqueue); err1: anx7808_free_gpio(anx7808); err0: the_chip = NULL; kfree(anx7808); exit: return ret; }
static int pm8901_probe(struct i2c_client *client, const struct i2c_device_id *id) { int i, rc; struct pm8901_platform_data *pdata = client->dev.platform_data; struct pm8901_chip *chip; if (pdata == NULL || !client->irq) { pr_err("%s: No platform_data or IRQ.\n", __func__); return -ENODEV; } if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C) == 0) { pr_err("%s: i2c_check_functionality failed.\n", __func__); return -ENODEV; } chip = kzalloc(sizeof *chip, GFP_KERNEL); if (chip == NULL) { pr_err("%s: kzalloc() failed.\n", __func__); return -ENOMEM; } chip->dev = client; /* Read PMIC chip revision */ rc = ssbi_read(chip->dev, SSBI_REG_REV, &chip->revision, 1); if (rc) pr_err("%s: Failed on ssbi_read for revision: rc=%d.\n", __func__, rc); pr_info("%s: PMIC revision: %X\n", __func__, chip->revision); (void) memcpy((void *)&chip->pdata, (const void *)pdata, sizeof(chip->pdata)); set_irq_data(chip->dev->irq, (void *)chip); set_irq_wake(chip->dev->irq, 1); chip->pm_max_irq = 0; chip->pm_max_blocks = 0; chip->pm_max_masters = 0; i2c_set_clientdata(client, chip); pmic_chip = chip; spin_lock_init(&chip->pm_lock); // kmj_el15.pm8901_patch // This api is s/w workaround for PM8901's abnormal spike which could // cause DDR problem on PCB. Because of the spike SS made new PCB for // h/w workaround. This s/w workaround is for old PCBs. And If a target // is new PCB, you should call a api to drop bypass voltage // to 1.725 originally. But you don't need that here, bacause you've done // that already at SBL3. So instead of calling api to drop bypass voltage // here you just need to check if SBL3 bootloader includes the api. // In other words this api has dependency with SBL3 change if( pm8901_is_old_PCB_with_PM8901()==1 ) pm8901_preload_dVdd(); /* Register for all reserved IRQs */ for (i = pdata->irq_base; i < (pdata->irq_base + MAX_PM_IRQ); i++) { set_irq_chip(i, &pm8901_irq_chip); set_irq_handler(i, handle_edge_irq); set_irq_flags(i, IRQF_VALID); set_irq_data(i, (void *)chip); } /* Add sub devices with the chip parameter as driver data */ for (i = 0; i < pdata->num_subdevs; i++) pdata->sub_devices[i].driver_data = chip; rc = mfd_add_devices(&chip->dev->dev, 0, pdata->sub_devices, pdata->num_subdevs, NULL, 0); if (rc) { pr_err("%s: could not add devices %d\n", __func__, rc); return rc; } rc = request_threaded_irq(chip->dev->irq, NULL, pm8901_isr_thread, IRQF_ONESHOT | IRQF_DISABLED | pdata->irq_trigger_flags, "pm8901-irq", chip); if (rc) pr_err("%s: could not request irq %d: %d\n", __func__, chip->dev->irq, rc); rc = pmic8901_dbg_probe(chip); if (rc < 0) pr_err("%s: could not set up debugfs: %d\n", __func__, rc); return rc; }