exit_remove:
        sysfs_remove_group(&client->dev.kobj, &adt7411_attr_grp);
  exit_free:
-       i2c_set_clientdata(client, NULL);
        kfree(data);
        return ret;
 }
 
        hwmon_device_unregister(data->hwmon_dev);
        sysfs_remove_group(&client->dev.kobj, &adt7411_attr_grp);
-       i2c_set_clientdata(client, NULL);
        kfree(data);
        return 0;
 }
 
                                   &(asc7621_params[i].sda.dev_attr));
        }
 
-       i2c_set_clientdata(client, NULL);
        kfree(data);
        return err;
 }
                                   &(asc7621_params[i].sda.dev_attr));
        }
 
-       i2c_set_clientdata(client, NULL);
        kfree(data);
        return 0;
 }
 
        sysfs_remove_group(&client->dev.kobj, &f75375_group);
 exit_free:
        kfree(data);
-       i2c_set_clientdata(client, NULL);
        return err;
 }
 
        hwmon_device_unregister(data->hwmon_dev);
        sysfs_remove_group(&client->dev.kobj, &f75375_group);
        kfree(data);
-       i2c_set_clientdata(client, NULL);
        return 0;
 }
 
 
        sysfs_remove_group(&client->dev.kobj, &g760a_group);
 error_sysfs_create_group:
        kfree(data);
-       i2c_set_clientdata(client, NULL);
 
        return err;
 }
        hwmon_device_unregister(data->hwmon_dev);
        sysfs_remove_group(&client->dev.kobj, &g760a_group);
        kfree(data);
-       i2c_set_clientdata(client, NULL);
 
        return 0;
 }
 
 
        hwmon_device_unregister(hwmon_dev);
        sysfs_remove_group(&client->dev.kobj, &lm73_group);
-       i2c_set_clientdata(client, NULL);
        return 0;
 }
 
 
 exit_remove:
        sysfs_remove_group(&client->dev.kobj, &lm75_group);
 exit_free:
-       i2c_set_clientdata(client, NULL);
        kfree(data);
        return status;
 }
        hwmon_device_unregister(data->hwmon_dev);
        sysfs_remove_group(&client->dev.kobj, &lm75_group);
        lm75_write_value(client, LM75_REG_CONF, data->orig_conf);
-       i2c_set_clientdata(client, NULL);
        kfree(data);
        return 0;
 }
 
        hwmon_device_unregister(data->hwmon_dev);
        sysfs_remove_group(&client->dev.kobj, &lm95241_group);
 
-       i2c_set_clientdata(client, NULL);
        kfree(data);
        return 0;
 }
 
 fail_restore_config:
        tmp102_write_reg(client, TMP102_CONF_REG, tmp102->config_orig);
 fail_free:
-       i2c_set_clientdata(client, NULL);
        kfree(tmp102);
 
        return status;
                                         config | TMP102_CONF_SD);
        }
 
-       i2c_set_clientdata(client, NULL);
        kfree(tmp102);
 
        return 0;
 
        sysfs_remove_group(&client->dev.kobj, &tmp421_group);
 
 exit_free:
-       i2c_set_clientdata(client, NULL);
        kfree(data);
 
        return err;
        hwmon_device_unregister(data->hwmon_dev);
        sysfs_remove_group(&client->dev.kobj, &tmp421_group);
 
-       i2c_set_clientdata(client, NULL);
        kfree(data);
 
        return 0;
 
        if (data->lm75[1])
                i2c_unregister_device(data->lm75[1]);
 ERROR3:
-       i2c_set_clientdata(client, NULL);
        kfree(data);
 ERROR1:
        return err;
        if (data->lm75[1])
                i2c_unregister_device(data->lm75[1]);
 
-       i2c_set_clientdata(client, NULL);
        kfree(data);
 
        return 0;
 
 
        cancel_work_sync(&alert->alert);
 
-       i2c_set_clientdata(ara, NULL);
        kfree(alert);
        return 0;
 }
 
        free_irq(client->irq, kpad);
        cancel_delayed_work_sync(&kpad->work);
        input_unregister_device(kpad->input);
