i2c-dev.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. i2c-dev.c - i2c-bus driver, char device interface
  4. Copyright (C) 1995-97 Simon G. Vogl
  5. Copyright (C) 1998-99 Frodo Looijaard <frodol@dds.nl>
  6. Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com>
  7. */
  8. /* Note that this is a complete rewrite of Simon Vogl's i2c-dev module.
  9. But I have used so much of his original code and ideas that it seems
  10. only fair to recognize him as co-author -- Frodo */
  11. /* The I2C_RDWR ioctl code is written by Kolja Waschk <waschk@telos.de> */
  12. #include <linux/cdev.h>
  13. #include <linux/compat.h>
  14. #include <linux/device.h>
  15. #include <linux/fs.h>
  16. #include <linux/i2c-dev.h>
  17. #include <linux/i2c.h>
  18. #include <linux/init.h>
  19. #include <linux/jiffies.h>
  20. #include <linux/kernel.h>
  21. #include <linux/list.h>
  22. #include <linux/module.h>
  23. #include <linux/notifier.h>
  24. #include <linux/slab.h>
  25. #include <linux/uaccess.h>
  26. /*
  27. * An i2c_dev represents an i2c_adapter ... an I2C or SMBus master, not a
  28. * slave (i2c_client) with which messages will be exchanged. It's coupled
  29. * with a character special file which is accessed by user mode drivers.
  30. *
  31. * The list of i2c_dev structures is parallel to the i2c_adapter lists
  32. * maintained by the driver model, and is updated using bus notifications.
  33. */
  34. struct i2c_dev {
  35. struct list_head list;
  36. struct i2c_adapter *adap;
  37. struct device dev;
  38. struct cdev cdev;
  39. };
  40. #define I2C_MINORS (MINORMASK + 1)
  41. static LIST_HEAD(i2c_dev_list);
  42. static DEFINE_SPINLOCK(i2c_dev_list_lock);
  43. static struct i2c_dev *i2c_dev_get_by_minor(unsigned index)
  44. {
  45. struct i2c_dev *i2c_dev;
  46. spin_lock(&i2c_dev_list_lock);
  47. list_for_each_entry(i2c_dev, &i2c_dev_list, list) {
  48. if (i2c_dev->adap->nr == index)
  49. goto found;
  50. }
  51. i2c_dev = NULL;
  52. found:
  53. spin_unlock(&i2c_dev_list_lock);
  54. return i2c_dev;
  55. }
  56. static struct i2c_dev *get_free_i2c_dev(struct i2c_adapter *adap)
  57. {
  58. struct i2c_dev *i2c_dev;
  59. if (adap->nr >= I2C_MINORS) {
  60. printk(KERN_ERR "i2c-dev: Out of device minors (%d)\n",
  61. adap->nr);
  62. return ERR_PTR(-ENODEV);
  63. }
  64. i2c_dev = kzalloc(sizeof(*i2c_dev), GFP_KERNEL);
  65. if (!i2c_dev)
  66. return ERR_PTR(-ENOMEM);
  67. i2c_dev->adap = adap;
  68. spin_lock(&i2c_dev_list_lock);
  69. list_add_tail(&i2c_dev->list, &i2c_dev_list);
  70. spin_unlock(&i2c_dev_list_lock);
  71. return i2c_dev;
  72. }
  73. static void put_i2c_dev(struct i2c_dev *i2c_dev, bool del_cdev)
  74. {
  75. spin_lock(&i2c_dev_list_lock);
  76. list_del(&i2c_dev->list);
  77. spin_unlock(&i2c_dev_list_lock);
  78. if (del_cdev)
  79. cdev_device_del(&i2c_dev->cdev, &i2c_dev->dev);
  80. put_device(&i2c_dev->dev);
  81. }
  82. static ssize_t name_show(struct device *dev,
  83. struct device_attribute *attr, char *buf)
  84. {
  85. struct i2c_dev *i2c_dev = i2c_dev_get_by_minor(MINOR(dev->devt));
  86. if (!i2c_dev)
  87. return -ENODEV;
  88. return sprintf(buf, "%s\n", i2c_dev->adap->name);
  89. }
  90. static DEVICE_ATTR_RO(name);
  91. static struct attribute *i2c_attrs[] = {
  92. &dev_attr_name.attr,
  93. NULL,
  94. };
  95. ATTRIBUTE_GROUPS(i2c);
  96. /* ------------------------------------------------------------------------- */
  97. /*
  98. * After opening an instance of this character special file, a file
  99. * descriptor starts out associated only with an i2c_adapter (and bus).
  100. *
  101. * Using the I2C_RDWR ioctl(), you can then *immediately* issue i2c_msg
  102. * traffic to any devices on the bus used by that adapter. That's because
  103. * the i2c_msg vectors embed all the addressing information they need, and
  104. * are submitted directly to an i2c_adapter. However, SMBus-only adapters
  105. * don't support that interface.
  106. *
  107. * To use read()/write() system calls on that file descriptor, or to use
  108. * SMBus interfaces (and work with SMBus-only hosts!), you must first issue
  109. * an I2C_SLAVE (or I2C_SLAVE_FORCE) ioctl. That configures an anonymous
  110. * (never registered) i2c_client so it holds the addressing information
  111. * needed by those system calls and by this SMBus interface.
  112. */
  113. static ssize_t i2cdev_read(struct file *file, char __user *buf, size_t count,
  114. loff_t *offset)
  115. {
  116. char *tmp;
  117. int ret;
  118. struct i2c_client *client = file->private_data;
  119. if (count > 8192)
  120. count = 8192;
  121. tmp = kzalloc(count, GFP_KERNEL);
  122. if (tmp == NULL)
  123. return -ENOMEM;
  124. pr_debug("i2c-dev: i2c-%d reading %zu bytes.\n",
  125. iminor(file_inode(file)), count);
  126. ret = i2c_master_recv(client, tmp, count);
  127. if (ret >= 0)
  128. if (copy_to_user(buf, tmp, ret))
  129. ret = -EFAULT;
  130. kfree(tmp);
  131. return ret;
  132. }
  133. static ssize_t i2cdev_write(struct file *file, const char __user *buf,
  134. size_t count, loff_t *offset)
  135. {
  136. int ret;
  137. char *tmp;
  138. struct i2c_client *client = file->private_data;
  139. if (count > 8192)
  140. count = 8192;
  141. tmp = memdup_user(buf, count);
  142. if (IS_ERR(tmp))
  143. return PTR_ERR(tmp);
  144. pr_debug("i2c-dev: i2c-%d writing %zu bytes.\n",
  145. iminor(file_inode(file)), count);
  146. ret = i2c_master_send(client, tmp, count);
  147. kfree(tmp);
  148. return ret;
  149. }
  150. static int i2cdev_check(struct device *dev, void *addrp)
  151. {
  152. struct i2c_client *client = i2c_verify_client(dev);
  153. if (!client || client->addr != *(unsigned int *)addrp)
  154. return 0;
  155. return dev->driver ? -EBUSY : 0;
  156. }
  157. /* walk up mux tree */
  158. static int i2cdev_check_mux_parents(struct i2c_adapter *adapter, int addr)
  159. {
  160. struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
  161. int result;
  162. result = device_for_each_child(&adapter->dev, &addr, i2cdev_check);
  163. if (!result && parent)
  164. result = i2cdev_check_mux_parents(parent, addr);
  165. return result;
  166. }
  167. /* recurse down mux tree */
  168. static int i2cdev_check_mux_children(struct device *dev, void *addrp)
  169. {
  170. int result;
  171. if (dev->type == &i2c_adapter_type)
  172. result = device_for_each_child(dev, addrp,
  173. i2cdev_check_mux_children);
  174. else
  175. result = i2cdev_check(dev, addrp);
  176. return result;
  177. }
  178. /* This address checking function differs from the one in i2c-core
  179. in that it considers an address with a registered device, but no
  180. driver bound to it, as NOT busy. */
  181. static int i2cdev_check_addr(struct i2c_adapter *adapter, unsigned int addr)
  182. {
  183. struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
  184. int result = 0;
  185. if (parent)
  186. result = i2cdev_check_mux_parents(parent, addr);
  187. if (!result)
  188. result = device_for_each_child(&adapter->dev, &addr,
  189. i2cdev_check_mux_children);
  190. return result;
  191. }
  192. static noinline int i2cdev_ioctl_rdwr(struct i2c_client *client,
  193. unsigned nmsgs, struct i2c_msg *msgs)
  194. {
  195. u8 __user **data_ptrs;
  196. int i, res;
  197. data_ptrs = kmalloc_array(nmsgs, sizeof(u8 __user *), GFP_KERNEL);
  198. if (data_ptrs == NULL) {
  199. kfree(msgs);
  200. return -ENOMEM;
  201. }
  202. res = 0;
  203. for (i = 0; i < nmsgs; i++) {
  204. /* Limit the size of the message to a sane amount */
  205. if (msgs[i].len > 8192) {
  206. res = -EINVAL;
  207. break;
  208. }
  209. data_ptrs[i] = (u8 __user *)msgs[i].buf;
  210. msgs[i].buf = memdup_user(data_ptrs[i], msgs[i].len);
  211. if (IS_ERR(msgs[i].buf)) {
  212. res = PTR_ERR(msgs[i].buf);
  213. break;
  214. }
  215. /* memdup_user allocates with GFP_KERNEL, so DMA is ok */
  216. msgs[i].flags |= I2C_M_DMA_SAFE;
  217. /*
  218. * If the message length is received from the slave (similar
  219. * to SMBus block read), we must ensure that the buffer will
  220. * be large enough to cope with a message length of
  221. * I2C_SMBUS_BLOCK_MAX as this is the maximum underlying bus
  222. * drivers allow. The first byte in the buffer must be
  223. * pre-filled with the number of extra bytes, which must be
  224. * at least one to hold the message length, but can be
  225. * greater (for example to account for a checksum byte at
  226. * the end of the message.)
  227. */
  228. if (msgs[i].flags & I2C_M_RECV_LEN) {
  229. if (!(msgs[i].flags & I2C_M_RD) ||
  230. msgs[i].len < 1 || msgs[i].buf[0] < 1 ||
  231. msgs[i].len < msgs[i].buf[0] +
  232. I2C_SMBUS_BLOCK_MAX) {
  233. i++;
  234. res = -EINVAL;
  235. break;
  236. }
  237. msgs[i].len = msgs[i].buf[0];
  238. }
  239. }
  240. if (res < 0) {
  241. int j;
  242. for (j = 0; j < i; ++j)
  243. kfree(msgs[j].buf);
  244. kfree(data_ptrs);
  245. kfree(msgs);
  246. return res;
  247. }
  248. res = i2c_transfer(client->adapter, msgs, nmsgs);
  249. while (i-- > 0) {
  250. if (res >= 0 && (msgs[i].flags & I2C_M_RD)) {
  251. if (copy_to_user(data_ptrs[i], msgs[i].buf,
  252. msgs[i].len))
  253. res = -EFAULT;
  254. }
  255. kfree(msgs[i].buf);
  256. }
  257. kfree(data_ptrs);
  258. kfree(msgs);
  259. return res;
  260. }
  261. static noinline int i2cdev_ioctl_smbus(struct i2c_client *client,
  262. u8 read_write, u8 command, u32 size,
  263. union i2c_smbus_data __user *data)
  264. {
  265. union i2c_smbus_data temp = {};
  266. int datasize, res;
  267. if ((size != I2C_SMBUS_BYTE) &&
  268. (size != I2C_SMBUS_QUICK) &&
  269. (size != I2C_SMBUS_BYTE_DATA) &&
  270. (size != I2C_SMBUS_WORD_DATA) &&
  271. (size != I2C_SMBUS_PROC_CALL) &&
  272. (size != I2C_SMBUS_BLOCK_DATA) &&
  273. (size != I2C_SMBUS_I2C_BLOCK_BROKEN) &&
  274. (size != I2C_SMBUS_I2C_BLOCK_DATA) &&
  275. (size != I2C_SMBUS_BLOCK_PROC_CALL)) {
  276. dev_dbg(&client->adapter->dev,
  277. "size out of range (%x) in ioctl I2C_SMBUS.\n",
  278. size);
  279. return -EINVAL;
  280. }
  281. /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,
  282. so the check is valid if size==I2C_SMBUS_QUICK too. */
  283. if ((read_write != I2C_SMBUS_READ) &&
  284. (read_write != I2C_SMBUS_WRITE)) {
  285. dev_dbg(&client->adapter->dev,
  286. "read_write out of range (%x) in ioctl I2C_SMBUS.\n",
  287. read_write);
  288. return -EINVAL;
  289. }
  290. /* Note that command values are always valid! */
  291. if ((size == I2C_SMBUS_QUICK) ||
  292. ((size == I2C_SMBUS_BYTE) &&
  293. (read_write == I2C_SMBUS_WRITE)))
  294. /* These are special: we do not use data */
  295. return i2c_smbus_xfer(client->adapter, client->addr,
  296. client->flags, read_write,
  297. command, size, NULL);
  298. if (data == NULL) {
  299. dev_dbg(&client->adapter->dev,
  300. "data is NULL pointer in ioctl I2C_SMBUS.\n");
  301. return -EINVAL;
  302. }
  303. if ((size == I2C_SMBUS_BYTE_DATA) ||
  304. (size == I2C_SMBUS_BYTE))
  305. datasize = sizeof(data->byte);
  306. else if ((size == I2C_SMBUS_WORD_DATA) ||
  307. (size == I2C_SMBUS_PROC_CALL))
  308. datasize = sizeof(data->word);
  309. else /* size == smbus block, i2c block, or block proc. call */
  310. datasize = sizeof(data->block);
  311. if ((size == I2C_SMBUS_PROC_CALL) ||
  312. (size == I2C_SMBUS_BLOCK_PROC_CALL) ||
  313. (size == I2C_SMBUS_I2C_BLOCK_DATA) ||
  314. (read_write == I2C_SMBUS_WRITE)) {
  315. if (copy_from_user(&temp, data, datasize))
  316. return -EFAULT;
  317. }
  318. if (size == I2C_SMBUS_I2C_BLOCK_BROKEN) {
  319. /* Convert old I2C block commands to the new
  320. convention. This preserves binary compatibility. */
  321. size = I2C_SMBUS_I2C_BLOCK_DATA;
  322. if (read_write == I2C_SMBUS_READ)
  323. temp.block[0] = I2C_SMBUS_BLOCK_MAX;
  324. }
  325. res = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
  326. read_write, command, size, &temp);
  327. if (!res && ((size == I2C_SMBUS_PROC_CALL) ||
  328. (size == I2C_SMBUS_BLOCK_PROC_CALL) ||
  329. (read_write == I2C_SMBUS_READ))) {
  330. if (copy_to_user(data, &temp, datasize))
  331. return -EFAULT;
  332. }
  333. return res;
  334. }
  335. static long i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  336. {
  337. struct i2c_client *client = file->private_data;
  338. unsigned long funcs;
  339. dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
  340. cmd, arg);
  341. switch (cmd) {
  342. case I2C_SLAVE:
  343. case I2C_SLAVE_FORCE:
  344. if ((arg > 0x3ff) ||
  345. (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
  346. return -EINVAL;
  347. if (cmd == I2C_SLAVE && i2cdev_check_addr(client->adapter, arg))
  348. return -EBUSY;
  349. /* REVISIT: address could become busy later */
  350. client->addr = arg;
  351. return 0;
  352. case I2C_TENBIT:
  353. if (arg)
  354. client->flags |= I2C_M_TEN;
  355. else
  356. client->flags &= ~I2C_M_TEN;
  357. return 0;
  358. case I2C_PEC:
  359. /*
  360. * Setting the PEC flag here won't affect kernel drivers,
  361. * which will be using the i2c_client node registered with
  362. * the driver model core. Likewise, when that client has
  363. * the PEC flag already set, the i2c-dev driver won't see
  364. * (or use) this setting.
  365. */
  366. if (arg)
  367. client->flags |= I2C_CLIENT_PEC;
  368. else
  369. client->flags &= ~I2C_CLIENT_PEC;
  370. return 0;
  371. case I2C_FUNCS:
  372. funcs = i2c_get_functionality(client->adapter);
  373. return put_user(funcs, (unsigned long __user *)arg);
  374. case I2C_RDWR: {
  375. struct i2c_rdwr_ioctl_data rdwr_arg;
  376. struct i2c_msg *rdwr_pa;
  377. if (copy_from_user(&rdwr_arg,
  378. (struct i2c_rdwr_ioctl_data __user *)arg,
  379. sizeof(rdwr_arg)))
  380. return -EFAULT;
  381. if (!rdwr_arg.msgs || rdwr_arg.nmsgs == 0)
  382. return -EINVAL;
  383. /*
  384. * Put an arbitrary limit on the number of messages that can
  385. * be sent at once
  386. */
  387. if (rdwr_arg.nmsgs > I2C_RDWR_IOCTL_MAX_MSGS)
  388. return -EINVAL;
  389. rdwr_pa = memdup_user(rdwr_arg.msgs,
  390. rdwr_arg.nmsgs * sizeof(struct i2c_msg));
  391. if (IS_ERR(rdwr_pa))
  392. return PTR_ERR(rdwr_pa);
  393. return i2cdev_ioctl_rdwr(client, rdwr_arg.nmsgs, rdwr_pa);
  394. }
  395. case I2C_SMBUS: {
  396. struct i2c_smbus_ioctl_data data_arg;
  397. if (copy_from_user(&data_arg,
  398. (struct i2c_smbus_ioctl_data __user *) arg,
  399. sizeof(struct i2c_smbus_ioctl_data)))
  400. return -EFAULT;
  401. return i2cdev_ioctl_smbus(client, data_arg.read_write,
  402. data_arg.command,
  403. data_arg.size,
  404. data_arg.data);
  405. }
  406. case I2C_RETRIES:
  407. if (arg > INT_MAX)
  408. return -EINVAL;
  409. client->adapter->retries = arg;
  410. break;
  411. case I2C_TIMEOUT:
  412. if (arg > INT_MAX)
  413. return -EINVAL;
  414. /* For historical reasons, user-space sets the timeout
  415. * value in units of 10 ms.
  416. */
  417. client->adapter->timeout = msecs_to_jiffies(arg * 10);
  418. break;
  419. default:
  420. /* NOTE: returning a fault code here could cause trouble
  421. * in buggy userspace code. Some old kernel bugs returned
  422. * zero in this case, and userspace code might accidentally
  423. * have depended on that bug.
  424. */
  425. return -ENOTTY;
  426. }
  427. return 0;
  428. }
  429. #ifdef CONFIG_COMPAT
  430. struct i2c_smbus_ioctl_data32 {
  431. u8 read_write;
  432. u8 command;
  433. u32 size;
  434. compat_caddr_t data; /* union i2c_smbus_data *data */
  435. };
  436. struct i2c_msg32 {
  437. u16 addr;
  438. u16 flags;
  439. u16 len;
  440. compat_caddr_t buf;
  441. };
  442. struct i2c_rdwr_ioctl_data32 {
  443. compat_caddr_t msgs; /* struct i2c_msg __user *msgs */
  444. u32 nmsgs;
  445. };
  446. static long compat_i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  447. {
  448. struct i2c_client *client = file->private_data;
  449. unsigned long funcs;
  450. switch (cmd) {
  451. case I2C_FUNCS:
  452. funcs = i2c_get_functionality(client->adapter);
  453. return put_user(funcs, (compat_ulong_t __user *)arg);
  454. case I2C_RDWR: {
  455. struct i2c_rdwr_ioctl_data32 rdwr_arg;
  456. struct i2c_msg32 *p;
  457. struct i2c_msg *rdwr_pa;
  458. int i;
  459. if (copy_from_user(&rdwr_arg,
  460. (struct i2c_rdwr_ioctl_data32 __user *)arg,
  461. sizeof(rdwr_arg)))
  462. return -EFAULT;
  463. if (!rdwr_arg.msgs || rdwr_arg.nmsgs == 0)
  464. return -EINVAL;
  465. if (rdwr_arg.nmsgs > I2C_RDWR_IOCTL_MAX_MSGS)
  466. return -EINVAL;
  467. rdwr_pa = kmalloc_array(rdwr_arg.nmsgs, sizeof(struct i2c_msg),
  468. GFP_KERNEL);
  469. if (!rdwr_pa)
  470. return -ENOMEM;
  471. p = compat_ptr(rdwr_arg.msgs);
  472. for (i = 0; i < rdwr_arg.nmsgs; i++) {
  473. struct i2c_msg32 umsg;
  474. if (copy_from_user(&umsg, p + i, sizeof(umsg))) {
  475. kfree(rdwr_pa);
  476. return -EFAULT;
  477. }
  478. rdwr_pa[i] = (struct i2c_msg) {
  479. .addr = umsg.addr,
  480. .flags = umsg.flags,
  481. .len = umsg.len,
  482. .buf = compat_ptr(umsg.buf)
  483. };
  484. }
  485. return i2cdev_ioctl_rdwr(client, rdwr_arg.nmsgs, rdwr_pa);
  486. }
  487. case I2C_SMBUS: {
  488. struct i2c_smbus_ioctl_data32 data32;
  489. if (copy_from_user(&data32,
  490. (void __user *) arg,
  491. sizeof(data32)))
  492. return -EFAULT;
  493. return i2cdev_ioctl_smbus(client, data32.read_write,
  494. data32.command,
  495. data32.size,
  496. compat_ptr(data32.data));
  497. }
  498. default:
  499. return i2cdev_ioctl(file, cmd, arg);
  500. }
  501. }
  502. #else
  503. #define compat_i2cdev_ioctl NULL
  504. #endif
  505. static int i2cdev_open(struct inode *inode, struct file *file)
  506. {
  507. unsigned int minor = iminor(inode);
  508. struct i2c_client *client;
  509. struct i2c_adapter *adap;
  510. adap = i2c_get_adapter(minor);
  511. if (!adap)
  512. return -ENODEV;
  513. /* This creates an anonymous i2c_client, which may later be
  514. * pointed to some address using I2C_SLAVE or I2C_SLAVE_FORCE.
  515. *
  516. * This client is ** NEVER REGISTERED ** with the driver model
  517. * or I2C core code!! It just holds private copies of addressing
  518. * information and maybe a PEC flag.
  519. */
  520. client = kzalloc(sizeof(*client), GFP_KERNEL);
  521. if (!client) {
  522. i2c_put_adapter(adap);
  523. return -ENOMEM;
  524. }
  525. snprintf(client->name, I2C_NAME_SIZE, "i2c-dev %d", adap->nr);
  526. client->adapter = adap;
  527. file->private_data = client;
  528. return 0;
  529. }
  530. static int i2cdev_release(struct inode *inode, struct file *file)
  531. {
  532. struct i2c_client *client = file->private_data;
  533. i2c_put_adapter(client->adapter);
  534. kfree(client);
  535. file->private_data = NULL;
  536. return 0;
  537. }
  538. static const struct file_operations i2cdev_fops = {
  539. .owner = THIS_MODULE,
  540. .llseek = no_llseek,
  541. .read = i2cdev_read,
  542. .write = i2cdev_write,
  543. .unlocked_ioctl = i2cdev_ioctl,
  544. .compat_ioctl = compat_i2cdev_ioctl,
  545. .open = i2cdev_open,
  546. .release = i2cdev_release,
  547. };
  548. /* ------------------------------------------------------------------------- */
  549. static struct class *i2c_dev_class;
  550. static void i2cdev_dev_release(struct device *dev)
  551. {
  552. struct i2c_dev *i2c_dev;
  553. i2c_dev = container_of(dev, struct i2c_dev, dev);
  554. kfree(i2c_dev);
  555. }
  556. static int i2cdev_attach_adapter(struct device *dev, void *dummy)
  557. {
  558. struct i2c_adapter *adap;
  559. struct i2c_dev *i2c_dev;
  560. int res;
  561. if (dev->type != &i2c_adapter_type)
  562. return 0;
  563. adap = to_i2c_adapter(dev);
  564. i2c_dev = get_free_i2c_dev(adap);
  565. if (IS_ERR(i2c_dev))
  566. return PTR_ERR(i2c_dev);
  567. cdev_init(&i2c_dev->cdev, &i2cdev_fops);
  568. i2c_dev->cdev.owner = THIS_MODULE;
  569. device_initialize(&i2c_dev->dev);
  570. i2c_dev->dev.devt = MKDEV(I2C_MAJOR, adap->nr);
  571. i2c_dev->dev.class = i2c_dev_class;
  572. i2c_dev->dev.parent = &adap->dev;
  573. i2c_dev->dev.release = i2cdev_dev_release;
  574. dev_set_name(&i2c_dev->dev, "i2c-%d", adap->nr);
  575. res = cdev_device_add(&i2c_dev->cdev, &i2c_dev->dev);
  576. if (res) {
  577. put_i2c_dev(i2c_dev, false);
  578. return res;
  579. }
  580. pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",
  581. adap->name, adap->nr);
  582. return 0;
  583. }
  584. static int i2cdev_detach_adapter(struct device *dev, void *dummy)
  585. {
  586. struct i2c_adapter *adap;
  587. struct i2c_dev *i2c_dev;
  588. if (dev->type != &i2c_adapter_type)
  589. return 0;
  590. adap = to_i2c_adapter(dev);
  591. i2c_dev = i2c_dev_get_by_minor(adap->nr);
  592. if (!i2c_dev) /* attach_adapter must have failed */
  593. return 0;
  594. put_i2c_dev(i2c_dev, true);
  595. pr_debug("i2c-dev: adapter [%s] unregistered\n", adap->name);
  596. return 0;
  597. }
  598. static int i2cdev_notifier_call(struct notifier_block *nb, unsigned long action,
  599. void *data)
  600. {
  601. struct device *dev = data;
  602. switch (action) {
  603. case BUS_NOTIFY_ADD_DEVICE:
  604. return i2cdev_attach_adapter(dev, NULL);
  605. case BUS_NOTIFY_DEL_DEVICE:
  606. return i2cdev_detach_adapter(dev, NULL);
  607. }
  608. return 0;
  609. }
  610. static struct notifier_block i2cdev_notifier = {
  611. .notifier_call = i2cdev_notifier_call,
  612. };
  613. /* ------------------------------------------------------------------------- */
  614. /*
  615. * module load/unload record keeping
  616. */
  617. static int __init i2c_dev_init(void)
  618. {
  619. int res;
  620. printk(KERN_INFO "i2c /dev entries driver\n");
  621. res = register_chrdev_region(MKDEV(I2C_MAJOR, 0), I2C_MINORS, "i2c");
  622. if (res)
  623. goto out;
  624. i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");
  625. if (IS_ERR(i2c_dev_class)) {
  626. res = PTR_ERR(i2c_dev_class);
  627. goto out_unreg_chrdev;
  628. }
  629. i2c_dev_class->dev_groups = i2c_groups;
  630. /* Keep track of adapters which will be added or removed later */
  631. res = bus_register_notifier(&i2c_bus_type, &i2cdev_notifier);
  632. if (res)
  633. goto out_unreg_class;
  634. /* Bind to already existing adapters right away */
  635. i2c_for_each_dev(NULL, i2cdev_attach_adapter);
  636. return 0;
  637. out_unreg_class:
  638. class_destroy(i2c_dev_class);
  639. out_unreg_chrdev:
  640. unregister_chrdev_region(MKDEV(I2C_MAJOR, 0), I2C_MINORS);
  641. out:
  642. printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);
  643. return res;
  644. }
  645. static void __exit i2c_dev_exit(void)
  646. {
  647. bus_unregister_notifier(&i2c_bus_type, &i2cdev_notifier);
  648. i2c_for_each_dev(NULL, i2cdev_detach_adapter);
  649. class_destroy(i2c_dev_class);
  650. unregister_chrdev_region(MKDEV(I2C_MAJOR, 0), I2C_MINORS);
  651. }
  652. MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
  653. MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
  654. MODULE_DESCRIPTION("I2C /dev entries driver");
  655. MODULE_LICENSE("GPL");
  656. module_init(i2c_dev_init);
  657. module_exit(i2c_dev_exit);