int felica_snfc_unregister(struct device *dev)
{
struct felica_dev *d = dev_get_drvdata(dev);
dev_dbg(dev, "%s\n", __func__);
if (!dev || !reg_device || reg_device != dev)
return -EINVAL;
remove_sysfs_interfaces(&d->sysfs_dev);
device_unregister(&d->sysfs_dev);
felica_rws_remove_func(d);
felica_int_remove_func(d);
felica_rfs_remove_func(d);
felica_pon_remove_func(d);
felica_cen_remove_func(d);
if (FELICA_SNFC == d->felica_data->type) {
nfc_available_poll_remove_func(d);
nfc_intu_poll_remove_func(d);
nfc_hsel_remove_func(d);
}
kfree(d);
reg_device = 0;
return 0;
}
static int felica_remove(struct platform_device *pdev)
{
struct felica_dev *dev = platform_get_drvdata(pdev);
struct felica_platform_data *flc_pfdata;
dev_dbg(&pdev->dev, "%s\n", __func__);
remove_sysfs_interfaces(&pdev->dev);
felica_rws_remove_func(dev);
felica_int_remove_func(dev);
felica_rfs_remove_func(dev);
felica_pon_remove_func(dev);
felica_cen_remove_func(dev);
#ifdef CONFIG_SONY_FELICA_NFC_SUPPORT
snfc_available_poll_remove_func(dev);
snfc_intu_poll_remove_func(dev);
snfc_hsel_remove_func(dev);
#endif
flc_pfdata = pdev->dev.platform_data;
flc_pfdata->reg_release(dev);
kfree(dev);
return 0;
}
static int __devexit lsm303dlh_mag_remove(struct i2c_client *client)
{
struct lsm303dlh_mag_data *mag = i2c_get_clientdata(client);
input_unregister_device(mag->input_dev);
remove_sysfs_interfaces(&client->dev);
kfree(mag);
return 0;
}
static int __devexit lm356x_remove(struct i2c_client *client)
{
struct lm356x_drv_data *data = dev_get_drvdata(&client->dev);
struct lm356x_platform_data *pdata = client->dev.platform_data;
remove_sysfs_interfaces(&client->dev);
pdata->hw_disable();
kfree(data);
return 0;
}
static int __devexit lsm303dlhc_mag_remove(struct i2c_client *client)
{
struct lsm303dlhc_mag_data *mag = i2c_get_clientdata(client);
device_remove_file(&mag->input_dev->dev,&dev_attr_enable);
input_unregister_device(mag->input_dev);
remove_sysfs_interfaces(mag->dev);
sensors_classdev_unregister(mag->dev);
kfree(mag);
return 0;
}
static int __devexit lm3561_remove(struct i2c_client *client)
{
struct lm3561_drv_data *data = dev_get_drvdata(&client->dev);
struct lm3561_platform_data *pdata = client->dev.platform_data;
remove_sysfs_interfaces(&client->dev);
pm_runtime_suspend(&client->dev);
pm_runtime_disable(&client->dev);
if (pdata->platform_init)
pdata->platform_init(&client->dev, false);
kfree(data);
return 0;
}
static int gps_remove(struct platform_device *pdev)
{
struct gps_dev *dev = _gps_dev;
struct gps_config_info *gps_info = &dev->gps_info;
remove_sysfs_interfaces(&pdev->dev);
if(gps_info->gps_clk && strcmp(gps_info->gps_clk, "")){
enable_gps_32k(0);
clk_put(gps_32k);
}
return 0;
}
static int __devexit mpu_remove(struct i2c_client *client)
{
struct mpu_data *mpu = i2c_get_clientdata(client);
dev_dbg(&client->dev, "enter %s\n", __func__);
if (client->irq > 0) {
free_irq(client->irq, mpu);
gpio_free(mpu->gpio);
}
disable_irq(mpu->client->irq);
input_unregister_device(mpu->input_dev);
mpu_disable(mpu);
remove_sysfs_interfaces(&client->dev);
kfree(mpu);
return 0;
}
static int __devexit mma8452_remove(struct i2c_client *client)
{
int ret;
struct gs_mma8452_data *mma=i2c_get_clientdata(client);
struct mma8452_acc_platform_data *devpd = client->dev.platform_data;
ret = mma8452_disable(mma);
input_unregister_device(mma->input_dev);
input_free_device(mma->input_dev);
remove_sysfs_interfaces(&client->dev);
kfree(mma);
if(devpd->power_off)
devpd->power_off();
return ret;
}
static int simple_remote_remove(struct platform_device *pdev)
{
struct simple_remote_driver *jack = platform_get_drvdata(pdev);
if (switch_get_state(&jack->swdev)) {
jack->interface->unregister_hssd_button_interrupt(jack);
jack->interface->enable_mic_bias(0);
switch_set_state(&jack->swdev, NO_DEVICE);
}
jack->interface->unregister_plug_detect_interrupt(jack);
remove_sysfs_interfaces(&pdev->dev);
input_unregister_device(jack->indev_appkey);
input_unregister_device(jack->indev);
switch_dev_unregister(&jack->swdev);
kzfree(jack);
return 0;
}
static int __devexit mipi_r63306_lcd_remove(struct platform_device *pdev)
{
struct mipi_dsi_data *dsi_data;
dsi_data = platform_get_drvdata(pdev);
if (!dsi_data)
return -ENODEV;
#ifdef CONFIG_DEBUG_FS
mipi_dsi_panel_remove_debugfs(pdev);
#endif
#ifdef CONFIG_FB_MSM_RECOVER_PANEL
remove_sysfs_interfaces(&pdev->dev);
#endif
platform_set_drvdata(pdev, NULL);
mipi_dsi_buf_release(&dsi_data->tx_buf);
mipi_dsi_buf_release(&dsi_data->rx_buf);
kfree(dsi_data);
return 0;
}
static int __devexit bma250_remove(struct i2c_client *ic_dev)
{
struct driver_data *dd = bma250_ic_get_data(ic_dev);
int rc;
rc = bma250_power_down(dd);
if (rc)
dev_err(&dd->ip_dev->dev,
"%s: power down failed with error %d\n",
__func__, rc);
remove_sysfs_interfaces(&dd->ip_dev->dev);
input_unregister_device(dd->ip_dev);
bma250_remove_dbfs_entry(dd);
bma250_ic_set_data(ic_dev, NULL);
mutex_lock(&bma250_dd_lock);
list_del(&dd->next_dd);
mutex_unlock(&bma250_dd_lock);
kfree(dd);
return 0;
}
static int felica_remove(struct platform_device *pdev)
{
struct felica_dev *dev = platform_get_drvdata(pdev);
struct felica_platform_data *flc_pfdata;
dev_dbg(&pdev->dev, "%s\n", __func__);
remove_sysfs_interfaces(&pdev->dev);
felica_rws_remove_func(dev);
felica_int_remove_func(dev);
felica_rfs_remove_func(dev);
felica_pon_remove_func(dev);
felica_cen_remove_func(dev);
flc_pfdata = pdev->dev.platform_data;
flc_pfdata->reg_release(dev);
kfree(dev);
return 0;
}
static int l3g4200d_remove(struct i2c_client *client)
{
struct l3g4200d_data *gyro = i2c_get_clientdata(client);
dev_info(&client->dev, "L3G4200D driver removing\n");
remove_sysfs_interfaces(&client->dev);
unregister_early_suspend(&gyro->es);
mutex_lock(&gyro->lock);
l3g4200d_disable(gyro);
mutex_unlock(&gyro->lock);
/* there may be still a delayed work in execution, we must wait for
* its completion before we could reclaim resources.
*/
cancel_delayed_work_sync(&gyro->work);
mutex_destroy(&gyro->lock);
input_unregister_device(gyro->input_dev);
kfree(gyro->pdata);
kfree(gyro);
return 0;
}
static int __devinit lsm303dlh_mag_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct lsm303dlh_mag_platform_data *pdata = client->dev.platform_data;
struct lsm303dlh_mag_data *mag;
int result = 0;
dev_info(&client->dev, "%s\n", __func__);
if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
result = -EIO;
goto err_check_functionality;
}
if (!pdata) {
result = -EINVAL;
dev_err(&client->dev, "%s: platform data required.\n",
__func__);
goto err_no_platform_data;
}
mag = kzalloc(sizeof(*mag), GFP_KERNEL);
if (NULL == mag) {
result = -ENOMEM;
goto err_alloc_data_failed;
}
mag->client = client;
mag->poll_interval_ms = pdata->poll_interval_ms;
mag->range = pdata->range;
i2c_set_clientdata(client, mag);
if (pdata->power_on)
mag->power_on = pdata->power_on;
else
mag->power_on = lsm303dlh_mag_power_stub;
if (pdata->power_off)
mag->power_off = pdata->power_off;
else
mag->power_off = lsm303dlh_mag_power_stub;
mag->power_on();
result = i2c_smbus_write_byte_data(client, MR_REG_M, IDLE_MODE);
mag->power_off();
if (result) {
dev_err(&client->dev, "%s: Device not responding.\n",
__func__);
goto err_not_responding;
}
INIT_DELAYED_WORK(&mag->work, lsm303dlh_mag_poll_func);
mutex_init(&mag->lock);
result = create_sysfs_interfaces(&client->dev);
if (result)
goto err_sys_attr;
mag->input_dev = input_allocate_device();
if (!mag->input_dev) {
dev_err(&client->dev, "%s: input_allocate_device failed\n",
__func__);
result = -ENOMEM;
goto err_allocate_device;
}
input_set_drvdata(mag->input_dev, mag);
mag->input_dev->open = lsm303dlh_mag_open;
mag->input_dev->close = lsm303dlh_mag_close;
mag->input_dev->name = LSM303DLH_MAG_DEV_NAME;
set_bit(EV_ABS, mag->input_dev->evbit);
set_bit(ABS_X, mag->input_dev->absbit);
set_bit(ABS_Y, mag->input_dev->absbit);
set_bit(ABS_Z, mag->input_dev->absbit);
input_set_abs_params(mag->input_dev, ABS_X, -MAG_RANGE_MG,
MAG_RANGE_MG - 1, 0, 0);
input_set_abs_params(mag->input_dev, ABS_Y, -MAG_RANGE_MG,
MAG_RANGE_MG - 1, 0, 0);
input_set_abs_params(mag->input_dev, ABS_Z, -MAG_RANGE_MG,
MAG_RANGE_MG - 1, 0, 0);
result = input_register_device(mag->input_dev);
if (result) {
dev_err(&client->dev, "%s: input_register_device failed!",
__func__);
goto err_register_device;
}
dev_info(&client->dev, "%s completed.\n", __func__);
return 0;
err_register_device:
input_free_device(mag->input_dev);
err_allocate_device:
remove_sysfs_interfaces(&client->dev);
err_sys_attr:
err_not_responding:
kfree(mag);
err_alloc_data_failed:
err_no_platform_data:
err_check_functionality:
dev_err(&client->dev, "%s failed.\n", __func__);
return result;
}
static int __devinit lsm303dlhc_mag_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct lsm303dlhc_mag_platform_data *pdata = client->dev.platform_data;
struct lsm303dlhc_mag_data *mag;
int result = 0;
dev_info(&client->dev, "%s \n", __func__);
if (!pdata) {
result = -EINVAL;
dev_err(&client->dev, "%s: platform data required.\n",
__func__);
goto err_no_platform_data;
}
mag = kzalloc(sizeof(*mag), GFP_KERNEL);
if (NULL == mag) {
result = -ENOMEM;
goto err_alloc_data_failed;
}
mag->client = client;
mag->poll_interval_ms = pdata->poll_interval_ms;
mag->range = pdata->range;
dev_info(&client->dev, "%s:pdata->range:%d\n", __func__, pdata->range);
i2c_set_clientdata(client, mag);
if (pdata->power_on)
mag->power_on = pdata->power_on;
else
mag->power_on = lsm303dlhc_mag_power_stub;
if (pdata->power_off)
mag->power_off = pdata->power_off;
else
mag->power_off = lsm303dlhc_mag_power_stub;
mag->power_on();
lsm303dlhc_mag_config_regulator( mag , true);
msleep(500);
if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
result = -EIO;
goto err_check_functionality;
}
result = i2c_smbus_write_byte_data(client, MR_REG_M, IDLE_MODE);
mag->power_off();
lsm303dlhc_mag_config_regulator( mag , false);
if (result) {
dev_err(&client->dev, "%s: Device not responding.\n",
__func__);
goto err_not_responding;
}
INIT_DELAYED_WORK(&mag->work, lsm303dlhc_mag_poll_func);
mutex_init(&mag->lock);
mag->dev = sensors_classdev_register("magnetometer");
result = create_sysfs_interfaces(mag->dev);
if (result)
goto err_sys_attr;
dev_set_drvdata(mag->dev, mag);
mag->input_dev = input_allocate_device();
if (!mag->input_dev) {
dev_err(&client->dev, "%s: input_allocate_device failed\n",
__func__);
result = -ENOMEM;
goto err_allocate_device;
}
input_set_drvdata(mag->input_dev, mag);
mag->input_dev->name = "magnetometer";
set_bit(EV_ABS, mag->input_dev->evbit);
set_bit(ABS_X, mag->input_dev->absbit);
set_bit(ABS_Y, mag->input_dev->absbit);
set_bit(ABS_Z, mag->input_dev->absbit);
input_set_abs_params(mag->input_dev, ABS_X, -MAG_RANGE_MG,
MAG_RANGE_MG - 1, 0, 0);
input_set_abs_params(mag->input_dev, ABS_Y, -MAG_RANGE_MG,
MAG_RANGE_MG - 1, 0, 0);
input_set_abs_params(mag->input_dev, ABS_Z, -MAG_RANGE_MG,
MAG_RANGE_MG - 1, 0, 0);
result = input_register_device(mag->input_dev);
if (result) {
dev_err(&client->dev, "%s: input_register_device failed!",
__func__);
goto err_register_device;
}
dev_set_drvdata(&mag->input_dev->dev, mag);
if (device_create_file(&mag->input_dev->dev,
&dev_attr_enable) < 0) {
pr_err("%s: Failed to create device file(%s)!\n", __func__,
dev_attr_enable.attr.name);
goto err_check_functionality;
}
mag->irq_m = pdata->irq_m;
if (mag->irq_m > 0) { /* interrupt */
mag->interruptible = true;
result = request_threaded_irq(gpio_to_irq(mag->irq_m), NULL,
lsm303dlhc_m_gpio_irq,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "lsm303dlhc_m",
mag);
if (result) {
dev_err(&client->dev, "request irq EGPIO_PIN_1 failed\n");
goto err_check_functionality;
}
disable_irq(gpio_to_irq(mag->irq_m));
}
mag->interruptible = false;
dev_info(&client->dev, "%s mag->interruptible=%d completed.\n", __func__, mag->interruptible);
return 0;
err_register_device:
input_free_device(mag->input_dev);
err_allocate_device:
remove_sysfs_interfaces(mag->dev);
err_sys_attr:
err_not_responding:
kfree(mag);
err_alloc_data_failed:
err_no_platform_data:
err_check_functionality:
dev_err(&client->dev, "%s failed.\n", __func__);
return result;
}
static int __devinit mpu_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct mpu_data *mpu;
int ret;
dev_info(&client->dev, "probe start. - new\n");
mpu = kzalloc(sizeof(struct mpu_data), GFP_KERNEL);
if (!mpu) {
ret = -ENOMEM;
dev_err(&client->dev, "failed to alloc memory: %d\n", ret);
goto exit_alloc_failed;
}
mutex_init(&mpu->lock);
mpu->client = client;
i2c_set_clientdata(client, mpu);
mpu->poll_interval = DEFAULT_POLL_INTERVAL;
mpu->gpio = client->irq;
ret = mpu_input_init(mpu);
if (ret < 0) {
dev_err(&client->dev, "input init failed\n");
goto err_input_init_fail;
}
ret = mpu_reset(mpu);
if (ret < 0) {
dev_err(&client->dev, "reset failed\n");
goto err_reset;
}
ret = mpu_hw_init(mpu);
if (ret < 0) {
dev_err(&client->dev, "hw init failed\n");
goto err_hw_init;
}
ret = mpu_setup_irq(mpu);
if (ret < 0) {
dev_err(&client->dev,
"fail to setup irq for gpio %d\n", mpu->gpio);
goto err_setup_irq;
}
mpu->enabled = 0;
mpu_disable(mpu);
dev_info(&client->dev, "probed\n");
return 0;
err_setup_irq:
err_hw_init:
mpu_disable(mpu);
err_reset:
input_unregister_device(mpu->input_dev);
remove_sysfs_interfaces(&client->dev);
err_input_init_fail:
kfree(mpu);
exit_alloc_failed:
dev_err(&client->dev, "Driver Init failed\n");
return ret;
}
static int mma8452_probe(struct i2c_client *client ,
const struct i2c_device_id *id)
{
int err=-1,client_id;
struct i2c_adapter *adapter;
struct gs_mma8452_data *mma;
struct mma8452_acc_platform_data *devpd =client->dev.platform_data;
pr_info("%s: probe start.\n", MMA8452_ACC_DEV_NAME);
if (!devpd)
{
dev_err(&client->dev, "No platfrom data!\n");
err=-ENODEV;
goto err_get_power_fail;
}
/*get power*/
if(devpd->power_on)
{
err = devpd->power_on(&client->dev);
if(err < 0)
{
dev_err(&client->dev, "mma8452_acc_probe: get power fail! result=%d\n", err);
goto err_get_power_fail;
}
dev_dbg(&client->dev,"mma8452_acc_probe: get power success! \n");
}
dev_info(&client->dev, "mma8452_acc_probe: get power success! result=%d\n", err);
/*check functionality*/
adapter = to_i2c_adapter(client->dev.parent);
err = i2c_check_functionality(adapter,
I2C_FUNC_SMBUS_BYTE |
I2C_FUNC_SMBUS_BYTE_DATA);
if (!err)
{
dev_err(&client->dev, "client not i2c capable\n");
err=-ENODEV;
goto err_out;
}
msleep(5);
client_id = i2c_smbus_read_byte_data(client, MMA8452_WHO_AM_I); // MMA8452_WHO_AM_I=3A
if (client_id != MMA8452_ID)
{
dev_err(&client->dev,
"read chip ID 0x%x is not equal to 0x%x or 0x%x!\n",
err, MMA8452_ID, MMA8452_ID);
err = -EINVAL;
goto err_out;
}
dev_info(&client->dev, "Read mma8452 chip ok, ID is 0x%x\n", client_id);
err = set_sensor_chip_info(ACC, "FREESCALE MMA8452");
if (err) {
dev_err(&client->dev, "set_sensor_chip_info error \n");
}
/*allocate memory*/
mma=kzalloc(sizeof(struct gs_mma8452_data), GFP_KERNEL);
if (!mma)
{
err = -ENOMEM;
dev_err(&client->dev,
"failed to allocate memory for module data: "
"%d\n",err);
goto err_out;
}
err = i2c_smbus_write_byte_data(client, MMA8452_CTRL_REG3, 0x2);
if (err < 0) {
dev_err(&client->dev, "%s: failed to selects the polarity of the interrupt signal\n", __func__);
goto err_out;
}
mutex_init(&mma->lock);
mma->client=client;
i2c_set_clientdata(client,mma);
/* Initialize the MMA8452 chip */
err = mma8452_hw_init(mma); // MOD_2G 0
if (err<0)
{
dev_err(&client->dev,
"error mma8452_hw_init init chip failed:(%d)\n", err);
goto err_init;
}
/*Initialize the input device */
err=mma8452_input_init(mma);
if(err<0)
{
dev_err(&client->dev,"input init failed \n");
goto err_init;
}
err = create_sysfs_interfaces(&client->dev);
if (err < 0)
{
dev_err(&client->dev, "device MMA8452_ACC_DEV_NAME sysfs register failed\n");
goto err_create_sysfs;
}
dev_info(&client->dev, "create_sysfs_interfaces: create interfaces success! ");
mma->mma_status.position = devpd->config_mxc_mma_position;
#ifdef CONFIG_HAS_EARLYSUSPEND
mma->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
mma->early_suspend.suspend = mma8452_early_suspend;
mma->early_suspend.resume = mma8452_early_resume;
register_early_suspend(&mma->early_suspend);
#endif
#ifdef CONFIG_HUAWEI_HW_DEV_DCT
/* detect current device successful, set the flag as present */
set_hw_dev_flag(DEV_I2C_G_SENSOR);
#endif
pr_info("%s: probe success.\n", MMA8452_ACC_DEV_NAME);
return 0;
err_create_sysfs:
remove_sysfs_interfaces(&client->dev);
input_unregister_device(mma->input_dev);
input_free_device(mma->input_dev);
err_init:
kfree(mma);
err_out:
if(devpd->power_off)
devpd->power_off();
err_get_power_fail:
return err;
}