-       i2c_set_clientdata(client, NULL);
        kfree(kpad);
 
        return 0;
 
        struct lm8323_chip *lm = i2c_get_clientdata(client);
        int i;
 
-       i2c_set_clientdata(client, NULL);
-
        disable_irq_wake(client->irq);
        free_irq(client->irq, lm);
        cancel_work_sync(&lm->work);
 
 
        free_irq(client->irq, keypad);
        input_unregister_device(keypad->input_dev);
-       i2c_set_clientdata(client, NULL);
        kfree(keypad);
 
        return 0;
 
        input_unregister_device(qt2160->input);
        kfree(qt2160);
 
-       i2c_set_clientdata(client, NULL);
        return 0;
 }
 
 
        input_unregister_device(chip->input);
        kfree(chip);
 
-       i2c_set_clientdata(client, NULL);
-
        return 0;
 }
 
 
        struct ad714x_chip *chip = i2c_get_clientdata(client);
 
        ad714x_remove(chip);
-       i2c_set_clientdata(client, NULL);
 
        return 0;
 }
 
        input_unregister_device(lp->idev);
        kfree(lp);
 
-       i2c_set_clientdata(client, NULL);
-
        return 0;
 }
 
 
                free_irq(client->irq, touch);
 
        input_unregister_device(touch->input);
-       i2c_set_clientdata(client, NULL);
        kfree(touch);
 
        return 0;
 
        ts->bus = client;
 
        error = ad7879_construct(client, ts);
-       if (error) {
-               i2c_set_clientdata(client, NULL);
+       if (error)
                kfree(ts);
-       }
 
        return error;
 }
        struct ad7879 *ts = dev_get_drvdata(&client->dev);
 
        ad7879_destroy(client, ts);
-       i2c_set_clientdata(client, NULL);
        kfree(ts);
 
        return 0;
 
        input = NULL; /* so we dont try to free it below */
 err1:
        input_free_device(input);
-       i2c_set_clientdata(client, NULL);
        kfree(priv);
 err0:
        return err;
        enable_irq(priv->irq);
 
        input_unregister_device(priv->input);
-       i2c_set_clientdata(client, NULL);
        kfree(priv);
 
        return 0;
 
        free_irq(client->irq, data);
        input_unregister_device(data->input_dev);
        kfree(data);
-       i2c_set_clientdata(client, NULL);
 
        return 0;
 }
 
        struct tsc2007  *ts = i2c_get_clientdata(client);
        struct tsc2007_platform_data *pdata = client->dev.platform_data;
 
-       i2c_set_clientdata(client, NULL);
-
        tsc2007_free_irq(ts);
 
        if (pdata->exit_platform_hw)
 
        for (i--; i >= 0; i--)
                device_remove_file(&led->client->dev, bd2802_attributes[i]);
 failed_free:
-       i2c_set_clientdata(client, NULL);
        kfree(led);
 
        return ret;
                bd2802_disable_adv_conf(led);
        for (i = 0; i < ARRAY_SIZE(bd2802_attributes); i++)
                device_remove_file(&led->client->dev, bd2802_attributes[i]);
-       i2c_set_clientdata(client, NULL);
        kfree(led);
 
        return 0;
 
                }
 
        kfree(data);
-       i2c_set_clientdata(client, NULL);
 
        return 0;
 }
 
        mutex_init(&data->update_lock);
 
        err = pca9532_configure(client, data, pca9532_pdata);
-       if (err) {
+       if (err)
                kfree(data);
-               i2c_set_clientdata(client, NULL);
-       }
 
        return err;
 }
                }
 
        kfree(data);
-       i2c_set_clientdata(client, NULL);
        return 0;
 }
 
 
        }
 
        kfree(pca955x);
-       i2c_set_clientdata(client, NULL);
 
        return err;
 }
        }
 
        kfree(pca955x);
-       i2c_set_clientdata(client, NULL);
 
        return 0;
 }
 
 
        thermostat = NULL;
 
