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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
i2c-core.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：35k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

i2c-core.c：源码内容
  1. /* i2c-core.c - a device driver for the iic-bus interface      */
  2. /* ------------------------------------------------------------------------- */
  3. /*   Copyright (C) 1995-99 Simon G. Vogl
  5.     This program is free software; you can redistribute it and/or modify
  6.     it under the terms of the GNU General Public License as published by
  7.     the Free Software Foundation; either version 2 of the License, or
  8.     (at your option) any later version.
  10.     This program is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.     GNU General Public License for more details.
  15.     You should have received a copy of the GNU General Public License
  16.     along with this program; if not, write to the Free Software
  17.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.      */
  18. /* ------------------------------------------------------------------------- */
  20. /* With some changes from Ky鰏ti M鋖kki <kmalkki@cc.hut.fi>.
  21.    All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl> */
  23. /* $Id: i2c-core.c,v 1.64 2001/08/13 01:35:56 mds Exp $ */
  25. #include <linux/module.h>
  26. #include <linux/kernel.h>
  27. #include <linux/errno.h>
  28. #include <linux/slab.h>
  29. #include <linux/proc_fs.h>
  30. #include <linux/config.h>
  32. #include <linux/i2c.h>
  34. /* ----- compatibility stuff ----------------------------------------------- */
  36. #include <linux/version.h>
  37. #include <linux/init.h>
  39. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,1)
  40. #define init_MUTEX(s) do { *(s) = MUTEX; } while(0)
  41. #endif
  43. #include <asm/uaccess.h>
  45. /* ----- global defines ---------------------------------------------------- */
  47. /* exclusive access to the bus */
  48. #define I2C_LOCK(adap) down(&adap->lock)
  49. #define I2C_UNLOCK(adap) up(&adap->lock) 
  51. #define ADAP_LOCK() down(&adap_lock)
  52. #define ADAP_UNLOCK() up(&adap_lock)
  54. #define DRV_LOCK() down(&driver_lock)
  55. #define DRV_UNLOCK() up(&driver_lock)
  57. #define DEB(x) if (i2c_debug>=1) x;
  58. #define DEB2(x) if (i2c_debug>=2) x;
  60. /* ----- global variables -------------------------------------------------- */
  62. /**** lock for writing to global variables: the adapter & driver list */
  63. struct semaphore adap_lock;
  64. struct semaphore driver_lock;
  66. /**** adapter list */
  67. static struct i2c_adapter *adapters[I2C_ADAP_MAX];
  68. static int adap_count;
  70. /**** drivers list */
  71. static struct i2c_driver *drivers[I2C_DRIVER_MAX];
  72. static int driver_count;
  74. /**** debug level */
  75. static int i2c_debug = 0;
  77. /* ---------------------------------------------------
  78.  * /proc entry declarations
  79.  *----------------------------------------------------
  80.  */
  82. #ifdef CONFIG_PROC_FS
  84. static int i2cproc_init(void);
  85. static void i2cproc_cleanup(void);
  87. #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,3,27))
  88. static void monitor_bus_i2c(struct inode *inode, int fill);
  89. #endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,58)) */
  91. static ssize_t i2cproc_bus_read(struct file * file, char * buf,size_t count, 
  92.                                 loff_t *ppos);
  93. static int read_bus_i2c(char *buf, char **start, off_t offset, int len,
  94.                            int *eof , void *private);
  96. /* To implement the dynamic /proc/bus/i2c-? files, we need our own 
  97.    implementation of the read hook */
  98. static struct file_operations i2cproc_operations = {
  99. read: i2cproc_bus_read,
  100. };
  102. #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,48))
  103. static struct inode_operations i2cproc_inode_operations = {
  104. &i2cproc_operations
  105. };
  106. #endif
  108. static int i2cproc_initialized = 0;
  110. #else /* undef CONFIG_PROC_FS */
  112. #define i2cproc_init() 0
  113. #define i2cproc_cleanup() 0
  115. #endif /* CONFIG_PROC_FS */
  118. /* ---------------------------------------------------
  119.  * registering functions 
  120.  * --------------------------------------------------- 
  121.  */
  123. /* -----
  124.  * i2c_add_adapter is called from within the algorithm layer,
  125.  * when a new hw adapter registers. A new device is register to be
  126.  * available for clients.
  127.  */
  128. int i2c_add_adapter(struct i2c_adapter *adap)
  129. {
  130. int i,j,res;
  132. ADAP_LOCK();
  133. for (i = 0; i < I2C_ADAP_MAX; i++)
  134. if (NULL == adapters[i])
  135. break;
  136. if (I2C_ADAP_MAX == i) {
  137. printk(KERN_WARNING 
  138.        " i2c-core.o: register_adapter(%s) - enlarge I2C_ADAP_MAX.n",
  139. adap->name);
  140. res = -ENOMEM;
  141. goto ERROR0;
  142. }
  144. adapters[i] = adap;
  145. adap_count++;
  146. ADAP_UNLOCK();
  148. /* init data types */
  149. init_MUTEX(&adap->lock);
  151. #ifdef CONFIG_PROC_FS
  153. if (i2cproc_initialized) {
  154. char name[8];
  155. struct proc_dir_entry *proc_entry;
  157. sprintf(name,"i2c-%d", i);
  159. proc_entry = create_proc_entry(name,0,proc_bus);
  160. if (! proc_entry) {
  161. printk("i2c-core.o: Could not create /proc/bus/%sn",
  162.        name);
  163. res = -ENOENT;
  164. goto ERROR1;
  165. }
  167. #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,48))
  168. proc_entry->proc_fops = &i2cproc_operations;
  169. #else
  170. proc_entry->ops = &i2cproc_inode_operations;
  171. #endif
  172. #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,27))
  173. proc_entry->owner = THIS_MODULE;
  174. #else
  175. proc_entry->fill_inode = &monitor_bus_i2c;
  176. #endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,58)) */
  177. adap->inode = proc_entry->low_ino;
  178. }
  180. #endif /* def CONFIG_PROC_FS */
  182. /* inform drivers of new adapters */
  183. DRV_LOCK();
  184. for (j=0;j<I2C_DRIVER_MAX;j++)
  185. if (drivers[j]!=NULL && 
  186.     (drivers[j]->flags&(I2C_DF_NOTIFY|I2C_DF_DUMMY)))
  187. /* We ignore the return code; if it fails, too bad */
  188. drivers[j]->attach_adapter(adap);
  189. DRV_UNLOCK();
  191. DEB(printk("i2c-core.o: adapter %s registered as adapter %d.n",
  192.            adap->name,i));
  194. return 0;
  197. ERROR1:
  198. ADAP_LOCK();
  199. adapters[i] = NULL;
  200. adap_count--;
  201. ERROR0:
  202. ADAP_UNLOCK();
  203. return res;
  204. }
  207. int i2c_del_adapter(struct i2c_adapter *adap)
  208. {
  209. int i,j,res;
  211. ADAP_LOCK();
  213. for (i = 0; i < I2C_ADAP_MAX; i++)
  214. if (adap == adapters[i])
  215. break;
  216. if (I2C_ADAP_MAX == i) {
  217. printk( "i2c-core.o: unregister_adapter adap [%s] not found.n",
  218. adap->name);
  219. res = -ENODEV;
  220. goto ERROR0;
  221. }
  223. /* DUMMY drivers do not register their clients, so we have to
  224.  * use a trick here: we call driver->attach_adapter to
  225.  * *detach* it! Of course, each dummy driver should know about
  226.  * this or hell will break loose...
  227.  */
  228. DRV_LOCK();
  229. for (j = 0; j < I2C_DRIVER_MAX; j++) 
  230. if (drivers[j] && (drivers[j]->flags & I2C_DF_DUMMY))
  231. if ((res = drivers[j]->attach_adapter(adap))) {
  232. printk("i2c-core.o: can't detach adapter %s "
  233.        "while detaching driver %s: driver not "
  234.        "detached!",adap->name,drivers[j]->name);
  235. goto ERROR1;
  236. }
  237. DRV_UNLOCK();
  240. /* detach any active clients. This must be done first, because
  241.  * it can fail; in which case we give upp. */
  242. for (j=0;j<I2C_CLIENT_MAX;j++) {
  243. struct i2c_client *client = adap->clients[j];
  244. if (client!=NULL)
  245.     /* detaching devices is unconditional of the set notify
  246.      * flag, as _all_ clients that reside on the adapter
  247.      * must be deleted, as this would cause invalid states.
  248.      */
  249. if ((res=client->driver->detach_client(client))) {
  250. printk("i2c-core.o: adapter %s not "
  251. "unregistered, because client at "
  252. "address %02x can't be detached. ",
  253. adap->name, client->addr);
  254. goto ERROR0;
  255. }
  256. }
  257. #ifdef CONFIG_PROC_FS
  258. if (i2cproc_initialized) {
  259. char name[8];
  260. sprintf(name,"i2c-%d", i);
  261. remove_proc_entry(name,proc_bus);
  262. }
  263. #endif /* def CONFIG_PROC_FS */
  265. adapters[i] = NULL;
  266. adap_count--;
  268. ADAP_UNLOCK();
  269. DEB(printk("i2c-core.o: adapter unregistered: %sn",adap->name));
  270. return 0;
  272. ERROR0:
  273. ADAP_UNLOCK();
  274. return res;
  275. ERROR1:
  276. DRV_UNLOCK();
  277. return res;
  278. }
  281. /* -----
  282.  * What follows is the "upwards" interface: commands for talking to clients,
  283.  * which implement the functions to access the physical information of the
  284.  * chips.
  285.  */
  287. int i2c_add_driver(struct i2c_driver *driver)
  288. {
  289. int i;
  290. DRV_LOCK();
  291. for (i = 0; i < I2C_DRIVER_MAX; i++)
  292. if (NULL == drivers[i])
  293. break;
  294. if (I2C_DRIVER_MAX == i) {
  295. printk(KERN_WARNING 
  296.        " i2c-core.o: register_driver(%s) "
  297.        "- enlarge I2C_DRIVER_MAX.n",
  298. driver->name);
  299. DRV_UNLOCK();
  300. return -ENOMEM;
  301. }
  303. drivers[i] = driver;
  304. driver_count++;
  306. DRV_UNLOCK(); /* driver was successfully added */
  308. DEB(printk("i2c-core.o: driver %s registered.n",driver->name));
  310. ADAP_LOCK();
  312. /* now look for instances of driver on our adapters
  313.  */
  314. if (driver->flags& (I2C_DF_NOTIFY|I2C_DF_DUMMY)) {
  315. for (i=0;i<I2C_ADAP_MAX;i++)
  316. if (adapters[i]!=NULL)
  317. /* Ignore errors */
  318. driver->attach_adapter(adapters[i]);
  319. }
  320. ADAP_UNLOCK();
  321. return 0;
  322. }
  324. int i2c_del_driver(struct i2c_driver *driver)
  325. {
  326. int i,j,k,res;
  328. DRV_LOCK();
  329. for (i = 0; i < I2C_DRIVER_MAX; i++)
  330. if (driver == drivers[i])
  331. break;
  332. if (I2C_DRIVER_MAX == i) {
  333. printk(KERN_WARNING " i2c-core.o: unregister_driver: "
  334.     "[%s] not foundn",
  335. driver->name);
  336. DRV_UNLOCK();
  337. return -ENODEV;
  338. }
  339. /* Have a look at each adapter, if clients of this driver are still
  340.  * attached. If so, detach them to be able to kill the driver 
  341.  * afterwards.
  342.  */
  343. DEB2(printk("i2c-core.o: unregister_driver - looking for clients.n"));
  344. /* removing clients does not depend on the notify flag, else 
  345.  * invalid operation might (will!) result, when using stale client
  346.  * pointers.
  347.  */
  348. ADAP_LOCK(); /* should be moved inside the if statement... */
  349. for (k=0;k<I2C_ADAP_MAX;k++) {
  350. struct i2c_adapter *adap = adapters[k];
  351. if (adap == NULL) /* skip empty entries. */
  352. continue;
  353. DEB2(printk("i2c-core.o: examining adapter %s:n",
  354.     adap->name));
  355. if (driver->flags & I2C_DF_DUMMY) {
  356. /* DUMMY drivers do not register their clients, so we have to
  357.  * use a trick here: we call driver->attach_adapter to
  358.  * *detach* it! Of course, each dummy driver should know about
  359.  * this or hell will break loose...  
  360.  */
  361. if ((res = driver->attach_adapter(adap))) {
  362. printk("i2c-core.o: while unregistering "
  363.        "dummy driver %s, adapter %s could "
  364.        "not be detached properly; driver "
  365.        "not unloaded!",driver->name,
  366.        adap->name);
  367. ADAP_UNLOCK();
  368. return res;
  369. }
  370. } else {
  371. for (j=0;j<I2C_CLIENT_MAX;j++) { 
  372. struct i2c_client *client = adap->clients[j];
  373. if (client != NULL && 
  374.     client->driver == driver) {
  375. DEB2(printk("i2c-core.o: "
  376.     "detaching client %s:n",
  377.             client->name));
  378. if ((res = driver->
  379. detach_client(client)))
  380. {
  381. printk("i2c-core.o: while "
  382.        "unregistering driver "
  383.        "`%s', the client at "
  384.        "address %02x of
  385.        adapter `%s' could not
  386.        be detached; driver
  387.        not unloaded!",
  388.        driver->name,
  389.        client->addr,
  390.        adap->name);
  391. ADAP_UNLOCK();
  392. return res;
  393. }
  394. }
  395. }
  396. }
  397. }
  398. ADAP_UNLOCK();
  399. drivers[i] = NULL;
  400. driver_count--;
  401. DRV_UNLOCK();
  403. DEB(printk("i2c-core.o: driver unregistered: %sn",driver->name));
  404. return 0;
  405. }
  407. int i2c_check_addr (struct i2c_adapter *adapter, int addr)
  408. {
  409. int i;
  410. for (i = 0; i < I2C_CLIENT_MAX ; i++) 
  411. if (adapter->clients[i] && (adapter->clients[i]->addr == addr))
  412. return -EBUSY;
  413. return 0;
  414. }
  416. int i2c_attach_client(struct i2c_client *client)
  417. {
  418. struct i2c_adapter *adapter = client->adapter;
  419. int i;
  421. if (i2c_check_addr(client->adapter,client->addr))
  422. return -EBUSY;
  424. for (i = 0; i < I2C_CLIENT_MAX; i++)
  425. if (NULL == adapter->clients[i])
  426. break;
  427. if (I2C_CLIENT_MAX == i) {
  428. printk(KERN_WARNING 
  429.        " i2c-core.o: attach_client(%s) - enlarge I2C_CLIENT_MAX.n",
  430. client->name);
  431. return -ENOMEM;
  432. }
  434. adapter->clients[i] = client;
  435. adapter->client_count++;
  437. if (adapter->client_register) 
  438. if (adapter->client_register(client)) 
  439. printk("i2c-core.o: warning: client_register seems "
  440.        "to have failed for client %02x at adapter %sn",
  441.        client->addr,adapter->name);
  442. DEB(printk("i2c-core.o: client [%s] registered to adapter [%s](pos. %d).n",
  443. client->name, adapter->name,i));
  445. if(client->flags & I2C_CLIENT_ALLOW_USE)
  446. client->usage_count = 0;
  448. return 0;
  449. }
  452. int i2c_detach_client(struct i2c_client *client)
  453. {
  454. struct i2c_adapter *adapter = client->adapter;
  455. int i,res;
  457. for (i = 0; i < I2C_CLIENT_MAX; i++)
  458. if (client == adapter->clients[i])
  459. break;
  460. if (I2C_CLIENT_MAX == i) {
  461. printk(KERN_WARNING " i2c-core.o: unregister_client "
  462.     "[%s] not foundn",
  463. client->name);
  464. return -ENODEV;
  465. }
  467. if( (client->flags & I2C_CLIENT_ALLOW_USE) && 
  468.     (client->usage_count>0))
  469. return -EBUSY;
  471. if (adapter->client_unregister != NULL) 
  472. if ((res = adapter->client_unregister(client))) {
  473. printk("i2c-core.o: client_unregister [%s] failed, "
  474.        "client not detached",client->name);
  475. return res;
  476. }
  478. adapter->clients[i] = NULL;
  479. adapter->client_count--;
  481. DEB(printk("i2c-core.o: client [%s] unregistered.n",client->name));
  482. return 0;
  483. }
  485. void i2c_inc_use_client(struct i2c_client *client)
  486. {
  488. if (client->driver->inc_use != NULL)
  489. client->driver->inc_use(client);
  491. if (client->adapter->inc_use != NULL)
  492. client->adapter->inc_use(client->adapter);
  493. }
  495. void i2c_dec_use_client(struct i2c_client *client)
  496. {
  498. if (client->driver->dec_use != NULL)
  499. client->driver->dec_use(client);
  501. if (client->adapter->dec_use != NULL)
  502. client->adapter->dec_use(client->adapter);
  503. }
  505. struct i2c_client *i2c_get_client(int driver_id, int adapter_id, 
  506. struct i2c_client *prev)
  507. {
  508. int i,j;
  510. /* Will iterate through the list of clients in each adapter of adapters-list
  511.    in search for a client that matches the search criteria. driver_id or 
  512.    adapter_id are ignored if set to 0. If both are ignored this returns 
  513.    first client found. */
  515. i = j = 0;  
  517. /* set starting point */ 
  518. if(prev)
  519. {
  520. if(!(prev->adapter))
  521. return (struct i2c_client *) -EINVAL;
  523. for(j=0; j < I2C_ADAP_MAX; j++)
  524. if(prev->adapter == adapters[j])
  525. break;
  527. /* invalid starting point? */
  528. if (I2C_ADAP_MAX == j) {
  529. printk(KERN_WARNING " i2c-core.o: get_client adapter for client:[%s] not foundn",
  530. prev->name);
  531. return (struct i2c_client *) -ENODEV;
  532. }
  534. for(i=0; i < I2C_CLIENT_MAX; i++)
  535. if(prev == adapters[j]->clients[i])
  536. break;
  538. /* invalid starting point? */
  539. if (I2C_CLIENT_MAX == i) {
  540. printk(KERN_WARNING " i2c-core.o: get_client client:[%s] not foundn",
  541. prev->name);
  542. return (struct i2c_client *) -ENODEV;
  543. }
  545. i++; /* start from one after prev */
  546. }
  548. for(; j < I2C_ADAP_MAX; j++)
  549. {
  550. if(!adapters[j])
  551. continue;
  553. if(adapter_id && (adapters[j]->id != adapter_id))
  554. continue;
  556. for(; i < I2C_CLIENT_MAX; i++)
  557. {
  558. if(!adapters[j]->clients[i])
  559. continue;
  561. if(driver_id && (adapters[j]->clients[i]->driver->id != driver_id))
  562. continue;
  563. if(adapters[j]->clients[i]->flags & I2C_CLIENT_ALLOW_USE)
  564. return adapters[j]->clients[i];
  565. }
  566. i = 0;
  567. }
  569. return 0;
  570. }
  572. int i2c_use_client(struct i2c_client *client)
  573. {
  574. if(client->flags & I2C_CLIENT_ALLOW_USE) {
  575. if (client->flags & I2C_CLIENT_ALLOW_MULTIPLE_USE) 
  576. client->usage_count++;
  577. else {
  578. if(client->usage_count > 0) 
  579. return -EBUSY;
  580.  else 
  581. client->usage_count++;
  582. }
  583. }
  585. i2c_inc_use_client(client);
  587. return 0;
  588. }
  590. int i2c_release_client(struct i2c_client *client)
  591. {
  592. if(client->flags & I2C_CLIENT_ALLOW_USE) {
  593. if(client->usage_count>0)
  594. client->usage_count--;
  595. else
  596. {
  597. printk(KERN_WARNING " i2c-core.o: dec_use_client used one too many timesn");
  598. return -EPERM;
  599. }
  600. }
  602. i2c_dec_use_client(client);
  604. return 0;
  605. }
  607. /* ----------------------------------------------------
  608.  * The /proc functions
  609.  * ----------------------------------------------------
  610.  */
  612. #ifdef CONFIG_PROC_FS
  614. #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,3,27))
  615. /* Monitor access to /proc/bus/i2c*; make unloading i2c-proc impossible
  616.    if some process still uses it or some file in it */
  617. void monitor_bus_i2c(struct inode *inode, int fill)
  618. {
  619. if (fill)
  620. MOD_INC_USE_COUNT;
  621. else
  622. MOD_DEC_USE_COUNT;
  623. }
  624. #endif /* (LINUX_VERSION_CODE <= KERNEL_VERSION(2,3,37)) */
  626. /* This function generates the output for /proc/bus/i2c */
  627. int read_bus_i2c(char *buf, char **start, off_t offset, int len, int *eof, 
  628.                  void *private)
  629. {
  630. int i;
  631. int nr = 0;
  632. /* Note that it is safe to write a `little' beyond len. Yes, really. */
  633. for (i = 0; (i < I2C_ADAP_MAX) && (nr < len); i++)
  634. if (adapters[i]) {
  635. nr += sprintf(buf+nr, "i2c-%dt", i);
  636. if (adapters[i]->algo->smbus_xfer) {
  637. if (adapters[i]->algo->master_xfer)
  638. nr += sprintf(buf+nr,"smbus/i2c");
  639. else
  640. nr += sprintf(buf+nr,"smbus    ");
  641. } else if (adapters[i]->algo->master_xfer)
  642. nr += sprintf(buf+nr,"i2c       ");
  643. else
  644. nr += sprintf(buf+nr,"dummy     ");
  645. nr += sprintf(buf+nr,"t%-32st%-32sn",
  646.               adapters[i]->name,
  647.               adapters[i]->algo->name);
  648. }
  649. return nr;
  650. }
  652. /* This function generates the output for /proc/bus/i2c-? */
  653. ssize_t i2cproc_bus_read(struct file * file, char * buf,size_t count, 
  654.                          loff_t *ppos)
  655. {
  656. struct inode * inode = file->f_dentry->d_inode;
  657. char *kbuf;
  658. struct i2c_client *client;
  659. int i,j,k,order_nr,len=0,len_total;
  660. int order[I2C_CLIENT_MAX];
  662. if (count > 4000)
  663. return -EINVAL; 
  664. len_total = file->f_pos + count;
  665. /* Too bad if this gets longer (unlikely) */
  666. if (len_total > 4000)
  667. len_total = 4000;
  668. for (i = 0; i < I2C_ADAP_MAX; i++)
  669. if (adapters[i]->inode == inode->i_ino) {
  670. /* We need a bit of slack in the kernel buffer; this makes the
  671.    sprintf safe. */
  672. if (! (kbuf = kmalloc(count + 80,GFP_KERNEL)))
  673. return -ENOMEM;
  674. /* Order will hold the indexes of the clients
  675.    sorted by address */
  676. order_nr=0;
  677. for (j = 0; j < I2C_CLIENT_MAX; j++) {
  678. if ((client = adapters[i]->clients[j]) && 
  679.     (client->driver->id != I2C_DRIVERID_I2CDEV))  {
  680. for(k = order_nr; 
  681.     (k > 0) && 
  682.     adapters[i]->clients[order[k-1]]->
  683.              addr > client->addr; 
  684.     k--)
  685. order[k] = order[k-1];
  686. order[k] = j;
  687. order_nr++;
  688. }
  689. }
  692. for (j = 0; (j < order_nr) && (len < len_total); j++) {
  693. client = adapters[i]->clients[order[j]];
  694. len += sprintf(kbuf+len,"%02xt%-32st%-32sn",
  695.               client->addr,
  696.               client->name,
  697.               client->driver->name);
  698. }
  699. len = len - file->f_pos;
  700. if (len > count)
  701. len = count;
  702. if (len < 0) 
  703. len = 0;
  704. if (copy_to_user (buf,kbuf+file->f_pos, len)) {
  705. kfree(kbuf);
  706. return -EFAULT;
  707. }
  708. file->f_pos += len;
  709. kfree(kbuf);
  710. return len;
  711. }
  712. return -ENOENT;
  713. }
  715. int i2cproc_init(void)
  716. {
  718. struct proc_dir_entry *proc_bus_i2c;
  720. i2cproc_initialized = 0;
  722. if (! proc_bus) {
  723. printk("i2c-core.o: /proc/bus/ does not exist");
  724. i2cproc_cleanup();
  725. return -ENOENT;
  726.   } 
  727. proc_bus_i2c = create_proc_entry("i2c",0,proc_bus);
  728. if (!proc_bus_i2c) {
  729. printk("i2c-core.o: Could not create /proc/bus/i2c");
  730. i2cproc_cleanup();
  731. return -ENOENT;
  732.   }
  733. proc_bus_i2c->read_proc = &read_bus_i2c;
  734. #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,27))
  735. proc_bus_i2c->owner = THIS_MODULE;
  736. #else
  737. proc_bus_i2c->fill_inode = &monitor_bus_i2c;
  738. #endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,27)) */
  739. i2cproc_initialized += 2;
  740. return 0;
  741. }
  743. static void i2cproc_cleanup(void)
  744. {
  746. if (i2cproc_initialized >= 1) {
  747. remove_proc_entry("i2c",proc_bus);
  748. i2cproc_initialized -= 2;
  749. }
  750. }
  753. #endif /* def CONFIG_PROC_FS */
  755. /* ----------------------------------------------------
  756.  * the functional interface to the i2c busses.
  757.  * ----------------------------------------------------
  758.  */
  760. int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg msgs[],int num)
  761. {
  762. int ret;
  764. if (adap->algo->master_xfer) {
  765.     DEB2(printk("i2c-core.o: master_xfer: %s with %d msgs.n",
  766.             adap->name,num));
  768. I2C_LOCK(adap);
  769. ret = adap->algo->master_xfer(adap,msgs,num);
  770. I2C_UNLOCK(adap);
  772. return ret;
  773. } else {
  774. printk("i2c-core.o: I2C adapter %04x: I2C level transfers not supportedn",
  775.        adap->id);
  776. return -ENOSYS;
  777. }
  778. }
  780. int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
  781. {
  782. int ret;
  783. struct i2c_adapter *adap=client->adapter;
  784. struct i2c_msg msg;
  786. if (client->adapter->algo->master_xfer) {
  787. msg.addr   = client->addr;
  788. msg.flags = client->flags & I2C_M_TEN;
  789. msg.len = count;
  790. (const char *)msg.buf = buf;
  792. DEB2(printk("i2c-core.o: master_send: writing %d bytes on %s.n",
  793. count,client->adapter->name));
  795. I2C_LOCK(adap);
  796. ret = adap->algo->master_xfer(adap,&msg,1);
  797. I2C_UNLOCK(adap);
  799. /* if everything went ok (i.e. 1 msg transmitted), return #bytes
  800.  * transmitted, else error code.
  801.  */
  802. return (ret == 1 )? count : ret;
  803. } else {
  804. printk("i2c-core.o: I2C adapter %04x: I2C level transfers not supportedn",
  805.        client->adapter->id);
  806. return -ENOSYS;
  807. }
  808. }
  810. int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
  811. {
  812. struct i2c_adapter *adap=client->adapter;
  813. struct i2c_msg msg;
  814. int ret;
  815. if (client->adapter->algo->master_xfer) {
  816. msg.addr   = client->addr;
  817. msg.flags = client->flags & I2C_M_TEN;
  818. msg.flags |= I2C_M_RD;
  819. msg.len = count;
  820. msg.buf = buf;
  822. DEB2(printk("i2c-core.o: master_recv: reading %d bytes on %s.n",
  823. count,client->adapter->name));
  825. I2C_LOCK(adap);
  826. ret = adap->algo->master_xfer(adap,&msg,1);
  827. I2C_UNLOCK(adap);
  829. DEB2(printk("i2c-core.o: master_recv: return:%d (count:%d, addr:0x%02x)n",
  830. ret, count, client->addr));
  832. /* if everything went ok (i.e. 1 msg transmitted), return #bytes
  833.   * transmitted, else error code.
  834.   */
  835. return (ret == 1 )? count : ret;
  836. } else {
  837. printk("i2c-core.o: I2C adapter %04x: I2C level transfers not supportedn",
  838.        client->adapter->id);
  839. return -ENOSYS;
  840. }
  841. }
  844. int i2c_control(struct i2c_client *client,
  845. unsigned int cmd, unsigned long arg)
  846. {
  847. int ret = 0;
  848. struct i2c_adapter *adap = client->adapter;
  850. DEB2(printk("i2c-core.o: i2c ioctl, cmd: 0x%x, arg: %#lxn", cmd, arg));
  851. switch ( cmd ) {
  852. case I2C_RETRIES:
  853. adap->retries = arg;
  854. break;
  855. case I2C_TIMEOUT:
  856. adap->timeout = arg;
  857. break;
  858. default:
  859. if (adap->algo->algo_control!=NULL)
  860. ret = adap->algo->algo_control(adap,cmd,arg);
  861. }
  862. return ret;
  863. }
  865. /* ----------------------------------------------------
  866.  * the i2c address scanning function
  867.  * Will not work for 10-bit addresses!
  868.  * ----------------------------------------------------
  869.  */
  870. int i2c_probe(struct i2c_adapter *adapter,
  871.                    struct i2c_client_address_data *address_data,
  872.                    i2c_client_found_addr_proc *found_proc)
  873. {
  874. int addr,i,found,err;
  875. int adap_id = i2c_adapter_id(adapter);
  877. /* Forget it if we can't probe using SMBUS_QUICK */
  878. if (! i2c_check_functionality(adapter,I2C_FUNC_SMBUS_QUICK))
  879. return -1;
  881. for (addr = 0x00; addr <= 0x7f; addr++) {
  883. /* Skip if already in use */
  884. if (i2c_check_addr(adapter,addr))
  885. continue;
  887. /* If it is in one of the force entries, we don't do any detection
  888.    at all */
  889. found = 0;
  891. for (i = 0; !found && (address_data->force[i] != I2C_CLIENT_END); i += 3) {
  892. if (((adap_id == address_data->force[i]) || 
  893.      (address_data->force[i] == ANY_I2C_BUS)) &&
  894.      (addr == address_data->force[i+1])) {
  895. DEB2(printk("i2c-core.o: found force parameter for adapter %d, addr %04xn",
  896.             adap_id,addr));
  897. if ((err = found_proc(adapter,addr,0,0)))
  898. return err;
  899. found = 1;
  900. }
  901. }
  902. if (found) 
  903. continue;
  905. /* If this address is in one of the ignores, we can forget about
  906.    it right now */
  907. for (i = 0;
  908.      !found && (address_data->ignore[i] != I2C_CLIENT_END);
  909.      i += 2) {
  910. if (((adap_id == address_data->ignore[i]) || 
  911.     ((address_data->ignore[i] == ANY_I2C_BUS))) &&
  912.     (addr == address_data->ignore[i+1])) {
  913. DEB2(printk("i2c-core.o: found ignore parameter for adapter %d, "
  914.      "addr %04xn", adap_id ,addr));
  915. found = 1;
  916. }
  917. }
  918. for (i = 0;
  919.      !found && (address_data->ignore_range[i] != I2C_CLIENT_END);
  920.      i += 3) {
  921. if (((adap_id == address_data->ignore_range[i]) ||
  922.     ((address_data->ignore_range[i]==ANY_I2C_BUS))) &&
  923.     (addr >= address_data->ignore_range[i+1]) &&
  924.     (addr <= address_data->ignore_range[i+2])) {
  925. DEB2(printk("i2c-core.o: found ignore_range parameter for adapter %d, "
  926.             "addr %04xn", adap_id,addr));
  927. found = 1;
  928. }
  929. }
  930. if (found) 
  931. continue;
  933. /* Now, we will do a detection, but only if it is in the normal or 
  934.    probe entries */  
  935. for (i = 0;
  936.      !found && (address_data->normal_i2c[i] != I2C_CLIENT_END);
  937.      i += 1) {
  938. if (addr == address_data->normal_i2c[i]) {
  939. found = 1;
  940. DEB2(printk("i2c-core.o: found normal i2c entry for adapter %d, "
  941.             "addr %02x", adap_id,addr));
  942. }
  943. }
  945. for (i = 0;
  946.      !found && (address_data->normal_i2c_range[i] != I2C_CLIENT_END);
  947.      i += 2) {
  948. if ((addr >= address_data->normal_i2c_range[i]) &&
  949.     (addr <= address_data->normal_i2c_range[i+1])) {
  950. found = 1;
  951. DEB2(printk("i2c-core.o: found normal i2c_range entry for adapter %d, "
  952.             "addr %04xn", adap_id,addr));
  953. }
  954. }
  956. for (i = 0;
  957.      !found && (address_data->probe[i] != I2C_CLIENT_END);
  958.      i += 2) {
  959. if (((adap_id == address_data->probe[i]) ||
  960.     ((address_data->probe[i] == ANY_I2C_BUS))) &&
  961.     (addr == address_data->probe[i+1])) {
  962. found = 1;
  963. DEB2(printk("i2c-core.o: found probe parameter for adapter %d, "
  964.             "addr %04xn", adap_id,addr));
  965. }
  966. }
  967. for (i = 0;
  968.      !found && (address_data->probe_range[i] != I2C_CLIENT_END);
  969.      i += 3) {
  970. if (((adap_id == address_data->probe_range[i]) ||
  971.    (address_data->probe_range[i] == ANY_I2C_BUS)) &&
  972.    (addr >= address_data->probe_range[i+1]) &&
  973.    (addr <= address_data->probe_range[i+2])) {
  974. found = 1;
  975. DEB2(printk("i2c-core.o: found probe_range parameter for adapter %d, "
  976.             "addr %04xn", adap_id,addr));
  977. }
  978. }
  979. if (!found) 
  980. continue;
  982. /* OK, so we really should examine this address. First check
  983.    whether there is some client here at all! */
  984. if (i2c_smbus_xfer(adapter,addr,0,0,0,I2C_SMBUS_QUICK,NULL) >= 0)
  985. if ((err = found_proc(adapter,addr,0,-1)))
  986. return err;
  987. }
  988. return 0;
  989. }
  991. /*
  992.  * return id number for a specific adapter
  993.  */
  994. int i2c_adapter_id(struct i2c_adapter *adap)
  995. {
  996. int i;
  997. for (i = 0; i < I2C_ADAP_MAX; i++)
  998. if (adap == adapters[i])
  999. return i;
  1000. return -1;
  1001. }
  1003. /* The SMBus parts */
  1005. extern s32 i2c_smbus_write_quick(struct i2c_client * client, u8 value)
  1006. {
  1007. return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
  1008.                         value,0,I2C_SMBUS_QUICK,NULL);
  1009. }
  1011. extern s32 i2c_smbus_read_byte(struct i2c_client * client)
  1012. {
  1013. union i2c_smbus_data data;
  1014. if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
  1015.                    I2C_SMBUS_READ,0,I2C_SMBUS_BYTE, &data))
  1016. return -1;
  1017. else
  1018. return 0x0FF & data.byte;
  1019. }
  1021. extern s32 i2c_smbus_write_byte(struct i2c_client * client, u8 value)
  1022. {
  1023. return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
  1024.                       I2C_SMBUS_WRITE,value, I2C_SMBUS_BYTE,NULL);
  1025. }
  1027. extern s32 i2c_smbus_read_byte_data(struct i2c_client * client, u8 command)
  1028. {
  1029. union i2c_smbus_data data;
  1030. if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
  1031.                    I2C_SMBUS_READ,command, I2C_SMBUS_BYTE_DATA,&data))
  1032. return -1;
  1033. else
  1034. return 0x0FF & data.byte;
  1035. }
  1037. extern s32 i2c_smbus_write_byte_data(struct i2c_client * client, u8 command,
  1038.                                      u8 value)
  1039. {
  1040. union i2c_smbus_data data;
  1041. data.byte = value;
  1042. return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
  1043.                       I2C_SMBUS_WRITE,command,
  1044.                       I2C_SMBUS_BYTE_DATA,&data);
  1045. }
  1047. extern s32 i2c_smbus_read_word_data(struct i2c_client * client, u8 command)
  1048. {
  1049. union i2c_smbus_data data;
  1050. if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
  1051.                    I2C_SMBUS_READ,command, I2C_SMBUS_WORD_DATA, &data))
  1052. return -1;
  1053. else
  1054. return 0x0FFFF & data.word;
  1055. }
  1057. extern s32 i2c_smbus_write_word_data(struct i2c_client * client,
  1058.                                      u8 command, u16 value)
  1059. {
  1060. union i2c_smbus_data data;
  1061. data.word = value;
  1062. return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
  1063.                       I2C_SMBUS_WRITE,command,
  1064.                       I2C_SMBUS_WORD_DATA,&data);
  1065. }
  1067. extern s32 i2c_smbus_process_call(struct i2c_client * client,
  1068.                                   u8 command, u16 value)
  1069. {
  1070. union i2c_smbus_data data;
  1071. data.word = value;
  1072. if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
  1073.                    I2C_SMBUS_WRITE,command,
  1074.                    I2C_SMBUS_PROC_CALL, &data))
  1075. return -1;
  1076. else
  1077. return 0x0FFFF & data.word;
  1078. }
  1080. /* Returns the number of read bytes */
  1081. extern s32 i2c_smbus_read_block_data(struct i2c_client * client,
  1082.                                      u8 command, u8 *values)
  1083. {
  1084. union i2c_smbus_data data;
  1085. int i;
  1086. if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
  1087.                    I2C_SMBUS_READ,command,
  1088.                    I2C_SMBUS_BLOCK_DATA,&data))
  1089. return -1;
  1090. else {
  1091. for (i = 1; i <= data.block[0]; i++)
  1092. values[i-1] = data.block[i];
  1093. return data.block[0];
  1094. }
  1095. }
  1097. extern s32 i2c_smbus_write_block_data(struct i2c_client * client,
  1098.                                       u8 command, u8 length, u8 *values)
  1099. {
  1100. union i2c_smbus_data data;
  1101. int i;
  1102. if (length > 32)
  1103. length = 32;
  1104. for (i = 1; i <= length; i++)
  1105. data.block[i] = values[i-1];
  1106. data.block[0] = length;
  1107. return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
  1108.                       I2C_SMBUS_WRITE,command,
  1109.                       I2C_SMBUS_BLOCK_DATA,&data);
  1110. }
  1112. extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client * client,
  1113.                                           u8 command, u8 length, u8 *values)
  1114. {
  1115. union i2c_smbus_data data;
  1116. int i;
  1117. if (length > 32)
  1118. length = 32;
  1119. for (i = 1; i <= length; i++)
  1120. data.block[i] = values[i-1];
  1121. data.block[0] = length;
  1122. return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
  1123.                       I2C_SMBUS_WRITE,command,
  1124.                       I2C_SMBUS_I2C_BLOCK_DATA,&data);
  1125. }
  1127. /* Simulate a SMBus command using the i2c protocol 
  1128.    No checking of parameters is done!  */
  1129. static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr, 
  1130.                                    unsigned short flags,
  1131.                                    char read_write, u8 command, int size, 
  1132.                                    union i2c_smbus_data * data)
  1133. {
  1134. /* So we need to generate a series of msgs. In the case of writing, we
  1135.   need to use only one message; when reading, we need two. We initialize
  1136.   most things with sane defaults, to keep the code below somewhat
  1137.   simpler. */
  1138. unsigned char msgbuf0[34];
  1139. unsigned char msgbuf1[34];
  1140. int num = read_write == I2C_SMBUS_READ?2:1;
  1141. struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 }, 
  1142.                           { addr, flags | I2C_M_RD, 0, msgbuf1 }
  1143.                         };
  1144. int i;
  1146. msgbuf0[0] = command;
  1147. switch(size) {
  1148. case I2C_SMBUS_QUICK:
  1149. msg[0].len = 0;
  1150. /* Special case: The read/write field is used as data */
  1151. msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
  1152. num = 1;
  1153. break;
  1154. case I2C_SMBUS_BYTE:
  1155. if (read_write == I2C_SMBUS_READ) {
  1156. /* Special case: only a read! */
  1157. msg[0].flags = I2C_M_RD | flags;
  1158. num = 1;
  1159. }
  1160. break;
  1161. case I2C_SMBUS_BYTE_DATA:
  1162. if (read_write == I2C_SMBUS_READ)
  1163. msg[1].len = 1;
  1164. else {
  1165. msg[0].len = 2;
  1166. msgbuf0[1] = data->byte;
  1167. }
  1168. break;
  1169. case I2C_SMBUS_WORD_DATA:
  1170. if (read_write == I2C_SMBUS_READ)
  1171. msg[1].len = 2;
  1172. else {
  1173. msg[0].len=3;
  1174. msgbuf0[1] = data->word & 0xff;
  1175. msgbuf0[2] = (data->word >> 8) & 0xff;
  1176. }
  1177. break;
  1178. case I2C_SMBUS_PROC_CALL:
  1179. num = 2; /* Special case */
  1180. msg[0].len = 3;
  1181. msg[1].len = 2;
  1182. msgbuf0[1] = data->word & 0xff;
  1183. msgbuf0[2] = (data->word >> 8) & 0xff;
  1184. break;
  1185. case I2C_SMBUS_BLOCK_DATA:
  1186. if (read_write == I2C_SMBUS_READ) {
  1187. printk("i2c-core.o: Block read not supported under "
  1188.        "I2C emulation!n");
  1189. return -1;
  1190. } else {
  1191. msg[0].len = data->block[0] + 2;
  1192. if (msg[0].len > 34) {
  1193. printk("i2c-core.o: smbus_access called with "
  1194.        "invalid block write size (%d)n",
  1195.        msg[0].len);
  1196. return -1;
  1197. }
  1198. for (i = 1; i <= msg[0].len; i++)
  1199. msgbuf0[i] = data->block[i-1];
  1200. }
  1201. break;
  1202. default:
  1203. printk("i2c-core.o: smbus_access called with invalid size (%d)n",
  1204.        size);
  1205. return -1;
  1206. }
  1208. if (i2c_transfer(adapter, msg, num) < 0)
  1209. return -1;
  1211. if (read_write == I2C_SMBUS_READ)
  1212. switch(size) {
  1213. case I2C_SMBUS_BYTE:
  1214. data->byte = msgbuf0[0];
  1215. break;
  1216. case I2C_SMBUS_BYTE_DATA:
  1217. data->byte = msgbuf1[0];
  1218. break;
  1219. case I2C_SMBUS_WORD_DATA: 
  1220. case I2C_SMBUS_PROC_CALL:
  1221. data->word = msgbuf1[0] | (msgbuf1[1] << 8);
  1222. break;
  1223. }
  1224. return 0;
  1225. }
  1228. s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
  1229.                    char read_write, u8 command, int size, 
  1230.                    union i2c_smbus_data * data)
  1231. {
  1232. s32 res;
  1233. flags = flags & I2C_M_TEN;
  1234. if (adapter->algo->smbus_xfer) {
  1235. I2C_LOCK(adapter);
  1236. res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
  1237.                                 command,size,data);
  1238. I2C_UNLOCK(adapter);
  1239. } else
  1240. res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
  1241.                                       command,size,data);
  1242. return res;
  1243. }
  1246. /* You should always define `functionality'; the 'else' is just for
  1247.    backward compatibility. */ 
  1248. u32 i2c_get_functionality (struct i2c_adapter *adap)
  1249. {
  1250. if (adap->algo->functionality)
  1251. return adap->algo->functionality(adap);
  1252. else
  1253. return 0xffffffff;
  1254. }
  1256. int i2c_check_functionality (struct i2c_adapter *adap, u32 func)
  1257. {
  1258. u32 adap_func = i2c_get_functionality (adap);
  1259. return (func & adap_func) == func;
  1260. }
  1263. static int __init i2c_init(void)
  1264. {
  1265. printk(KERN_DEBUG "i2c-core.o: i2c core modulen");
  1266. memset(adapters,0,sizeof(adapters));
  1267. memset(drivers,0,sizeof(drivers));
  1268. adap_count=0;
  1269. driver_count=0;
  1271. init_MUTEX(&adap_lock);
  1272. init_MUTEX(&driver_lock);
  1274. i2cproc_init();
  1276. return 0;
  1277. }
  1279. EXPORT_SYMBOL(i2c_add_adapter);
  1280. EXPORT_SYMBOL(i2c_del_adapter);
  1281. EXPORT_SYMBOL(i2c_add_driver);
  1282. EXPORT_SYMBOL(i2c_del_driver);
  1283. EXPORT_SYMBOL(i2c_attach_client);
  1284. EXPORT_SYMBOL(i2c_detach_client);
  1285. EXPORT_SYMBOL(i2c_inc_use_client);
  1286. EXPORT_SYMBOL(i2c_dec_use_client);
  1287. EXPORT_SYMBOL(i2c_get_client);
  1288. EXPORT_SYMBOL(i2c_use_client);
  1289. EXPORT_SYMBOL(i2c_release_client);
  1290. EXPORT_SYMBOL(i2c_check_addr);
  1293. EXPORT_SYMBOL(i2c_master_send);
  1294. EXPORT_SYMBOL(i2c_master_recv);
  1295. EXPORT_SYMBOL(i2c_control);
  1296. EXPORT_SYMBOL(i2c_transfer);
  1297. EXPORT_SYMBOL(i2c_adapter_id);
  1298. EXPORT_SYMBOL(i2c_probe);
  1300. EXPORT_SYMBOL(i2c_smbus_xfer);
  1301. EXPORT_SYMBOL(i2c_smbus_write_quick);
  1302. EXPORT_SYMBOL(i2c_smbus_read_byte);
  1303. EXPORT_SYMBOL(i2c_smbus_write_byte);
  1304. EXPORT_SYMBOL(i2c_smbus_read_byte_data);
  1305. EXPORT_SYMBOL(i2c_smbus_write_byte_data);
  1306. EXPORT_SYMBOL(i2c_smbus_read_word_data);
  1307. EXPORT_SYMBOL(i2c_smbus_write_word_data);
  1308. EXPORT_SYMBOL(i2c_smbus_process_call);
  1309. EXPORT_SYMBOL(i2c_smbus_read_block_data);
  1310. EXPORT_SYMBOL(i2c_smbus_write_block_data);
  1312. EXPORT_SYMBOL(i2c_get_functionality);
  1313. EXPORT_SYMBOL(i2c_check_functionality);
  1315. MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
  1316. MODULE_DESCRIPTION("I2C-Bus main module");
  1317. MODULE_PARM(i2c_debug, "i");
  1318. MODULE_PARM_DESC(i2c_debug,"debug level");
  1319. MODULE_LICENSE("GPL");
  1321. module_init(i2c_init);
  1322. module_exit(i2cproc_cleanup);