tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

i2c: Remove all i2c_set_clientdata(client, NULL) in drivers

I2C drivers can use the clientdata-pointer to point to private data. As I2C
devices are not really unregistered, but merely detached from their driver, it
used to be the drivers obligation to clear this pointer during remove() or a
failed probe(). As a couple of drivers forgot to do this, it was agreed that it
was cleaner if the i2c-core does this clearance when appropriate, as there is
no guarantee for the lifetime of the clientdata-pointer after remove() anyhow.
This feature was added to the core with commit
e4a7b9b04de15f6b63da5ccdd373ffa3057a3681 to fix the faulty drivers.

As there is no need anymore to clear the clientdata-pointer, remove all current
occurrences in the drivers to simplify the code and prevent confusion.

Signed-off-by: Wolfram Sang <w.sang@pengutronix.de>
Acked-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Richard Purdie <rpurdie@linux.intel.com>
Acked-by: Dmitry Torokhov <dtor@mail.ru>
Signed-off-by: Jean Delvare <khali@linux-fr.org>

authored by

Wolfram Sang and committed by
Jean Delvare fbae3fb1 35bfc353

+4 -141
-2
drivers/hwmon/adt7411.c
··· 316 316 exit_remove: 317 317 sysfs_remove_group(&client->dev.kobj, &adt7411_attr_grp); 318 318 exit_free: 319 - i2c_set_clientdata(client, NULL); 320 319 kfree(data); 321 320 return ret; 322 321 } ··· 326 327 327 328 hwmon_device_unregister(data->hwmon_dev); 328 329 sysfs_remove_group(&client->dev.kobj, &adt7411_attr_grp); 329 - i2c_set_clientdata(client, NULL); 330 330 kfree(data); 331 331 return 0; 332 332 }
-2
drivers/hwmon/asc7621.c
··· 1141 1141 &(asc7621_params[i].sda.dev_attr)); 1142 1142 } 1143 1143 1144 - i2c_set_clientdata(client, NULL); 1145 1144 kfree(data); 1146 1145 return err; 1147 1146 } ··· 1195 1196 &(asc7621_params[i].sda.dev_attr)); 1196 1197 } 1197 1198 1198 - i2c_set_clientdata(client, NULL); 1199 1199 kfree(data); 1200 1200 return 0; 1201 1201 }
-2
drivers/hwmon/f75375s.c
··· 662 662 sysfs_remove_group(&client->dev.kobj, &f75375_group); 663 663 exit_free: 664 664 kfree(data); 665 - i2c_set_clientdata(client, NULL); 666 665 return err; 667 666 } 668 667 ··· 671 672 hwmon_device_unregister(data->hwmon_dev); 672 673 sysfs_remove_group(&client->dev.kobj, &f75375_group); 673 674 kfree(data); 674 - i2c_set_clientdata(client, NULL); 675 675 return 0; 676 676 } 677 677
-2
drivers/hwmon/g760a.c
··· 236 236 sysfs_remove_group(&client->dev.kobj, &g760a_group); 237 237 error_sysfs_create_group: 238 238 kfree(data); 239 - i2c_set_clientdata(client, NULL); 240 239 241 240 return err; 242 241 } ··· 246 247 hwmon_device_unregister(data->hwmon_dev); 247 248 sysfs_remove_group(&client->dev.kobj, &g760a_group); 248 249 kfree(data); 249 - i2c_set_clientdata(client, NULL); 250 250 251 251 return 0; 252 252 }
-1
drivers/hwmon/lm73.c
··· 136 136 137 137 hwmon_device_unregister(hwmon_dev); 138 138 sysfs_remove_group(&client->dev.kobj, &lm73_group); 139 - i2c_set_clientdata(client, NULL); 140 139 return 0; 141 140 } 142 141
-2
drivers/hwmon/lm75.c
··· 192 192 exit_remove: 193 193 sysfs_remove_group(&client->dev.kobj, &lm75_group); 194 194 exit_free: 195 - i2c_set_clientdata(client, NULL); 196 195 kfree(data); 197 196 return status; 198 197 } ··· 203 204 hwmon_device_unregister(data->hwmon_dev); 204 205 sysfs_remove_group(&client->dev.kobj, &lm75_group); 205 206 lm75_write_value(client, LM75_REG_CONF, data->orig_conf); 206 - i2c_set_clientdata(client, NULL); 207 207 kfree(data); 208 208 return 0; 209 209 }
-1
drivers/hwmon/lm95241.c
··· 399 399 hwmon_device_unregister(data->hwmon_dev); 400 400 sysfs_remove_group(&client->dev.kobj, &lm95241_group); 401 401 402 - i2c_set_clientdata(client, NULL); 403 402 kfree(data); 404 403 return 0; 405 404 }
-2
drivers/hwmon/tmp102.c
··· 224 224 fail_restore_config: 225 225 tmp102_write_reg(client, TMP102_CONF_REG, tmp102->config_orig); 226 226 fail_free: 227 - i2c_set_clientdata(client, NULL); 228 227 kfree(tmp102); 229 228 230 229 return status; ··· 246 247 config | TMP102_CONF_SD); 247 248 } 248 249 249 - i2c_set_clientdata(client, NULL); 250 250 kfree(tmp102); 251 251 252 252 return 0;
-2
drivers/hwmon/tmp421.c
··· 295 295 sysfs_remove_group(&client->dev.kobj, &tmp421_group); 296 296 297 297 exit_free: 298 - i2c_set_clientdata(client, NULL); 299 298 kfree(data); 300 299 301 300 return err; ··· 307 308 hwmon_device_unregister(data->hwmon_dev); 308 309 sysfs_remove_group(&client->dev.kobj, &tmp421_group); 309 310 310 - i2c_set_clientdata(client, NULL); 311 311 kfree(data); 312 312 313 313 return 0;
-2
drivers/hwmon/w83781d.c
··· 1197 1197 if (data->lm75[1]) 1198 1198 i2c_unregister_device(data->lm75[1]); 1199 1199 ERROR3: 1200 - i2c_set_clientdata(client, NULL); 1201 1200 kfree(data); 1202 1201 ERROR1: 1203 1202 return err; ··· 1218 1219 if (data->lm75[1]) 1219 1220 i2c_unregister_device(data->lm75[1]); 1220 1221 1221 - i2c_set_clientdata(client, NULL); 1222 1222 kfree(data); 1223 1223 1224 1224 return 0;
-1
drivers/i2c/i2c-smbus.c
··· 173 173 174 174 cancel_work_sync(&alert->alert); 175 175 176 - i2c_set_clientdata(ara, NULL); 177 176 kfree(alert); 178 177 return 0; 179 178 }
-1
drivers/input/keyboard/adp5588-keys.c
··· 287 287 free_irq(client->irq, kpad); 288 288 cancel_delayed_work_sync(&kpad->work); 289 289 input_unregister_device(kpad->input); 290 - i2c_set_clientdata(client, NULL); 291 290 kfree(kpad); 292 291 293 292 return 0;
-2
drivers/input/keyboard/lm8323.c
··· 778 778 struct lm8323_chip *lm = i2c_get_clientdata(client); 779 779 int i; 780 780 781 - i2c_set_clientdata(client, NULL); 782 - 783 781 disable_irq_wake(client->irq); 784 782 free_irq(client->irq, lm); 785 783 cancel_work_sync(&lm->work);
-1
drivers/input/keyboard/max7359_keypad.c
··· 265 265 266 266 free_irq(client->irq, keypad); 267 267 input_unregister_device(keypad->input_dev); 268 - i2c_set_clientdata(client, NULL); 269 268 kfree(keypad); 270 269 271 270 return 0;
-1
drivers/input/keyboard/qt2160.c
··· 358 358 input_unregister_device(qt2160->input); 359 359 kfree(qt2160); 360 360 361 - i2c_set_clientdata(client, NULL); 362 361 return 0; 363 362 } 364 363
-2
drivers/input/keyboard/tca6416-keypad.c
··· 316 316 input_unregister_device(chip->input); 317 317 kfree(chip); 318 318 319 - i2c_set_clientdata(client, NULL); 320 - 321 319 return 0; 322 320 } 323 321
-1
drivers/input/misc/ad714x-i2c.c
··· 97 97 struct ad714x_chip *chip = i2c_get_clientdata(client); 98 98 99 99 ad714x_remove(chip); 100 - i2c_set_clientdata(client, NULL); 101 100 102 101 return 0; 103 102 }
-2
drivers/input/misc/pcf8574_keypad.c
··· 168 168 input_unregister_device(lp->idev); 169 169 kfree(lp); 170 170 171 - i2c_set_clientdata(client, NULL); 172 - 173 171 return 0; 174 172 } 175 173
-1
drivers/input/mouse/synaptics_i2c.c
··· 613 613 free_irq(client->irq, touch); 614 614 615 615 input_unregister_device(touch->input); 616 - i2c_set_clientdata(client, NULL); 617 616 kfree(touch); 618 617 619 618 return 0;
+1 -4
drivers/input/touchscreen/ad7879.c
··· 812 812 ts->bus = client; 813 813 814 814 error = ad7879_construct(client, ts); 815 - if (error) { 816 - i2c_set_clientdata(client, NULL); 815 + if (error) 817 816 kfree(ts); 818 - } 819 817 820 818 return error; 821 819 } ··· 823 825 struct ad7879 *ts = dev_get_drvdata(&client->dev); 824 826 825 827 ad7879_destroy(client, ts); 826 - i2c_set_clientdata(client, NULL); 827 828 kfree(ts); 828 829 829 830 return 0;
-2
drivers/input/touchscreen/eeti_ts.c
··· 238 238 input = NULL; /* so we dont try to free it below */ 239 239 err1: 240 240 input_free_device(input); 241 - i2c_set_clientdata(client, NULL); 242 241 kfree(priv); 243 242 err0: 244 243 return err; ··· 255 256 enable_irq(priv->irq); 256 257 257 258 input_unregister_device(priv->input); 258 - i2c_set_clientdata(client, NULL); 259 259 kfree(priv); 260 260 261 261 return 0;
-1
drivers/input/touchscreen/mcs5000_ts.c
··· 256 256 free_irq(client->irq, data); 257 257 input_unregister_device(data->input_dev); 258 258 kfree(data); 259 - i2c_set_clientdata(client, NULL); 260 259 261 260 return 0; 262 261 }
-2
drivers/input/touchscreen/tsc2007.c
··· 347 347 struct tsc2007 *ts = i2c_get_clientdata(client); 348 348 struct tsc2007_platform_data *pdata = client->dev.platform_data; 349 349 350 - i2c_set_clientdata(client, NULL); 351 - 352 350 tsc2007_free_irq(ts); 353 351 354 352 if (pdata->exit_platform_hw)
-2
drivers/leds/leds-bd2802.c
··· 742 742 for (i--; i >= 0; i--) 743 743 device_remove_file(&led->client->dev, bd2802_attributes[i]); 744 744 failed_free: 745 - i2c_set_clientdata(client, NULL); 746 745 kfree(led); 747 746 748 747 return ret; ··· 758 759 bd2802_disable_adv_conf(led); 759 760 for (i = 0; i < ARRAY_SIZE(bd2802_attributes); i++) 760 761 device_remove_file(&led->client->dev, bd2802_attributes[i]); 761 - i2c_set_clientdata(client, NULL); 762 762 kfree(led); 763 763 764 764 return 0;
-1
drivers/leds/leds-lp3944.c
··· 432 432 } 433 433 434 434 kfree(data); 435 - i2c_set_clientdata(client, NULL); 436 435 437 436 return 0; 438 437 }
+1 -4
drivers/leds/leds-pca9532.c
··· 320 320 mutex_init(&data->update_lock); 321 321 322 322 err = pca9532_configure(client, data, pca9532_pdata); 323 - if (err) { 323 + if (err) 324 324 kfree(data); 325 - i2c_set_clientdata(client, NULL); 326 - } 327 325 328 326 return err; 329 327 } ··· 349 351 } 350 352 351 353 kfree(data); 352 - i2c_set_clientdata(client, NULL); 353 354 return 0; 354 355 } 355 356
-2
drivers/leds/leds-pca955x.c
··· 342 342 } 343 343 344 344 kfree(pca955x); 345 - i2c_set_clientdata(client, NULL); 346 345 347 346 return err; 348 347 } ··· 357 358 } 358 359 359 360 kfree(pca955x); 360 - i2c_set_clientdata(client, NULL); 361 361 362 362 return 0; 363 363 }
-2
drivers/macintosh/therm_adt746x.c
··· 182 182 183 183 thermostat = NULL; 184 184 185 - i2c_set_clientdata(client, NULL); 186 185 kfree(th); 187 186 188 187 return 0; ··· 399 400 rc = read_reg(th, CONFIG_REG); 400 401 if (rc < 0) { 401 402 dev_err(&client->dev, "Thermostat failed to read config!\n"); 402 - i2c_set_clientdata(client, NULL); 403 403 kfree(th); 404 404 return -ENODEV; 405 405 }
+1 -4
drivers/macintosh/windfarm_lm75_sensor.c
··· 107 107 i2c_set_clientdata(client, lm); 108 108 109 109 rc = wf_register_sensor(&lm->sens); 110 - if (rc) { 111 - i2c_set_clientdata(client, NULL); 110 + if (rc) 112 111 kfree(lm); 113 - } 114 112 115 113 return rc; 116 114 } ··· 214 216 /* release sensor */ 215 217 wf_unregister_sensor(&lm->sens); 216 218 217 - i2c_set_clientdata(client, NULL); 218 219 return 0; 219 220 } 220 221
-1
drivers/macintosh/windfarm_max6690_sensor.c
··· 81 81 82 82 rc = wf_register_sensor(&max->sens); 83 83 if (rc) { 84 - i2c_set_clientdata(client, NULL); 85 84 kfree(max); 86 85 } 87 86
-1
drivers/macintosh/windfarm_smu_sat.c
··· 376 376 /* XXX TODO */ 377 377 378 378 sat->i2c = NULL; 379 - i2c_set_clientdata(client, NULL); 380 379 return 0; 381 380 } 382 381
-1
drivers/media/radio/si470x/radio-si470x-i2c.c
··· 482 482 cancel_work_sync(&radio->radio_work); 483 483 video_unregister_device(radio->videodev); 484 484 kfree(radio); 485 - i2c_set_clientdata(client, NULL); 486 485 487 486 return 0; 488 487 }
-2
drivers/media/video/mt9m001.c
··· 785 785 ret = mt9m001_video_probe(icd, client); 786 786 if (ret) { 787 787 icd->ops = NULL; 788 - i2c_set_clientdata(client, NULL); 789 788 kfree(mt9m001); 790 789 } 791 790 ··· 798 799 799 800 icd->ops = NULL; 800 801 mt9m001_video_remove(icd); 801 - i2c_set_clientdata(client, NULL); 802 802 client->driver = NULL; 803 803 kfree(mt9m001); 804 804
-2
drivers/media/video/mt9m111.c
··· 1068 1068 ret = mt9m111_video_probe(icd, client); 1069 1069 if (ret) { 1070 1070 icd->ops = NULL; 1071 - i2c_set_clientdata(client, NULL); 1072 1071 kfree(mt9m111); 1073 1072 } 1074 1073 ··· 1080 1081 struct soc_camera_device *icd = client->dev.platform_data; 1081 1082 1082 1083 icd->ops = NULL; 1083 - i2c_set_clientdata(client, NULL); 1084 1084 client->driver = NULL; 1085 1085 kfree(mt9m111); 1086 1086
-2
drivers/media/video/mt9t031.c
··· 883 883 if (ret) { 884 884 if (icd) 885 885 icd->ops = NULL; 886 - i2c_set_clientdata(client, NULL); 887 886 kfree(mt9t031); 888 887 } 889 888 ··· 896 897 897 898 if (icd) 898 899 icd->ops = NULL; 899 - i2c_set_clientdata(client, NULL); 900 900 client->driver = NULL; 901 901 kfree(mt9t031); 902 902
-2
drivers/media/video/mt9t112.c
··· 1119 1119 ret = mt9t112_camera_probe(icd, client); 1120 1120 if (ret) { 1121 1121 icd->ops = NULL; 1122 - i2c_set_clientdata(client, NULL); 1123 1122 kfree(priv); 1124 1123 } 1125 1124 ··· 1131 1132 struct soc_camera_device *icd = client->dev.platform_data; 1132 1133 1133 1134 icd->ops = NULL; 1134 - i2c_set_clientdata(client, NULL); 1135 1135 kfree(priv); 1136 1136 return 0; 1137 1137 }
-2
drivers/media/video/mt9v022.c
··· 920 920 ret = mt9v022_video_probe(icd, client); 921 921 if (ret) { 922 922 icd->ops = NULL; 923 - i2c_set_clientdata(client, NULL); 924 923 kfree(mt9v022); 925 924 } 926 925 ··· 933 934 934 935 icd->ops = NULL; 935 936 mt9v022_video_remove(icd); 936 - i2c_set_clientdata(client, NULL); 937 937 client->driver = NULL; 938 938 kfree(mt9v022); 939 939
-2
drivers/media/video/ov772x.c
··· 1159 1159 ret = ov772x_video_probe(icd, client); 1160 1160 if (ret) { 1161 1161 icd->ops = NULL; 1162 - i2c_set_clientdata(client, NULL); 1163 1162 kfree(priv); 1164 1163 } 1165 1164 ··· 1171 1172 struct soc_camera_device *icd = client->dev.platform_data; 1172 1173 1173 1174 icd->ops = NULL; 1174 - i2c_set_clientdata(client, NULL); 1175 1175 kfree(priv); 1176 1176 return 0; 1177 1177 }
-2
drivers/media/video/ov9640.c
··· 783 783 784 784 if (ret) { 785 785 icd->ops = NULL; 786 - i2c_set_clientdata(client, NULL); 787 786 kfree(priv); 788 787 } 789 788 ··· 793 794 { 794 795 struct ov9640_priv *priv = i2c_get_clientdata(client); 795 796 796 - i2c_set_clientdata(client, NULL); 797 797 kfree(priv); 798 798 return 0; 799 799 }
-2
drivers/media/video/rj54n1cb0c.c
··· 1444 1444 ret = rj54n1_video_probe(icd, client, rj54n1_priv); 1445 1445 if (ret < 0) { 1446 1446 icd->ops = NULL; 1447 - i2c_set_clientdata(client, NULL); 1448 1447 kfree(rj54n1); 1449 1448 return ret; 1450 1449 } ··· 1460 1461 icd->ops = NULL; 1461 1462 if (icl->free_bus) 1462 1463 icl->free_bus(icl); 1463 - i2c_set_clientdata(client, NULL); 1464 1464 client->driver = NULL; 1465 1465 kfree(rj54n1); 1466 1466
+1 -7
drivers/media/video/tcm825x.c
··· 850 850 const struct i2c_device_id *did) 851 851 { 852 852 struct tcm825x_sensor *sensor = &tcm825x; 853 - int rval; 854 853 855 854 if (i2c_get_clientdata(client)) 856 855 return -EBUSY; ··· 870 871 sensor->pix.height = tcm825x_sizes[QVGA].height; 871 872 sensor->pix.pixelformat = V4L2_PIX_FMT_RGB565; 872 873 873 - rval = v4l2_int_device_register(sensor->v4l2_int_device); 874 - if (rval) 875 - i2c_set_clientdata(client, NULL); 876 - 877 - return rval; 874 + return v4l2_int_device_register(sensor->v4l2_int_device); 878 875 } 879 876 880 877 static int tcm825x_remove(struct i2c_client *client) ··· 881 886 return -ENODEV; /* our client isn't attached */ 882 887 883 888 v4l2_int_device_unregister(sensor->v4l2_int_device); 884 - i2c_set_clientdata(client, NULL); 885 889 886 890 return 0; 887 891 }
-2
drivers/media/video/tw9910.c
··· 977 977 ret = tw9910_video_probe(icd, client); 978 978 if (ret) { 979 979 icd->ops = NULL; 980 - i2c_set_clientdata(client, NULL); 981 980 kfree(priv); 982 981 } 983 982 ··· 989 990 struct soc_camera_device *icd = client->dev.platform_data; 990 991 991 992 icd->ops = NULL; 992 - i2c_set_clientdata(client, NULL); 993 993 kfree(priv); 994 994 return 0; 995 995 }
-2
drivers/mfd/88pm860x-i2c.c
··· 200 200 201 201 pm860x_device_exit(chip); 202 202 i2c_unregister_device(chip->companion); 203 - i2c_set_clientdata(chip->client, NULL); 204 - i2c_set_clientdata(client, NULL); 205 203 kfree(chip); 206 204 return 0; 207 205 }
-2
drivers/mfd/ab3100-core.c
··· 957 957 i2c_unregister_device(ab3100->testreg_client); 958 958 exit_no_testreg_client: 959 959 exit_no_detect: 960 - i2c_set_clientdata(client, NULL); 961 960 kfree(ab3100); 962 961 return err; 963 962 } ··· 978 979 * their notifiers so deactivate IRQ 979 980 */ 980 981 free_irq(client->irq, ab3100); 981 - i2c_set_clientdata(client, NULL); 982 982 kfree(ab3100); 983 983 return 0; 984 984 }
-1
drivers/mfd/ab3550-core.c
··· 1362 1362 * their notifiers so deactivate IRQ 1363 1363 */ 1364 1364 free_irq(client->irq, ab); 1365 - i2c_set_clientdata(client, NULL); 1366 1365 kfree(ab); 1367 1366 return 0; 1368 1367 }
-2
drivers/mfd/adp5520.c
··· 302 302 free_irq(chip->irq, chip); 303 303 304 304 out_free_chip: 305 - i2c_set_clientdata(client, NULL); 306 305 kfree(chip); 307 306 308 307 return ret; ··· 316 317 317 318 adp5520_remove_subdevs(chip); 318 319 adp5520_write(chip->dev, ADP5520_MODE_STATUS, 0); 319 - i2c_set_clientdata(client, NULL); 320 320 kfree(chip); 321 321 return 0; 322 322 }
-2
drivers/mfd/da903x.c
··· 534 534 out_free_irq: 535 535 free_irq(client->irq, chip); 536 536 out_free_chip: 537 - i2c_set_clientdata(client, NULL); 538 537 kfree(chip); 539 538 return ret; 540 539 } ··· 543 544 struct da903x_chip *chip = i2c_get_clientdata(client); 544 545 545 546 da903x_remove_subdevs(chip); 546 - i2c_set_clientdata(client, NULL); 547 547 kfree(chip); 548 548 return 0; 549 549 }
-1
drivers/mfd/max8925-i2c.c
··· 173 173 max8925_device_exit(chip); 174 174 i2c_unregister_device(chip->adc); 175 175 i2c_unregister_device(chip->rtc); 176 - i2c_set_clientdata(chip->i2c, NULL); 177 176 kfree(chip); 178 177 return 0; 179 178 }
-2
drivers/mfd/menelaus.c
··· 1228 1228 free_irq(client->irq, menelaus); 1229 1229 flush_scheduled_work(); 1230 1230 fail1: 1231 - i2c_set_clientdata(client, NULL); 1232 1231 kfree(menelaus); 1233 1232 return err; 1234 1233 } ··· 1237 1238 struct menelaus_chip *menelaus = i2c_get_clientdata(client); 1238 1239 1239 1240 free_irq(client->irq, menelaus); 1240 - i2c_set_clientdata(client, NULL); 1241 1241 kfree(menelaus); 1242 1242 the_menelaus = NULL; 1243 1243 return 0;
-2
drivers/mfd/pcf50633-core.c
··· 336 336 return 0; 337 337 338 338 err_free: 339 - i2c_set_clientdata(client, NULL); 340 339 kfree(pcf); 341 340 342 341 return ret; ··· 356 357 for (i = 0; i < PCF50633_NUM_REGULATORS; i++) 357 358 platform_device_unregister(pcf->regulator_pdev[i]); 358 359 359 - i2c_set_clientdata(client, NULL); 360 360 kfree(pcf); 361 361 362 362 return 0;
-2
drivers/mfd/tc35892.c
··· 296 296 out_removeirq: 297 297 tc35892_irq_remove(tc35892); 298 298 out_free: 299 - i2c_set_clientdata(i2c, NULL); 300 299 kfree(tc35892); 301 300 return ret; 302 301 } ··· 309 310 free_irq(tc35892->i2c->irq, tc35892); 310 311 tc35892_irq_remove(tc35892); 311 312 312 - i2c_set_clientdata(client, NULL); 313 313 kfree(tc35892); 314 314 315 315 return 0;
-1
drivers/mfd/tps65010.c
··· 530 530 cancel_delayed_work(&tps->work); 531 531 flush_scheduled_work(); 532 532 debugfs_remove(tps->file); 533 - i2c_set_clientdata(client, NULL); 534 533 kfree(tps); 535 534 the_tps = NULL; 536 535 return 0;
-2
drivers/mfd/wm8350-i2c.c
··· 80 80 return ret; 81 81 82 82 err: 83 - i2c_set_clientdata(i2c, NULL); 84 83 kfree(wm8350); 85 84 return ret; 86 85 } ··· 89 90 struct wm8350 *wm8350 = i2c_get_clientdata(i2c); 90 91 91 92 wm8350_device_exit(wm8350); 92 - i2c_set_clientdata(i2c, NULL); 93 93 kfree(wm8350); 94 94 95 95 return 0;
-2
drivers/mfd/wm8400-core.c
··· 415 415 return 0; 416 416 417 417 struct_err: 418 - i2c_set_clientdata(i2c, NULL); 419 418 kfree(wm8400); 420 419 err: 421 420 return ret; ··· 425 426 struct wm8400 *wm8400 = i2c_get_clientdata(i2c); 426 427 427 428 wm8400_release(wm8400); 428 - i2c_set_clientdata(i2c, NULL); 429 429 kfree(wm8400); 430 430 431 431 return 0;
-1
drivers/misc/eeprom/at24.c
··· 643 643 644 644 kfree(at24->writebuf); 645 645 kfree(at24); 646 - i2c_set_clientdata(client, NULL); 647 646 return 0; 648 647 } 649 648
-2
drivers/mtd/maps/pismo.c
··· 234 234 /* FIXME: set_vpp needs saner arguments */ 235 235 pismo_setvpp_remove_fix(pismo); 236 236 237 - i2c_set_clientdata(client, NULL); 238 237 kfree(pismo); 239 238 240 239 return 0; ··· 285 286 return 0; 286 287 287 288 exit_free: 288 - i2c_set_clientdata(client, NULL); 289 289 kfree(pismo); 290 290 return ret; 291 291 }
-2
drivers/power/max17040_battery.c
··· 225 225 ret = power_supply_register(&client->dev, &chip->battery); 226 226 if (ret) { 227 227 dev_err(&client->dev, "failed: power supply register\n"); 228 - i2c_set_clientdata(client, NULL); 229 228 kfree(chip); 230 229 return ret; 231 230 } ··· 244 245 245 246 power_supply_unregister(&chip->battery); 246 247 cancel_delayed_work(&chip->work); 247 - i2c_set_clientdata(client, NULL); 248 248 kfree(chip); 249 249 return 0; 250 250 }
-2
drivers/regulator/lp3971.c
··· 519 519 struct lp3971 *lp3971 = i2c_get_clientdata(i2c); 520 520 int i; 521 521 522 - i2c_set_clientdata(i2c, NULL); 523 - 524 522 for (i = 0; i < lp3971->num_regulators; i++) 525 523 regulator_unregister(lp3971->rdev[i]); 526 524
-1
drivers/regulator/max1586.c
··· 244 244 for (i = 0; i <= MAX1586_V6; i++) 245 245 if (rdev[i]) 246 246 regulator_unregister(rdev[i]); 247 - i2c_set_clientdata(client, NULL); 248 247 kfree(rdev); 249 248 250 249 return 0;
-2
drivers/regulator/max8649.c
··· 357 357 dev_info(info->dev, "Max8649 regulator device is detected.\n"); 358 358 return 0; 359 359 out: 360 - i2c_set_clientdata(client, NULL); 361 360 kfree(info); 362 361 return ret; 363 362 } ··· 368 369 if (info) { 369 370 if (info->regulator) 370 371 regulator_unregister(info->regulator); 371 - i2c_set_clientdata(client, NULL); 372 372 kfree(info); 373 373 } 374 374
-1
drivers/regulator/max8660.c
··· 471 471 for (i = 0; i < MAX8660_V_END; i++) 472 472 if (rdev[i]) 473 473 regulator_unregister(rdev[i]); 474 - i2c_set_clientdata(client, NULL); 475 474 kfree(rdev); 476 475 477 476 return 0;
-3
drivers/regulator/tps65023-regulator.c
··· 538 538 struct tps_pmic *tps = i2c_get_clientdata(client); 539 539 int i; 540 540 541 - /* clear the client data in i2c */ 542 - i2c_set_clientdata(client, NULL); 543 - 544 541 for (i = 0; i < TPS65023_NUM_REGULATOR; i++) 545 542 regulator_unregister(tps->rdev[i]); 546 543
-2
drivers/rtc/rtc-ds1374.c
··· 403 403 free_irq(client->irq, client); 404 404 405 405 out_free: 406 - i2c_set_clientdata(client, NULL); 407 406 kfree(ds1374); 408 407 return ret; 409 408 } ··· 421 422 } 422 423 423 424 rtc_device_unregister(ds1374->rtc); 424 - i2c_set_clientdata(client, NULL); 425 425 kfree(ds1374); 426 426 return 0; 427 427 }
-2
drivers/rtc/rtc-rx8025.c
··· 632 632 rtc_device_unregister(rx8025->rtc); 633 633 634 634 errout_free: 635 - i2c_set_clientdata(client, NULL); 636 635 kfree(rx8025); 637 636 638 637 errout: ··· 655 656 656 657 rx8025_sysfs_unregister(&client->dev); 657 658 rtc_device_unregister(rx8025->rtc); 658 - i2c_set_clientdata(client, NULL); 659 659 kfree(rx8025); 660 660 return 0; 661 661 }
-2
drivers/rtc/rtc-s35390a.c
··· 275 275 if (s35390a->client[i]) 276 276 i2c_unregister_device(s35390a->client[i]); 277 277 kfree(s35390a); 278 - i2c_set_clientdata(client, NULL); 279 278 280 279 exit: 281 280 return err; ··· 291 292 292 293 rtc_device_unregister(s35390a->rtc); 293 294 kfree(s35390a); 294 - i2c_set_clientdata(client, NULL); 295 295 296 296 return 0; 297 297 }
-2
drivers/staging/dream/synaptics_i2c_rmi.c
··· 519 519 err_input_dev_alloc_failed: 520 520 err_detect_failed: 521 521 err_power_failed: 522 - i2c_set_clientdata(client, NULL); 523 522 kfree(ts); 524 523 err_alloc_data_failed: 525 524 err_check_functionality_failed: ··· 536 537 else 537 538 hrtimer_cancel(&ts->timer); 538 539 input_unregister_device(ts->input_dev); 539 - i2c_set_clientdata(client, NULL); 540 540 kfree(ts); 541 541 return 0; 542 542 }
-2
drivers/staging/go7007/wis-saa7113.c
··· 289 289 if (write_regs(client, initial_registers) < 0) { 290 290 printk(KERN_ERR 291 291 "wis-saa7113: error initializing SAA7113\n"); 292 - i2c_set_clientdata(client, NULL); 293 292 kfree(dec); 294 293 return -ENODEV; 295 294 } ··· 300 301 { 301 302 struct wis_saa7113 *dec = i2c_get_clientdata(client); 302 303 303 - i2c_set_clientdata(client, NULL); 304 304 kfree(dec); 305 305 return 0; 306 306 }
-2
drivers/staging/go7007/wis-saa7115.c
··· 422 422 if (write_regs(client, initial_registers) < 0) { 423 423 printk(KERN_ERR 424 424 "wis-saa7115: error initializing SAA7115\n"); 425 - i2c_set_clientdata(client, NULL); 426 425 kfree(dec); 427 426 return -ENODEV; 428 427 } ··· 433 434 { 434 435 struct wis_saa7115 *dec = i2c_get_clientdata(client); 435 436 436 - i2c_set_clientdata(client, NULL); 437 437 kfree(dec); 438 438 return 0; 439 439 }
-1
drivers/staging/go7007/wis-sony-tuner.c
··· 684 684 { 685 685 struct wis_sony_tuner *t = i2c_get_clientdata(client); 686 686 687 - i2c_set_clientdata(client, NULL); 688 687 kfree(t); 689 688 return 0; 690 689 }
-1
drivers/staging/go7007/wis-tw2804.c
··· 323 323 { 324 324 struct wis_tw2804 *dec = i2c_get_clientdata(client); 325 325 326 - i2c_set_clientdata(client, NULL); 327 326 kfree(dec); 328 327 return 0; 329 328 }
-2
drivers/staging/go7007/wis-tw9903.c
··· 294 294 295 295 if (write_regs(client, initial_registers) < 0) { 296 296 printk(KERN_ERR "wis-tw9903: error initializing TW9903\n"); 297 - i2c_set_clientdata(client, NULL); 298 297 kfree(dec); 299 298 return -ENODEV; 300 299 } ··· 305 306 { 306 307 struct wis_tw9903 *dec = i2c_get_clientdata(client); 307 308 308 - i2c_set_clientdata(client, NULL); 309 309 kfree(dec); 310 310 return 0; 311 311 }
-2
drivers/staging/iio/adc/max1363_core.c
··· 1011 1011 if (!IS_ERR(st->reg)) 1012 1012 regulator_put(st->reg); 1013 1013 error_free_st: 1014 - i2c_set_clientdata(client, NULL); 1015 1014 kfree(st); 1016 1015 1017 1016 error_ret: ··· 1029 1030 regulator_disable(st->reg); 1030 1031 regulator_put(st->reg); 1031 1032 } 1032 - i2c_set_clientdata(client, NULL); 1033 1033 kfree(st); 1034 1034 1035 1035 return 0;
-2
drivers/staging/iio/light/tsl2563.c
··· 694 694 fail2: 695 695 iio_device_unregister(chip->indio_dev); 696 696 fail1: 697 - i2c_set_clientdata(client, NULL); 698 697 kfree(chip); 699 698 return err; 700 699 } ··· 704 705 705 706 iio_device_unregister(chip->indio_dev); 706 707 707 - i2c_set_clientdata(client, NULL); 708 708 kfree(chip); 709 709 return 0; 710 710 }
-2
drivers/video/backlight/adp8860_bl.c
··· 756 756 out1: 757 757 backlight_device_unregister(bl); 758 758 out2: 759 - i2c_set_clientdata(client, NULL); 760 759 kfree(data); 761 760 762 761 return ret; ··· 775 776 &adp8860_bl_attr_group); 776 777 777 778 backlight_device_unregister(data->bl); 778 - i2c_set_clientdata(client, NULL); 779 779 kfree(data); 780 780 781 781 return 0;
-2
drivers/video/backlight/tosa_bl.c
··· 119 119 120 120 err_reg: 121 121 data->bl = NULL; 122 - i2c_set_clientdata(client, NULL); 123 122 err_gpio_dir: 124 123 gpio_free(TOSA_GPIO_BL_C20MA); 125 124 err_gpio_bl: ··· 132 133 133 134 backlight_device_unregister(data->bl); 134 135 data->bl = NULL; 135 - i2c_set_clientdata(client, NULL); 136 136 137 137 gpio_free(TOSA_GPIO_BL_C20MA); 138 138