-       i2c_set_clientdata(client, NULL);
        kfree(th);
 
        return 0;
        rc = read_reg(th, CONFIG_REG);
        if (rc < 0) {
                dev_err(&client->dev, "Thermostat failed to read config!\n");
-               i2c_set_clientdata(client, NULL);
                kfree(th);
                return -ENODEV;
        }
 
        i2c_set_clientdata(client, lm);
 
        rc = wf_register_sensor(&lm->sens);
-       if (rc) {
-               i2c_set_clientdata(client, NULL);
+       if (rc)
                kfree(lm);
-       }
 
        return rc;
 }
        /* release sensor */
        wf_unregister_sensor(&lm->sens);
 
-       i2c_set_clientdata(client, NULL);
        return 0;
 }
 
 
 
        rc = wf_register_sensor(&max->sens);
        if (rc) {
-               i2c_set_clientdata(client, NULL);
                kfree(max);
        }
 
 
        /* XXX TODO */
 
        sat->i2c = NULL;
-       i2c_set_clientdata(client, NULL);
        return 0;
 }
 
 
        cancel_work_sync(&radio->radio_work);
        video_unregister_device(radio->videodev);
        kfree(radio);
-       i2c_set_clientdata(client, NULL);
 
        return 0;
 }
 
        ret = mt9m001_video_probe(icd, client);
        if (ret) {
                icd->ops = NULL;
-               i2c_set_clientdata(client, NULL);
                kfree(mt9m001);
        }
 
 
        icd->ops = NULL;
        mt9m001_video_remove(icd);
-       i2c_set_clientdata(client, NULL);
        client->driver = NULL;
        kfree(mt9m001);
 
 
        ret = mt9m111_video_probe(icd, client);
        if (ret) {
                icd->ops = NULL;
-               i2c_set_clientdata(client, NULL);
                kfree(mt9m111);
        }
 
        struct soc_camera_device *icd = client->dev.platform_data;
 
        icd->ops = NULL;
-       i2c_set_clientdata(client, NULL);
        client->driver = NULL;
        kfree(mt9m111);
 
 
        if (ret) {
                if (icd)
                        icd->ops = NULL;
-               i2c_set_clientdata(client, NULL);
                kfree(mt9t031);
        }
 
 
        if (icd)
                icd->ops = NULL;
-       i2c_set_clientdata(client, NULL);
        client->driver = NULL;
        kfree(mt9t031);
 
 
        ret = mt9t112_camera_probe(icd, client);
        if (ret) {
                icd->ops = NULL;
-               i2c_set_clientdata(client, NULL);
                kfree(priv);
        }
 
        struct soc_camera_device *icd = client->dev.platform_data;
 
        icd->ops = NULL;
-       i2c_set_clientdata(client, NULL);
        kfree(priv);
        return 0;
 }
 
        ret = mt9v022_video_probe(icd, client);
        if (ret) {
                icd->ops = NULL;
-               i2c_set_clientdata(client, NULL);
                kfree(mt9v022);
        }
 
 
        icd->ops = NULL;
        mt9v022_video_remove(icd);
-       i2c_set_clientdata(client, NULL);
        client->driver = NULL;
        kfree(mt9v022);
 
 
        ret = ov772x_video_probe(icd, client);
        if (ret) {
                icd->ops = NULL;
-               i2c_set_clientdata(client, NULL);
                kfree(priv);
        }
 
        struct soc_camera_device *icd = client->dev.platform_data;
 
        icd->ops = NULL;
-       i2c_set_clientdata(client, NULL);
        kfree(priv);
        return 0;
 }
 
 
        if (ret) {
                icd->ops = NULL;
-               i2c_set_clientdata(client, NULL);
                kfree(priv);
        }
 
 {
        struct ov9640_priv *priv = i2c_get_clientdata(client);
 
-       i2c_set_clientdata(client, NULL);
        kfree(priv);
        return 0;
 }
 
        ret = rj54n1_video_probe(icd, client, rj54n1_priv);
        if (ret < 0) {
                icd->ops = NULL;
-               i2c_set_clientdata(client, NULL);
                kfree(rj54n1);
                return ret;
        }
        icd->ops = NULL;
        if (icl->free_bus)
                icl->free_bus(icl);
