static int cm3663_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = -ENODEV;
struct input_dev *input_dev;
struct cm3663_data *cm3663;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s: i2c functionality check failed!\n", __func__);
return ret;
}
cm3663 = kzalloc(sizeof(struct cm3663_data), GFP_KERNEL);
if (!cm3663) {
pr_err("%s: failed to alloc memory for module data\n",
__func__);
return -ENOMEM;
}
cm3663->pdata = client->dev.platform_data;
cm3663->i2c_client = client;
i2c_set_clientdata(client, cm3663);
/* wake lock init */
wake_lock_init(&cm3663->prx_wake_lock, WAKE_LOCK_SUSPEND,
"prx_wake_lock");
mutex_init(&cm3663->power_lock);
/* setup initial registers */
ret = cm3663_setup_reg(cm3663);
if (ret < 0) {
pr_err("%s: could not setup regs\n", __func__);
goto err_setup_reg;
}
ret = cm3663_setup_irq(cm3663);
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;
}
cm3663->proximity_input_dev = input_dev;
input_set_drvdata(input_dev, cm3663);
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);
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;
}
/* light_timer settings. we poll for light values using a timer. */
hrtimer_init(&cm3663->light_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
cm3663->light_poll_delay = ns_to_ktime(200 * NSEC_PER_MSEC);
cm3663->light_timer.function = cm3663_light_timer_func;
/* prox_timer settings. we poll for light values using a timer. */
hrtimer_init(&cm3663->prox_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
cm3663->prox_poll_delay = ns_to_ktime(2000 * NSEC_PER_MSEC);
cm3663->prox_timer.function = cm3663_prox_timer_func;
/* the timer just fires off a work queue request. we need a thread
to read the i2c (can be slow and blocking). */
cm3663->light_wq = create_singlethread_workqueue("cm3663_light_wq");
if (!cm3663->light_wq) {
ret = -ENOMEM;
pr_err("%s: could not create light workqueue\n", __func__);
goto err_create_light_workqueue;
}
cm3663->prox_wq = create_singlethread_workqueue("cm3663_prox_wq");
if (!cm3663->prox_wq) {
ret = -ENOMEM;
pr_err("%s: could not create prox workqueue\n", __func__);
goto err_create_prox_workqueue;
}
/* this is the thread function we run on the work queue */
INIT_WORK(&cm3663->work_light, cm3663_work_func_light);
INIT_WORK(&cm3663->work_prox, cm3663_work_func_prox);
/* 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, cm3663);
input_dev->name = "light_sensor";
#if defined(CONFIG_MACH_S2PLUS)
input_set_capability(input_dev, EV_REL, REL_MISC);
#else
input_set_capability(input_dev, EV_ABS, ABS_MISC);
input_set_abs_params(input_dev, ABS_MISC, 0, 1, 0, 0);
#endif
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;
}
cm3663->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;
}
#if defined(CONFIG_MACH_S2PLUS)
/* set sysfs for proximity sensor */
cm3663->proximity_dev = sensors_classdev_register("proximity_sensor");
if (IS_ERR(cm3663->proximity_dev)) {
pr_err("%s: could not create proximity_dev\n", __func__);
goto err_proximity_classdev_create;
}
if (device_create_file(cm3663->proximity_dev,
&dev_attr_state) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_state.attr.name);
goto err_proximity_device_create_file1;
}
if (device_create_file(cm3663->proximity_dev,
&dev_attr_prox_avg) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_prox_avg.attr.name);
goto err_proximity_device_create_file2;
}
dev_set_drvdata(cm3663->proximity_dev, cm3663);
/* set sysfs for light sensor */
cm3663->switch_cmd_dev = sensors_classdev_register("light_sensor");
if (IS_ERR(cm3663->switch_cmd_dev)) {
pr_err("%s: could not create switch_cmd_dev\n", __func__);
goto err_light_classdev_create;
}
if (device_create_file(cm3663->switch_cmd_dev,
&dev_attr_lux) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_lux.attr.name);
goto err_light_device_create_file;
}
dev_set_drvdata(cm3663->switch_cmd_dev, cm3663);
#else
/* set sysfs for proximity sensor */
cm3663->proximity_class = class_create(THIS_MODULE, "proximity");
if (IS_ERR(cm3663->proximity_class)) {
pr_err("%s: could not create proximity_class\n", __func__);
goto err_proximity_class_create;
}
cm3663->proximity_dev = device_create(cm3663->proximity_class,
NULL, 0, NULL, "proximity");
if (IS_ERR(cm3663->proximity_dev)) {
pr_err("%s: could not create proximity_dev\n", __func__);
goto err_proximity_device_create;
}
if (device_create_file(cm3663->proximity_dev,
&dev_attr_proximity_state) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_proximity_state.attr.name);
goto err_proximity_device_create_file1;
}
if (device_create_file(cm3663->proximity_dev,
&dev_attr_proximity_avg) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_proximity_avg.attr.name);
goto err_proximity_device_create_file2;
}
dev_set_drvdata(cm3663->proximity_dev, cm3663);
/* set sysfs for light sensor */
cm3663->lightsensor_class = class_create(THIS_MODULE, "lightsensor");
if (IS_ERR(cm3663->lightsensor_class)) {
pr_err("%s: could not create lightsensor_class\n", __func__);
goto err_light_class_create;
}
cm3663->switch_cmd_dev = device_create(cm3663->lightsensor_class,
NULL, 0, NULL, "switch_cmd");
if (IS_ERR(cm3663->switch_cmd_dev)) {
pr_err("%s: could not create switch_cmd_dev\n", __func__);
goto err_light_device_create;
}
if (device_create_file(cm3663->switch_cmd_dev,
&dev_attr_lightsensor_file_state) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_lightsensor_file_state.attr.name);
goto err_light_device_create_file;
}
dev_set_drvdata(cm3663->switch_cmd_dev, cm3663);
#endif
goto done;
/* error, unwind it all */
#if defined(CONFIG_MACH_S2PLUS)
err_light_device_create_file:
sensors_classdev_unregister(cm3663->switch_cmd_dev);
err_light_classdev_create:
device_remove_file(cm3663->proximity_dev, &dev_attr_prox_avg);
err_proximity_device_create_file2:
device_remove_file(cm3663->proximity_dev, &dev_attr_state);
err_proximity_device_create_file1:
sensors_classdev_unregister(cm3663->proximity_dev);
err_proximity_classdev_create:
#else
err_light_device_create_file:
device_destroy(cm3663->lightsensor_class, 0);
err_light_device_create:
class_destroy(cm3663->lightsensor_class);
err_light_class_create:
device_remove_file(cm3663->proximity_dev, &dev_attr_proximity_avg);
err_proximity_device_create_file2:
device_remove_file(cm3663->proximity_dev, &dev_attr_proximity_state);
err_proximity_device_create_file1:
device_destroy(cm3663->proximity_class, 0);
err_proximity_device_create:
class_destroy(cm3663->proximity_class);
err_proximity_class_create:
#endif
sysfs_remove_group(&input_dev->dev.kobj,
&light_attribute_group);
err_sysfs_create_group_light:
input_unregister_device(cm3663->light_input_dev);
err_input_register_device_light:
err_input_allocate_device_light:
destroy_workqueue(cm3663->prox_wq);
err_create_prox_workqueue:
destroy_workqueue(cm3663->light_wq);
err_create_light_workqueue:
sysfs_remove_group(&cm3663->proximity_input_dev->dev.kobj,
&proximity_attribute_group);
err_sysfs_create_group_proximity:
input_unregister_device(cm3663->proximity_input_dev);
err_input_register_device_proximity:
err_input_allocate_device_proximity:
free_irq(cm3663->irq, 0);
err_setup_irq:
err_setup_reg:
mutex_destroy(&cm3663->power_lock);
wake_lock_destroy(&cm3663->prx_wake_lock);
kfree(cm3663);
done:
return ret;
}
static inline void deinit_suspend(void)
{
wake_lock_destroy(&mt9t013_wake_lock);
}
static int pn547_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret;
int err;
int addr;
char tmp[4] = {0x20, 0x00, 0x01, 0x01};
int addrcnt;
struct pn547_i2c_platform_data *platform_data;
struct pn547_dev *pn547_dev;
#ifdef CONFIG_MACH_VICTORLTE_CTC
pr_info("%s : start system_rev : %d\n", __func__,system_rev);
if (system_rev < 3)
{
pr_info("%s : probe fail \n", __func__);
return -ENODEV;
}
#endif
if (client->dev.of_node) {
platform_data = devm_kzalloc(&client->dev,
sizeof(struct pn547_i2c_platform_data), GFP_KERNEL);
if (!platform_data) {
dev_err(&client->dev, "Failed to allocate memory\n");
return -ENOMEM;
}
err = pn547_parse_dt(&client->dev, platform_data);
if (err)
return err;
} else {
platform_data = client->dev.platform_data;
}
if (platform_data == NULL) {
pr_err("%s : nfc probe fail\n", __func__);
return -ENODEV;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s : need I2C_FUNC_I2C\n", __func__);
return -ENODEV;
}
ret = gpio_request(platform_data->irq_gpio, "nfc_int");
if (ret)
return -ENODEV;
ret = gpio_request(platform_data->ven_gpio, "nfc_ven");
if (ret)
goto err_ven;
ret = gpio_request(platform_data->firm_gpio, "nfc_firm");
if (ret)
goto err_firm;
#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
ret = gpio_request(platform_data->clk_req_gpio, "nfc_clk_req");
if (ret)
goto err_clk_req;
#endif
#ifdef CONFIG_NFC_PN547_8226_USE_BBCLK2
ret = gpio_request(platform_data->clk_req_gpio, "nfc_clk_req");
if (ret)
goto err_clk_req;
#endif
pn547_dev = kzalloc(sizeof(*pn547_dev), GFP_KERNEL);
if (pn547_dev == NULL) {
dev_err(&client->dev,
"failed to allocate memory for module data\n");
ret = -ENOMEM;
goto err_exit;
}
#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
pn547_dev->nfc_clock = msm_xo_get(MSM_XO_TCXO_A1, "nfc");
if (IS_ERR(pn547_dev->nfc_clock)) {
ret = PTR_ERR(pn547_dev->nfc_clock);
printk(KERN_ERR "%s: Couldn't get TCXO_A1 vote for NFC (%d)\n",
__func__, ret);
ret = -ENODEV;
goto err_get_clock;
}
pn547_dev->clock_state = false;
#endif
#ifdef CONFIG_NFC_PN547_8226_USE_BBCLK2
pn547_dev->nfc_clock = clk_get(NULL, "nfc_clock");
if (IS_ERR(pn547_dev->nfc_clock)) {
ret = PTR_ERR(pn547_dev->nfc_clock);
printk(KERN_ERR "%s: Couldn't get D1 (%d)\n",
__func__, ret);
} else {
if (clk_prepare_enable(pn547_dev->nfc_clock))
printk(KERN_ERR "%s: Couldn't prepare D1\n",
__func__);
}
#endif
#ifdef CONFIG_NFC_PN547_PMC8974_CLK_REQ
#ifdef CONFIG_NFC_I2C_OVERWRITE
pn547_dev->nfc_clk = clk_get(NULL, "nfc_clk");
#else
pn547_dev->nfc_clk = clk_get(&client->dev, "nfc_clk");
#endif
if (IS_ERR(pn547_dev->nfc_clk)) {
ret = PTR_ERR(pn547_dev->nfc_clk);
printk(KERN_ERR "%s: Couldn't get D1 (%d)\n",
__func__, ret);
} else {
if (clk_prepare_enable(pn547_dev->nfc_clk))
printk(KERN_ERR "%s: Couldn't prepare D1\n",
__func__);
}
#endif
pr_info("%s : IRQ num %d\n", __func__, client->irq);
pn547_dev->irq_gpio = platform_data->irq_gpio;
pn547_dev->ven_gpio = platform_data->ven_gpio;
pn547_dev->firm_gpio = platform_data->firm_gpio;
pn547_dev->conf_gpio = platform_data->conf_gpio;
#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
pn547_dev->clk_req_gpio = platform_data->clk_req_gpio;
pn547_dev->clk_req_irq = platform_data->clk_req_irq;
#endif
#ifdef CONFIG_NFC_PN547_8226_USE_BBCLK2
pn547_dev->clk_req_gpio = platform_data->clk_req_gpio;
#endif
pn547_dev->client = client;
/* init mutex and queues */
init_waitqueue_head(&pn547_dev->read_wq);
mutex_init(&pn547_dev->read_mutex);
pn547_dev->pn547_device.minor = MISC_DYNAMIC_MINOR;
#ifdef CONFIG_NFC_PN547
pn547_dev->pn547_device.name = "pn547";
#else
pn547_dev->pn547_device.name = "pn544";
#endif
pn547_dev->pn547_device.fops = &pn547_dev_fops;
ret = misc_register(&pn547_dev->pn547_device);
if (ret) {
pr_err("%s : misc_register failed\n", __FILE__);
goto err_misc_register;
}
/* request irq. the irq is set whenever the chip has data available
* for reading. it is cleared when all data has been read.
*/
pr_info("%s : requesting IRQ %d\n", __func__, client->irq);
gpio_direction_input(pn547_dev->irq_gpio);
gpio_direction_output(pn547_dev->ven_gpio, 0);
gpio_direction_output(pn547_dev->firm_gpio, 0);
#if defined(CONFIG_NFC_PN547_CLOCK_REQUEST) || defined(CONFIG_NFC_PN547_8226_USE_BBCLK2)
gpio_direction_input(pn547_dev->clk_req_gpio);
#endif
i2c_set_clientdata(client, pn547_dev);
wake_lock_init(&pn547_dev->nfc_wake_lock,
WAKE_LOCK_SUSPEND, "nfc_wake_lock");
#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
pn547_dev->wq_clock = create_singlethread_workqueue("nfc_wq");
if (!pn547_dev->wq_clock) {
ret = -ENOMEM;
pr_err("%s: could not create workqueue\n", __func__);
goto err_create_workqueue;
}
INIT_WORK(&pn547_dev->work_nfc_clock, nfc_work_func_clock);
#endif
if(client->irq <=0)
{
pr_info("%s : [Before] requesting IRQ %d\n", __func__, client->irq);
client->irq = gpio_to_irq(pn547_dev->irq_gpio);
pr_info("%s : [After] requesting IRQ %d\n", __func__, client->irq);
}
ret = request_irq(client->irq, pn547_dev_irq_handler,
IRQF_TRIGGER_RISING, "pn547", pn547_dev);
if (ret) {
dev_err(&client->dev, "request_irq failed\n");
goto err_request_irq_failed;
}
disable_irq_nosync(pn547_dev->client->irq);
atomic_set(&pn547_dev->irq_enabled, 0);
#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
ret = request_irq(pn547_dev->clk_req_irq, pn547_dev_clk_req_irq_handler,
IRQF_SHARED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING
, "pn547_clk_req", pn547_dev);
if (ret) {
dev_err(&client->dev, "request_irq(clk_req) failed\n");
goto err_request_irq_failed;
}
enable_irq_wake(pn547_dev->clk_req_irq);
#endif
gpio_set_value(pn547_dev->ven_gpio, 1);
gpio_set_value(pn547_dev->firm_gpio, 1); /* add firmware pin */
usleep_range(4900, 5000);
gpio_set_value(pn547_dev->ven_gpio, 0);
usleep_range(4900, 5000);
gpio_set_value(pn547_dev->ven_gpio, 1);
usleep_range(4900, 5000);
for (addr = 0x2B; addr > 0x27; addr--) {
client->addr = addr;
addrcnt = 2;
do {
ret = i2c_master_send(client, tmp, 4);
if (ret > 0) {
pr_info("%s : i2c addr=0x%X\n",
__func__, client->addr);
break;
}
} while (addrcnt--);
if (ret > 0)
break;
}
if(ret <= 0)
client->addr = 0x2B;
gpio_set_value(pn547_dev->ven_gpio, 0);
gpio_set_value(pn547_dev->firm_gpio, 0); /* add */
if (ret < 0)
pr_err("%s : fail to get i2c addr\n", __func__);
/* goto err_request_irq_failed; */
else
pr_info("%s : success\n", __func__);
return 0;
err_request_irq_failed:
#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
err_create_workqueue:
#endif
misc_deregister(&pn547_dev->pn547_device);
wake_lock_destroy(&pn547_dev->nfc_wake_lock);
err_misc_register:
mutex_destroy(&pn547_dev->read_mutex);
#ifdef CONFIG_NFC_PN547_CLOCK_REQUEST
msm_xo_put(pn547_dev->nfc_clock);
err_get_clock:
#endif
kfree(pn547_dev);
err_exit:
#if defined(CONFIG_NFC_PN547_CLOCK_REQUEST) || defined(CONFIG_NFC_PN547_8226_USE_BBCLK2)
gpio_free(platform_data->clk_req_gpio);
err_clk_req:
#endif
gpio_free(platform_data->firm_gpio);
err_firm:
gpio_free(platform_data->ven_gpio);
err_ven:
gpio_free(platform_data->irq_gpio);
pr_err("[pn547] pn547_probe fail!\n");
return ret;
}
static int ssp_probe(struct spi_device *spi_dev)
{
int iRet = 0;
struct ssp_data *data;
struct ssp_platform_data *pdata;
if (poweroff_charging == 1 || recovery_mode == 1) {
pr_err("[SSP] probe exit : lpm %d recovery %d \n",
poweroff_charging, recovery_mode);
return -ENODEV;
}
data = kzalloc(sizeof(*data), GFP_KERNEL);
if (data == NULL) {
pr_err("[SSP]: %s - failed to allocate memory for data\n",
__func__);
iRet = -ENOMEM;
goto exit;
}
if (spi_dev->dev.of_node) {
iRet = ssp_parse_dt(&spi_dev->dev, data);
if (iRet) {
pr_err("[SSP]: %s - Failed to parse DT\n", __func__);
goto err_setup;
}
data->ssp_changes = SSP_MCU_L5; /* K330, MPU L5*/
} else {
pdata = spi_dev->dev.platform_data;
if (pdata == NULL) {
pr_err("[SSP]: %s - platform_data is null\n", __func__);
iRet = -ENOMEM;
goto err_setup;
}
data->wakeup_mcu = pdata->wakeup_mcu;
data->check_mcu_ready = pdata->check_mcu_ready;
data->check_mcu_busy = pdata->check_mcu_busy;
data->set_mcu_reset = pdata->set_mcu_reset;
data->read_chg = pdata->read_chg;
/* AP system_rev */
if (pdata->check_ap_rev)
data->ap_rev = pdata->check_ap_rev();
else
data->ap_rev = 0;
/* For changed devices */
if (pdata->check_changes)
data->ssp_changes = pdata->check_changes();
else
data->ssp_changes = SSP_MCU_L5; /* K330, MPU L5*/
/* Get sensor positions */
if (pdata->get_positions)
pdata->get_positions(&data->accel_position,
&data->mag_position);
else if (spi_dev->dev.of_node == NULL) {
data->accel_position = 0;
data->mag_position = 0;
}
}
spi_dev->mode = SPI_MODE_1;
if (spi_setup(spi_dev)) {
pr_err("failed to setup spi for ssp_spi\n");
goto err_setup;
}
data->bProbeIsDone = false;
data->fw_dl_state = FW_DL_STATE_NONE;
data->spi = spi_dev;
spi_set_drvdata(spi_dev, data);
#ifdef CONFIG_SENSORS_SSP_SHTC1
mutex_init(&data->cp_temp_adc_lock);
mutex_init(&data->bulk_temp_read_lock);
#endif
#ifdef CONFIG_SENSORS_SSP_STM
mutex_init(&data->comm_mutex);
mutex_init(&data->pending_mutex);
#endif
if (((data->wakeup_mcu == NULL)
|| (data->check_mcu_ready == NULL)
|| (data->check_mcu_busy == NULL)
|| (data->set_mcu_reset == NULL)
|| (data->read_chg == NULL))
&& (spi_dev->dev.of_node == NULL)) {
pr_err("[SSP]: %s - function callback is null\n", __func__);
iRet = -EIO;
goto err_reset_null;
}
pr_info("\n#####################################################\n");
INIT_DELAYED_WORK(&data->work_firmware, work_function_firmware_update);
wake_lock_init(&data->ssp_wake_lock,
WAKE_LOCK_SUSPEND, "ssp_wake_lock");
iRet = initialize_input_dev(data);
if (iRet < 0) {
pr_err("[SSP]: %s - could not create input device\n", __func__);
goto err_input_register_device;
}
iRet = initialize_debug_timer(data);
if (iRet < 0) {
pr_err("[SSP]: %s - could not create workqueue\n", __func__);
goto err_create_workqueue;
}
iRet = initialize_irq(data);
if (iRet < 0) {
pr_err("[SSP]: %s - could not create irq\n", __func__);
goto err_setup_irq;
}
iRet = initialize_sysfs(data);
if (iRet < 0) {
pr_err("[SSP]: %s - could not create sysfs\n", __func__);
goto err_sysfs_create;
}
iRet = initialize_event_symlink(data);
if (iRet < 0) {
pr_err("[SSP]: %s - could not create symlink\n", __func__);
goto err_symlink_create;
}
initialize_variable(data);
ssp_enable(data, true);
/* check boot loader binary */
data->fw_dl_state = check_fwbl(data);
if (data->fw_dl_state == FW_DL_STATE_NONE) {
iRet = initialize_mcu(data);
if (iRet == ERROR) {
data->uResetCnt++;
toggle_mcu_reset(data);
msleep(SSP_SW_RESET_TIME);
initialize_mcu(data);
} else if (iRet < ERROR) {
pr_err("[SSP]: %s - initialize_mcu failed\n", __func__);
goto err_read_reg;
}
}
#ifdef CONFIG_HAS_EARLYSUSPEND
data->early_suspend.suspend = ssp_early_suspend;
data->early_suspend.resume = ssp_late_resume;
register_early_suspend(&data->early_suspend);
#endif
#ifdef CONFIG_SENSORS_SSP_SENSORHUB
/* init sensorhub device */
iRet = ssp_sensorhub_initialize(data);
if (iRet < 0) {
pr_err("%s: ssp_sensorhub_initialize err(%d)", __func__, iRet);
ssp_sensorhub_remove(data);
}
#endif
data->bMcuDumpMode = sec_debug_is_enabled();
iRet = ssp_send_cmd(data, MSG2SSP_AP_MCU_SET_DUMPMODE,data->bMcuDumpMode);
if (iRet < 0) {
pr_err("[SSP]: %s - MSG2SSP_AP_MCU_SET_DUMPMODE failed\n", __func__);
}
pr_info("[SSP]: %s - setup debuglevel %d!\n", __func__,data->bMcuDumpMode);
pr_info("[SSP]: %s - probe success!\n", __func__);
enable_debug_timer(data);
iRet = 0;
if (data->fw_dl_state == FW_DL_STATE_NEED_TO_SCHEDULE) {
pr_info("[SSP]: Firmware update is scheduled\n");
schedule_delayed_work(&data->work_firmware,
msecs_to_jiffies(1000));
data->fw_dl_state = FW_DL_STATE_SCHEDULED;
} else if (data->fw_dl_state == FW_DL_STATE_FAIL)
data->bSspShutdown = true;
data->bProbeIsDone = true;
goto exit;
err_read_reg:
err_symlink_create:
remove_sysfs(data);
err_sysfs_create:
free_irq(data->iIrq, data);
gpio_free(data->mcu_int1);
err_setup_irq:
destroy_workqueue(data->debug_wq);
err_create_workqueue:
remove_input_dev(data);
err_input_register_device:
wake_lock_destroy(&data->ssp_wake_lock);
err_reset_null:
#ifdef CONFIG_SENSORS_SSP_SHTC1
mutex_destroy(&data->cp_temp_adc_lock);
mutex_destroy(&data->bulk_temp_read_lock);
#endif
#ifdef CONFIG_SENSORS_SSP_STM
mutex_destroy(&data->comm_mutex);
mutex_destroy(&data->pending_mutex);
#endif
err_setup:
kfree(data);
pr_err("[SSP]: %s - probe failed!\n", __func__);
exit:
pr_info("#####################################################\n\n");
return iRet;
}
static int gp2a_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct gp2a_data *gp2a;
struct gp2a_platform_data *pdata = client->dev.platform_data;
u8 value = 0;
int err = 0;
pr_info("%s : probe start!\n", __func__);
if (!pdata) {
pr_err("%s: missing pdata!\n", __func__);
err = -EINVAL;
goto done;
}
if (!pdata->power_on) {
pr_err("%s: incomplete pdata!\n", __func__);
err = -EINVAL;
goto done;
}
/* allocate driver_data */
gp2a = kzalloc(sizeof(struct gp2a_data), GFP_KERNEL);
if (!gp2a) {
pr_err("kzalloc error\n");
err = -ENOMEM;
goto done;
}
gp2a->pdata = pdata;
gp2a->client = client;
gp2a->proximity_enabled = 0;
gp2a->light_enabled = 0;
gp2a->light_delay = SENSOR_DEFAULT_DELAY;
gp2a->light_zero_count = 0;
gp2a->light_reset_count = 0;
i2c_set_clientdata(client, gp2a);
if (pdata->power_on)
pdata->power_on(true);
if (pdata->version) { /* GP2AP030 */
gp2a_reg[1][1] = 0x1A;
if (pdata->thresh[0])
gp2a_reg[3][1] = pdata->thresh[0];
else
gp2a_reg[3][1] = 0x08;
if (pdata->thresh[1])
gp2a_reg[5][1] = pdata->thresh[1];
else
gp2a_reg[5][1] = 0x0A;
}
INIT_DELAYED_WORK(&gp2a->light_work, gp2a_work_func_light);
INIT_WORK(&gp2a->proximity_work, gp2a_work_func_prox);
err = proximity_input_init(gp2a);
if (err < 0)
goto error_setup_reg_prox;
err = light_input_init(gp2a);
if (err < 0)
goto error_setup_reg_light;
err = sysfs_create_group(&gp2a->proximity_input_dev->dev.kobj,
&proximity_attribute_group);
if (err < 0)
goto err_sysfs_create_group_proximity;
err = sysfs_create_group(&gp2a->light_input_dev->dev.kobj,
&lightsensor_attribute_group);
if (err)
goto err_sysfs_create_group_light;
mutex_init(&gp2a->light_mutex);
mutex_init(&gp2a->data_mutex);
/* wake lock init */
wake_lock_init(&gp2a->prx_wake_lock, WAKE_LOCK_SUSPEND,
"prx_wake_lock");
/* GP2A Regs INIT SETTINGS and Check I2C communication */
/* shutdown mode op[3]=0 */
value = 0x00;
err = gp2a_i2c_write(gp2a, (u8) (COMMAND1), &value);
if (err < 0) {
pr_err("%s failed : threre is no such device.\n", __func__);
goto err_no_device;
}
/* Setup irq */
err = gp2a_setup_irq(gp2a);
if (err) {
pr_err("%s: could not setup irq\n", __func__);
goto err_setup_irq;
}
err = sensors_register(&(gp2a->light_sensor_device),
gp2a, additional_light_attrs, "light_sensor");
if (err) {
pr_err("%s: cound not register sensor device\n", __func__);
goto err_sysfs_create_factory_light;
}
err = sensors_register(&(gp2a->proximity_sensor_device),
gp2a, additional_proximity_attrs, "proximity_sensor");
if (err) {
pr_err("%s: cound not register sensor device\n", __func__);
goto err_sysfs_create_factory_proximity;
}
pr_info("%s : probe success!\n", __func__);
return 0;
err_sysfs_create_factory_proximity:
err_sysfs_create_factory_light:
free_irq(gp2a->irq, gp2a);
gpio_free(gp2a->pdata->p_out);
err_setup_irq:
err_no_device:
wake_lock_destroy(&gp2a->prx_wake_lock);
mutex_destroy(&gp2a->light_mutex);
mutex_destroy(&gp2a->data_mutex);
sysfs_remove_group(&gp2a->light_input_dev->dev.kobj,
&lightsensor_attribute_group);
err_sysfs_create_group_light:
sysfs_remove_group(&gp2a->proximity_input_dev->dev.kobj,
&proximity_attribute_group);
err_sysfs_create_group_proximity:
input_unregister_device(gp2a->light_input_dev);
error_setup_reg_light:
input_unregister_device(gp2a->proximity_input_dev);
error_setup_reg_prox:
if (pdata->power_on)
pdata->power_on(false);
kfree(gp2a);
done:
return err;
}
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;
sec_battery_platform_data_t *pdata = NULL;
struct battery_data_t *battery_data = NULL;
int ret = 0;
union power_supply_propval raw_soc_val;
dev_info(&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;
if (client->dev.of_node) {
int error;
pdata = devm_kzalloc(&client->dev,
sizeof(sec_battery_platform_data_t),
GFP_KERNEL);
if (!pdata) {
dev_err(&client->dev, "Failed to allocate memory\n");
ret = -ENOMEM;
goto err_free;
}
battery_data = devm_kzalloc(&client->dev,
sizeof(struct battery_data_t),
GFP_KERNEL);
if (!battery_data) {
dev_err(&client->dev, "Failed to allocate memory\n");
devm_kfree(&client->dev, pdata);
ret = -ENOMEM;
goto err_free;
}
pdata->battery_data = (void *)battery_data;
fuelgauge->pdata = pdata;
error = fuelgauge_parse_dt(&client->dev, fuelgauge);
if (error) {
dev_err(&client->dev,
"%s: Failed to get fuel_int\n", __func__);
}
} else {
dev_err(&client->dev,
"%s: Failed to get of_node\n", __func__);
fuelgauge->pdata = client->dev.platform_data;
}
i2c_set_clientdata(client, fuelgauge);
if (!sec_hal_fg_init(fuelgauge->client)) {
dev_err(&client->dev,
"%s: Failed to Initialize Fuelgauge\n", __func__);
goto err_free;
}
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;
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);
/*
if (!fuelgauge->pdata->fg_gpio_init()) {
dev_err(&client->dev,
"%s: Failed to Initialize GPIO\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) {
fuelgauge->fg_irq = gpio_to_irq(fuelgauge->pdata->fg_irq);
INIT_DELAYED_WORK(
&fuelgauge->isr_work, sec_fg_isr_work);
ret = request_threaded_irq(fuelgauge->fg_irq,
NULL, sec_fg_irq_thread,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT,
"fuelgauge-irq", fuelgauge);
if (ret) {
dev_err(&client->dev,
"%s: Failed to Reqeust IRQ\n", __func__);
goto err_supply_unreg;
}
ret = enable_irq_wake(fuelgauge->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_info(&client->dev,
"%s: SEC Fuelgauge Driver Loaded\n", __func__);
return 0;
err_irq:
if (fuelgauge->fg_irq)
free_irq(fuelgauge->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 __init multipdp_init(void)
{
int ret;
wake_lock_init(&pdp_wake_lock, WAKE_LOCK_SUSPEND, "MULTI_PDP");
pdp_arg_t pdp_arg = { .id = 1, .ifname = "ttyCSD", };
pdp_arg_t efs_arg = { .id = 8, .ifname = "ttyEFS", };
pdp_arg_t gps_arg = { .id = 5, .ifname = "ttyGPS", };
pdp_arg_t xtra_arg = { .id = 6, .ifname = "ttyXTRA", };
pdp_arg_t smd_arg = { .id = 25, .ifname = "ttySMD", };
pdp_arg_t pcm_arg = { .id = 30, .ifname = "ttyPCM", } ;
#ifdef LOOP_BACK_TEST
pdp_arg_t loopback_arg = { .id = 31, .ifname = "ttyLOBK", };
#endif
/* run DPRAM I/O thread */
ret = kernel_thread(dpram_thread, NULL, CLONE_FS | CLONE_FILES);
if (ret < 0) {
EPRINTK("kernel_thread() failed\n");
return ret;
}
wait_for_completion(&dpram_complete);
if (!dpram_task) {
EPRINTK("DPRAM I/O thread error\n");
return -EIO;
}
/* create serial device for Circuit Switched Data */
ret = pdp_activate(&pdp_arg, DEV_TYPE_SERIAL, DEV_FLAG_STICKY);
if (ret < 0) {
EPRINTK("failed to create a serial device for CSD\n");
goto err0;
}
ret = pdp_activate(&efs_arg, DEV_TYPE_SERIAL, DEV_FLAG_STICKY);
if (ret < 0) {
EPRINTK("failed to create a serial device for EFS\n");
goto err1;
}
ret = pdp_activate(&gps_arg, DEV_TYPE_SERIAL, DEV_FLAG_STICKY);
if (ret < 0) {
EPRINTK("failed to create a serial device for GPS\n");
goto err2;
}
ret = pdp_activate(&xtra_arg, DEV_TYPE_SERIAL, DEV_FLAG_STICKY);
if (ret < 0) {
EPRINTK("failed to create a serial device for XTRA\n");
goto err3;
}
ret = pdp_activate(&smd_arg, DEV_TYPE_SERIAL, DEV_FLAG_STICKY);
if (ret < 0) {
EPRINTK("failed to create a serial device for SMD\n");
goto err4;
}
ret = pdp_activate(&pcm_arg, DEV_TYPE_SERIAL, DEV_FLAG_STICKY);
if (ret < 0) {
EPRINTK("failed to create a serial device for SMD\n");
goto err5;
}
#ifdef LOOP_BACK_TEST
ret = pdp_activate(&loopback_arg, DEV_TYPE_SERIAL, DEV_FLAG_STICKY);
if (ret < 0) {
EPRINTK("failed to create a serial device for LoopBack\n");
goto err6;
}
#endif
/* create app. interface device */
ret = misc_register(&multipdp_dev);
if (ret < 0) {
EPRINTK("misc_register() failed\n");
goto err1;
}
#ifdef LOOP_BACK_TEST
ret = device_create_file(multipdp_dev.this_device, &dev_attr_loopback);
#endif
#ifdef CONFIG_PROC_FS
create_proc_read_entry(APP_DEVNAME, 0, 0,
multipdp_proc_read, NULL);
#endif
#ifdef NO_TTY_DPRAM
printk("multipdp_init:multipdp_rx_noti_regi calling");
multipdp_rx_noti_regi(multipdp_rx_cback );
#endif
// printk(KERN_INFO
// "$Id: multipdp.c,v 1.10 2008/01/11 05:40:56 melonzz Exp $\n");
return 0;
#ifdef LOOP_BACK_TEST
err6:
pdp_deactivate(&loopback_arg, 1);
#endif
err5:
/* undo serial device for Circuit Switched Data */
pdp_deactivate(&pcm_arg, 1);
err4:
/* undo serial device for Circuit Switched Data */
pdp_deactivate(&smd_arg, 1);
err3:
/* undo serial device for Circuit Switched Data */
pdp_deactivate(&xtra_arg, 1);
err2:
/* undo serial device for Circuit Switched Data */
pdp_deactivate(&gps_arg, 1);
err1:
/* undo serial device for Circuit Switched Data */
pdp_deactivate(&pdp_arg, 1);
err0:
/* kill DPRAM I/O thread */
if (dpram_task) {
send_sig(SIGUSR1, dpram_task, 1);
wait_for_completion(&dpram_complete);
}
return ret;
}
static void __exit multipdp_exit(void)
{
wake_lock_destroy(&pdp_wake_lock);
#ifdef CONFIG_PROC_FS
remove_proc_entry(APP_DEVNAME, 0);
#endif
/* remove app. interface device */
misc_deregister(&multipdp_dev);
/* clean up PDP context table */
pdp_cleanup();
/* kill DPRAM I/O thread */
if (dpram_task) {
send_sig(SIGUSR1, dpram_task, 1);
wait_for_completion(&dpram_complete);
}
}
//module_init(multipdp_init);
late_initcall(multipdp_init);
module_exit(multipdp_exit);
MODULE_AUTHOR("SAMSUNG ELECTRONICS CO., LTD");
MODULE_DESCRIPTION("Multiple PDP Muxer / Demuxer");
MODULE_LICENSE("GPL");
static void memdump_wake_lock_stop(void)
{
wake_unlock(&memdump_wake_lock);
wake_lock_destroy(&memdump_wake_lock);
}
