static int gs_probe( struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct gs_data *gs; struct vreg *vreg_gp4=NULL; int rc; vreg_gp4 = vreg_get(NULL, "gp4"); /* set gp4 voltage as 2700mV for all */ rc = vreg_set_level(vreg_gp4,VREG_GP4_VOLTAGE_VALUE_2700); if (rc) { printk("%s: vreg_gp4 vreg_set_level failed \n", __func__); return rc; } rc = vreg_enable(vreg_gp4); if (rc) { printk("%s: vreg_gp4 vreg_enable failed \n", __func__); return rc; } mdelay(5); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { printk(KERN_ERR "gs_probe: need I2C_FUNC_I2C\n"); ret = -ENODEV; goto err_check_functionality_failed; } #ifndef GS_POLLING ret = gs_config_int1_pin(); if(ret <0) { goto err_check_functionality_failed; } ret = gs_config_int2_pin(); if(ret <0) { goto err_check_functionality_failed; } #endif gs = kzalloc(sizeof(*gs), GFP_KERNEL); if (gs == NULL) { ret = -ENOMEM; goto err_alloc_data_failed; } /*BK4D00238, add mlock, dingxifeng KF14049, 2009-4-3 begin */ mutex_init(&gs->mlock); /*BK4D00238, add mlock, dingxifeng KF14049, 2009-4-3 end */ INIT_WORK(&gs->work, gs_work_func); gs->client = client; i2c_set_clientdata(client, gs); /*BK4D00238, add accelerometer code, dingxifeng KF14049, 2009-5-9 begin */ ret =reg_read(gs,GS_ADI_REG_DEVID); if ( ret <0 ) goto err_detect_failed; switch (ret) { case ID_ADXL345: break; default: printk(KERN_ERR, "Failed to probe \n" ); goto err_detect_failed; } /*BK4D01637, gs_probe interface set standby mode , dingxifeng KF14049, 2009-6-22 begin*/ ret = reg_write(gs,GS_ADI_REG_POWER_CTL,0x14); /* auto low power ,deep sleep */ /*BK4D01637, gs_probe interface set standby mode , dingxifeng KF14049, 2009-6-22 end*/ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_BW,0x0a); /* Rate: 100Hz, IDD: 130uA */ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_DATA_FORMAT,0x01); /* Data Format: 8g right justified 128=1g 8g*/ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_INT_ENABLE,0x80); /* enable int Int En: Data Rdy*/ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_TAP_AXES,0x01); /* Z Axis Tap */ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_THRESH_TAP,0x20); /* Tap Threshold: 2G */ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_DUR,0x50); /* Dur:50ms */ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_LATENT,0x20); /* Latent: 40ms */ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_WINDOW,0xF0); /* Window: 300ms */ if ( ret <0 ) goto err_detect_failed; if (sensor_dev == NULL) { gs->input_dev = input_allocate_device(); if (gs->input_dev == NULL) { ret = -ENOMEM; printk(KERN_ERR "gs_probe: Failed to allocate input device\n"); goto err_input_dev_alloc_failed; } gs->input_dev->name = "sensors"; sensor_dev = gs->input_dev; }else{ gs->input_dev = sensor_dev; } gs->input_dev->id.vendor = GS_ADIX345;//for akm8973 compass detect. set_bit(EV_ABS,gs->input_dev->evbit); /* modify for ES-version*/ input_set_abs_params(gs->input_dev, ABS_X, -11520, 11520, 0, 0); input_set_abs_params(gs->input_dev, ABS_Y, -11520, 11520, 0, 0); input_set_abs_params(gs->input_dev, ABS_Z, -11520, 11520, 0, 0); set_bit(EV_SYN,gs->input_dev->evbit); gs->input_dev->id.bustype = BUS_I2C; //gs->input_dev->open = gs_adi_input_open; //gs->input_dev->close = gs_adi_input_close; input_set_drvdata(gs->input_dev, gs); ret = input_register_device(gs->input_dev); if (ret) { printk(KERN_ERR "gs_probe: Unable to register %s input device\n", gs->input_dev->name); goto err_input_register_device_failed; } ret = misc_register(&gsensor_device); if (ret) { /*BK4D02639, modify printk mesg, dingxifeng KF14049, 2009-7-13 begin */ printk(KERN_ERR "gs_probe: gsensor_device register failed\n"); /*BK4D02639, modify printk mesg, dingxifeng KF14049, 2009-7-13 end */ goto err_misc_device_register_failed; } /*BK4D00263, add for input devices, dingxifeng KF14049, 2009-5-20 end*/ #ifndef GS_POLLING if (client->irq) { ret = request_irq(client->irq, gs_irq_handler, 0, client->name, gs); if (ret == 0) gs->use_irq = 1; else dev_err(&client->dev, "request_irq failed\n"); } #endif /*BK4D00238, add accelerometer code, dingxifeng KF14049, 2009-5-9 end */ if (!gs->use_irq) { hrtimer_init(&gs->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); gs->timer.function = gs_timer_func; } #ifdef CONFIG_HAS_EARLYSUSPEND gs->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; gs->early_suspend.suspend = gs_early_suspend; gs->early_suspend.resume = gs_late_resume; register_early_suspend(&gs->early_suspend); #endif gs_wq = create_singlethread_workqueue("gs_wq"); if (!gs_wq) return -ENOMEM; /*BK4D00263, add for misc devices, dingxifeng KF14049, 2009-5-20begin */ #if 0 else GS_SENSOR_ADI_FLAG =1; #endif this_gs_data =gs; /*BK4D00263, add for misc devices, dingxifeng KF14049, 2009-5-20 end */ printk(KERN_INFO "gs_probe: Start gs_adixl345 in %s mode\n", gs->use_irq ? "interrupt" : "polling"); return 0; /*BK4D00263, add for misc devices, dingxifeng KF14049, 2009-5-20 begin */ err_misc_device_register_failed: misc_deregister(&gsensor_device); err_input_register_device_failed: input_free_device(gs->input_dev); err_input_dev_alloc_failed: /*BK4D00263, add for misc devices, dingxifeng KF14049, 2009-5-20 end */ err_detect_failed: kfree(gs); #ifndef GS_POLLING gs_free_int1(); gs_free_int2(); #endif err_alloc_data_failed: err_check_functionality_failed: if (vreg_gp4!=NULL) { rc = vreg_disable(vreg_gp4); if (rc) { printk("%s: vreg_gp4 vreg_enable failed \n", __func__); return rc; } } return ret; }
static int wacom_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct wacom_g5_platform_data *pdata; struct wacom_i2c *wac_i2c; struct input_dev *input; int ret = 0; int error; int fw_ver; /*Check I2C functionality */ ret = i2c_check_functionality(client->adapter, I2C_FUNC_I2C); if (!ret) { printk(KERN_ERR "%s: No I2C functionality found\n", __func__); ret = -ENODEV; goto err_i2c_fail; } /*Obtain kernel memory space for wacom i2c */ if (client->dev.of_node) { pdata = devm_kzalloc(&client->dev, sizeof(struct wacom_g5_platform_data), GFP_KERNEL); if (!pdata) { dev_err(&client->dev, "%s: Failed to allocate memory\n", __func__); return -ENOMEM; } error = wacom_parse_dt(&client->dev, pdata); if (error) return error; } else { pdata = client->dev.platform_data; if (pdata == NULL) { dev_err(&client->dev, "%s: no pdata\n", __func__); ret = -ENODEV; goto err_i2c_fail; } } wacom_connect_platform_data(pdata); wacom_request_gpio(pdata); wac_i2c = kzalloc(sizeof(struct wacom_i2c), GFP_KERNEL); if (NULL == wac_i2c) { dev_err(&client->dev, "%s: failed to allocate wac_i2c.\n", __func__); ret = -ENOMEM; goto err_i2c_fail; } wac_i2c->client_boot = i2c_new_dummy(client->adapter, WACOM_I2C_BOOT); if (!wac_i2c->client_boot) { dev_err(&client->dev, "Fail to register sub client[0x%x]\n", WACOM_I2C_BOOT); } input = input_allocate_device(); if (NULL == input) { dev_err(&client->dev, "%s: failed to allocate input device.\n", __func__); ret = -ENOMEM; goto err_freemem; } wacom_i2c_set_input_values(client, wac_i2c, input); wac_i2c->wac_feature = &wacom_feature_EMR; wac_i2c->wac_pdata = pdata; wac_i2c->input_dev = input; wac_i2c->client = client; client->irq = gpio_to_irq(pdata->gpio_int); printk(KERN_ERR "%s: wacom : gpio_to_irq : %d\n", __func__, client->irq); wac_i2c->irq = client->irq; /*Set client data */ i2c_set_clientdata(client, wac_i2c); i2c_set_clientdata(wac_i2c->client_boot, wac_i2c); #ifdef WACOM_PDCT_WORK_AROUND wac_i2c->irq_pdct = gpio_to_irq(pdata->gpio_pen_pdct); wac_i2c->pen_pdct = PDCT_NOSIGNAL; #endif #ifdef WACOM_PEN_DETECT wac_i2c->gpio_pen_insert = pdata->gpio_pen_insert; wac_i2c->irq_pen_insert = gpio_to_irq(wac_i2c->gpio_pen_insert); #endif #ifdef WACOM_IMPORT_FW_ALGO wac_i2c->use_offset_table = true; wac_i2c->use_aveTransition = false; #endif #ifdef USE_WACOM_CALLBACK /*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); #endif #ifdef CONFIG_SEC_VIENNA_PROJECT if (system_rev >= WACOM_BOOT_REVISION) { wac_i2c->wac_pdata->ic_mpu_ver = MPU_W9007; wac_i2c->boot_ver = 0x92; } #endif #ifdef CONFIG_SEC_LT03_PROJECT wac_i2c->boot_ver = 0x92; #endif if (wac_i2c->wac_pdata->ic_mpu_ver > 0) { wac_i2c->ic_mpu_ver = wac_i2c->wac_pdata->ic_mpu_ver; wac_i2c->wac_pdata->compulsory_flash_mode(wac_i2c, false); wac_i2c->wac_pdata->wacom_start(wac_i2c); msleep(200); } else { wac_i2c->wac_pdata->compulsory_flash_mode(wac_i2c, true); /*Reset */ wac_i2c->wac_pdata->wacom_start(wac_i2c); msleep(200); ret = wacom_check_mpu_version(wac_i2c); if (ret == -ETIMEDOUT) #if defined(CONFIG_SEC_H_PROJECT) || defined(CONFIG_SEC_FRESCO_PROJECT) goto err_wacom_i2c_send_timeout; #else pr_err("[E-PEN] wacom_i2c_send failed.\n"); #endif wac_i2c->ic_mpu_ver = wacom_check_flash_mode(wac_i2c, BOOT_MPU); dev_info(&wac_i2c->client->dev, "%s: mpu version: %x\n", __func__, ret); if (wac_i2c->ic_mpu_ver == MPU_W9001) wac_i2c->client_boot = i2c_new_dummy(client->adapter, WACOM_I2C_9001_BOOT); else if (wac_i2c->ic_mpu_ver == MPU_W9007) { ret = wacom_enter_bootloader(wac_i2c); if (ret < 0) { dev_info(&wac_i2c->client->dev, "%s: failed to get BootLoader version, %d\n", __func__, ret); goto err_wacom_i2c_bootloader_ver; } else { dev_info(&wac_i2c->client->dev, "%s: BootLoader version: %x\n", __func__, ret); } } wac_i2c->wac_pdata->compulsory_flash_mode(wac_i2c, false); wac_i2c->wac_pdata->reset_platform_hw(wac_i2c); wac_i2c->power_enable = true; } /* Firmware Feature */ wacom_i2c_init_firm_data(); pr_err("%s: wacon ic turn on\n", __func__); fw_ver = wacom_i2c_query(wac_i2c); wacom_init_abs_params(wac_i2c); input_set_drvdata(input, wac_i2c); /*Initializing for semaphor */ mutex_init(&wac_i2c->lock); #if defined(CONFIG_SEC_LT03_PROJECT) || defined(CONFIG_SEC_VIENNA_PROJECT) mutex_init(&wac_i2c->irq_lock); #endif #ifdef WACOM_BOOSTER wacom_init_dvfs(wac_i2c); #endif INIT_DELAYED_WORK(&wac_i2c->resume_work, wacom_i2c_resume_work); #ifdef USE_WACOM_BLOCK_KEYEVENT INIT_DELAYED_WORK(&wac_i2c->touch_pressed_work, wacom_i2c_touch_pressed_work); wac_i2c->key_delay_time = 100; #endif #ifdef USE_WACOM_LCD_WORKAROUND wac_i2c->wait_done = true; wac_i2c->delay_time = 5; INIT_DELAYED_WORK(&wac_i2c->read_vsync_work, wacom_i2c_read_vsync_work); wac_i2c->boot_done = false; INIT_DELAYED_WORK(&wac_i2c->boot_done_work, wacom_i2c_boot_done_work); #endif #ifdef WACOM_PEN_DETECT INIT_DELAYED_WORK(&wac_i2c->pen_insert_dwork, pen_insert_work); #endif #ifdef WACOM_RESETPIN_DELAY INIT_DELAYED_WORK(&wac_i2c->work_wacom_reset, wacom_reset); #endif /*Before registering input device, data in each input_dev must be set */ ret = input_register_device(input); if (ret) { pr_err("[E-PEN] failed to register input device.\n"); goto err_input_allocate_device; } #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 wac_i2c->dev = device_create(sec_class, NULL, 0, NULL, "sec_epen"); if (IS_ERR(wac_i2c->dev)) { dev_err(&wac_i2c->client->dev, "%s: Failed to create device(wac_i2c->dev)!\n", __func__); goto err_sysfs_create_group; } dev_set_drvdata(wac_i2c->dev, wac_i2c); ret = sysfs_create_group(&wac_i2c->dev->kobj, &epen_attr_group); if (ret) { dev_err(&wac_i2c->client->dev, "%s: failed to create sysfs group\n", __func__); goto err_sysfs_create_group; } ret = wacom_firmware_update(wac_i2c); if (ret) { dev_err(&wac_i2c->client->dev, "%s: firmware update failed.\n", __func__); if (fw_ver > 0 && wac_i2c->ic_mpu_ver < 0) dev_err(&wac_i2c->client->dev, "%s: read query but not enter boot mode[%x,%x]\n", __func__, fw_ver, wac_i2c->ic_mpu_ver); else goto err_fw_update; } /*Request IRQ */ if (pdata->irq_flags) { ret = request_threaded_irq(wac_i2c->irq, NULL, wacom_interrupt, IRQF_DISABLED | pdata->irq_flags | IRQF_ONESHOT, wac_i2c->name, wac_i2c); if (ret < 0) { dev_err(&wac_i2c->client->dev, "%s: failed to request irq(%d) - %d\n", __func__, wac_i2c->irq, ret); goto err_fw_update; } #if defined(WACOM_PDCT_WORK_AROUND) ret = request_threaded_irq(wac_i2c->irq_pdct, NULL, wacom_interrupt_pdct, IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, wac_i2c->name, wac_i2c); if (ret < 0) { dev_err(&wac_i2c->client->dev, "%s: failed to request irq(%d) - %d\n", __func__, wac_i2c->irq_pdct, ret); goto err_request_irq_pdct; } #endif #ifdef WACOM_PEN_DETECT ret = request_threaded_irq( wac_i2c->irq_pen_insert, NULL, wacom_pen_detect, IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "pen_insert", wac_i2c); if (ret < 0) { dev_err(&wac_i2c->client->dev, "%s: failed to request irq(%d) - %d\n", __func__, wac_i2c->irq_pen_insert, ret); goto err_request_irq_pen_inster; } enable_irq_wake(wac_i2c->irq_pen_insert); /* update the current status */ schedule_delayed_work(&wac_i2c->pen_insert_dwork, HZ / 2); #endif } #ifdef USE_WACOM_LCD_WORKAROUND schedule_delayed_work(&wac_i2c->boot_done_work, msecs_to_jiffies(20 * 1000)); #endif #ifdef WACOM_RESETPIN_DELAY schedule_delayed_work(&wac_i2c->work_wacom_reset, msecs_to_jiffies(5000)); #endif return 0; err_request_irq_pen_inster: #ifdef WACOM_PDCT_WORK_AROUND free_irq(wac_i2c->irq_pdct, wac_i2c); err_request_irq_pdct: #endif free_irq(wac_i2c->irq, wac_i2c); err_fw_update: sysfs_remove_group(&wac_i2c->dev->kobj, &epen_attr_group); err_sysfs_create_group: wac_i2c->init_fail = true; input_unregister_device(input); err_input_allocate_device: cancel_delayed_work_sync(&wac_i2c->resume_work); cancel_delayed_work_sync(&wac_i2c->touch_pressed_work); #ifdef USE_WACOM_LCD_WORKAROUND cancel_delayed_work_sync(&wac_i2c->read_vsync_work); cancel_delayed_work_sync(&wac_i2c->boot_done_work); #endif cancel_delayed_work_sync(&wac_i2c->pen_insert_dwork); #ifdef WACOM_RESETPIN_DELAY cancel_delayed_work_sync(&wac_i2c->work_wacom_reset); #endif #ifdef WACOM_BOOSTER cancel_delayed_work_sync(&wac_i2c->work_dvfs_off); cancel_delayed_work_sync(&wac_i2c->work_dvfs_chg); mutex_destroy(&wac_i2c->dvfs_lock); #endif wac_i2c->wac_pdata->wacom_stop(wac_i2c); mutex_destroy(&wac_i2c->lock); err_wacom_i2c_bootloader_ver: #if defined(CONFIG_SEC_H_PROJECT) || defined(CONFIG_SEC_FRESCO_PROJECT) err_wacom_i2c_send_timeout: #endif input_free_device(input); err_freemem: kfree(wac_i2c); err_i2c_fail: return ret; }
static int __devinit fsa9485_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct fsa9485_usbsw *usbsw; int ret = 0; struct input_dev *input; struct device *switch_dev; struct fsa9485_platform_data *pdata; dev_info(&client->dev, "%s\n", __func__); if (client->dev.of_node) { pdata = devm_kzalloc(&client->dev, sizeof(struct fsa9485_platform_data), GFP_KERNEL); if (!pdata) { dev_err(&client->dev, "Failed to allocate memory\n"); return -ENOMEM; } pdata = &fsa9485_pdata; fsa9485_parse_dt(&client->dev, pdata); client->irq = gpio_to_irq(pdata->gpio_int); } else pdata = client->dev.platform_data; if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; input = input_allocate_device(); if (!input) { dev_err(&client->dev, "failed to allocate input device data\n"); return -ENOMEM; } usbsw = kzalloc(sizeof(struct fsa9485_usbsw), GFP_KERNEL); if (!usbsw) { dev_err(&client->dev, "failed to allocate driver data\n"); input_free_device(input); return -ENOMEM; } usbsw->input = input; input->name = client->name; input->phys = "deskdock-key/input0"; input->dev.parent = &client->dev; input->id.bustype = BUS_HOST; input->id.vendor = 0x0001; input->id.product = 0x0001; input->id.version = 0x0001; /* Enable auto repeat feature of Linux input subsystem */ __set_bit(EV_REP, input->evbit); input_set_capability(input, EV_KEY, KEY_VOLUMEUP); input_set_capability(input, EV_KEY, KEY_VOLUMEDOWN); input_set_capability(input, EV_KEY, KEY_PLAYPAUSE); input_set_capability(input, EV_KEY, KEY_PREVIOUSSONG); input_set_capability(input, EV_KEY, KEY_NEXTSONG); ret = input_register_device(input); if (ret) { dev_err(&client->dev, "input_register_device %s: err %d\n", __func__, ret); input_free_device(input); kfree(usbsw); return ret; } usbsw->client = client; usbsw->pdata = pdata; if (!usbsw->pdata) goto fail1; #if !defined(CONFIG_MUIC_FSA9485_SUPPORT_CAR_DOCK) usbsw->is_factory_start = false; #endif /* !CONFIG_MUIC_FSA9485_SUPPORT_CAR_DOCK */ i2c_set_clientdata(client, usbsw); mutex_init(&usbsw->mutex); local_usbsw = usbsw; if (usbsw->pdata->cfg_gpio) usbsw->pdata->cfg_gpio(); fsa9485_reg_init(usbsw); uart_connecting = 0; ret = sysfs_create_group(&client->dev.kobj, &fsa9485_group); if (ret) { dev_err(&client->dev, "failed to create fsa9485 attribute group\n"); goto fail2; } /* make sysfs node /sys/class/sec/switch/usb_state */ switch_dev = device_create(sec_class, NULL, 0, NULL, "switch"); if (IS_ERR(switch_dev)) { pr_err("[FSA9485] Failed to create device (switch_dev)!\n"); ret = PTR_ERR(switch_dev); goto fail2; } ret = device_create_file(switch_dev, &dev_attr_usb_state); if (ret < 0) { pr_err("[FSA9485] Failed to create file (usb_state)!\n"); goto err_create_file_state; } ret = device_create_file(switch_dev, &dev_attr_adc); if (ret < 0) { pr_err("[FSA9485] Failed to create file (adc)!\n"); goto err_create_file_adc; } ret = device_create_file(switch_dev, &dev_attr_reset_switch); if (ret < 0) { pr_err("[FSA9485] Failed to create file (reset_switch)!\n"); goto err_create_file_reset_switch; } #if !defined(CONFIG_MUIC_FSA9485_SUPPORT_CAR_DOCK) ret = device_create_file(switch_dev, &dev_attr_apo_factory); if (ret < 0) { pr_err("[FSA9485] Failed to create file (apo_factory)!\n"); goto err_create_file_apo_factory; } #endif dev_set_drvdata(switch_dev, usbsw); /* fsa9485 dock init*/ if (usbsw->pdata->dock_init) usbsw->pdata->dock_init(); /* fsa9485 reset */ if (usbsw->pdata->reset_cb) usbsw->pdata->reset_cb(); /* set fsa9485 init flag. */ if (usbsw->pdata->set_init_flag) usbsw->pdata->set_init_flag(); local_usbsw->dock_ready = 0; local_usbsw->mhl_ready = 0; /* initial cable detection */ INIT_DELAYED_WORK(&usbsw->init_work, fsa9485_init_detect); schedule_delayed_work(&usbsw->init_work, msecs_to_jiffies(2700)); INIT_DELAYED_WORK(&usbsw->audio_work, fsa9485_delayed_audio); schedule_delayed_work(&usbsw->audio_work, msecs_to_jiffies(20000)); #if defined(CONFIG_VIDEO_MHL_V1) || defined(CONFIG_VIDEO_MHL_V2) INIT_WORK(&usbsw->mhl_work, fsa9485_mhl_detect); #endif return 0; #if !defined(CONFIG_MUIC_FSA9485_SUPPORT_CAR_DOCK) err_create_file_apo_factory: device_remove_file(switch_dev, &dev_attr_apo_factory); #endif err_create_file_reset_switch: device_remove_file(switch_dev, &dev_attr_reset_switch); err_create_file_adc: device_remove_file(switch_dev, &dev_attr_adc); err_create_file_state: device_remove_file(switch_dev, &dev_attr_usb_state); fail2: if (client->irq) free_irq(client->irq, usbsw); fail1: input_unregister_device(input); mutex_destroy(&usbsw->mutex); i2c_set_clientdata(client, NULL); input_free_device(input); kfree(usbsw); return ret; }
static int __init ami304_probe(struct i2c_client *client, const struct i2c_device_id * devid) { int err = 0; struct ami304_i2c_data *data; struct ecom_platform_data* ecom_pdata; if (AMI304_DEBUG_FUNC_TRACE & ami304_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 ami304_i2c_data), GFP_KERNEL))) { err = -ENOMEM; goto exit; } memset(data, 0, sizeof(struct ami304_i2c_data)); i2c_set_clientdata(client, data); ami304_i2c_client = client; ecom_pdata = ami304_i2c_client->dev.platform_data; ecom_pdata->power(1); AMI304_Init(AMI304_FORCE_MODE); // default is Force State atomic_set(&o_status, 0); atomic_set(&m_status, 0); atomic_set(&a_status, 0); #if defined(CONFIG_HAS_EARLYSUSPEND) ami304_sensor_early_suspend.suspend = ami304_early_suspend; ami304_sensor_early_suspend.resume = ami304_late_resume; register_early_suspend(&ami304_sensor_early_suspend); atomic_set(&ami304_report_enabled, 1); #endif data->input_dev = input_allocate_device(); if (!data->input_dev) { err = -ENOMEM; AMIE("ami304_i2c_detect: Failed to allocate input device\n"); goto exit_input_dev_alloc_failed; } set_bit(EV_ABS, data->input_dev->evbit); /* yaw */ input_set_abs_params(data->input_dev, ABS_RX, 0, 360, 0, 0); /* pitch */ input_set_abs_params(data->input_dev, ABS_RY, -180, 180, 0, 0); /* roll */ input_set_abs_params(data->input_dev, ABS_RZ, -90, 90, 0, 0); /* status of magnetic sensor */ input_set_abs_params(data->input_dev, ABS_RUDDER, 0, 5, 0, 0); /* x-axis acceleration */ input_set_abs_params(data->input_dev, ABS_X, -2000, 2000, 0, 0); /* y-axis acceleration */ input_set_abs_params(data->input_dev, ABS_Y, -2000, 2000, 0, 0); /* z-axis acceleration */ input_set_abs_params(data->input_dev, ABS_Z, -2000, 2000, 0, 0); /* x-axis of raw magnetic vector */ input_set_abs_params(data->input_dev, ABS_HAT0X, -3000, 3000, 0, 0); /* y-axis of raw magnetic vector */ input_set_abs_params(data->input_dev, ABS_HAT0Y, -3000, 3000, 0, 0); /* z-axis of raw magnetic vector */ input_set_abs_params(data->input_dev, ABS_BRAKE, -3000, 3000, 0, 0); /* status of acceleration sensor */ input_set_abs_params(data->input_dev, ABS_WHEEL, 0, 5, 0, 0); data->input_dev->name = "Acompass"; err = input_register_device(data->input_dev); if (err) { AMIE("ami304_i2c_detect: Unable to register input device: %s\n", data->input_dev->name); goto exit_input_register_device_failed; } if (AMI304_DEBUG_FUNC_TRACE & ami304_debug_mask) AMID("register input device successfully!!!\n"); err = misc_register(&ami304_device); if (err) { AMIE("ami304_device register failed\n"); goto exit_misc_device_register_failed; } err = device_create_file(&client->dev, &dev_attr_chipinfo); err = device_create_file(&client->dev, &dev_attr_sensordata); err = device_create_file(&client->dev, &dev_attr_posturedata); err = device_create_file(&client->dev, &dev_attr_calidata); err = device_create_file(&client->dev, &dev_attr_midcontrol); err = device_create_file(&client->dev, &dev_attr_mode); /* Test mode attribute */ err = device_create_file(&client->dev, &dev_attr_pitch); err = device_create_file(&client->dev, &dev_attr_roll); err = misc_register(&ami304daemon_device); if (err) { AMIE("ami304daemon_device register failed\n"); goto exit_misc_device_register_failed; } err = misc_register(&ami304hal_device); if (err) { AMIE("ami304hal_device register failed\n"); goto exit_misc_device_register_failed; } return 0; exit_misc_device_register_failed: exit_input_register_device_failed: input_free_device(data->input_dev); exit_input_dev_alloc_failed: kfree(data); exit: return err; }
/** * ctp_detect - Device detection callback for automatic device creation * return value: * = 0; success; * < 0; err */ static int ctp_detect(struct i2c_client *client, struct i2c_board_info *info) { struct i2c_adapter *adapter = client->adapter; int ret; u8 buf[8] = {GTP_REG_VERSION >> 8, GTP_REG_VERSION & 0xff}; if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)){ pr_err("i2c_check_functionality err\n======return=====\n"); return -ENODEV; } if(twi_id == adapter->nr){ pr_debug("%s: addr= %x\n",__func__,client->addr); msleep(50); ret = gtp_i2c_read(client, buf, 6); gtp_i2c_end_cmd(client); if(buf[3] != 0x18) { pr_debug("%s:IC is not gt818\n",__func__); return -ENODEV; } GTP_INFO("IC VERSION:%02x%02x_%02x%02x", buf[3], buf[2], buf[5], buf[4]); strlcpy(info->type, CTP_NAME, I2C_NAME_SIZE); //printk("%s:I2C connection might be something wrong ! \n",__func__); return 0; }else{ return -ENODEV; } } /** * ctp_print_info - sysconfig print function * return value: * */ static void ctp_print_info(struct ctp_config_info info,int debug_level) { if(debug_level == DEBUG_INIT) { dprintk(DEBUG_INIT,"info.ctp_used:%d\n",info.ctp_used); dprintk(DEBUG_INIT,"info.twi_id:%d\n",info.twi_id); dprintk(DEBUG_INIT,"info.screen_max_x:%d\n",info.screen_max_x); dprintk(DEBUG_INIT,"info.screen_max_y:%d\n",info.screen_max_y); dprintk(DEBUG_INIT,"info.revert_x_flag:%d\n",info.revert_x_flag); dprintk(DEBUG_INIT,"info.revert_y_flag:%d\n",info.revert_y_flag); dprintk(DEBUG_INIT,"info.exchange_x_y_flag:%d\n",info.exchange_x_y_flag); dprintk(DEBUG_INIT,"info.irq_gpio_number:%d\n",info.irq_gpio.gpio); dprintk(DEBUG_INIT,"info.wakeup_gpio_number:%d\n",info.wakeup_gpio.gpio); } } /** * ctp_wakeup - function * */ static int ctp_wakeup(int status,int ms) { dprintk(DEBUG_INIT,"***CTP*** %s:status:%d,ms = %d\n",__func__,status,ms); if (status == 0) { if(ms == 0) { __gpio_set_value(config_info.wakeup_gpio.gpio, 0); }else { __gpio_set_value(config_info.wakeup_gpio.gpio, 0); msleep(ms); __gpio_set_value(config_info.wakeup_gpio.gpio, 1); } } if (status == 1) { if(ms == 0) { __gpio_set_value(config_info.wakeup_gpio.gpio, 1); }else { __gpio_set_value(config_info.wakeup_gpio.gpio, 1); msleep(ms); __gpio_set_value(config_info.wakeup_gpio.gpio, 0); } } msleep(5); return 0; }
static __devinit int adv7180_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct adv7180_state *state; struct v4l2_subdev *sd; int ret; /* Check if the adapter supports the needed features */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; v4l_info(client, "chip found @ 0x%02x (%s)\n", client->addr << 1, client->adapter->name); state = kzalloc(sizeof(struct adv7180_state), GFP_KERNEL); if (state == NULL) { ret = -ENOMEM; goto err; } state->irq = client->irq; INIT_WORK(&state->work, adv7180_work); mutex_init(&state->mutex); state->autodetect = true; sd = &state->sd; v4l2_i2c_subdev_init(sd, client, &adv7180_ops); /* Initialize adv7180 */ /* Enable autodetection */ ret = i2c_smbus_write_byte_data(client, ADV7180_INPUT_CONTROL_REG, ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM); if (ret < 0) goto err_unreg_subdev; ret = i2c_smbus_write_byte_data(client, ADV7180_AUTODETECT_ENABLE_REG, ADV7180_AUTODETECT_DEFAULT); if (ret < 0) goto err_unreg_subdev; /* ITU-R BT.656-4 compatible */ ret = i2c_smbus_write_byte_data(client, ADV7180_EXTENDED_OUTPUT_CONTROL_REG, ADV7180_EXTENDED_OUTPUT_CONTROL_NTSCDIS); if (ret < 0) goto err_unreg_subdev; /* read current norm */ __adv7180_status(client, NULL, &state->curr_norm); /* register for interrupts */ if (state->irq > 0) { ret = request_irq(state->irq, adv7180_irq, 0, DRIVER_NAME, state); if (ret) goto err_unreg_subdev; ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG, ADV7180_ADI_CTRL_IRQ_SPACE); if (ret < 0) goto err_unreg_subdev; /* config the Interrupt pin to be active low */ ret = i2c_smbus_write_byte_data(client, ADV7180_ICONF1_ADI, ADV7180_ICONF1_ACTIVE_LOW | ADV7180_ICONF1_PSYNC_ONLY); if (ret < 0) goto err_unreg_subdev; ret = i2c_smbus_write_byte_data(client, ADV7180_IMR1_ADI, 0); if (ret < 0) goto err_unreg_subdev; ret = i2c_smbus_write_byte_data(client, ADV7180_IMR2_ADI, 0); if (ret < 0) goto err_unreg_subdev; /* enable AD change interrupts interrupts */ ret = i2c_smbus_write_byte_data(client, ADV7180_IMR3_ADI, ADV7180_IRQ3_AD_CHANGE); if (ret < 0) goto err_unreg_subdev; ret = i2c_smbus_write_byte_data(client, ADV7180_IMR4_ADI, 0); if (ret < 0) goto err_unreg_subdev; ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG, 0); if (ret < 0) goto err_unreg_subdev; } return 0; err_unreg_subdev: mutex_destroy(&state->mutex); v4l2_device_unregister_subdev(sd); kfree(state); err: printk(KERN_ERR DRIVER_NAME ": Failed to probe: %d\n", ret); return ret; }
static int rt9450_probe(struct i2c_client *client, const struct i2c_device_id *id) { int err; struct rt9450_data* drv_data; INFO("RT9450 irq # = %d\n",client->irq); if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { ERR("No Support for I2C_FUNC_SMBUS_BYTE_DATA\n"); err = -ENODEV; goto i2c_check_functionality_fail; } drv_data = kzalloc(sizeof(struct rt9450_data),GFP_KERNEL); drv_data->client = client; pDrvData = drv_data; i2c_set_clientdata(client,drv_data); if (client->dev.platform_data) memcpy(&platform_data,client->dev.platform_data,sizeof(struct rtsmc_platform_data)); else memset(&platform_data,0,sizeof(struct rtsmc_platform_data)); INIT_DELAYED_WORK_DEFERRABLE(&drv_data->rt9450_charger_work,rt9450_charger_work); #if CONFIG_RTSMC_IRQ_NUMBER<0 client->irq = gpio_to_irq(CONFIG_RTSMC_INT_GPIO_NUMBER); #endif #ifdef CONFIG_RTSMC_INT_CONFIG INFO("gpio pin # = %d\n",(int)CONFIG_RTSMC_INT_GPIO_NUMBER); err = gpio_request(CONFIG_RTSMC_INT_GPIO_NUMBER,"RT9450_EINT"); // Request for gpio pin if (err<0) WARNING("Request GPIO %d failed\n",(int)CONFIG_RTSMC_INT_GPIO_NUMBER); err = gpio_direction_input(CONFIG_RTSMC_INT_GPIO_NUMBER); if (err<0) WARNING("Set GPIO Direction to input : failed\n"); #endif // CONFIG_RTMUSC_INT_CONFIG if (!init_reg_setting()) { err = -EINVAL; goto init_fail; } #ifdef CONFIG_RT_SYSFS_DBG err = sysfs_create_group(&client->dev.kobj, &rt9450_dbg_attrs_group); if (err<0) { WARNING("Can't create engineer debug node), error code = %d\r\n",err); } #endif //CONFIG_RT_SYSFS_DBG err = request_irq(client->irq, rt9450smc_irq_handler, IRQF_TRIGGER_FALLING, DEVICE_NAME, drv_data); if (err<0) { WARNING("Can't use INT (use polling only), error code = %d\r\n",err); } return 0; init_fail: cancel_delayed_work(&drv_data->rt9450_charger_work); kfree(pDrvData); pDrvData = NULL; i2c_check_functionality_fail: return err; }
static int lm3554_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct lm3554_platform_data *pdata = client->dev.platform_data; struct lm3554_data *torch_data; int err = -1; if (pdata == NULL) { err = -ENODEV; dev_err(&client->dev, "platform data is NULL. exiting.\n"); goto error1; } if (!pdata->flags) { pr_err("%s: Device does not exist\n", __func__); return -ENODEV; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { err = -ENODEV; dev_err(&client->dev, "client not i2c capable\n"); goto error1; } torch_data = kzalloc(sizeof(struct lm3554_data), GFP_KERNEL); if (torch_data == NULL) { err = -ENOMEM; dev_err(&client->dev, "kzalloc failed\n"); goto error1; } torch_data->client = client; torch_data->pdata = pdata; i2c_set_clientdata(client, torch_data); err = lm3554_init_registers(torch_data); if (err < 0) goto error2; torch_data->led_dev.name = LM3554_LED_DEV; torch_data->led_dev.brightness_set = lm3554_brightness_set; err = led_classdev_register((struct device *) &client->dev, &torch_data->led_dev); if (err < 0) { err = -ENODEV; pr_err("%s: Register led class failed: %d\n", __func__, err); goto error3; } err = device_create_file(torch_data->led_dev.dev, &dev_attr_flash_light); if (err < 0) { err = -ENODEV; pr_err("%s:File device creation failed: %d\n", __func__, err); goto error4; } err = device_create_file(torch_data->led_dev.dev, &dev_attr_camera_strobe); if (err < 0) { err = -ENODEV; pr_err("%s:File device creation failed: %d\n", __func__, err); goto error5; } err = device_create_file(torch_data->led_dev.dev, &dev_attr_strobe_err); if (err < 0) { err = -ENODEV; pr_err("%s:File device creation failed: %d\n", __func__, err); goto error6; } torch_data->spotlight_dev.name = LM3554_LED_SPOTLIGHT; torch_data->spotlight_dev.brightness_set = lm3554_spot_light_brightness_set; err = led_classdev_register((struct device *) &client->dev, &torch_data->spotlight_dev); if (err < 0) { err = -ENODEV; pr_err("%s: Register led class failed: %d\n", __func__, err); goto error6; } pr_info("LM3554 torch initialized\n"); return 0; error6: device_remove_file(torch_data->led_dev.dev, &dev_attr_camera_strobe); error5: device_remove_file(torch_data->led_dev.dev, &dev_attr_flash_light); error4: led_classdev_unregister(&torch_data->led_dev); error3: error2: kfree(torch_data); error1: return err; }
/* This function is called by i2c_probe */ static int bcm3450_detect(struct i2c_adapter *adapter, int address, int kind) { struct i2c_client *client; int err = 0; #ifdef PROCFS_HOOKS struct proc_dir_entry *p; #endif BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Entering the function %s \n", __FUNCTION__); if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) goto exit; if (!(pclient_data = kzalloc(sizeof(struct bcm3450_data), GFP_KERNEL))) { err = -ENOMEM; goto exit; } /* Setup the i2c client data */ client = &pclient_data->client; i2c_set_clientdata(client, pclient_data); client->addr = address; client->adapter = adapter; client->driver = &bcm3450_driver; client->flags = 0; strlcpy(client->name, "bcm3450", I2C_NAME_SIZE); /* Tell the I2C layer a new client has arrived */ if ((err = i2c_attach_client(client))) goto exit_kfree; #ifdef SYSFS_HOOKS /* Register sysfs hooks */ err = sysfs_create_group(&client->dev.kobj, &bcm3450_attr_group); if (err) goto exit_detach; #endif #ifdef PROCFS_HOOKS p = create_proc_entry(PROC_ENTRY_NAME1, 0, 0); if (!p) { BCM_LOG_ERROR(BCM_LOG_ID_I2C, "bcmlog: unable to create /proc/%s!\n", PROC_ENTRY_NAME1); err = -EIO; #ifdef SYSFS_HOOKS sysfs_remove_group(&client->dev.kobj, &bcm3450_attr_group); #endif goto exit_detach; } p->read_proc = b3450_proc_read; p->write_proc = b3450_proc_write; p->data = (void *)pclient_data; #ifdef MOCA_I2C_TEST p = create_proc_entry(PROC_ENTRY_NAME2, 0, 0); if (p) { p->proc_fops = &b3450Test_fops; } #endif #endif return 0; #if defined(SYSFS_HOOKS) || defined(PROCFS_HOOKS) exit_detach: i2c_detach_client(client); #endif exit_kfree: kfree(pclient_data); exit: return err; }
static int gs_probe( struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct gs_data *gs; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { printk(KERN_ERR "gs_probe: need I2C_FUNC_I2C\n"); ret = -ENODEV; goto err_check_functionality_failed; } #ifndef GS_POLLING ret = gs_config_int1_pin(); if(ret <0) { goto err_check_functionality_failed; } ret = gs_config_int2_pin(); if(ret <0) { goto err_check_functionality_failed; } #endif gs = kzalloc(sizeof(*gs), GFP_KERNEL); if (gs == NULL) { ret = -ENOMEM; goto err_alloc_data_failed; } mutex_init(&gs->mlock); INIT_WORK(&gs->work, gs_work_func); gs->client = client; i2c_set_clientdata(client, gs); ret =reg_read(gs,GS_ADI_REG_DEVID); if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_POWER_CTL,0x14); /* auto low power ,deep sleep */ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_BW,0x0a); /* Rate: 100Hz, IDD: 130uA */ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_DATA_FORMAT,0x01); /* Data Format: 8g right justified 128=1g 8g*/ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_INT_ENABLE,0x80); /* enable int Int En: Data Rdy*/ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_TAP_AXES,0x01); /* Z Axis Tap */ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_THRESH_TAP,0x20); /* Tap Threshold: 2G */ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_DUR,0x50); /* Dur:50ms */ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_LATENT,0x20); /* Latent: 40ms */ if ( ret <0 ) goto err_detect_failed; ret = reg_write(gs,GS_ADI_REG_WINDOW,0xF0); /* Window: 300ms */ if ( ret <0 ) goto err_detect_failed; if (sensor_dev == NULL) { gs->input_dev = input_allocate_device(); if (gs->input_dev == NULL) { ret = -ENOMEM; printk(KERN_ERR "gs_probe: Failed to allocate input device\n"); goto err_input_dev_alloc_failed; } gs->input_dev->name = "sensors"; sensor_dev = gs->input_dev; }else{ gs->input_dev = sensor_dev; } gs->input_dev->id.vendor = GS_ADIX345;//for akm8973 compass detect. set_bit(EV_ABS,gs->input_dev->evbit); set_bit(ABS_X, gs->input_dev->absbit); set_bit(ABS_Y, gs->input_dev->absbit); set_bit(ABS_Z, gs->input_dev->absbit); set_bit(EV_SYN,gs->input_dev->evbit); gs->input_dev->id.bustype = BUS_I2C; //gs->input_dev->open = gs_adi_input_open; //gs->input_dev->close = gs_adi_input_close; input_set_drvdata(gs->input_dev, gs); ret = input_register_device(gs->input_dev); if (ret) { printk(KERN_ERR "gs_probe: Unable to register %s input device\n", gs->input_dev->name); goto err_input_register_device_failed; } ret = misc_register(&gsensor_device); if (ret) { printk(KERN_ERR "gs_probe: gsensor_device register failed\n"); goto err_misc_device_register_failed; } #ifndef GS_POLLING if (client->irq) { ret = request_irq(client->irq, gs_irq_handler, 0, client->name, gs); if (ret == 0) gs->use_irq = 1; else dev_err(&client->dev, "request_irq failed\n"); } #endif if (!gs->use_irq) { hrtimer_init(&gs->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); gs->timer.function = gs_timer_func; } #ifdef CONFIG_HAS_EARLYSUSPEND gs->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; gs->early_suspend.suspend = gs_early_suspend; gs->early_suspend.resume = gs_late_resume; register_early_suspend(&gs->early_suspend); #endif gs_wq = create_singlethread_workqueue("gs_wq"); if (!gs_wq) return -ENOMEM; #if 0 else GS_SENSOR_ADI_FLAG =1; #endif this_gs_data =gs; printk(KERN_INFO "gs_probe: Start gs_adixl345 in %s mode\n", gs->use_irq ? "interrupt" : "polling"); return 0; err_misc_device_register_failed: misc_deregister(&gsensor_device); err_input_register_device_failed: input_free_device(gs->input_dev); err_input_dev_alloc_failed: err_detect_failed: kfree(gs); #ifndef GS_POLLING gs_free_int1(); gs_free_int2(); #endif err_alloc_data_failed: err_check_functionality_failed: return ret; }
static int __devinit lm2755_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; int error; struct lm2755_data *data; struct lm2755_platform_data *pdata = NULL; uint32_t min_tstep; #ifdef CONFIG_OF if (client->dev.of_node) { pdata = devm_kzalloc(&client->dev, sizeof(struct lm2755_platform_data), GFP_KERNEL); if (!pdata) { dev_err(&client->dev, "Failed to allocate memory\n"); return -ENOMEM; } else { data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); if (!data) { pr_err("unable to kzalloc lm2755_data\n"); return -ENOMEM; } } error = lm2755_parse_dt(&client->dev, pdata); if (error) return error; } #else /* We need platform data */ if (!client->dev.platform_data) { pr_err("no platform data\n"); return -EINVAL; } pdata = client->dev.platform_data; #endif /* Check I2C functionality */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { pr_err("I2C_FUNC_SMBUS_BYTE_DATA not supported\n"); return -ENOTSUPP; } if (pdata->clock_mode == LM2755_CLOCK_EXT) { if (pdata->min_tstep == 0) { pr_err("invalid min_tstep 0 for external clock\n"); return -EINVAL; } else { min_tstep = pdata->min_tstep; } } else { min_tstep = LM2755_MIN_TSTEP_INT * 1000; } /* Allocate our internal data structure */ data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); if (!data) { pr_err("unable to kzalloc lm2755_data\n"); return -ENOMEM; } i2c_set_clientdata(client, data); data->client = client; data->config = pdata->clock_mode | pdata->charge_pump_mode; /* Save min tstep for external clock */ if (pdata->clock_mode == LM2755_CLOCK_EXT) data->min_tstep = min_tstep; lm2755_set_tsteps(data, min_tstep); pr_info("max_time = %d\n", data->max_time); data->max_level = pdata->max_level; if (data->max_level == 0 || data->max_level > LM2755_MAX_LEVEL) data->max_level = LM2755_MAX_LEVEL; /* Populate groups */ data->rgb_group[LM2755_D1] = LM2755_D1_BASE; data->rgb_group[LM2755_D2] = LM2755_D2_BASE; data->rgb_group[LM2755_D3] = LM2755_D3_BASE; data->rgb_mask[LM2755_D1] = LM2755_D1_MASK; data->rgb_mask[LM2755_D2] = LM2755_D2_MASK; data->rgb_mask[LM2755_D3] = LM2755_D3_MASK; mutex_init(&data->lock); data->enable = pdata->enable; if (data->enable) data->enable(1); ret = lm2755_write(data->client, LM2755_REG_GENERAL, data->config); if (ret < 0) { pr_err("unable to write to the chip\n"); goto fail1; } /* HIGH part of the brightness has power on value 1110b */ /* LOW part of the brightness has power on value 0000b */ lm2755_write(data->client, LM2755_REG_D1_HIGH, 0); lm2755_write(data->client, LM2755_REG_D2_HIGH, 0); lm2755_write(data->client, LM2755_REG_D3_HIGH, 0); /* Register named LEDs */ ret = lm2755_register_leds(data, pdata->led_names); if (ret < 0) { pr_err("unable to register leds\n"); goto fail1; } /* Register RGB LED class if requested */ if (pdata->rgb_name) { data->led_cdev.brightness_set = lm2755_rgb_brightness_set; data->led_cdev.brightness_get = lm2755_rgb_brightness_get; data->led_cdev.name = pdata->rgb_name; ret = led_classdev_register(&client->dev, &data->led_cdev); if (ret < 0) { pr_err("couldn't register \'%s\' LED class\n", pdata->rgb_name); goto fail2; } pr_info("registered \'%s\' LED class\n", pdata->rgb_name); INIT_WORK(&data->rgb_work, lm2755_rgb_work); ret = sysfs_create_group(&data->led_cdev.dev->kobj, &lm2755_attribute_group); if (ret < 0) { pr_err("couldn't register attribute sysfs group\n"); goto fail3; } } pr_info("finished successfully\n"); return 0; fail3: led_classdev_unregister(&data->led_cdev); fail2: lm2755_unregister_leds(data); fail1: if (data->enable) data->enable(0); return ret; }
static int bma255_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = -ENODEV; struct bma255_p *data = NULL; pr_info("##########################################################\n"); pr_info("[SENSOR]: %s - Probe Start!\n", __func__); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("[SENSOR]: %s - i2c_check_functionality error\n", __func__); goto exit; } data = kzalloc(sizeof(struct bma255_p), GFP_KERNEL); if (data == NULL) { pr_err("[SENSOR]: %s - kzalloc error\n", __func__); ret = -ENOMEM; goto exit_kzalloc; } ret = bma255_parse_dt(data, &client->dev); if (ret < 0) { pr_err("[SENSOR]: %s - of_node error\n", __func__); ret = -ENODEV; goto exit_of_node; } /* read chip id */ ret = i2c_smbus_read_word_data(client, BMA255_CHIP_ID_REG); #if defined(CONFIG_MACH_CS03_SGLTE) if ((ret & 0x00ff) != 0x95) { #else if ((ret & 0x00ff) != BMA255_CHIP_ID) { #endif pr_err("[SENSOR]: %s - chip id failed %d\n", __func__, ret); ret = -ENODEV; goto exit_read_chipid; } i2c_set_clientdata(client, data); data->client = client; bma255_power_on(data, 1); ret = bma255_setup_pin(data); if (ret < 0) { pr_err("[SENSOR]: %s - could not setup pin\n", __func__); goto exit_setup_pin; } /* input device init */ ret = bma255_input_init(data); if (ret < 0) goto exit_input_init; sensors_register(data->factory_device, data, sensor_attrs, MODULE_NAME); /* workqueue init */ INIT_DELAYED_WORK(&data->work, bma255_work_func); atomic_set(&data->delay, BMA255_DEFAULT_DELAY); atomic_set(&data->enable, OFF); data->time_count = 0; data->irq_state = 0; data->recog_flag = OFF; bma255_set_bandwidth(data->client, BMA255_BW_125HZ); bma255_set_range(data->client, BMA255_RANGE_2G); bma255_set_mode(data->client, BMA255_MODE_SUSPEND); pr_info("[SENSOR]: %s - Probe done!(chip pos : %d)\n", __func__, data->chip_pos); return 0; exit_input_init: free_irq(data->irq1, data); wake_lock_destroy(&data->reactive_wake_lock); gpio_free(data->acc_int2); gpio_free(data->acc_int1); exit_read_chipid: exit_setup_pin: exit_of_node: kfree(data); exit_kzalloc: exit: pr_err("[SENSOR]: %s - Probe fail!\n", __func__); return ret; } static int __devexit bma255_remove(struct i2c_client *client) { struct bma255_p *data = (struct bma255_p *)i2c_get_clientdata(client); if (atomic_read(&data->enable) == ON) bma255_set_enable(data, OFF); cancel_delayed_work_sync(&data->work); sensors_unregister(data->factory_device); //sensors_delete_symlink(data->input->dev); sysfs_remove_group(&data->input->dev.kobj, &bma255_attribute_group); input_unregister_device(data->input); free_irq(data->irq1, data); wake_lock_destroy(&data->reactive_wake_lock); gpio_free(data->acc_int2); gpio_free(data->acc_int1); kfree(data); return 0; } static int bma255_suspend(struct device *dev) { struct bma255_p *data = dev_get_drvdata(dev); //struct bma255_p *data = bma_acc_get_data(); if (atomic_read(&data->enable) == ON) { if (data->recog_flag == ON) bma255_set_mode(data->client, BMA255_MODE_LOWPOWER1); else bma255_set_mode(data->client, BMA255_MODE_SUSPEND); cancel_delayed_work_sync(&data->work); } bma255_power_on(data, 0); return 0; } static int bma255_resume(struct device *dev) { struct bma255_p *data = dev_get_drvdata(dev); //struct bma255_p *data = bma_acc_get_data(); bma255_power_on(data, 1); if (atomic_read(&data->enable) == ON) { bma255_set_mode(data->client, BMA255_MODE_NORMAL); schedule_delayed_work(&data->work, msecs_to_jiffies(atomic_read(&data->delay))); } return 0; } static struct of_device_id bma255_match_table[] = { { .compatible = "bma255-i2c",}, {}, };
static int __devinit bma250_accl_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct drv_data *dd; int rc = 0; unsigned char tempvalue; struct bma250_accl_platform_data *pdata = pdata = client->dev.platform_data; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("i2c_check_functionality error\n"); goto probe_exit; } dd = kzalloc(sizeof(struct drv_data), GFP_KERNEL); if (!dd) { rc = -ENOMEM; goto probe_exit; } bma250_accl_client = client; mutex_lock(&bma250_accl_dd_lock); list_add_tail(&dd->next_dd, &dd_list); mutex_unlock(&bma250_accl_dd_lock); INIT_DELAYED_WORK(&dd->work_data, bma250_accl_work_f); dd->i2c = client; if (pdata && pdata->init) { rc = pdata->init(&client->dev); if (rc) goto probe_err_cfg; } /* check chip id */ tempvalue = i2c_smbus_read_byte_data(client, BMA250_CHIP_ID_REG); if (tempvalue == BMA250_CHIP_ID) { printk(KERN_INFO "Bosch Sensortec Device detected!\n" "BMA250 registered I2C driver!\n"); } else { printk(KERN_INFO "Bosch Sensortec Device not found" "i2c error %d \n", tempvalue); goto probe_err_cfg; } dd->ip_dev = input_allocate_device(); if (!dd->ip_dev) { rc = -ENOMEM; goto probe_err_reg; } input_set_drvdata(dd->ip_dev, dd); dd->irq = client->irq; dd->ip_dev->open = bma250_accl_open; dd->ip_dev->close = bma250_accl_release; dd->ip_dev->name = ACCL_NAME; dd->ip_dev->phys = ACCL_NAME; dd->ip_dev->id.vendor = ACCL_VENDORID; dd->ip_dev->id.product = 1; dd->ip_dev->id.version = 1; set_bit(EV_REL, dd->ip_dev->evbit); set_bit(REL_X, dd->ip_dev->relbit); set_bit(REL_Y, dd->ip_dev->relbit); set_bit(REL_Z, dd->ip_dev->relbit); rc = input_register_device(dd->ip_dev); if (rc) { dev_err(&dd->ip_dev->dev, "bma250_accl_probe: input_register_device rc=%d\n", rc); goto probe_err_reg_dev; } rc = misc_register(&bma250_accl_misc_device); if (rc < 0) { dev_err(&client->dev, "bma250 misc_device register failed\n"); goto probe_err_reg_misc; } /* bma250 sensor initial */ if (rc < 0) { dev_err(&dd->ip_dev->dev, "bma250_accl_probe: \ Error configuring device rc=%d\n", rc); goto probe_err_smbcfg; }
static int lm3639_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct lm3639_chip_data *pchip; struct lm3639_platform_data *pdata = client->dev.platform_data; struct backlight_properties props; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "i2c functionality check fail.\n"); return -EOPNOTSUPP; } if (pdata == NULL) { dev_err(&client->dev, "Needs Platform Data.\n"); return -ENODATA; } pchip = devm_kzalloc(&client->dev, sizeof(struct lm3639_chip_data), GFP_KERNEL); if (!pchip) return -ENOMEM; pchip->pdata = pdata; pchip->dev = &client->dev; pchip->regmap = devm_regmap_init_i2c(client, &lm3639_regmap); if (IS_ERR(pchip->regmap)) { ret = PTR_ERR(pchip->regmap); dev_err(&client->dev, "fail : allocate register map: %d\n", ret); return ret; } i2c_set_clientdata(client, pchip); /* chip initialize */ ret = lm3639_chip_init(pchip); if (ret < 0) { dev_err(&client->dev, "fail : chip init\n"); goto err_out; } /* backlight */ props.type = BACKLIGHT_RAW; props.brightness = pdata->init_brt_led; props.max_brightness = pdata->max_brt_led; pchip->bled = backlight_device_register("lm3639_bled", pchip->dev, pchip, &lm3639_bled_ops, &props); if (IS_ERR(pchip->bled)) { dev_err(&client->dev, "fail : backlight register\n"); ret = -EIO; goto err_out; } ret = device_create_file(&(pchip->bled->dev), &dev_attr_bled_mode); if (ret < 0) { dev_err(&client->dev, "failed : add sysfs entries\n"); ret = -EIO; goto err_bled_mode; } /* flash */ pchip->cdev_flash.name = "lm3639_flash"; pchip->cdev_flash.max_brightness = 16; pchip->cdev_flash.brightness_set = lm3639_flash_brightness_set; ret = led_classdev_register((struct device *) &client->dev, &pchip->cdev_flash); if (ret < 0) { dev_err(&client->dev, "fail : flash register\n"); ret = -EIO; goto err_flash; } /* torch */ pchip->cdev_torch.name = "lm3639_torch"; pchip->cdev_torch.max_brightness = 8; pchip->cdev_torch.brightness_set = lm3639_torch_brightness_set; ret = led_classdev_register((struct device *) &client->dev, &pchip->cdev_torch); if (ret < 0) { dev_err(&client->dev, "fail : torch register\n"); ret = -EIO; goto err_torch; } return 0; err_torch: led_classdev_unregister(&pchip->cdev_flash); err_flash: device_remove_file(&(pchip->bled->dev), &dev_attr_bled_mode); err_bled_mode: backlight_device_unregister(pchip->bled); err_out: 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; 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; } INIT_DELAYED_WORK(&isl_chg->charge_work, isl9519q_charge); 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; /* h/w ignores lower 7 bits of charging current and input current */ isl_chg->chgcurrent &= ~0x7F; isl_chg->input_current &= ~0x7F; isl_chg->adapter_hw_chg.type = CHG_TYPE_AC; isl_chg->adapter_hw_chg.rating = 2; isl_chg->adapter_hw_chg.name = "isl-adapter"; isl_chg->adapter_hw_chg.start_charging = isl9519q_start_charging; isl_chg->adapter_hw_chg.stop_charging = isl9519q_stop_charging; isl_chg->adapter_hw_chg.charging_switched = isl9519q_charging_switched; 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; } } ret = gpio_request(pdata->valid_n_gpio, "isl_charger_valid"); if (ret) { dev_err(&client->dev, "%s gpio_request failed for %d ret=%d\n", __func__, pdata->valid_n_gpio, ret); goto free_isl_chg; } i2c_set_clientdata(client, isl_chg); ret = msm_charger_register(&isl_chg->adapter_hw_chg); if (ret) { dev_err(&client->dev, "%s msm_charger_register failed for ret =%d\n", __func__, ret); goto free_gpio; } ret = request_threaded_irq(client->irq, NULL, isl_valid_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "isl_charger_valid", client); if (ret) { dev_err(&client->dev, "%s request_threaded_irq failed for %d ret =%d\n", __func__, client->irq, ret); goto unregister; } set_irq_wake(client->irq, 1); 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_write_reg(isl_chg->client, MAX_SYS_VOLTAGE_REG, isl_chg->max_system_voltage); if (ret) { dev_err(&client->dev, "%s couldnt write to MAX_SYS_VOLTAGE_REG ret=%d\n", __func__, ret); goto free_irq; } ret = isl9519q_write_reg(isl_chg->client, MIN_SYS_VOLTAGE_REG, isl_chg->min_system_voltage); if (ret) { dev_err(&client->dev, "%s couldnt write to MIN_SYS_VOLTAGE_REG ret=%d\n", __func__, ret); goto free_irq; } if (isl_chg->input_current) { ret = isl9519q_write_reg(isl_chg->client, INPUT_CURRENT_REG, isl_chg->input_current); if (ret) { dev_err(&client->dev, "%s couldnt write INPUT_CURRENT_REG ret=%d\n", __func__, ret); goto free_irq; } } ret = gpio_get_value_cansleep(isl_chg->valid_n_gpio); if (ret < 0) { dev_err(&client->dev, "%s gpio_get_value failed for %d ret=%d\n", __func__, pdata->valid_n_gpio, ret); /* assume absent */ ret = 1; } if (!ret) { msm_charger_notify_event(&isl_chg->adapter_hw_chg, CHG_INSERTED_EVENT); isl_chg->present = 1; } pr_debug("%s OK chg_present=%d\n", __func__, isl_chg->present); return 0; free_irq: free_irq(client->irq, NULL); unregister: msm_charger_register(&isl_chg->adapter_hw_chg); free_gpio: gpio_free(pdata->valid_n_gpio); free_isl_chg: kfree(isl_chg); out: return ret; }
static int __devinit max17040_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct input_dev *input_data = NULL; int ret; #ifdef USE_MAX17040_QUICKSTART int aflag=0; #endif printk("[MAX17040] max17040_probe [IN]\n"); if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE)) return -EIO; max17040_data.client = client; i2c_set_clientdata(client, &max17040_data); //sys file system are registered max17040_data.battery.name = "batterys"; max17040_data.battery.type = POWER_SUPPLY_TYPE_BATTERY; max17040_data.battery.get_property = max17040_get_property; max17040_data.battery.properties = max17040_battery_props; max17040_data.battery.external_power_changed = max17040_bat_external_power_changed; max17040_data.battery.num_properties = ARRAY_SIZE(max17040_battery_props); ret = power_supply_register(&client->dev, &max17040_data.battery); if (ret) { pr_err("[MAX17040] failed: power supply register [ERROR]\n"); i2c_set_clientdata(client, NULL); return ret; } //The code used in the test mode [TEST MODE] ret = sysfs_create_group(&client->dev.kobj, &max17040_attr_group); if (ret) { pr_err("[MAX17040] failed: sysfs_create_group [ERROR]\n"); } //mutex is init mutex_init(&max17040_data.data_mutex); mutex_init(&max17040_data.i2c_mutex); mutex_init(&max17040_data.quick_mutex); //rcomp is set max17040_set_rcomp(); //Version of reading max17040_get_version(); //read vell and soc max17040_quick_get_vcell(); #ifdef USE_MAX17040_QUICKSTART //check quick start aflag=max17040_check_restart(max17040_data.quick_data.quick_vcell,max17040_data.quick_data.quick_soc); if(aflag) { max17040_restart(); msleep(300); //quick start update time } #endif //The code used in the test mode [TEST MODE] atomic_set(&max17040_data.set_test, 0); input_data = input_allocate_device(); if (!input_data) { pr_err("[MAX17040]: Unable to input_allocate_device \n"); return -1; } set_bit(EV_ABS,input_data->evbit); input_set_capability(input_data, EV_ABS, ABS_X); input_set_capability(input_data, EV_ABS, ABS_Y); /* wake */ input_set_capability(input_data, EV_ABS, ABS_WAKE); /* wake */ input_data->name="max17040"; ret =input_register_device(input_data); if (ret) { pr_err("[MAX17040]: Unable to register input_data device\n"); return -1; } input_set_drvdata(input_data, &max17040_data); max17040_data.max17040_input_data=input_data; //initialize workqueue and alarm setting wake_lock_init(&max17040_data.work_wake_lock, WAKE_LOCK_SUSPEND, "max17040-battery"); #ifdef MAX17040_ALARM_RTC_ENABLE max17040_data.last_poll=alarm_get_elapsed_realtime(); INIT_WORK(&max17040_data.monitor_work, max17040_work); max17040_data.monitor_wqueue = create_freezeable_workqueue("max17040"); /* init to something sane */ if (!max17040_data.monitor_wqueue) { sleep_dbg("fail_workqueue Error [PROBE FUNCTION]"); return -1; } alarm_init(&max17040_data.alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP, max_battery_alarm_callback); //prevent suspend max17040_prevent_suspend(); #ifdef CONFIG_HAS_EARLYSUSPEND max17040_data.early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN; max17040_data.early_suspend.suspend = max17040_batt_early_suspend; max17040_data.early_suspend.resume = max17040_batt_late_resume; dbg("set max17040 EARLY_SUSPEND\n"); register_early_suspend(&max17040_data.early_suspend); #endif //CONFIG_HAS_EARLYSUSPEND queue_work(max17040_data.monitor_wqueue, &max17040_data.monitor_work); #else INIT_DELAYED_WORK_DEFERRABLE(&max17040_data.work, max17040_work); schedule_delayed_work(&max17040_data.work, 0); #endif //MAX17040_ALARM_RTC_ENABLE // sleep_dbg("[MAX17040] max17040_probe [OUT]\n"); pr_info("[MAX17040]max17040_probe...\n"); return 0; }
static int __devinit tmp102_temp_sensor_probe( struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; struct tmp102_temp_sensor *tmp102; #ifdef CONFIG_THERMAL_DEBUG printk(KERN_DEBUG "%s\n", __func__); #endif if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA)) { dev_err(&client->dev, "adapter doesn't support SMBus word " "transactions\n"); return -ENODEV; } tmp102 = kzalloc(sizeof(struct tmp102_temp_sensor), GFP_KERNEL); if (!tmp102) return -ENOMEM; tmp102_data=tmp102; mutex_init(&tmp102->sensor_mutex); tmp102->iclient = client; i2c_set_clientdata(client, tmp102); /*Reset TMP102*/ tmp102_write_reg(client, TMP102_CONF_REG,TMP102_RESET); if (ret < 0) { dev_err(&client->dev, "error writing config register\n"); goto free_err;; } /*Config TMP102*/ ret = tmp102_write_reg(client, TMP102_CONF_REG, TMP102_CONFIG); if (ret < 0) { dev_err(&client->dev, "error writing config register\n"); goto restore_config_err; } /*Verify config*/ ret = tmp102_read_reg(client, TMP102_CONF_REG); if (ret < 0) { dev_err(&client->dev, "error reading config register\n"); goto restore_config_err; } #ifdef CONFIG_THERMAL_DEBUG printk(KERN_DEBUG "config=0x%X\n", ret); #endif ret &= ~TMP102_CONFIG_RD_ONLY; if (ret != TMP102_CONFIG) { dev_err(&client->dev, "config settings did not stick\n"); ret = -ENODEV; goto restore_config_err; } tmp102->last_update = jiffies - HZ; tmp102->temp=DEFAULT_TEMPERATURE; tmp102->state=LOW_TEMP_STATE; ret = sysfs_create_group(&client->dev.kobj, &temp102_attr_group); if (ret){ dev_err(&client->dev, "unable to create attribute\n"); goto sysfs_create_err; } tmp102->tpcb=kzalloc(sizeof(struct pcb_sens), GFP_KERNEL); if(tmp102->tpcb){ tmp102->tpcb->update_temp=tmp102_read_current_temp; omap4_duty_pcb_register(tmp102->tpcb); }else { ret = -ENOMEM; goto tpcb_alloc_err; } dev_info(&client->dev, "initialized\n"); return 0; tpcb_alloc_err: sysfs_remove_group(&client->dev.kobj, &temp102_attr_group); sysfs_create_err: restore_config_err: tmp102_write_reg(client, TMP102_CONF_REG,(TMP102_RESET|TMP102_CONF_SD)); free_err: mutex_destroy(&tmp102->sensor_mutex); kfree(tmp102); return ret; }
static int silead_ts_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct silead_ts_data *data; struct device *dev = &client->dev; int error; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C | I2C_FUNC_SMBUS_READ_I2C_BLOCK | I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) { dev_err(dev, "I2C functionality check failed\n"); return -ENXIO; } data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; i2c_set_clientdata(client, data); data->client = client; error = silead_ts_set_default_fw_name(data, id); if (error) return error; silead_ts_read_props(client); /* We must have the IRQ provided by DT or ACPI subsytem */ if (client->irq <= 0) return -ENODEV; data->regulators[0].supply = "vddio"; data->regulators[1].supply = "avdd"; error = devm_regulator_bulk_get(dev, ARRAY_SIZE(data->regulators), data->regulators); if (error) return error; /* * Enable regulators at probe and disable them at remove, we need * to keep the chip powered otherwise it forgets its firmware. */ error = regulator_bulk_enable(ARRAY_SIZE(data->regulators), data->regulators); if (error) return error; error = devm_add_action_or_reset(dev, silead_disable_regulator, data); if (error) return error; /* Power GPIO pin */ data->gpio_power = devm_gpiod_get_optional(dev, "power", GPIOD_OUT_LOW); if (IS_ERR(data->gpio_power)) { if (PTR_ERR(data->gpio_power) != -EPROBE_DEFER) dev_err(dev, "Shutdown GPIO request failed\n"); return PTR_ERR(data->gpio_power); } error = silead_ts_setup(client); if (error) return error; error = silead_ts_request_input_dev(data); if (error) return error; error = devm_request_threaded_irq(dev, client->irq, NULL, silead_ts_threaded_irq_handler, IRQF_ONESHOT, client->name, data); if (error) { if (error != -EPROBE_DEFER) dev_err(dev, "IRQ request failed %d\n", error); return error; } return 0; }
static int __devinit sec_fuelgauge_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct sec_fuelgauge_info *fuelgauge; int ret = 0; union power_supply_propval raw_soc_val; dev_dbg(&client->dev, "%s: SEC Fuelgauge Driver Loading\n", __func__); if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE)) return -EIO; fuelgauge = kzalloc(sizeof(*fuelgauge), GFP_KERNEL); if (!fuelgauge) return -ENOMEM; mutex_init(&fuelgauge->fg_lock); fuelgauge->client = client; fuelgauge->pdata = client->dev.platform_data; i2c_set_clientdata(client, fuelgauge); fuelgauge->psy_fg.name = "sec-fuelgauge"; fuelgauge->psy_fg.type = POWER_SUPPLY_TYPE_UNKNOWN; fuelgauge->psy_fg.get_property = sec_fg_get_property; fuelgauge->psy_fg.set_property = sec_fg_set_property; fuelgauge->psy_fg.properties = sec_fuelgauge_props; fuelgauge->psy_fg.num_properties = ARRAY_SIZE(sec_fuelgauge_props); fuelgauge->capacity_max = fuelgauge->pdata->capacity_max; #if 0 raw_soc_val.intval = SEC_FUELGAUGE_CAPACITY_TYPE_RAW; sec_hal_fg_get_property(fuelgauge->client, POWER_SUPPLY_PROP_CAPACITY, &raw_soc_val); raw_soc_val.intval /= 10; if(raw_soc_val.intval > fuelgauge->pdata->capacity_max) sec_fg_calculate_dynamic_scale(fuelgauge); #endif if (!fuelgauge->pdata->fg_gpio_init()) { dev_err(&client->dev, "%s: Failed to Initialize GPIO\n", __func__); goto err_free; } if (!sec_hal_fg_init(fuelgauge->client)) { dev_err(&client->dev, "%s: Failed to Initialize Fuelgauge\n", __func__); goto err_free; } ret = power_supply_register(&client->dev, &fuelgauge->psy_fg); if (ret) { dev_err(&client->dev, "%s: Failed to Register psy_fg\n", __func__); goto err_free; } if (fuelgauge->pdata->fg_irq) { INIT_DELAYED_WORK_DEFERRABLE( &fuelgauge->isr_work, sec_fg_isr_work); ret = request_threaded_irq(fuelgauge->pdata->fg_irq, NULL, sec_fg_irq_thread, fuelgauge->pdata->fg_irq_attr, "fuelgauge-irq", fuelgauge); if (ret) { dev_err(&client->dev, "%s: Failed to Reqeust IRQ\n", __func__); goto err_supply_unreg; } ret = enable_irq_wake(gpio_to_irq(fuelgauge->pdata->fg_irq)); if (ret < 0) dev_err(&client->dev, "%s: Failed to Enable Wakeup Source(%d)\n", __func__, ret); } fuelgauge->is_fuel_alerted = false; if (fuelgauge->pdata->fuel_alert_soc >= 0) { if (sec_hal_fg_fuelalert_init(fuelgauge->client, fuelgauge->pdata->fuel_alert_soc)) wake_lock_init(&fuelgauge->fuel_alert_wake_lock, WAKE_LOCK_SUSPEND, "fuel_alerted"); else { dev_err(&client->dev, "%s: Failed to Initialize Fuel-alert\n", __func__); goto err_irq; } } fuelgauge->initial_update_of_soc = true; ret = sec_fg_create_attrs(fuelgauge->psy_fg.dev); if (ret) { dev_err(&client->dev, "%s : Failed to create_attrs\n", __func__); goto err_irq; } dev_dbg(&client->dev, "%s: SEC Fuelgauge Driver Loaded\n", __func__); return 0; err_irq: if (fuelgauge->pdata->fg_irq) free_irq(fuelgauge->pdata->fg_irq, fuelgauge); wake_lock_destroy(&fuelgauge->fuel_alert_wake_lock); err_supply_unreg: power_supply_unregister(&fuelgauge->psy_fg); err_free: mutex_destroy(&fuelgauge->fg_lock); kfree(fuelgauge); return ret; }
static int bq275x0_battery_probe(struct i2c_client *client, const struct i2c_device_id *id) { int num; char *name; int retval = 0; struct bq275x0_device_info *di; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { BQ275x0_ERR("[%s,%d]: need I2C_FUNC_I2C\n",__FUNCTION__,__LINE__); return -ENODEV; } i2c_smbus_write_word_data(client,0x00,0x0008); mdelay(2); retval = i2c_smbus_read_word_data(client,0x00); if(retval<0) { printk(KERN_ERR "[%s,%d] Coulometer Damaged or Firmware Error\n",__FUNCTION__,__LINE__); } else { printk(KERN_ERR "Normal Mode and read Firmware version=%04x\n", retval); } retval = driver_create_file(&(bq275x0_battery_driver.driver), &driver_attr_state); if (0 != retval) { printk("failed to create sysfs entry(state): %d\n", retval); return -1; } power_set_batt_measurement_type(BATT_MEASURE_BY_BQ275x0); /* Get new ID for the new battery device */ retval = idr_pre_get(&bq275x0_battery_id, GFP_KERNEL); if (retval == 0) { retval = -ENOMEM; goto batt_failed_0; } mutex_lock(&bq275x0_battery_mutex); retval = idr_get_new(&bq275x0_battery_id, client, &num); mutex_unlock(&bq275x0_battery_mutex); if (retval < 0) { goto batt_failed_0; } name = kasprintf(GFP_KERNEL, "bq275x0-%d", num); if (!name) { dev_err(&client->dev, "failed to allocate device name\n"); retval = -ENOMEM; goto batt_failed_1; } di = kzalloc(sizeof(*di), GFP_KERNEL); if (!di) { dev_err(&client->dev, "failed to allocate device info data\n"); retval = -ENOMEM; goto batt_failed_2; } di->id = num; i2c_set_clientdata(client, di); di->dev = &client->dev; di->bat.name = name; di->client = client; bq275x0_powersupply_init(di); g_battery_measure_by_bq275x0_i2c_client = client; dev_info(&client->dev, "bq275x0 support ver. %s enabled\n", DRIVER_VERSION); return 0; batt_failed_2: kfree(name); batt_failed_1: mutex_lock(&bq275x0_battery_mutex); idr_remove(&bq275x0_battery_id, num); mutex_unlock(&bq275x0_battery_mutex); batt_failed_0: power_set_batt_measurement_type(BATT_MEASURE_UNKNOW); return retval; }
int32_t msm_sensor_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int rc = 0; char front_cam[10] = "mt9m114"; struct msm_sensor_ctrl_t *s_ctrl; CDBG("%s_i2c_probe called\n", client->name); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { CDBG("i2c_check_functionality failed\n"); rc = -EFAULT; return rc; } s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data); if (s_ctrl->sensor_i2c_client != NULL) { s_ctrl->sensor_i2c_client->client = client; if (s_ctrl->sensor_i2c_addr != 0) s_ctrl->sensor_i2c_client->client->addr = s_ctrl->sensor_i2c_addr; } else { rc = -EFAULT; return rc; } s_ctrl->sensordata = client->dev.platform_data; if (s_ctrl->sensordata == NULL) { pr_err("%s: NULL sensor data\n", __func__); return -EFAULT; } rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl); if (rc < 0) goto probe_fail; rc = msm_sensor_match_id(s_ctrl); /*BEGIN Chaoyen_Wu@pegatron[2012.4.12][front camera 2nd source porting]*/ if(rc < 0 && !(strcmp(client->name, front_cam))){ s_ctrl->sensor_i2c_client->client->addr = s_ctrl->sensor_i2c_addr_high; CDBG("2nd source i2c addr: 0x%x\n",s_ctrl->sensor_i2c_client->client->addr); rc = msm_sensor_match_id(s_ctrl); } /*END Chaoyen_Wu@pegatron[2012.4.12][front camera 2nd source porting]*/ if (rc < 0) goto probe_fail; if (s_ctrl->sensor_eeprom_client != NULL) { struct msm_camera_eeprom_client *eeprom_client = s_ctrl->sensor_eeprom_client; if (eeprom_client->func_tbl.eeprom_init != NULL && eeprom_client->func_tbl.eeprom_release != NULL) { rc = eeprom_client->func_tbl.eeprom_init( eeprom_client, s_ctrl->sensor_i2c_client->client->adapter); if (rc < 0) goto probe_fail; rc = msm_camera_eeprom_read_tbl(eeprom_client, eeprom_client->read_tbl, eeprom_client->read_tbl_size); eeprom_client->func_tbl.eeprom_release(eeprom_client); if (rc < 0) goto probe_fail; } } snprintf(s_ctrl->sensor_v4l2_subdev.name, sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name); v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client, s_ctrl->sensor_v4l2_subdev_ops); msm_sensor_register(&s_ctrl->sensor_v4l2_subdev); goto power_down; probe_fail: CDBG("%s_i2c_probe failed\n", client->name); power_down: if (rc > 0) rc = 0; s_ctrl->func_tbl->sensor_power_down(s_ctrl); return rc; }
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__); /*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); if (wac_i2c == NULL) goto fail; wac_i2c->wac_feature = &wacom_feature_EMR; pdata->init_platform_hw(); /*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 defined(CONFIG_USA_MODEL_SGH_I717) if( get_hw_rev() == 0x01 ) { printk("[E-PEN] Wacom driver is working for 4.4mm pitch pad.\n"); /* Firmware Feature */ Firmware_version_of_file = 0x340; Binary = Binary_44; } else 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 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; } #endif 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 */ #if defined(CONFIG_USA_MODEL_SGH_I717) gpio_set_value(GPIO_PEN_RESET, 0); msleep(200); gpio_set_value(GPIO_PEN_RESET, 1); msleep(200); #else gpio_set_value(GPIO_PEN_RESET, 0); msleep(120); gpio_set_value(GPIO_PEN_RESET, 1); msleep(15); #endif 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); if (device_create_file(sec_epen, &dev_attr_epen_checksum)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_checksum.attr.name); if (device_create_file(sec_epen, &dev_attr_epen_checksum_result)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_checksum_result.attr.name); if (device_create_file(sec_epen, &dev_attr_set_epen_module_off) < 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_set_epen_module_off.attr.name); if (device_create_file(sec_epen, &dev_attr_set_epen_module_on) < 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_set_epen_module_on.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 } /* To send exact checksum data at sleep state ... Xtopher */ printk(KERN_ERR"[E-PEN]: Verify CHECKSUM.\n"); epen_checksum_read_atBoot(wac_i2c); msleep(20); 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 pn544_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct pn544_i2c_platform_data *platform_data; struct pn544_dev *pn544_dev; platform_data = client->dev.platform_data; if (platform_data == NULL) { printk("%s : nfc probe fail\n", __func__); return -ENODEV; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { printk("%s : need I2C_FUNC_I2C\n", __func__); return -ENODEV; } //IRQ ret = gpio_request(platform_data->irq_gpio, "nfc_int"); if (ret) { printk("gpio_nfc_int request error\n"); return -ENODEV; } //VEN ret = gpio_request(platform_data->ven_gpio, "nfc_ven"); if (ret) { printk("gpio_nfc_ven request error\n"); return -ENODEV; } //PVDD ret = gpio_request(PN544_PW_EN, "nfc_pvdd"); if (ret) { printk("gpio_nfc_ven request error\n"); return -ENODEV; } //FIRM ret = gpio_request(platform_data->firm_gpio, "nfc_firm"); if (ret) { printk("gpio_nfc_firm request error\n"); return -ENODEV; } pn544_dev = kzalloc(sizeof(*pn544_dev), GFP_KERNEL); if (pn544_dev == NULL) { dev_err(&client->dev, "failed to allocate memory for module data\n"); ret = -ENOMEM; goto err_exit; } gpio_set_value(PN544_PW_EN, 1); pn544_dev->irq_gpio = platform_data->irq_gpio; pn544_dev->ven_gpio = platform_data->ven_gpio; pn544_dev->firm_gpio = platform_data->firm_gpio; pn544_dev->client = client; /* init mutex and queues */ init_waitqueue_head(&pn544_dev->read_wq); mutex_init(&pn544_dev->read_mutex); spin_lock_init(&pn544_dev->irq_enabled_lock); pn544_dev->pn544_device.minor = MISC_DYNAMIC_MINOR; pn544_dev->pn544_device.name = "pn544"; pn544_dev->pn544_device.fops = &pn544_dev_fops; ret = misc_register(&pn544_dev->pn544_device); if (ret) { printk("%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); pn544_dev->irq_enabled = true; // ts->irq = gpio_to_irq(ts->platform_data->irq_gpio); ret = request_irq(client->irq, pn544_dev_irq_handler, IRQF_TRIGGER_HIGH, client->name, pn544_dev); if (ret) { dev_err(&client->dev, "request_irq failed\n"); goto err_request_irq_failed; } printk("pn544_probe -> request_irq,%d\n", ret); pn544_disable_irq(pn544_dev); i2c_set_clientdata(client, pn544_dev); return 0; err_request_irq_failed: misc_deregister(&pn544_dev->pn544_device); err_misc_register: mutex_destroy(&pn544_dev->read_mutex); kfree(pn544_dev); err_exit: gpio_free(pn544_dev->irq_gpio); gpio_free(pn544_dev->ven_gpio); gpio_free(pn544_dev->firm_gpio); return ret; }
static int lm25066_probe(struct i2c_client *client, const struct i2c_device_id *id) { int config; int ret; struct lm25066_data *data; struct pmbus_driver_info *info; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA)) return -ENODEV; data = kzalloc(sizeof(struct lm25066_data), GFP_KERNEL); if (!data) return -ENOMEM; config = i2c_smbus_read_byte_data(client, LM25066_DEVICE_SETUP); if (config < 0) { ret = config; goto err_mem; } data->id = id->driver_data; info = &data->info; info->pages = 2; info->format[PSC_VOLTAGE_IN] = direct; info->format[PSC_VOLTAGE_OUT] = direct; info->format[PSC_CURRENT_IN] = direct; info->format[PSC_TEMPERATURE] = direct; info->format[PSC_POWER] = direct; info->m[PSC_TEMPERATURE] = 16; info->b[PSC_TEMPERATURE] = 0; info->R[PSC_TEMPERATURE] = 0; info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_PIN | PMBUS_HAVE_IIN | PMBUS_HAVE_STATUS_INPUT | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; info->func[1] = PMBUS_HAVE_VOUT; info->read_word_data = lm25066_read_word_data; info->write_word_data = lm25066_write_word_data; info->write_byte = lm25066_write_byte; switch (id->driver_data) { case lm25066: info->m[PSC_VOLTAGE_IN] = 22070; info->b[PSC_VOLTAGE_IN] = 0; info->R[PSC_VOLTAGE_IN] = -2; info->m[PSC_VOLTAGE_OUT] = 22070; info->b[PSC_VOLTAGE_OUT] = 0; info->R[PSC_VOLTAGE_OUT] = -2; if (config & LM25066_DEV_SETUP_CL) { info->m[PSC_CURRENT_IN] = 6852; info->b[PSC_CURRENT_IN] = 0; info->R[PSC_CURRENT_IN] = -2; info->m[PSC_POWER] = 369; info->b[PSC_POWER] = 0; info->R[PSC_POWER] = -2; } else { info->m[PSC_CURRENT_IN] = 13661; info->b[PSC_CURRENT_IN] = 0; info->R[PSC_CURRENT_IN] = -2; info->m[PSC_POWER] = 736; info->b[PSC_POWER] = 0; info->R[PSC_POWER] = -2; } break; case lm5064: info->m[PSC_VOLTAGE_IN] = 22075; info->b[PSC_VOLTAGE_IN] = 0; info->R[PSC_VOLTAGE_IN] = -2; info->m[PSC_VOLTAGE_OUT] = 22075; info->b[PSC_VOLTAGE_OUT] = 0; info->R[PSC_VOLTAGE_OUT] = -2; if (config & LM25066_DEV_SETUP_CL) { info->m[PSC_CURRENT_IN] = 6713; info->b[PSC_CURRENT_IN] = 0; info->R[PSC_CURRENT_IN] = -2; info->m[PSC_POWER] = 3619; info->b[PSC_POWER] = 0; info->R[PSC_POWER] = -3; } else { info->m[PSC_CURRENT_IN] = 13426; info->b[PSC_CURRENT_IN] = 0; info->R[PSC_CURRENT_IN] = -2; info->m[PSC_POWER] = 7238; info->b[PSC_POWER] = 0; info->R[PSC_POWER] = -3; } break; case lm5066: info->m[PSC_VOLTAGE_IN] = 4587; info->b[PSC_VOLTAGE_IN] = 0; info->R[PSC_VOLTAGE_IN] = -2; info->m[PSC_VOLTAGE_OUT] = 4587; info->b[PSC_VOLTAGE_OUT] = 0; info->R[PSC_VOLTAGE_OUT] = -2; if (config & LM25066_DEV_SETUP_CL) { info->m[PSC_CURRENT_IN] = 10753; info->b[PSC_CURRENT_IN] = 0; info->R[PSC_CURRENT_IN] = -2; info->m[PSC_POWER] = 1204; info->b[PSC_POWER] = 0; info->R[PSC_POWER] = -3; } else { info->m[PSC_CURRENT_IN] = 5405; info->b[PSC_CURRENT_IN] = 0; info->R[PSC_CURRENT_IN] = -2; info->m[PSC_POWER] = 605; info->b[PSC_POWER] = 0; info->R[PSC_POWER] = -3; } break; default: ret = -ENODEV; goto err_mem; } ret = pmbus_do_probe(client, id, info); if (ret) goto err_mem; return 0; err_mem: kfree(data); return ret; }
static int mma845x_mod_probe(struct i2c_client *client, const struct i2c_device_id *devid) { struct ext_slave_platform_data *pdata; struct mma845x_mod_private_data *private_data; int result = 0; unsigned char product_id = 0xff; dev_info(&client->adapter->dev, "%s: %s\n", __func__, devid->name); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { result = -ENODEV; goto out_no_free; } pdata = client->dev.platform_data; if (!pdata) { dev_err(&client->adapter->dev, "Missing platform data for slave %s\n", devid->name); result = -EFAULT; goto out_no_free; } result = inv_serial_read(client->adapter, pdata->address, ACCEL_MMA845X_WHO_AM_I, sizeof(product_id), &product_id); printk("mma845x detect 0x%x\n", product_id); if (result || (product_id != ACCEL_MMA845X_ID)) { dev_err(&client->adapter->dev, "mma845x not found\n"); result = -ENODEV; goto out_no_free; } printk("mma845x find\n"); private_data = kzalloc(sizeof(*private_data), GFP_KERNEL); if (!private_data) { result = -ENOMEM; goto out_no_free; } i2c_set_clientdata(client, private_data); private_data->client = client; private_data->pdata = pdata; result = inv_mpu_register_slave(THIS_MODULE, client, pdata, mma845x_get_slave_descr); if (result) { dev_err(&client->adapter->dev, "Slave registration failed: %s, %d\n", devid->name, result); goto out_free_memory; } return result; out_free_memory: kfree(private_data); out_no_free: dev_err(&client->adapter->dev, "%s failed %d\n", __func__, result); return result; }
int akm8975_probe(struct i2c_client *client, const struct i2c_device_id *devid) { struct akm8975_data *akm; int err; printk("ak8975 probe start!\n"); if (client->dev.platform_data == NULL) { dev_err(&client->dev, "platform data is NULL. exiting.\n"); err = -ENODEV; goto exit_platform_data_null; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "I2C check failed, exiting.\n"); err = -ENODEV; goto exit_check_functionality_failed; } akm = kzalloc(sizeof(struct akm8975_data), GFP_KERNEL); if (!akm) { dev_err(&client->dev, "failed to allocate memory for module data\n"); err = -ENOMEM; goto exit_alloc_data_failed; } akm->pdata = client->dev.platform_data; mutex_init(&akm->lock); init_completion(&akm->data_ready); i2c_set_clientdata(client, akm); akm->this_client = client; err = akm8975_ecs_set_mode_power_down(akm); if (err < 0) { pr_err("%s: akm8975_ecs_set_mode_power_down failed(%d)\n", __func__, err); goto exit_set_mode_power_down_failed; } err = akm8975_setup_irq(akm); if (err) { pr_err("%s: could not setup irq\n", __func__); goto exit_setup_irq; } akm->akmd_device.minor = MISC_DYNAMIC_MINOR; akm->akmd_device.name = "akm8975"; akm->akmd_device.fops = &akmd_fops; err = misc_register(&akm->akmd_device); if (err) { pr_err("%s misc_register failed\n", __func__); goto exit_akmd_device_register_failed; } init_waitqueue_head(&akm->state_wq); printk("ak8975 probe success!\n"); return 0; exit_akmd_device_register_failed: free_irq(akm->irq, akm); gpio_free(akm->pdata->gpio_data_ready_int); exit_setup_irq: exit_set_mode_power_down_failed: mutex_destroy(&akm->lock); kfree(akm); exit_alloc_data_failed: exit_check_functionality_failed: exit_platform_data_null: return err; }
static int s5k8aay_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int rc = 0; struct msm_sensor_ctrl_t *s_ctrl; CAM_DEBUG(" E"); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { cam_err("i2c_check_functionality failed"); rc = -ENOTSUPP; goto probe_failure; } s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data); if (s_ctrl->sensor_i2c_client != NULL) { s_ctrl->sensor_i2c_client->client = client; if (s_ctrl->sensor_i2c_addr != 0) s_ctrl->sensor_i2c_client->client->addr = s_ctrl->sensor_i2c_addr; } else { cam_err("s_ctrl->sensor_i2c_client is NULL"); rc = -EFAULT; goto probe_failure; } s_ctrl->sensordata = client->dev.platform_data; if (s_ctrl->sensordata == NULL) { cam_err(" NULL sensor data"); rc = -EFAULT; goto probe_failure; } s5k8aay_client = client; s5k8aay_dev = s_ctrl->sensor_i2c_client->client->dev; s5k8aay_ctrl = kzalloc(sizeof(struct s5k8aay_ctrl), GFP_KERNEL); if (!s5k8aay_ctrl) { cam_err(" s5k8aay_ctrl alloc failed!"); rc = -ENOMEM; goto probe_failure; } memset(s5k8aay_ctrl, 0, sizeof(s5k8aay_ctrl)); snprintf(s_ctrl->sensor_v4l2_subdev.name, sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name); v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client, &s5k8aay_subdev_ops); s5k8aay_ctrl->sensor_dev = &s_ctrl->sensor_v4l2_subdev; s5k8aay_ctrl->sensordata = client->dev.platform_data; rc = msm_sensor_register(&s_ctrl->sensor_v4l2_subdev); if (rc < 0) { cam_err(" msm_sensor_register failed!"); kfree(s5k8aay_ctrl); goto probe_failure; } CAM_DEBUG(" success!"); CAM_DEBUG(" X"); return 0; probe_failure: CAM_DEBUG(" fail!"); CAM_DEBUG(" X"); return rc; }
static int rs5c372_probe(struct i2c_client *client, const struct i2c_device_id *id) { int err = 0; int smbus_mode = 0; struct rs5c372 *rs5c372; struct rtc_time tm; dev_dbg(&client->dev, "%s\n", __func__); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C | I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK)) { if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK)) smbus_mode = 1; else { err = -ENODEV; goto exit; } } if (!(rs5c372 = kzalloc(sizeof(struct rs5c372), GFP_KERNEL))) { err = -ENOMEM; goto exit; } rs5c372->client = client; i2c_set_clientdata(client, rs5c372); rs5c372->type = id->driver_data; rs5c372->regs = &rs5c372->buf[1]; rs5c372->smbus = smbus_mode; err = rs5c_get_regs(rs5c372); if (err < 0) goto exit_kfree; switch (rs5c372->type) { case rtc_rs5c372a: case rtc_rs5c372b: if (rs5c372->regs[RS5C_REG_CTRL2] & RS5C372_CTRL2_24) rs5c372->time24 = 1; break; case rtc_r2025sd: case rtc_rv5c386: case rtc_rv5c387a: if (rs5c372->regs[RS5C_REG_CTRL1] & RV5C387_CTRL1_24) rs5c372->time24 = 1; break; default: dev_err(&client->dev, "unknown RTC type\n"); goto exit_kfree; } err = rs5c_oscillator_setup(rs5c372); if (unlikely(err < 0)) { dev_err(&client->dev, "setup error\n"); goto exit_kfree; } if (rs5c372_get_datetime(client, &tm) < 0) dev_warn(&client->dev, "clock needs to be set\n"); dev_info(&client->dev, "%s found, %s, driver version " DRV_VERSION "\n", ({ char *s; switch (rs5c372->type) { case rtc_r2025sd: s = "r2025sd"; break; case rtc_rs5c372a: s = "rs5c372a"; break; case rtc_rs5c372b: s = "rs5c372b"; break; case rtc_rv5c386: s = "rv5c386"; break; case rtc_rv5c387a: s = "rv5c387a"; break; default: s = "chip"; break; }; s;}),
static int pn547_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; int rc = 0; struct clk *nfc_clk = NULL; struct pn547_i2c_platform_data *platform_data; struct pn547_dev *pn547_dev; printk("### %s begin! \n",__func__); dev_info(&client->dev, "%s ++\n", __func__); platform_data = kzalloc(sizeof(struct pn547_i2c_platform_data), GFP_KERNEL); if (platform_data == NULL) { dev_err(&client->dev, "failed to allocate memory\n"); ret = -ENOMEM; goto err_platform_data; } printk("### %s 11 begin! \n",__func__); ret = pn547_parse_dt(&client->dev, platform_data); if (ret < 0) { dev_err(&client->dev, "failed to parse device tree: %d\n", ret); goto err_parse_dt; } printk("pn547 dev kobj_name=%s,init_name=%s,id=%d\n",client->dev.kobj.name,client->dev.init_name, client->dev.id); nfc_clk = clk_get(&client->dev, "nfc_pn547clk"); if (nfc_clk == NULL) { dev_err(&client->dev, "failed to get clk: %d\n", ret); goto err_parse_dt; } rc = clk_set_rate(nfc_clk,19200000); if(rc){ dev_err(&client->dev, "Clock set rate failed: %d\n",rc); } ret = clk_prepare_enable(nfc_clk); if (ret) { dev_err(&client->dev, "failed to enable clk: %d\n", ret); goto err_parse_dt; } ret = pn547_gpio_request(&client->dev, platform_data); if (ret) { dev_err(&client->dev, "failed to request gpio\n"); goto err_gpio_request; } dev_dbg(&client->dev, "%s:\n", __func__); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "%s: i2c check failed\n", __func__); ret = -ENODEV; goto err_i2c; } printk("### %s 22 begin! \n",__func__); 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; } client->irq = gpio_to_irq(platform_data->irq_gpio); pn547_dev->irq_gpio = platform_data->irq_gpio; pn547_dev->ven_gpio = platform_data->ven_gpio; pn547_dev->firm_gpio = platform_data->fwdl_en_gpio; pn547_dev->clk_req_gpio = platform_data->clk_req_gpio; pn547_dev->client = client; pn547_dev->dev = &client->dev; pn547_dev->do_reading = 0; /* Initialise mutex and work queue */ init_waitqueue_head(&pn547_dev->read_wq); mutex_init(&pn547_dev->read_mutex); spin_lock_init(&pn547_dev->irq_enabled_lock); wake_lock_init(&pn547_dev->wl,WAKE_LOCK_SUSPEND,"nfc_locker"); pn547_dev->pn547_device.minor = MISC_DYNAMIC_MINOR; pn547_dev->pn547_device.name = "pn544"; pn547_dev->pn547_device.fops = &pn547_dev_fops; printk("### %s 33 begin! \n",__func__); ret = misc_register(&pn547_dev->pn547_device); if (ret) { dev_err(&client->dev, "%s: misc_register err %d\n", __func__, ret); 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. */ dev_info(&client->dev, "%s : requesting IRQ %d\n", __func__, client->irq); pn547_dev->irq_enabled = true; ret = request_irq(client->irq, pn547_dev_irq_handler, IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND | IRQF_ONESHOT, client->name, pn547_dev); if (ret) { dev_err(&client->dev, "request_irq failed\n"); goto err_request_irq_failed; } pn547_disable_irq(pn547_dev); i2c_set_clientdata(client, pn547_dev); return 0; err_request_irq_failed: misc_deregister(&pn547_dev->pn547_device); err_misc_register: mutex_destroy(&pn547_dev->read_mutex); kfree(pn547_dev); err_exit: err_i2c: pn547_gpio_release(platform_data); err_gpio_request: err_parse_dt: kfree(platform_data); err_platform_data: dev_err(&client->dev, "%s: err %d\n", __func__, ret); return ret; }
static int pm2xxx_wall_charger_probe(struct i2c_client *i2c_client, const struct i2c_device_id *id) { struct pm2xxx_platform_data *pl_data = i2c_client->dev.platform_data; struct power_supply_config psy_cfg = {}; struct pm2xxx_charger *pm2; int ret = 0; u8 val; int i; if (!pl_data) { dev_err(&i2c_client->dev, "No platform data supplied\n"); return -EINVAL; } pm2 = kzalloc(sizeof(struct pm2xxx_charger), GFP_KERNEL); if (!pm2) { dev_err(&i2c_client->dev, "pm2xxx_charger allocation failed\n"); return -ENOMEM; } /* get parent data */ pm2->dev = &i2c_client->dev; pm2->pm2_int = &pm2xxx_int; /* get charger spcific platform data */ if (!pl_data->wall_charger) { dev_err(pm2->dev, "no charger platform data supplied\n"); ret = -EINVAL; goto free_device_info; } pm2->pdata = pl_data->wall_charger; /* get battery specific platform data */ if (!pl_data->battery) { dev_err(pm2->dev, "no battery platform data supplied\n"); ret = -EINVAL; goto free_device_info; } pm2->bat = pl_data->battery; if (!i2c_check_functionality(i2c_client->adapter, I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_READ_WORD_DATA)) { ret = -ENODEV; dev_info(pm2->dev, "pm2301 i2c_check_functionality failed\n"); goto free_device_info; } pm2->config.pm2xxx_i2c = i2c_client; pm2->config.pm2xxx_id = (struct i2c_device_id *) id; i2c_set_clientdata(i2c_client, pm2); /* AC supply */ /* power_supply base class */ pm2->ac_chg_desc.name = pm2->pdata->label; pm2->ac_chg_desc.type = POWER_SUPPLY_TYPE_MAINS; pm2->ac_chg_desc.properties = pm2xxx_charger_ac_props; pm2->ac_chg_desc.num_properties = ARRAY_SIZE(pm2xxx_charger_ac_props); pm2->ac_chg_desc.get_property = pm2xxx_charger_ac_get_property; psy_cfg.supplied_to = pm2->pdata->supplied_to; psy_cfg.num_supplicants = pm2->pdata->num_supplicants; /* pm2xxx_charger sub-class */ pm2->ac_chg.ops.enable = &pm2xxx_charger_ac_en; pm2->ac_chg.ops.kick_wd = &pm2xxx_charger_watchdog_kick; pm2->ac_chg.ops.update_curr = &pm2xxx_charger_update_charger_current; pm2->ac_chg.max_out_volt = pm2xxx_charger_voltage_map[ ARRAY_SIZE(pm2xxx_charger_voltage_map) - 1]; pm2->ac_chg.max_out_curr = pm2xxx_charger_current_map[ ARRAY_SIZE(pm2xxx_charger_current_map) - 1]; pm2->ac_chg.wdt_refresh = WD_KICK_INTERVAL; pm2->ac_chg.enabled = true; pm2->ac_chg.external = true; /* Create a work queue for the charger */ pm2->charger_wq = create_singlethread_workqueue("pm2xxx_charger_wq"); if (pm2->charger_wq == NULL) { ret = -ENOMEM; dev_err(pm2->dev, "failed to create work queue\n"); goto free_device_info; } /* Init work for charger detection */ INIT_WORK(&pm2->ac_work, pm2xxx_charger_ac_work); /* Init work for checking HW status */ INIT_WORK(&pm2->check_main_thermal_prot_work, pm2xxx_charger_check_main_thermal_prot_work); /* Init work for HW failure check */ INIT_DEFERRABLE_WORK(&pm2->check_hw_failure_work, pm2xxx_charger_check_hw_failure_work); /* * VDD ADC supply needs to be enabled from this driver when there * is a charger connected to avoid erroneous BTEMP_HIGH/LOW * interrupts during charging */ pm2->regu = regulator_get(pm2->dev, "vddadc"); if (IS_ERR(pm2->regu)) { ret = PTR_ERR(pm2->regu); dev_err(pm2->dev, "failed to get vddadc regulator\n"); goto free_charger_wq; } /* Register AC charger class */ pm2->ac_chg.psy = power_supply_register(pm2->dev, &pm2->ac_chg_desc, &psy_cfg); if (IS_ERR(pm2->ac_chg.psy)) { dev_err(pm2->dev, "failed to register AC charger\n"); ret = PTR_ERR(pm2->ac_chg.psy); goto free_regulator; } /* Register interrupts */ ret = request_threaded_irq(gpio_to_irq(pm2->pdata->gpio_irq_number), NULL, pm2xxx_charger_irq[0].isr, pm2->pdata->irq_type, pm2xxx_charger_irq[0].name, pm2); if (ret != 0) { dev_err(pm2->dev, "failed to request %s IRQ %d: %d\n", pm2xxx_charger_irq[0].name, gpio_to_irq(pm2->pdata->gpio_irq_number), ret); goto unregister_pm2xxx_charger; } ret = pm_runtime_set_active(pm2->dev); if (ret) dev_err(pm2->dev, "set active Error\n"); pm_runtime_enable(pm2->dev); pm_runtime_set_autosuspend_delay(pm2->dev, PM2XXX_AUTOSUSPEND_DELAY); pm_runtime_use_autosuspend(pm2->dev); pm_runtime_resume(pm2->dev); /* pm interrupt can wake up system */ ret = enable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number)); if (ret) { dev_err(pm2->dev, "failed to set irq wake\n"); goto unregister_pm2xxx_interrupt; } mutex_init(&pm2->lock); if (gpio_is_valid(pm2->pdata->lpn_gpio)) { /* get lpn GPIO from platform data */ pm2->lpn_pin = pm2->pdata->lpn_gpio; /* * Charger detection mechanism requires pulling up the LPN pin * while i2c communication if Charger is not connected * LPN pin of PM2301 is GPIO60 of AB9540 */ ret = gpio_request(pm2->lpn_pin, "pm2301_lpm_gpio"); if (ret < 0) { dev_err(pm2->dev, "pm2301_lpm_gpio request failed\n"); goto disable_pm2_irq_wake; } ret = gpio_direction_output(pm2->lpn_pin, 0); if (ret < 0) { dev_err(pm2->dev, "pm2301_lpm_gpio direction failed\n"); goto free_gpio; } set_lpn_pin(pm2); } /* read interrupt registers */ for (i = 0; i < PM2XXX_NUM_INT_REG; i++) pm2xxx_reg_read(pm2, pm2xxx_interrupt_registers[i], &val); ret = pm2xxx_charger_detection(pm2, &val); if ((ret == 0) && val) { pm2->ac.charger_connected = 1; ab8500_override_turn_on_stat(~AB8500_POW_KEY_1_ON, AB8500_MAIN_CH_DET); pm2->ac_conn = true; power_supply_changed(pm2->ac_chg.psy); sysfs_notify(&pm2->ac_chg.psy->dev.kobj, NULL, "present"); } return 0; free_gpio: if (gpio_is_valid(pm2->lpn_pin)) gpio_free(pm2->lpn_pin); disable_pm2_irq_wake: disable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number)); unregister_pm2xxx_interrupt: /* disable interrupt */ free_irq(gpio_to_irq(pm2->pdata->gpio_irq_number), pm2); unregister_pm2xxx_charger: /* unregister power supply */ power_supply_unregister(pm2->ac_chg.psy); free_regulator: /* disable the regulator */ regulator_put(pm2->regu); free_charger_wq: destroy_workqueue(pm2->charger_wq); free_device_info: kfree(pm2); return ret; }