-       i2c_set_clientdata(client, NULL);
        client->driver = NULL;
        kfree(rj54n1);
 
 
                         const struct i2c_device_id *did)
 {
        struct tcm825x_sensor *sensor = &tcm825x;
-       int rval;
 
        if (i2c_get_clientdata(client))
                return -EBUSY;
        sensor->pix.height = tcm825x_sizes[QVGA].height;
        sensor->pix.pixelformat = V4L2_PIX_FMT_RGB565;
 
-       rval = v4l2_int_device_register(sensor->v4l2_int_device);
-       if (rval)
-               i2c_set_clientdata(client, NULL);
-
-       return rval;
+       return v4l2_int_device_register(sensor->v4l2_int_device);
 }
 
 static int tcm825x_remove(struct i2c_client *client)
                return -ENODEV; /* our client isn't attached */
 
        v4l2_int_device_unregister(sensor->v4l2_int_device);
-       i2c_set_clientdata(client, NULL);
 
        return 0;
 }
 
        ret = tw9910_video_probe(icd, client);
        if (ret) {
                icd->ops = NULL;
-               i2c_set_clientdata(client, NULL);
                kfree(priv);
        }
 
        struct soc_camera_device *icd = client->dev.platform_data;
 
        icd->ops = NULL;
-       i2c_set_clientdata(client, NULL);
        kfree(priv);
        return 0;
 }
 
 
        pm860x_device_exit(chip);
        i2c_unregister_device(chip->companion);
-       i2c_set_clientdata(chip->client, NULL);
-       i2c_set_clientdata(client, NULL);
        kfree(chip);
        return 0;
 }
 
        i2c_unregister_device(ab3100->testreg_client);
  exit_no_testreg_client:
  exit_no_detect:
-       i2c_set_clientdata(client, NULL);
        kfree(ab3100);
        return err;
 }
         * their notifiers so deactivate IRQ
         */
        free_irq(client->irq, ab3100);
-       i2c_set_clientdata(client, NULL);
        kfree(ab3100);
        return 0;
 }
 
         * their notifiers so deactivate IRQ
         */
        free_irq(client->irq, ab);
-       i2c_set_clientdata(client, NULL);
        kfree(ab);
        return 0;
 }
 
                free_irq(chip->irq, chip);
 
 out_free_chip:
-       i2c_set_clientdata(client, NULL);
        kfree(chip);
 
        return ret;
 
        adp5520_remove_subdevs(chip);
        adp5520_write(chip->dev, ADP5520_MODE_STATUS, 0);
-       i2c_set_clientdata(client, NULL);
        kfree(chip);
        return 0;
 }
 
 out_free_irq:
        free_irq(client->irq, chip);
 out_free_chip:
-       i2c_set_clientdata(client, NULL);
        kfree(chip);
        return ret;
 }
        struct da903x_chip *chip = i2c_get_clientdata(client);
 
        da903x_remove_subdevs(chip);
-       i2c_set_clientdata(client, NULL);
        kfree(chip);
        return 0;
 }
 
        max8925_device_exit(chip);
        i2c_unregister_device(chip->adc);
        i2c_unregister_device(chip->rtc);
-       i2c_set_clientdata(chip->i2c, NULL);
        kfree(chip);
        return 0;
 }
 
        free_irq(client->irq, menelaus);
        flush_scheduled_work();
 fail1:
-       i2c_set_clientdata(client, NULL);
        kfree(menelaus);
        return err;
 }
        struct menelaus_chip    *menelaus = i2c_get_clientdata(client);
 
        free_irq(client->irq, menelaus);
-       i2c_set_clientdata(client, NULL);
        kfree(menelaus);
        the_menelaus = NULL;
        return 0;
 
        return 0;
 
 err_free:
-       i2c_set_clientdata(client, NULL);
        kfree(pcf);
 
        return ret;
        for (i = 0; i < PCF50633_NUM_REGULATORS; i++)
                platform_device_unregister(pcf->regulator_pdev[i]);
 
-       i2c_set_clientdata(client, NULL);
        kfree(pcf);
 
        return 0;
 
 out_removeirq:
        tc35892_irq_remove(tc35892);
 out_free:
