开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
i2c-dev.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：15k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

i2c-dev.c：源码内容
  1. /*
  2.     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>
  7.     This program is free software; you can redistribute it and/or modify
  8.     it under the terms of the GNU General Public License as published by
  9.     the Free Software Foundation; either version 2 of the License, or
  10.     (at your option) any later version.
  12.     This program is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  17.     You should have received a copy of the GNU General Public License
  18.     along with this program; if not, write to the Free Software
  19.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  22. /* Note that this is a complete rewrite of Simon Vogl's i2c-dev module.
  23.    But I have used so much of his original code and ideas that it seems
  24.    only fair to recognize him as co-author -- Frodo */
  26. /* The I2C_RDWR ioctl code is written by Kolja Waschk <waschk@telos.de> */
  28. /* The devfs code is contributed by Philipp Matthias Hahn 
  29.    <pmhahn@titan.lahn.de> */
  31. /* $Id: i2c-dev.c,v 1.40 2001/08/25 01:28:01 mds Exp $ */
  33. #include <linux/config.h>
  34. #include <linux/kernel.h>
  35. #include <linux/module.h>
  36. #include <linux/fs.h>
  37. #include <linux/slab.h>
  38. #include <linux/version.h>
  39. #if LINUX_KERNEL_VERSION >= KERNEL_VERSION(2,4,0)
  40. #include <linux/smp_lock.h>
  41. #endif /* LINUX_KERNEL_VERSION >= KERNEL_VERSION(2,4,0) */
  42. #ifdef CONFIG_DEVFS_FS
  43. #include <linux/devfs_fs_kernel.h>
  44. #endif
  47. /* If you want debugging uncomment: */
  48. /* #define DEBUG */
  50. #include <linux/init.h>
  51. #include <asm/uaccess.h>
  53. #include <linux/i2c.h>
  54. #include <linux/i2c-dev.h>
  56. #ifdef MODULE
  57. extern int init_module(void);
  58. extern int cleanup_module(void);
  59. #endif /* def MODULE */
  61. /* struct file_operations changed too often in the 2.1 series for nice code */
  63. #if LINUX_KERNEL_VERSION < KERNEL_VERSION(2,4,9)
  64. static loff_t i2cdev_lseek (struct file *file, loff_t offset, int origin);
  65. #endif
  66. static ssize_t i2cdev_read (struct file *file, char *buf, size_t count, 
  67.                             loff_t *offset);
  68. static ssize_t i2cdev_write (struct file *file, const char *buf, size_t count, 
  69.                              loff_t *offset);
  71. static int i2cdev_ioctl (struct inode *inode, struct file *file, 
  72.                          unsigned int cmd, unsigned long arg);
  73. static int i2cdev_open (struct inode *inode, struct file *file);
  75. static int i2cdev_release (struct inode *inode, struct file *file);
  77. static int i2cdev_attach_adapter(struct i2c_adapter *adap);
  78. static int i2cdev_detach_client(struct i2c_client *client);
  79. static int i2cdev_command(struct i2c_client *client, unsigned int cmd,
  80.                            void *arg);
  82. #ifdef MODULE
  83. static
  84. #else
  85. extern
  86. #endif
  87.        int __init i2c_dev_init(void);
  88. static int i2cdev_cleanup(void);
  90. static struct file_operations i2cdev_fops = {
  91. #if LINUX_KERNEL_VERSION >= KERNEL_VERSION(2,4,0)
  92. owner: THIS_MODULE,
  93. #endif /* LINUX_KERNEL_VERSION >= KERNEL_VERSION(2,4,0) */
  94. #if LINUX_KERNEL_VERSION < KERNEL_VERSION(2,4,9)
  95. llseek: i2cdev_lseek,
  96. #else
  97. llseek: no_llseek,
  98. #endif
  99. read: i2cdev_read,
  100. write: i2cdev_write,
  101. ioctl: i2cdev_ioctl,
  102. open: i2cdev_open,
  103. release: i2cdev_release,
  104. };
  106. #define I2CDEV_ADAPS_MAX I2C_ADAP_MAX
  107. static struct i2c_adapter *i2cdev_adaps[I2CDEV_ADAPS_MAX];
  108. #ifdef CONFIG_DEVFS_FS
  109. static devfs_handle_t devfs_i2c[I2CDEV_ADAPS_MAX];
  110. static devfs_handle_t devfs_handle = NULL;
  111. #endif
  113. static struct i2c_driver i2cdev_driver = {
  114. name: "i2c-dev dummy driver",
  115. id: I2C_DRIVERID_I2CDEV,
  116. flags: I2C_DF_DUMMY,
  117. attach_adapter: i2cdev_attach_adapter,
  118. detach_client: i2cdev_detach_client,
  119. command: i2cdev_command,
  120. /* inc_use: NULL,
  121. dec_use: NULL, */
  122. };
  124. static struct i2c_client i2cdev_client_template = {
  125. name: "I2C /dev entry",
  126. id: 1,
  127. flags: 0,
  128. addr: -1,
  129. /* adapter: NULL, */
  130. driver: &i2cdev_driver,
  131. /* data: NULL */
  132. };
  134. static int i2cdev_initialized;
  136. #if LINUX_KERNEL_VERSION < KERNEL_VERSION(2,4,9)
  137. /* Note that the lseek function is called llseek in 2.1 kernels. But things
  138.    are complicated enough as is. */
  139. loff_t i2cdev_lseek (struct file *file, loff_t offset, int origin)
  140. {
  141. #ifdef DEBUG
  142. struct inode *inode = file->f_dentry->d_inode;
  143. printk("i2c-dev.o: i2c-%d lseek to %ld bytes relative to %d.n",
  144.        MINOR(inode->i_rdev),(long) offset,origin);
  145. #endif /* DEBUG */
  146. return -ESPIPE;
  147. }
  148. #endif
  150. static ssize_t i2cdev_read (struct file *file, char *buf, size_t count,
  151.                             loff_t *offset)
  152. {
  153. char *tmp;
  154. int ret;
  156. #ifdef DEBUG
  157. struct inode *inode = file->f_dentry->d_inode;
  158. #endif /* DEBUG */
  160. struct i2c_client *client = (struct i2c_client *)file->private_data;
  162. if(count > 8192)
  163. count = 8192;
  165. /* copy user space data to kernel space. */
  166. tmp = kmalloc(count,GFP_KERNEL);
  167. if (tmp==NULL)
  168. return -ENOMEM;
  170. #ifdef DEBUG
  171. printk("i2c-dev.o: i2c-%d reading %d bytes.n",MINOR(inode->i_rdev),
  172.        count);
  173. #endif
  175. ret = i2c_master_recv(client,tmp,count);
  176. if (ret >= 0)
  177. ret = copy_to_user(buf,tmp,count)?-EFAULT:ret;
  178. kfree(tmp);
  179. return ret;
  180. }
  182. static ssize_t i2cdev_write (struct file *file, const char *buf, size_t count,
  183.                              loff_t *offset)
  184. {
  185. int ret;
  186. char *tmp;
  187. struct i2c_client *client = (struct i2c_client *)file->private_data;
  189. #ifdef DEBUG
  190. struct inode *inode = file->f_dentry->d_inode;
  191. #endif /* DEBUG */
  193. if(count > 8192)
  194. count = 8192;
  196. /* copy user space data to kernel space. */
  197. tmp = kmalloc(count,GFP_KERNEL);
  198. if (tmp==NULL)
  199. return -ENOMEM;
  200. if (copy_from_user(tmp,buf,count)) {
  201. kfree(tmp);
  202. return -EFAULT;
  203. }
  205. #ifdef DEBUG
  206. printk("i2c-dev.o: i2c-%d writing %d bytes.n",MINOR(inode->i_rdev),
  207.        count);
  208. #endif
  209. ret = i2c_master_send(client,tmp,count);
  210. kfree(tmp);
  211. return ret;
  212. }
  214. int i2cdev_ioctl (struct inode *inode, struct file *file, unsigned int cmd, 
  215.                   unsigned long arg)
  216. {
  217. struct i2c_client *client = (struct i2c_client *)file->private_data;
  218. struct i2c_rdwr_ioctl_data rdwr_arg;
  219. struct i2c_smbus_ioctl_data data_arg;
  220. union i2c_smbus_data temp;
  221. struct i2c_msg *rdwr_pa;
  222. int i,datasize,res;
  223. unsigned long funcs;
  225. #ifdef DEBUG
  226. printk("i2c-dev.o: i2c-%d ioctl, cmd: 0x%x, arg: %lx.n", 
  227.        MINOR(inode->i_rdev),cmd, arg);
  228. #endif /* DEBUG */
  230. switch ( cmd ) {
  231. case I2C_SLAVE:
  232. case I2C_SLAVE_FORCE:
  233. if ((arg > 0x3ff) || 
  234.     (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
  235. return -EINVAL;
  236. if ((cmd == I2C_SLAVE) && i2c_check_addr(client->adapter,arg))
  237. return -EBUSY;
  238. client->addr = arg;
  239. return 0;
  240. case I2C_TENBIT:
  241. if (arg)
  242. client->flags |= I2C_M_TEN;
  243. else
  244. client->flags &= ~I2C_M_TEN;
  245. return 0;
  246. case I2C_FUNCS:
  247. funcs = i2c_get_functionality(client->adapter);
  248. return (copy_to_user((unsigned long *)arg,&funcs,
  249.                      sizeof(unsigned long)))?-EFAULT:0;
  251.         case I2C_RDWR:
  252. if (copy_from_user(&rdwr_arg, 
  253.    (struct i2c_rdwr_ioctl_data *)arg, 
  254.    sizeof(rdwr_arg)))
  255. return -EFAULT;
  257. rdwr_pa = (struct i2c_msg *)
  258. kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg), 
  259. GFP_KERNEL);
  261. if (rdwr_pa == NULL) return -ENOMEM;
  263. res = 0;
  264. for( i=0; i<rdwr_arg.nmsgs; i++ )
  265. {
  266.      if(copy_from_user(&(rdwr_pa[i]),
  267. &(rdwr_arg.msgs[i]),
  268. sizeof(rdwr_pa[i])))
  269. {
  270.         res = -EFAULT;
  271. break;
  272. }
  273. rdwr_pa[i].buf = kmalloc(rdwr_pa[i].len, GFP_KERNEL);
  274. if(rdwr_pa[i].buf == NULL)
  275. {
  276. res = -ENOMEM;
  277. break;
  278. }
  279. if(copy_from_user(rdwr_pa[i].buf,
  280. rdwr_arg.msgs[i].buf,
  281. rdwr_pa[i].len))
  282. {
  283.      kfree(rdwr_pa[i].buf);
  284.      res = -EFAULT;
  285. break;
  286. }
  287. }
  288. if (!res) 
  289. {
  290. res = i2c_transfer(client->adapter,
  291. rdwr_pa,
  292. rdwr_arg.nmsgs);
  293. }
  294. while(i-- > 0)
  295. {
  296. if( res>=0 && (rdwr_pa[i].flags & I2C_M_RD))
  297. {
  298. if(copy_to_user(
  299. rdwr_arg.msgs[i].buf,
  300. rdwr_pa[i].buf,
  301. rdwr_pa[i].len))
  302. {
  303. res = -EFAULT;
  304. }
  305. }
  306. kfree(rdwr_pa[i].buf);
  307. }
  308. kfree(rdwr_pa);
  309. return res;
  311. case I2C_SMBUS:
  312. if (copy_from_user(&data_arg,
  313.                    (struct i2c_smbus_ioctl_data *) arg,
  314.                    sizeof(struct i2c_smbus_ioctl_data)))
  315. return -EFAULT;
  316. if ((data_arg.size != I2C_SMBUS_BYTE) && 
  317.     (data_arg.size != I2C_SMBUS_QUICK) &&
  318.     (data_arg.size != I2C_SMBUS_BYTE_DATA) && 
  319.     (data_arg.size != I2C_SMBUS_WORD_DATA) &&
  320.     (data_arg.size != I2C_SMBUS_PROC_CALL) &&
  321.     (data_arg.size != I2C_SMBUS_BLOCK_DATA) &&
  322.     (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA)) {
  323. #ifdef DEBUG
  324. printk("i2c-dev.o: size out of range (%x) in ioctl I2C_SMBUS.n",
  325.        data_arg.size);
  326. #endif
  327. return -EINVAL;
  328. }
  329. /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1, 
  330.    so the check is valid if size==I2C_SMBUS_QUICK too. */
  331. if ((data_arg.read_write != I2C_SMBUS_READ) && 
  332.     (data_arg.read_write != I2C_SMBUS_WRITE)) {
  333. #ifdef DEBUG
  334. printk("i2c-dev.o: read_write out of range (%x) in ioctl I2C_SMBUS.n",
  335.        data_arg.read_write);
  336. #endif
  337. return -EINVAL;
  338. }
  340. /* Note that command values are always valid! */
  342. if ((data_arg.size == I2C_SMBUS_QUICK) ||
  343.     ((data_arg.size == I2C_SMBUS_BYTE) && 
  344.     (data_arg.read_write == I2C_SMBUS_WRITE)))
  345. /* These are special: we do not use data */
  346. return i2c_smbus_xfer(client->adapter, client->addr,
  347.                       client->flags,
  348.                       data_arg.read_write,
  349.                       data_arg.command,
  350.                       data_arg.size, NULL);
  352. if (data_arg.data == NULL) {
  353. #ifdef DEBUG
  354. printk("i2c-dev.o: data is NULL pointer in ioctl I2C_SMBUS.n");
  355. #endif
  356. return -EINVAL;
  357. }
  359. if ((data_arg.size == I2C_SMBUS_BYTE_DATA) ||
  360.     (data_arg.size == I2C_SMBUS_BYTE))
  361. datasize = sizeof(data_arg.data->byte);
  362. else if ((data_arg.size == I2C_SMBUS_WORD_DATA) || 
  363.          (data_arg.size == I2C_SMBUS_PROC_CALL))
  364. datasize = sizeof(data_arg.data->word);
  365. else /* size == I2C_SMBUS_BLOCK_DATA */
  366. datasize = sizeof(data_arg.data->block);
  368. if ((data_arg.size == I2C_SMBUS_PROC_CALL) || 
  369.     (data_arg.read_write == I2C_SMBUS_WRITE)) {
  370. if (copy_from_user(&temp, data_arg.data, datasize))
  371. return -EFAULT;
  372. }
  373. res = i2c_smbus_xfer(client->adapter,client->addr,client->flags,
  374.       data_arg.read_write,
  375.       data_arg.command,data_arg.size,&temp);
  376. if (! res && ((data_arg.size == I2C_SMBUS_PROC_CALL) || 
  377.       (data_arg.read_write == I2C_SMBUS_READ))) {
  378. if (copy_to_user(data_arg.data, &temp, datasize))
  379. return -EFAULT;
  380. }
  381. return res;
  383. default:
  384. return i2c_control(client,cmd,arg);
  385. }
  386. return 0;
  387. }
  389. int i2cdev_open (struct inode *inode, struct file *file)
  390. {
  391. unsigned int minor = MINOR(inode->i_rdev);
  392. struct i2c_client *client;
  394. if ((minor >= I2CDEV_ADAPS_MAX) || ! (i2cdev_adaps[minor])) {
  395. #ifdef DEBUG
  396. printk("i2c-dev.o: Trying to open unattached adapter i2c-%dn",
  397.        minor);
  398. #endif
  399. return -ENODEV;
  400. }
  402. /* Note that we here allocate a client for later use, but we will *not*
  403.    register this client! Yes, this is safe. No, it is not very clean. */
  404. if(! (client = kmalloc(sizeof(struct i2c_client),GFP_KERNEL)))
  405. return -ENOMEM;
  406. memcpy(client,&i2cdev_client_template,sizeof(struct i2c_client));
  407. client->adapter = i2cdev_adaps[minor];
  408. file->private_data = client;
  410. if (i2cdev_adaps[minor]->inc_use)
  411. i2cdev_adaps[minor]->inc_use(i2cdev_adaps[minor]);
  412. #if LINUX_KERNEL_VERSION < KERNEL_VERSION(2,4,0)
  413. MOD_INC_USE_COUNT;
  414. #endif /* LINUX_KERNEL_VERSION < KERNEL_VERSION(2,4,0) */
  416. #ifdef DEBUG
  417. printk("i2c-dev.o: opened i2c-%dn",minor);
  418. #endif
  419. return 0;
  420. }
  422. static int i2cdev_release (struct inode *inode, struct file *file)
  423. {
  424. unsigned int minor = MINOR(inode->i_rdev);
  425. kfree(file->private_data);
  426. file->private_data=NULL;
  427. #ifdef DEBUG
  428. printk("i2c-dev.o: Closed: i2c-%dn", minor);
  429. #endif
  430. #if LINUX_KERNEL_VERSION < KERNEL_VERSION(2,4,0)
  431. MOD_DEC_USE_COUNT;
  432. #else /* LINUX_KERNEL_VERSION >= KERNEL_VERSION(2,4,0) */
  433. lock_kernel();
  434. #endif /* LINUX_KERNEL_VERSION < KERNEL_VERSION(2,4,0) */
  435. if (i2cdev_adaps[minor]->dec_use)
  436. i2cdev_adaps[minor]->dec_use(i2cdev_adaps[minor]);
  437. #if LINUX_KERNEL_VERSION >= KERNEL_VERSION(2,4,0)
  438. unlock_kernel();
  439. #endif /* LINUX_KERNEL_VERSION >= KERNEL_VERSION(2,4,0) */
  440. return 0;
  441. }
  443. int i2cdev_attach_adapter(struct i2c_adapter *adap)
  444. {
  445. int i;
  446. char name[8];
  448. if ((i = i2c_adapter_id(adap)) < 0) {
  449. printk("i2c-dev.o: Unknown adapter ?!?n");
  450. return -ENODEV;
  451. }
  452. if (i >= I2CDEV_ADAPS_MAX) {
  453. printk("i2c-dev.o: Adapter number too large?!? (%d)n",i);
  454. return -ENODEV;
  455. }
  457. sprintf (name, "%d", i);
  458. if (! i2cdev_adaps[i]) {
  459. i2cdev_adaps[i] = adap;
  460. #ifdef CONFIG_DEVFS_FS
  461. devfs_i2c[i] = devfs_register (devfs_handle, name,
  462. DEVFS_FL_DEFAULT, I2C_MAJOR, i,
  463. S_IFCHR | S_IRUSR | S_IWUSR,
  464. &i2cdev_fops, NULL);
  465. #endif
  466. printk("i2c-dev.o: Registered '%s' as minor %dn",adap->name,i);
  467. } else {
  468. /* This is actually a detach_adapter call! */
  469. #ifdef CONFIG_DEVFS_FS
  470. devfs_unregister(devfs_i2c[i]);
  471. #endif
  472. i2cdev_adaps[i] = NULL;
  473. #ifdef DEBUG
  474. printk("i2c-dev.o: Adapter unregistered: %sn",adap->name);
  475. #endif
  476. }
  478. return 0;
  479. }
  481. int i2cdev_detach_client(struct i2c_client *client)
  482. {
  483. return 0;
  484. }
  486. static int i2cdev_command(struct i2c_client *client, unsigned int cmd,
  487.                            void *arg)
  488. {
  489. return -1;
  490. }
  492. int __init i2c_dev_init(void)
  493. {
  494. int res;
  496. printk("i2c-dev.o: i2c /dev entries driver modulen");
  498. i2cdev_initialized = 0;
  499. #ifdef CONFIG_DEVFS_FS
  500. if (devfs_register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops)) {
  501. #else
  502. if (register_chrdev(I2C_MAJOR,"i2c",&i2cdev_fops)) {
  503. #endif
  504. printk("i2c-dev.o: unable to get major %d for i2c busn",
  505.        I2C_MAJOR);
  506. return -EIO;
  507. }
  508. #ifdef CONFIG_DEVFS_FS
  509. devfs_handle = devfs_mk_dir(NULL, "i2c", NULL);
  510. #endif
  511. i2cdev_initialized ++;
  513. if ((res = i2c_add_driver(&i2cdev_driver))) {
  514. printk("i2c-dev.o: Driver registration failed, module not inserted.n");
  515. i2cdev_cleanup();
  516. return res;
  517. }
  518. i2cdev_initialized ++;
  519. return 0;
  520. }
  522. int i2cdev_cleanup(void)
  523. {
  524. int res;
  526. if (i2cdev_initialized >= 2) {
  527. if ((res = i2c_del_driver(&i2cdev_driver))) {
  528. printk("i2c-dev.o: Driver deregistration failed, "
  529.        "module not removed.n");
  530. return res;
  531. }
  532. i2cdev_initialized --;
  533. }
  535. if (i2cdev_initialized >= 1) {
  536. #ifdef CONFIG_DEVFS_FS
  537. devfs_unregister(devfs_handle);
  538. if ((res = devfs_unregister_chrdev(I2C_MAJOR, "i2c"))) {
  539. #else
  540. if ((res = unregister_chrdev(I2C_MAJOR,"i2c"))) {
  541. #endif
  542. printk("i2c-dev.o: unable to release major %d for i2c busn",
  543.        I2C_MAJOR);
  544. return res;
  545. }
  546. i2cdev_initialized --;
  547. }
  548. return 0;
  549. }
  551. EXPORT_NO_SYMBOLS;
  553. #ifdef MODULE
  555. MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and Simon G. Vogl <simon@tk.uni-linz.ac.at>");
  556. MODULE_DESCRIPTION("I2C /dev entries driver");
  557. MODULE_LICENSE("GPL");
  559. int init_module(void)
  560. {
  561. return i2c_dev_init();
  562. }
  564. int cleanup_module(void)
  565. {
  566. return i2cdev_cleanup();
  567. }
  569. #endif /* def MODULE */