void initialize_temphumidity_factorytest(struct ssp_data *data) { int ret; /* alloc platform device for adc client */ data->pdev_pam_temp = platform_device_alloc("pam-temp-adc", -1); if (!data->pdev_pam_temp) pr_err("%s: could not allocation pam-temp-adc\n", __func__); data->adc_client = s3c_adc_register(data->pdev_pam_temp, NULL, NULL, 0); if (IS_ERR(data->adc_client)) pr_err("%s, fail to register pam-temp-adc(%ld)\n", __func__, IS_ERR(data->adc_client)); sensors_register(data->temphumidity_device, data, temphumidity_attrs, "temphumidity_sensor"); data->shtc1_device.minor = MISC_DYNAMIC_MINOR; data->shtc1_device.name = "shtc1_sensor"; data->shtc1_device.fops = &ssp_temphumidity_fops; ret = misc_register(&data->shtc1_device); if (ret < 0) { pr_err("register temphumidity misc device err(%d)", ret); } }
void __init exynos5_manta_battery_init(void) { int hw_rev = exynos5_manta_get_revision(); charger_gpio_init(); INIT_DELAYED_WORK(&redetect_work, redetect_work_proc); wake_lock_init(&manta_bat_chgdetect_wakelock, WAKE_LOCK_SUSPEND, "manta-chgdetect"); wake_lock_init(&manta_bat_redetect_wl, WAKE_LOCK_SUSPEND, "manta-chgredetect"); if (hw_rev >= MANTA_REV_DOGFOOD02) { s3c_gpio_cfgpin(GPIO_1WIRE_SLEEP, S3C_GPIO_OUTPUT); s3c_gpio_setpull(GPIO_1WIRE_SLEEP, S3C_GPIO_PULL_NONE); s5p_gpio_set_pd_cfg(GPIO_1WIRE_SLEEP, S5P_GPIO_PD_INPUT); s5p_gpio_set_pd_pull(GPIO_1WIRE_SLEEP, S5P_GPIO_PD_UPDOWN_DISABLE); ds2483_pdata.slpz_gpio = GPIO_1WIRE_SLEEP; } i2c_register_board_info(2, i2c_devs2, ARRAY_SIZE(i2c_devs2)); ta_adc_client = s3c_adc_register(&manta_bat_s3c_client_dev, NULL, NULL, 0); if (IS_ERR_OR_NULL(debugfs_create_file("manta-power", S_IRUGO, NULL, NULL, &manta_power_debug_fops))) pr_err("failed to create manta-power debugfs entry\n"); if (IS_ERR_OR_NULL(debugfs_create_file("manta-power-adc", S_IRUGO, NULL, NULL, &manta_power_adc_debug_fops))) pr_err("failed to create manta-power-adc debugfs entry\n"); }
static __devinit int sec_therm_probe(struct platform_device *pdev) { struct sec_therm_platform_data *pdata = dev_get_platdata(&pdev->dev); struct sec_therm_info *info; int ret = 0; dev_info(&pdev->dev, "%s: SEC Thermistor Driver Loading\n", __func__); info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) return -ENOMEM; platform_set_drvdata(pdev, info); info->dev = &pdev->dev; info->pdata = pdata; info->padc = s3c_adc_register(pdev, NULL, NULL, 0); ret = sysfs_create_group(&info->dev->kobj, &sec_therm_group); if (ret) { dev_err(info->dev, "failed to create sysfs attribute group\n"); } INIT_DELAYED_WORK_DEFERRABLE(&info->polling_work, sec_therm_polling_work); schedule_delayed_work(&info->polling_work, msecs_to_jiffies(info->pdata->polling_interval)); return ret; }
static bool sec_bat_adc_ap_init(struct platform_device *pdev) { if (!adc_client) { adc_client = s3c_adc_register(pdev, NULL, NULL, 0); if (IS_ERR(adc_client)) pr_err("ADC READ ERROR"); else pr_info("%s: sec_bat_adc_ap_init succeed\n", __func__); } return true; }
static int __devinit mixtile_adc_bat_probe(struct platform_device *pdev) { int i; int ret = 0; struct s3c_adc_client *client; dev = &pdev->dev; dev_info(dev, "%s\n", __func__); client = s3c_adc_register(pdev, NULL, NULL, 0); if (IS_ERR(client)) { dev_err(&pdev->dev, "cannot register adc\n"); return PTR_ERR(client); } platform_set_drvdata(pdev, client); mixtile_adc_bat_info.client = client; mixtile_adc_bat_info.present = 1; mixtile_adc_bat_info.bat_info.batt_id = 0; mixtile_adc_bat_info.bat_info.batt_vol = 0; mixtile_adc_bat_info.bat_info.batt_vol_adc = 0; mixtile_adc_bat_info.bat_info.batt_vol_adc_cal = 0; mixtile_adc_bat_info.bat_info.batt_temp = 0; mixtile_adc_bat_info.bat_info.batt_temp_adc = 0; mixtile_adc_bat_info.bat_info.batt_temp_adc_cal = 0; mixtile_adc_bat_info.bat_info.batt_current = 0; mixtile_adc_bat_info.bat_info.level = 0; mixtile_adc_bat_info.bat_info.charging_source = CHARGER_BATTERY; mixtile_adc_bat_info.bat_info.charging_enabled = 0; mixtile_adc_bat_info.bat_info.batt_health = POWER_SUPPLY_HEALTH_GOOD; /* init power supplier framework */ for (i = 0; i < ARRAY_SIZE(samsung_power_supplies); i++) { ret = power_supply_register(&pdev->dev, &samsung_power_supplies[i]); if (ret) { dev_err(dev, "Failed to register power supply %d,%d\n", i, ret); goto __end__; } } mixtile_adc_bat_create_attrs(samsung_power_supplies[CHARGER_BATTERY].dev); for(i=0; i<10; i++) adc_value[i] = 0; INIT_DELAYED_WORK(&bat_work, s3c_adc_bat_work); monitor_wqueue = create_singlethread_workqueue(dev_name(&pdev->dev)); queue_delayed_work(monitor_wqueue, &bat_work, POLL_MSTIME); __end__: return ret; }
void __init exynos_slim8_charger_init(void) { pr_info("%s: tab3 charger init\n", __func__); charger_gpio_init(); platform_add_devices(sec_battery_devices, ARRAY_SIZE(sec_battery_devices)); i2c_register_board_info(SEC_CHARGER_I2C_ID, sec_brdinfo_charger, ARRAY_SIZE(sec_brdinfo_charger)); i2c_register_board_info(SEC_FUELGAUGE_I2C_ID, sec_brdinfo_fuelgauge, ARRAY_SIZE(sec_brdinfo_fuelgauge)); temp_adc_client = s3c_adc_register(&sec_device_battery, NULL, NULL, 0); }
static int __devinit exynos_adc_probe(struct platform_device *dev) { int ret; mutex_init(&adcdev.lock); /* Register with the core ADC driver. */ adcdev.client = s3c_adc_register(dev, NULL, NULL, 0); if (IS_ERR(adcdev.client)) { printk("tiny4412_adc: cannot register adc\n"); ret = PTR_ERR(adcdev.client); goto err_mem; } ret = misc_register(&misc); printk(DEVICE_NAME"\tinitialized\n"); err_mem: return ret; }
static int fl2440adc_open (struct inode * inodp, struct file * filp) { unsigned int channel; struct s3c_adc_client * client; DPRINTK("File operations open...\n"); if (filp->f_flags & O_NONBLOCK) // S3C_ADC 驱动中读取时有睡眠的可能, 所以不接受非阻塞的访问 return -EINVAL; channel = MINOR(inodp->i_rdev); mutex_lock(&adc_dev.mutex); if (adc_dev.client[channel]) { mutex_unlock(&adc_dev.mutex); return 0; // 用户空间有可能同一时间段有数个进程都在打开着这个设备 } else { filp->private_data = (void *)channel; } client = s3c_adc_register(adc_dev.pltdev[channel], NULL, NULL, 0); if (IS_ERR(client)) { DPRINTK("Get S3C ADC clietn failed...\n"); adc_dev.client[channel] = NULL; mutex_unlock(&adc_dev.mutex); return PTR_ERR(client); } adc_dev.client[channel] = client; atomic_inc(&adc_dev.client_ref[channel]); mutex_unlock(&adc_dev.mutex); return 0; }
static int instinctq_battery_probe(struct platform_device *pdev) { struct s3c_adc_client *client; struct instinctq_battery_pdata *pdata = pdev->dev.platform_data; struct instinctq_battery *bat; int ret, i, irq; /* Platform data is required */ if (!pdata) { dev_err(&pdev->dev, "no platform data supplied\n"); return -ENODEV; } /* Check GPIOs */ if (!gpio_is_valid(pdata->gpio_pok)) { dev_err(&pdev->dev, "Invalid gpio pin for POK line\n"); return -EINVAL; } if (!gpio_is_valid(pdata->gpio_chg)) { dev_err(&pdev->dev, "Invalid gpio pin for CHG line\n"); return -EINVAL; } if (!gpio_is_valid(pdata->gpio_en)) { dev_err(&pdev->dev, "Invalid gpio pin for EN line\n"); return -EINVAL; } if (!pdata->supply_detect_init) { dev_err(&pdev->dev, "Supply detection is required\n"); return -EINVAL; } /* Register ADC client */ client = s3c_adc_register(pdev, NULL, NULL, 0); if (IS_ERR(client)) { dev_err(&pdev->dev, "could not register adc\n"); return PTR_ERR(client); } /* Allocate driver data */ bat = kzalloc(sizeof(struct instinctq_battery), GFP_KERNEL); if (!bat) { dev_err(&pdev->dev, "could not allocate driver data\n"); ret = -ENOMEM; goto err_free_adc; } /* Claim and setup GPIOs */ ret = gpio_request(pdata->gpio_pok, dev_name(&pdev->dev)); if (ret) { dev_err(&pdev->dev, "Failed to request POK pin: %d\n", ret); goto err_free; } ret = gpio_direction_input(pdata->gpio_pok); if (ret) { dev_err(&pdev->dev, "Failed to set POK to input: %d\n", ret); goto err_gpio_pok_free; } ret = gpio_request(pdata->gpio_chg, dev_name(&pdev->dev)); if (ret) { dev_err(&pdev->dev, "Failed to request CHG pin: %d\n", ret); goto err_gpio_pok_free; } ret = gpio_direction_input(pdata->gpio_chg); if (ret) { dev_err(&pdev->dev, "Failed to set CHG to input: %d\n", ret); goto err_gpio_chg_free; } ret = gpio_request(pdata->gpio_en, dev_name(&pdev->dev)); if (ret) { dev_err(&pdev->dev, "Failed to request EN pin: %d\n", ret); goto err_gpio_chg_free; } ret = gpio_direction_output(pdata->gpio_en, pdata->gpio_en_inverted); if (ret) { dev_err(&pdev->dev, "Failed to set EN to output: %d\n", ret); goto err_gpio_en_free; } platform_set_drvdata(pdev, bat); bat->dev = &pdev->dev; bat->client = client; bat->pdata = pdata; bat->status = POWER_SUPPLY_STATUS_DISCHARGING; bat->health = POWER_SUPPLY_HEALTH_GOOD; bat->supply = instinctq_BATTERY_NONE; bat->interval = BAT_POLL_INTERVAL; bat->calibration = pdata->calibration; ret = create_lookup_table(pdata->percent_lut, pdata->percent_lut_cnt, &bat->percent_lookup); if (ret) { dev_err(&pdev->dev, "could not get create percentage lookup table"); goto err_gpio_en_free; } ret = create_lookup_table(pdata->volt_lut, pdata->volt_lut_cnt, &bat->volt_lookup); if (ret) { dev_err(&pdev->dev, "could not get create voltage lookup table"); goto err_percent_free; } ret = create_lookup_table(pdata->temp_lut, pdata->temp_lut_cnt, &bat->temp_lookup); if (ret) { dev_err(&pdev->dev, "could not get create temperature lookup table"); goto err_volt_free; } INIT_WORK(&bat->work, instinctq_battery_work); INIT_DELAYED_WORK(&bat->poll_work, instinctq_battery_poll); mutex_init(&bat->mutex); #ifdef CONFIG_HAS_WAKELOCK wake_lock_init(&bat->wakelock, WAKE_LOCK_SUSPEND, "battery"); wake_lock_init(&bat->chg_wakelock, WAKE_LOCK_SUSPEND, "charger"); wake_lock_init(&bat->fault_wakelock, WAKE_LOCK_SUSPEND, "battery fault"); wake_lock_init(&bat->suspend_lock, WAKE_LOCK_SUSPEND, "suspend_lock"); #endif #ifdef CONFIG_RTC_INTF_ALARM alarm_init(&bat->alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP, instinctq_battery_alarm); #endif /* Get some initial data for averaging */ for (i = 0; i < NUM_SAMPLES; ++i) { int sample; /* Get a voltage sample from the ADC */ sample = instinctq_battery_adc_read(bat->client, bat->pdata->volt_channel); if (sample < 0) { dev_warn(&pdev->dev, "Failed to get ADC sample.\n"); continue; } sample += bat->compensation; bat->vol_adc = sample; /* Put the sample and get the new average */ bat->volt_value = put_sample_get_avg(&bat->volt_avg, sample); /* Get a temperature sample from the ADC */ sample = instinctq_battery_adc_read(bat->client, bat->pdata->temp_channel); if (sample < 0) { dev_warn(&pdev->dev, "Failed to get ADC sample.\n"); continue; } bat->temp_adc = sample; /* Put the sample and get the new average */ bat->temp_value = put_sample_get_avg(&bat->temp_avg, sample); } bat->percent_value = lookup_value(&bat->percent_lookup, bat->volt_value); bat->volt_value = lookup_value(&bat->volt_lookup, bat->volt_value); bat->temp_value = lookup_value(&bat->temp_lookup, bat->temp_value); bat->last_sample = ktime_get_boottime(); /* Register the power supplies */ for (i = 0; i < instinctq_BATTERY_NUM; ++i) { bat->psy[i] = instinctq_chg_templates[i]; ret = power_supply_register(&pdev->dev, &bat->psy[i]); if (ret < 0) { dev_err(&pdev->dev, "Failed to register power supply %s (%d)\n", bat->psy[i].name, ret); break; } } /* Undo the loop on error */ if (i-- != instinctq_BATTERY_NUM) { for (; i >= 0; --i) power_supply_unregister(&bat->psy[i]); goto err_temp_free; } #ifdef CONFIG_HAS_WAKELOCK ret = device_create_file(bat->psy[instinctq_BATTERY_AC].dev, &dev_attr_suspend_lock); if (ret < 0) { dev_err(&pdev->dev, "Failed to register device attribute.\n"); goto err_psy_unreg; } #endif /* Register the battery */ bat->bat = instinctq_bat_template; ret = power_supply_register(&pdev->dev, &bat->bat); if (ret < 0) { dev_err(&pdev->dev, "Failed to register battery power supply: %d\n", ret); goto err_attr_unreg; } for (i = 0; i < ARRAY_SIZE(battery_attrs); ++i) { ret = device_create_file(bat->bat.dev, battery_attrs[i]); if (ret < 0) break; } if (ret < 0) { for (; i >= 0; --i) device_remove_file(bat->bat.dev, battery_attrs[i]); goto err_bat_unreg; } bat->workqueue = create_freezable_workqueue(dev_name(&pdev->dev)); if (!bat->workqueue) { dev_err(&pdev->dev, "Failed to create freezeable workqueue\n"); ret = -ENOMEM; goto err_remove_bat_attr; } /* Claim IRQs */ irq = gpio_to_irq(pdata->gpio_pok); if (irq <= 0) { dev_err(&pdev->dev, "POK irq invalid.\n"); goto err_destroy_workqueue; } bat->irq_pok = irq; ret = request_irq(irq, instinctq_charger_irq, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, dev_name(&pdev->dev), bat); if (ret) { dev_err(&pdev->dev, "Failed to request POK irq (%d)\n", ret); goto err_destroy_workqueue; } ret = request_irq(IRQ_BATF, instinctq_battery_fault_irq, 0, dev_name(&pdev->dev), bat); if (ret) { dev_err(&pdev->dev, "Failed to request battery fault irq (%d)\n", ret); goto err_pok_irq_free; } enable_irq_wake(bat->irq_pok); instinctq_battery_set_fault_enable(1); /* Finish */ dev_info(&pdev->dev, "successfully loaded\n"); device_init_wakeup(&pdev->dev, 1); pdata->supply_detect_init(instinctq_battery_supply_notify); /* Schedule work to check current status */ #ifdef CONFIG_HAS_WAKELOCK wake_lock(&bat->wakelock); #endif queue_work(bat->workqueue, &bat->work); return 0; err_pok_irq_free: free_irq(bat->irq_pok, bat); err_destroy_workqueue: destroy_workqueue(bat->workqueue); err_remove_bat_attr: for (i = 0; i < ARRAY_SIZE(battery_attrs); ++i) device_remove_file(bat->bat.dev, battery_attrs[i]); err_bat_unreg: power_supply_unregister(&bat->bat); err_attr_unreg: #ifdef CONFIG_HAS_WAKELOCK device_remove_file(bat->psy[instinctq_BATTERY_AC].dev, &dev_attr_suspend_lock); err_psy_unreg: #endif for (i = 0; i < instinctq_BATTERY_NUM; ++i) power_supply_unregister(&bat->psy[i]); err_temp_free: #ifdef CONFIG_HAS_WAKELOCK wake_lock_destroy(&bat->wakelock); wake_lock_destroy(&bat->chg_wakelock); wake_lock_destroy(&bat->fault_wakelock); wake_lock_destroy(&bat->suspend_lock); #endif kfree(bat->temp_lookup.table); err_volt_free: kfree(bat->volt_lookup.table); err_percent_free: kfree(bat->percent_lookup.table); err_gpio_en_free: gpio_free(pdata->gpio_en); err_gpio_chg_free: gpio_free(pdata->gpio_chg); err_gpio_pok_free: gpio_free(pdata->gpio_pok); err_free: kfree(bat); err_free_adc: s3c_adc_release(client); return ret; }
/** * s3c_hwmon_probe - device probe entry. * @dev: The device being probed. */ static int __devinit s3c_hwmon_probe(struct platform_device *dev) { struct s3c_hwmon_pdata *pdata = dev->dev.platform_data; struct s3c_hwmon *hwmon; int ret = 0; int i; if (!pdata) { dev_err(&dev->dev, "no platform data supplied\n"); return -EINVAL; } shwmon = hwmon = kzalloc(sizeof(struct s3c_hwmon), GFP_KERNEL); if (hwmon == NULL) { dev_err(&dev->dev, "no memory\n"); return -ENOMEM; } platform_set_drvdata(dev, hwmon); mutex_init(&hwmon->lock); /* Register with the core ADC driver. */ hwmon->client = s3c_adc_register(dev, NULL, NULL, 0); if (IS_ERR(hwmon->client)) { dev_err(&dev->dev, "cannot register adc\n"); ret = PTR_ERR(hwmon->client); goto err_mem; } /* add attributes for our adc devices. */ ret = s3c_hwmon_add_raw(&dev->dev); if (ret) goto err_registered; /* register with the hwmon core */ hwmon->hwmon_dev = hwmon_device_register(&dev->dev); if (IS_ERR(hwmon->hwmon_dev)) { dev_err(&dev->dev, "error registering with hwmon\n"); ret = PTR_ERR(hwmon->hwmon_dev); goto err_raw_attribute; } for (i = 0; i < ARRAY_SIZE(pdata->in); i++) { struct s3c_hwmon_chcfg *cfg = pdata->in[i]; if (!cfg) continue; if (cfg->mult >= 0x10000) dev_warn(&dev->dev, "channel %d multiplier too large\n", i); if (cfg->div == 0) { dev_err(&dev->dev, "channel %d divider zero\n", i); continue; } ret = s3c_hwmon_create_attr(&dev->dev, pdata->in[i], &hwmon->attrs[i], i); if (ret) { dev_err(&dev->dev, "error creating channel %d\n", i); for (i--; i >= 0; i--) s3c_hwmon_remove_attr(&dev->dev, &hwmon->attrs[i]); goto err_hwmon_register; } } return 0; err_hwmon_register: hwmon_device_unregister(hwmon->hwmon_dev); err_raw_attribute: s3c_hwmon_remove_raw(&dev->dev); err_registered: s3c_adc_release(hwmon->client); err_mem: kfree(hwmon); return ret; }
void __init exynos4_smdk4270_charger_init(void) { pr_info("%s: harrison charger init\n", __func__); platform_add_devices(sec_battery_devices, ARRAY_SIZE(sec_battery_devices)); if (system_rev < 8) { i2c_register_board_info(CHG_ID, sec_brdinfo_charger, ARRAY_SIZE(sec_brdinfo_charger)); sec_battery_pdata.chg_float_voltage = 4350; } else { i2c_register_board_info(CHG_ID, sec_brdinfo_charger_smb328, ARRAY_SIZE(sec_brdinfo_charger_smb328)); sec_battery_pdata.chg_float_voltage = 4340; } if (system_rev > 9) { #if defined(CONFIG_MACH_DELOSLTE_KOR_SKT) || defined(CONFIG_MACH_DELOSLTE_KOR_KT) || \ defined(CONFIG_MACH_DELOSLTE_KOR_LGT) sec_battery_pdata.temp_high_threshold_event = 660; sec_battery_pdata.temp_high_recovery_event = 415; sec_battery_pdata.temp_low_threshold_event = -45; sec_battery_pdata.temp_low_recovery_event = 0; sec_battery_pdata.temp_high_threshold_normal = 660; sec_battery_pdata.temp_high_recovery_normal = 415; sec_battery_pdata.temp_low_threshold_normal = -45; sec_battery_pdata.temp_low_recovery_normal = 0; sec_battery_pdata.temp_high_threshold_lpm = 660; sec_battery_pdata.temp_high_recovery_lpm = 415; sec_battery_pdata.temp_low_threshold_lpm = -45; sec_battery_pdata.temp_low_recovery_lpm = 0; #else sec_battery_pdata.temp_high_threshold_event = 610; sec_battery_pdata.temp_high_recovery_event = 430; sec_battery_pdata.temp_low_threshold_event = -40; sec_battery_pdata.temp_low_recovery_event = 20; sec_battery_pdata.temp_high_threshold_normal = 480; sec_battery_pdata.temp_high_recovery_normal = 430; sec_battery_pdata.temp_low_threshold_normal = -40; sec_battery_pdata.temp_low_recovery_normal = 20; sec_battery_pdata.temp_high_threshold_lpm = 480; sec_battery_pdata.temp_high_recovery_lpm = 450; sec_battery_pdata.temp_low_threshold_lpm = -30; sec_battery_pdata.temp_low_recovery_lpm = 0; #endif } #if defined(CONFIG_MACH_DELOSLTE_KOR_SKT) || defined(CONFIG_MACH_DELOSLTE_KOR_KT) || \ defined(CONFIG_MACH_DELOSLTE_KOR_LGT) if (system_rev == 11 || system_rev == 12) { stc3115_battery_data[0].CC_cnf = 960; stc3115_battery_data[0].Rsense = 24; pr_info("%s: temp CC_cnf(%d), Rsense(%d)", __func__, stc3115_battery_data[0].CC_cnf, stc3115_battery_data[0].Rsense); } else if (system_rev == 13 || system_rev == 14 || system_rev == 15) { stc3115_battery_data[0].CC_cnf = 448; stc3115_battery_data[0].VM_cnf = 413; stc3115_battery_data[0].Rsense = 11; pr_info("%s: temp CC_cnf(%d), VM_cnf(%d), Rsense(%d)", __func__, stc3115_battery_data[0].CC_cnf, stc3115_battery_data[0].VM_cnf, stc3115_battery_data[0].Rsense); } sec_battery_pdata.recharge_condition_type = SEC_BATTERY_RECHARGE_CONDITION_AVGVCELL; #endif i2c_register_board_info(FG_ID, sec_brdinfo_fuelgauge, ARRAY_SIZE(sec_brdinfo_fuelgauge)); temp_adc_client = s3c_adc_register(&sec_device_battery, NULL, NULL, 0); }
static int gp2a_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = -ENODEV; struct input_dev *input_dev; struct gp2a_data *gp2a; struct gp2a_platform_data *pdata = client->dev.platform_data; pr_info("==============================\n"); pr_info("========= GP2A =======\n"); pr_info("==============================\n"); if (!pdata) { pr_err("%s: missing pdata!\n", __func__); return ret; } /* if (!pdata->power || !pdata->light_adc_value) { pr_err("%s: incomplete pdata!\n", __func__); return ret; } */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s: i2c functionality check failed!\n", __func__); return ret; } gp2a = kzalloc(sizeof(struct gp2a_data), GFP_KERNEL); if (!gp2a) { pr_err("%s: failed to alloc memory for module data\n", __func__); return -ENOMEM; } #if defined(CONFIG_OPTICAL_WAKE_ENABLE) if (system_rev >= 0x03) { pr_info("GP2A Reset GPIO = GPX0(1) (rev%02d)\n", system_rev); gp2a->enable_wakeup = true; } else { pr_info("GP2A Reset GPIO = GPL0(6) (rev%02d)\n", system_rev); gp2a->enable_wakeup = false; } #else gp2a->enable_wakeup = false; #endif gp2a->pdata = pdata; gp2a->i2c_client = client; i2c_set_clientdata(client, gp2a); /* wake lock init */ wake_lock_init(&gp2a->prx_wake_lock, WAKE_LOCK_SUSPEND, "prx_wake_lock"); mutex_init(&gp2a->power_mutex); mutex_init(&gp2a->adc_mutex); ret = gp2a_setup_irq(gp2a); if (ret) { pr_err("%s: could not setup irq\n", __func__); goto err_setup_irq; } /* allocate proximity input_device */ input_dev = input_allocate_device(); if (!input_dev) { pr_err("%s: could not allocate input device\n", __func__); goto err_input_allocate_device_proximity; } gp2a->proximity_input_dev = input_dev; input_set_drvdata(input_dev, gp2a); input_dev->name = "proximity_sensor"; input_set_capability(input_dev, EV_ABS, ABS_DISTANCE); input_set_abs_params(input_dev, ABS_DISTANCE, 0, 1, 0, 0); gp2a_dbgmsg("registering proximity input device\n"); ret = input_register_device(input_dev); if (ret < 0) { pr_err("%s: could not register input device\n", __func__); input_free_device(input_dev); goto err_input_register_device_proximity; } ret = sysfs_create_group(&input_dev->dev.kobj, &proximity_attribute_group); if (ret) { pr_err("%s: could not create sysfs group\n", __func__); goto err_sysfs_create_group_proximity; } /* hrtimer settings. we poll for light values using a timer. */ hrtimer_init(&gp2a->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); gp2a->light_poll_delay = ns_to_ktime(LIGHT_TIMER_PERIOD_MS * NSEC_PER_MSEC); gp2a->timer.function = gp2a_timer_func; /* the timer just fires off a work queue request. we need a thread to read the i2c (can be slow and blocking). */ gp2a->wq = create_singlethread_workqueue("gp2a_wq"); if (!gp2a->wq) { ret = -ENOMEM; pr_err("%s: could not create workqueue\n", __func__); goto err_create_workqueue; } /* this is the thread function we run on the work queue */ INIT_WORK(&gp2a->work_light, gp2a_work_func_light); #ifdef GP2A_MODE_B /* this is the thread function we run on the work queue */ INIT_WORK(&gp2a->work_proximity, gp2a_work_func_proximity); #endif /* allocate lightsensor-level input_device */ input_dev = input_allocate_device(); if (!input_dev) { pr_err("%s: could not allocate input device\n", __func__); ret = -ENOMEM; goto err_input_allocate_device_light; } input_set_drvdata(input_dev, gp2a); input_dev->name = "light_sensor"; input_set_capability(input_dev, EV_ABS, ABS_MISC); input_set_abs_params(input_dev, ABS_MISC, 0, 1, 0, 0); gp2a_dbgmsg("registering lightsensor-level input device\n"); ret = input_register_device(input_dev); if (ret < 0) { pr_err("%s: could not register input device\n", __func__); input_free_device(input_dev); goto err_input_register_device_light; } gp2a->light_input_dev = input_dev; ret = sysfs_create_group(&input_dev->dev.kobj, &light_attribute_group); if (ret) { pr_err("%s: could not create sysfs group\n", __func__); goto err_sysfs_create_group_light; } /* alloc platform device for adc client */ pdev_gp2a_adc = platform_device_alloc("gp2a-adc", -1); if (!pdev_gp2a_adc) { pr_err("%s: could not allocation pdev_gp2a_adc.\n", __func__); ret = -ENOMEM; goto err_platform_allocate_device_adc; } /* Register adc client */ gp2a->padc = s3c_adc_register(pdev_gp2a_adc, NULL, NULL, 0); if (IS_ERR(gp2a->padc)) { dev_err(&pdev_gp2a_adc->dev, "cannot register adc\n"); ret = PTR_ERR(gp2a->padc); goto err_platform_register_device_adc; } /* set sysfs for light sensor */ ret = misc_register(&light_device); if (ret) pr_err(KERN_ERR "misc_register failed - light\n"); gp2a->lightsensor_class = class_create(THIS_MODULE, "lightsensor"); if (IS_ERR(gp2a->lightsensor_class)) pr_err("Failed to create class(lightsensor)!\n"); gp2a->switch_cmd_dev = device_create(gp2a->lightsensor_class, NULL, 0, NULL, "switch_cmd"); if (IS_ERR(gp2a->switch_cmd_dev)) pr_err("Failed to create device(switch_cmd_dev)!\n"); if (device_create_file(gp2a->switch_cmd_dev, &dev_attr_lightsensor_file_illuminance) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_lightsensor_file_illuminance.attr.name); dev_set_drvdata(gp2a->switch_cmd_dev, gp2a); /* set initial proximity value as 1 */ input_report_abs(gp2a->proximity_input_dev, ABS_DISTANCE, 1); input_sync(gp2a->proximity_input_dev); gp2a->adc_total = 0; goto done; /* error, unwind it all */ err_sysfs_create_group_light: input_unregister_device(gp2a->light_input_dev); err_input_register_device_light: err_input_allocate_device_light: destroy_workqueue(gp2a->wq); err_platform_allocate_device_adc: platform_device_unregister(pdev_gp2a_adc); err_platform_register_device_adc: s3c_adc_release(gp2a->padc); err_create_workqueue: sysfs_remove_group(&gp2a->proximity_input_dev->dev.kobj, &proximity_attribute_group); err_sysfs_create_group_proximity: input_unregister_device(gp2a->proximity_input_dev); err_input_register_device_proximity: err_input_allocate_device_proximity: free_irq(gp2a->irq, 0); gpio_free(gp2a->pdata->p_out); err_setup_irq: mutex_destroy(&gp2a->adc_mutex); mutex_destroy(&gp2a->power_mutex); wake_lock_destroy(&gp2a->prx_wake_lock); kfree(gp2a); done: return ret; }
static __devinit int samsung_battery_probe(struct platform_device *pdev) { struct battery_info *info; int ret = 0; char *temper_src_name[] = { "fuelgauge", "ap adc", "ext adc", "unknown" }; pr_info("%s: SAMSUNG Battery Driver Loading\n", __func__); info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) return -ENOMEM; platform_set_drvdata(pdev, info); info->dev = &pdev->dev; info->pdata = pdev->dev.platform_data; /* Check charger name and fuelgauge name. */ if (!info->pdata->charger_name || !info->pdata->fuelgauge_name) { pr_err("%s: no charger or fuel gauge name\n", __func__); goto err_kfree; } info->charger_name = info->pdata->charger_name; info->fuelgauge_name = info->pdata->fuelgauge_name; #if defined(CONFIG_CHARGER_MAX8922_U1) if (system_rev >= 2) info->sub_charger_name = info->pdata->sub_charger_name; #endif pr_info("%s: Charger name: %s\n", __func__, info->charger_name); pr_info("%s: Fuelgauge name: %s\n", __func__, info->fuelgauge_name); #if defined(CONFIG_CHARGER_MAX8922_U1) if (system_rev >= 2) pr_info("%s: SubCharger name: %s\n", __func__, info->sub_charger_name); #endif info->psy_charger = power_supply_get_by_name(info->charger_name); info->psy_fuelgauge = power_supply_get_by_name(info->fuelgauge_name); #if defined(CONFIG_CHARGER_MAX8922_U1) if (system_rev >= 2) info->psy_sub_charger = power_supply_get_by_name(info->sub_charger_name); #endif if (!info->psy_charger || !info->psy_fuelgauge) { pr_err("%s: fail to get power supply\n", __func__); goto err_kfree; } /* WORKAROUND: set battery pdata in driver */ if (system_rev == 3) { info->pdata->temper_src = TEMPER_EXT_ADC; info->pdata->temper_ch = 7; } pr_info("%s: Temperature source: %s\n", __func__, temper_src_name[info->pdata->temper_src]); /* recalculate recharge voltage, it depends on max voltage value */ info->pdata->recharge_voltage = info->pdata->voltage_max - 50; pr_info("%s: Recharge voltage: %d\n", __func__, info->pdata->recharge_voltage); #if defined(CONFIG_S3C_ADC) #if defined(CONFIG_MACH_S2PLUS) if (system_rev >= 2) #endif /* adc register */ info->adc_client = s3c_adc_register(pdev, NULL, NULL, 0); #endif /* init battery info */ info->full_charged_state = false; info->abstimer_state = false; info->recharge_phase = false; info->siop_charge_current = CHARGER_USB_CURRENT; info->monitor_mode = MONITOR_NORM; info->led_state = BATT_LED_DISCHARGING; /* LPM charging state */ info->lpm_state = lpcharge; wake_lock_init(&info->monitor_wake_lock, WAKE_LOCK_SUSPEND, "battery-monitor"); wake_lock_init(&info->emer_wake_lock, WAKE_LOCK_SUSPEND, "battery-emergency"); if (!info->pdata->suspend_chging) wake_lock_init(&info->charge_wake_lock, WAKE_LOCK_SUSPEND, "battery-charging"); /* Init wq for battery */ INIT_WORK(&info->error_work, battery_error_work); INIT_WORK(&info->monitor_work, battery_monitor_work); /* Init Power supply class */ info->psy_bat.name = "battery"; info->psy_bat.type = POWER_SUPPLY_TYPE_BATTERY; info->psy_bat.properties = samsung_battery_props; info->psy_bat.num_properties = ARRAY_SIZE(samsung_battery_props); info->psy_bat.get_property = samsung_battery_get_property; info->psy_bat.set_property = samsung_battery_set_property; info->psy_usb.name = "usb"; info->psy_usb.type = POWER_SUPPLY_TYPE_USB; info->psy_usb.supplied_to = supply_list; info->psy_usb.num_supplicants = ARRAY_SIZE(supply_list); info->psy_usb.properties = samsung_power_props; info->psy_usb.num_properties = ARRAY_SIZE(samsung_power_props); info->psy_usb.get_property = samsung_usb_get_property; info->psy_ac.name = "ac"; info->psy_ac.type = POWER_SUPPLY_TYPE_MAINS; info->psy_ac.supplied_to = supply_list; info->psy_ac.num_supplicants = ARRAY_SIZE(supply_list); info->psy_ac.properties = samsung_power_props; info->psy_ac.num_properties = ARRAY_SIZE(samsung_power_props); info->psy_ac.get_property = samsung_ac_get_property; ret = power_supply_register(&pdev->dev, &info->psy_bat); if (ret) { pr_err("%s: failed to register psy_bat\n", __func__); goto err_psy_reg_bat; } ret = power_supply_register(&pdev->dev, &info->psy_usb); if (ret) { pr_err("%s: failed to register psy_usb\n", __func__); goto err_psy_reg_usb; } ret = power_supply_register(&pdev->dev, &info->psy_ac); if (ret) { pr_err("%s: failed to register psy_ac\n", __func__); goto err_psy_reg_ac; } /* Using android alarm for gauging instead of workqueue */ info->last_poll = alarm_get_elapsed_realtime(); alarm_init(&info->alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP, samsung_battery_alarm_start); /* update battery init status */ schedule_work(&info->monitor_work); /* Create samsung detail attributes */ battery_create_attrs(info->psy_bat.dev); pr_info("%s: SAMSUNG Battery Driver Loaded\n", __func__); return 0; err_psy_reg_ac: power_supply_unregister(&info->psy_usb); err_psy_reg_usb: power_supply_unregister(&info->psy_bat); err_psy_reg_bat: wake_lock_destroy(&info->monitor_wake_lock); wake_lock_destroy(&info->emer_wake_lock); if (!info->pdata->suspend_chging) wake_lock_destroy(&info->charge_wake_lock); err_kfree: kfree(info); return ret; }
static bool sec_bat_adc_ap_init(struct platform_device *pdev) { adc_client = s3c_adc_register(pdev, NULL, NULL, 0); return true; }
static int __devinit s3c_adc_bat_probe(struct platform_device *pdev) { struct s3c_adc_client *client; struct s3c_adc_bat_pdata *pdata = pdev->dev.platform_data; int ret; client = s3c_adc_register(pdev, NULL, NULL, 0); if (IS_ERR(client)) { dev_err(&pdev->dev, "cannot register adc\n"); return PTR_ERR(client); } platform_set_drvdata(pdev, client); main_bat.client = client; main_bat.pdata = pdata; main_bat.volt_value = -1; main_bat.cur_value = -1; main_bat.cable_plugged = 0; main_bat.status = POWER_SUPPLY_STATUS_DISCHARGING; ret = power_supply_register(&pdev->dev, &main_bat.psy); if (ret) goto err_reg_main; if (pdata->backup_volt_mult) { backup_bat.client = client; backup_bat.pdata = pdev->dev.platform_data; backup_bat.volt_value = -1; ret = power_supply_register(&pdev->dev, &backup_bat.psy); if (ret) goto err_reg_backup; } INIT_DELAYED_WORK(&bat_work, s3c_adc_bat_work); if (pdata->gpio_charge_finished >= 0) { ret = gpio_request(pdata->gpio_charge_finished, "charged"); if (ret) goto err_gpio; ret = request_irq(gpio_to_irq(pdata->gpio_charge_finished), s3c_adc_bat_charged, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "battery charged", NULL); if (ret) goto err_irq; } if (pdata->init) { ret = pdata->init(); if (ret) goto err_platform; } dev_info(&pdev->dev, "successfully loaded\n"); device_init_wakeup(&pdev->dev, 1); schedule_delayed_work(&bat_work, msecs_to_jiffies(JITTER_DELAY)); return 0; err_platform: if (pdata->gpio_charge_finished >= 0) free_irq(gpio_to_irq(pdata->gpio_charge_finished), NULL); err_irq: if (pdata->gpio_charge_finished >= 0) gpio_free(pdata->gpio_charge_finished); err_gpio: if (pdata->backup_volt_mult) power_supply_unregister(&backup_bat.psy); err_reg_backup: power_supply_unregister(&main_bat.psy); err_reg_main: return ret; }
static int __devinit gpio_switch_probe(struct platform_device *pdev) { struct gpio_switch_platform_data *pdata = pdev->dev.platform_data; int ret = 0; if (!pdata) return -EBUSY; switch_data = kzalloc(sizeof(struct gpio_switch_data), GFP_KERNEL); if (!switch_data) return -ENOMEM; platform_set_drvdata(pdev, switch_data); switch_data->sdev.name = pdata->name; switch_data->gpio = pdata->gpio; switch_data->name_on = pdata->name_on; switch_data->name_off = pdata->name_off; switch_data->state_on = pdata->state_on; switch_data->state_off = pdata->state_off; switch_data->sdev.print_state = switch_gpio_print_state; switch_data->active_level = pdata->active_level; switch_data->adc_channel = pdata->adc_channel; ret = switch_dev_register(&switch_data->sdev); if (ret < 0) goto err_switch_dev_register; ret = gpio_request(switch_data->gpio, pdev->name); if (ret < 0) goto err_request_gpio; ret = gpio_direction_input(switch_data->gpio); if (ret < 0) goto err_set_gpio_input; INIT_DELAYED_WORK(&switch_data->del_work, gpio_switch_work); INIT_WORK(&mic_adc_work, mic_adc_work_func); mic_input_dev = input_allocate_device(); mic_input_dev->name = "mx-mic-input"; mic_input_dev->phys = "mx-mic-input/input0"; if (input_register_device(mic_input_dev) != 0) { input_free_device(mic_input_dev); goto err_request_irq; } set_bit(EV_KEY, mic_input_dev->evbit); set_bit(KEY_FORWARDMAIL, mic_input_dev->keybit); switch_data->client = s3c_adc_register(pdev, NULL, NULL, 0); if (IS_ERR(switch_data->client)) { dev_err(&pdev->dev, "cannot register adc\n"); ret = PTR_ERR(switch_data->client); goto err_request_adc; } setup_timer(&detect_mic_adc_timer, mic_adc_detect_timer_func, 0); s3c_gpio_setpull(switch_data->gpio, S3C_GPIO_PULL_UP); switch_data->irq = gpio_to_irq(switch_data->gpio); if (switch_data->irq < 0) { ret = switch_data->irq; goto err_detect_irq_num_failed; } ret = request_threaded_irq(switch_data->irq, NULL, gpio_irq_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, pdev->name, switch_data); if (ret < 0) goto err_request_irq; #ifdef CONFIG_EARLYSUSPEND switch_data->early_suspends.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN; switch_data->early_suspends.suspend = gpio_switch_early_suspend; switch_data->early_suspends.resume= gpio_switch_late_resume; register_early_suspend(&switch_data->early_suspends); #endif schedule_delayed_work(&switch_data->del_work, msecs_to_jiffies(10)); return 0; err_request_irq: s3c_adc_release(switch_data->client); err_request_adc: err_detect_irq_num_failed: err_set_gpio_input: gpio_free(switch_data->gpio); err_request_gpio: switch_dev_unregister(&switch_data->sdev); err_switch_dev_register: kfree(switch_data); return ret; }
static int acc_con_probe(struct platform_device *pdev) { struct acc_con_info *acc; struct acc_con_platform_data *pdata = pdev->dev.platform_data; struct regulator *vadc_regulator; int retval; ACC_CONDEV_DBG(""); if (pdata == NULL) { pr_err("%s: no pdata\n", __func__); return -ENODEV; } #ifdef CONFIG_REGULATOR /* LDO1 regulator ON */ vadc_regulator = regulator_get(&pdev->dev, "vadc_3.3v"); if (IS_ERR(vadc_regulator)) { printk(KERN_ERR "failed to get resource %s\n", "vadc_3.3v"); return PTR_ERR(vadc_regulator); } regulator_enable(vadc_regulator); #endif acc = kzalloc(sizeof(*acc), GFP_KERNEL); if (!acc) return -ENOMEM; acc->pdata = pdata; acc->current_dock = DOCK_NONE; acc->current_accessory = ACCESSORY_NONE; #ifdef CONFIG_MHL_SII9234 acc->mhl_irq = gpio_to_irq(pdata->mhl_irq_gpio); acc->mhl_pwr_state = false; #endif mutex_init(&acc->lock); dev_set_drvdata(&pdev->dev, acc); acc->acc_dev = &pdev->dev; /* Register adc client */ acc->padc = s3c_adc_register(pdev, NULL, NULL, 0); #ifdef CONFIG_MHL_SII9234 retval = i2c_add_driver(&SII9234A_i2c_driver); if (retval) { pr_err("[MHL SII9234A] can't add i2c driver\n"); goto err_i2c_a; } else { pr_info("[MHL SII9234A] add i2c driver\n"); } retval = i2c_add_driver(&SII9234B_i2c_driver); if (retval) { pr_err("[MHL SII9234B] can't add i2c driver\n"); goto err_i2c_b; } else { pr_info("[MHL SII9234B] add i2c driver\n"); } retval = i2c_add_driver(&SII9234C_i2c_driver); if (retval) { pr_err("[MHL SII9234C] can't add i2c driver\n"); goto err_i2c_c; } else { pr_info("[MHL SII9234C] add i2c driver\n"); } retval = i2c_add_driver(&SII9234_i2c_driver); if (retval) { pr_err("[MHL SII9234] can't add i2c driver\n"); goto err_i2c; } else { pr_info("[MHL SII9234] add i2c driver\n"); } #endif acc->dock_switch.name = "dock"; retval = switch_dev_register(&acc->dock_switch); if (retval < 0) goto err_sw_dock; acc->ear_jack_switch.name = "usb_audio"; retval = switch_dev_register(&acc->ear_jack_switch); if (retval < 0) goto err_sw_jack; wake_lock_init(&acc->wake_lock, WAKE_LOCK_SUSPEND, "30pin_con"); INIT_DELAYED_WORK(&acc->acc_dwork, acc_dwork_int_init); schedule_delayed_work(&acc->acc_dwork, msecs_to_jiffies(10000)); INIT_DELAYED_WORK(&acc->acc_id_dwork, acc_dwork_accessory_detect); #ifdef CONFIG_MHL_SII9234 if (device_create_file(acc->acc_dev, &dev_attr_MHD_file) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_MHD_file.attr.name); #endif return 0; #ifndef CONFIG_SEC_KEYBOARD_DOCK err_irq_acc: free_irq(acc->accessory_irq, acc); err_irq_dock: switch_dev_unregister(&acc->ear_jack_switch); #endif err_sw_jack: switch_dev_unregister(&acc->dock_switch); err_sw_dock: #ifdef CONFIG_MHL_SII9234 i2c_del_driver(&SII9234_i2c_driver); err_i2c: i2c_del_driver(&SII9234C_i2c_driver); err_i2c_c: i2c_del_driver(&SII9234B_i2c_driver); err_i2c_b: i2c_del_driver(&SII9234A_i2c_driver); err_i2c_a: #endif kfree(acc); return retval; }