-       i2c_set_clientdata(i2c, NULL);
        kfree(tc35892);
        return ret;
 }
        free_irq(tc35892->i2c->irq, tc35892);
        tc35892_irq_remove(tc35892);
 
-       i2c_set_clientdata(client, NULL);
        kfree(tc35892);
 
        return 0;
 
        cancel_delayed_work(&tps->work);
        flush_scheduled_work();
        debugfs_remove(tps->file);
-       i2c_set_clientdata(client, NULL);
        kfree(tps);
        the_tps = NULL;
        return 0;
 
        return ret;
 
 err:
-       i2c_set_clientdata(i2c, NULL);
        kfree(wm8350);
        return ret;
 }
        struct wm8350 *wm8350 = i2c_get_clientdata(i2c);
 
        wm8350_device_exit(wm8350);
-       i2c_set_clientdata(i2c, NULL);
        kfree(wm8350);
 
        return 0;
 
        return 0;
 
 struct_err:
-       i2c_set_clientdata(i2c, NULL);
        kfree(wm8400);
 err:
        return ret;
        struct wm8400 *wm8400 = i2c_get_clientdata(i2c);
 
        wm8400_release(wm8400);
-       i2c_set_clientdata(i2c, NULL);
        kfree(wm8400);
 
        return 0;
 
 
        kfree(at24->writebuf);
        kfree(at24);
-       i2c_set_clientdata(client, NULL);
        return 0;
 }
 
 
        /* FIXME: set_vpp needs saner arguments */
        pismo_setvpp_remove_fix(pismo);
 
-       i2c_set_clientdata(client, NULL);
        kfree(pismo);
 
        return 0;
        return 0;
 
  exit_free:
-       i2c_set_clientdata(client, NULL);
        kfree(pismo);
        return ret;
 }
 
        ret = power_supply_register(&client->dev, &chip->battery);
        if (ret) {
                dev_err(&client->dev, "failed: power supply register\n");
-               i2c_set_clientdata(client, NULL);
                kfree(chip);
                return ret;
        }
 
        power_supply_unregister(&chip->battery);
        cancel_delayed_work(&chip->work);
-       i2c_set_clientdata(client, NULL);
        kfree(chip);
        return 0;
 }
 
        struct lp3971 *lp3971 = i2c_get_clientdata(i2c);
        int i;
 
-       i2c_set_clientdata(i2c, NULL);
-
        for (i = 0; i < lp3971->num_regulators; i++)
                regulator_unregister(lp3971->rdev[i]);
 
 
        for (i = 0; i <= MAX1586_V6; i++)
                if (rdev[i])
                        regulator_unregister(rdev[i]);
-       i2c_set_clientdata(client, NULL);
        kfree(rdev);
 
        return 0;
 
        dev_info(info->dev, "Max8649 regulator device is detected.\n");
        return 0;
 out:
-       i2c_set_clientdata(client, NULL);
        kfree(info);
        return ret;
 }
        if (info) {
                if (info->regulator)
                        regulator_unregister(info->regulator);
-               i2c_set_clientdata(client, NULL);
                kfree(info);
        }
 
 
        for (i = 0; i < MAX8660_V_END; i++)
                if (rdev[i])
                        regulator_unregister(rdev[i]);
-       i2c_set_clientdata(client, NULL);
        kfree(rdev);
 
        return 0;
 
        struct tps_pmic *tps = i2c_get_clientdata(client);
        int i;
 
-       /* clear the client data in i2c */
-       i2c_set_clientdata(client, NULL);
-
        for (i = 0; i < TPS65023_NUM_REGULATOR; i++)
                regulator_unregister(tps->rdev[i]);
 
 
                free_irq(client->irq, client);
 
 out_free:
-       i2c_set_clientdata(client, NULL);
        kfree(ds1374);
        return ret;
 }
        }
 
        rtc_device_unregister(ds1374->rtc);
-       i2c_set_clientdata(client, NULL);
        kfree(ds1374);
        return 0;
 }
 
        rtc_device_unregister(rx8025->rtc);
 
 errout_free:
-       i2c_set_clientdata(client, NULL);
        kfree(rx8025);
 
 errout:
 
        rx8025_sysfs_unregister(&client->dev);
        rtc_device_unregister(rx8025->rtc);
-       i2c_set_clientdata(client, NULL);
        kfree(rx8025);
        return 0;
 }
 
                if (s35390a->client[i])
                        i2c_unregister_device(s35390a->client[i]);
        kfree(s35390a);
-       i2c_set_clientdata(client, NULL);
 
 exit:
        return err;
 
        rtc_device_unregister(s35390a->rtc);
        kfree(s35390a);
-       i2c_set_clientdata(client, NULL);
 
        return 0;
 }
 
 err_input_dev_alloc_failed:
 err_detect_failed:
 err_power_failed:
-       i2c_set_clientdata(client, NULL);
        kfree(ts);
 err_alloc_data_failed:
 err_check_functionality_failed:
        else
                hrtimer_cancel(&ts->timer);
        input_unregister_device(ts->input_dev);
-       i2c_set_clientdata(client, NULL);
        kfree(ts);
        return 0;
 }
 
        if (write_regs(client, initial_registers) < 0) {
                printk(KERN_ERR
                        "wis-saa7113: error initializing SAA7113\n");
-               i2c_set_clientdata(client, NULL);
                kfree(dec);
                return -ENODEV;
        }
 {
        struct wis_saa7113 *dec = i2c_get_clientdata(client);
 
-       i2c_set_clientdata(client, NULL);
        kfree(dec);
        return 0;
 }
 
        if (write_regs(client, initial_registers) < 0) {
                printk(KERN_ERR
                        "wis-saa7115: error initializing SAA7115\n");
-               i2c_set_clientdata(client, NULL);
                kfree(dec);
                return -ENODEV;
        }
 {
        struct wis_saa7115 *dec = i2c_get_clientdata(client);
 
-       i2c_set_clientdata(client, NULL);
        kfree(dec);
        return 0;
 }
 
 {
        struct wis_sony_tuner *t = i2c_get_clientdata(client);
 
-       i2c_set_clientdata(client, NULL);
        kfree(t);
        return 0;
 }
 
 {
        struct wis_tw2804 *dec = i2c_get_clientdata(client);
 
-       i2c_set_clientdata(client, NULL);
        kfree(dec);
        return 0;
 }
 
 
        if (write_regs(client, initial_registers) < 0) {
                printk(KERN_ERR "wis-tw9903: error initializing TW9903\n");
-               i2c_set_clientdata(client, NULL);
                kfree(dec);
                return -ENODEV;
        }
 {
        struct wis_tw9903 *dec = i2c_get_clientdata(client);
 
-       i2c_set_clientdata(client, NULL);
        kfree(dec);
        return 0;
 }
 
        if (!IS_ERR(st->reg))
                regulator_put(st->reg);
 error_free_st:
-       i2c_set_clientdata(client, NULL);
        kfree(st);
 
 error_ret:
                regulator_disable(st->reg);
                regulator_put(st->reg);
        }
-       i2c_set_clientdata(client, NULL);
        kfree(st);
 
        return 0;
 
 fail2:
        iio_device_unregister(chip->indio_dev);
 fail1:
-       i2c_set_clientdata(client, NULL);
        kfree(chip);
        return err;
 }
 
        iio_device_unregister(chip->indio_dev);
 
-       i2c_set_clientdata(client, NULL);
        kfree(chip);
        return 0;
 }
 
 out1:
        backlight_device_unregister(bl);
 out2:
-       i2c_set_clientdata(client, NULL);
        kfree(data);
 
        return ret;
                        &adp8860_bl_attr_group);
 
        backlight_device_unregister(data->bl);
-       i2c_set_clientdata(client, NULL);
        kfree(data);
 
        return 0;
 
 
 err_reg:
        data->bl = NULL;
-       i2c_set_clientdata(client, NULL);
 err_gpio_dir:
        gpio_free(TOSA_GPIO_BL_C20MA);
 err_gpio_bl:
 
        backlight_device_unregister(data->bl);
        data->bl = NULL;
-       i2c_set_clientdata(client, NULL);
 
        gpio_free(TOSA_GPIO_BL_C20MA);