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

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

嵌入式Linux

开发平台：

Unix_Linux

i2c-algo-bit.c：源码内容
  1. /* ------------------------------------------------------------------------- */
  2. /* i2c-algo-bit.c i2c driver algorithms for bit-shift adapters      */
  3. /* ------------------------------------------------------------------------- */
  4. /*   Copyright (C) 1995-2000 Simon G. Vogl
  6.     This program is free software; you can redistribute it and/or modify
  7.     it under the terms of the GNU General Public License as published by
  8.     the Free Software Foundation; either version 2 of the License, or
  9.     (at your option) any later version.
  11.     This program is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  16.     You should have received a copy of the GNU General Public License
  17.     along with this program; if not, write to the Free Software
  18.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.      */
  19. /* ------------------------------------------------------------------------- */
  21. /* With some changes from Ky鰏ti M鋖kki <kmalkki@cc.hut.fi> and even
  22.    Frodo Looijaard <frodol@dds.nl> */
  24. /* $Id: i2c-algo-bit.c,v 1.30 2001/07/29 02:44:25 mds Exp $ */
  26. #include <linux/kernel.h>
  27. #include <linux/module.h>
  28. #include <linux/delay.h>
  29. #include <linux/slab.h>
  30. #include <linux/version.h>
  31. #include <linux/init.h>
  32. #include <asm/uaccess.h>
  33. #include <linux/ioport.h>
  34. #include <linux/errno.h>
  35. #include <linux/sched.h>
  37. #include <linux/i2c.h>
  38. #include <linux/i2c-algo-bit.h>
  40. /* ----- global defines ----------------------------------------------- */
  41. #define DEB(x) if (i2c_debug>=1) x;
  42. #define DEB2(x) if (i2c_debug>=2) x;
  43. #define DEBSTAT(x) if (i2c_debug>=3) x; /* print several statistical values*/
  44. #define DEBPROTO(x) if (i2c_debug>=9) { x; }
  45.   /* debug the protocol by showing transferred bits */
  47. /* debugging - slow down transfer to have a look at the data ..  */
  48. /* I use this with two leds&resistors, each one connected to sda,scl  */
  49. /* respectively. This makes sure that the algorithm works. Some chips   */
  50. /* might not like this, as they have an internal timeout of some mils */
  51. /*
  52. #define SLO_IO      jif=jiffies;while(jiffies<=jif+i2c_table[minor].veryslow)
  53.                         if (need_resched) schedule();
  54. */
  57. /* ----- global variables --------------------------------------------- */
  59. #ifdef SLO_IO
  60. int jif;
  61. #endif
  63. /* module parameters:
  64.  */
  65. static int i2c_debug;
  66. static int bit_test; /* see if the line-setting functions work */
  67. static int bit_scan; /* have a look at what's hanging 'round */
  69. /* --- setting states on the bus with the right timing: --------------- */
  71. #define setsda(adap,val) adap->setsda(adap->data, val)
  72. #define setscl(adap,val) adap->setscl(adap->data, val)
  73. #define getsda(adap) adap->getsda(adap->data)
  74. #define getscl(adap) adap->getscl(adap->data)
  76. static inline void sdalo(struct i2c_algo_bit_data *adap)
  77. {
  78. setsda(adap,0);
  79. udelay(adap->udelay);
  80. }
  82. static inline void sdahi(struct i2c_algo_bit_data *adap)
  83. {
  84. setsda(adap,1);
  85. udelay(adap->udelay);
  86. }
  88. static inline void scllo(struct i2c_algo_bit_data *adap)
  89. {
  90. setscl(adap,0);
  91. udelay(adap->udelay);
  92. #ifdef SLO_IO
  93. SLO_IO
  94. #endif
  95. }
  97. /*
  98.  * Raise scl line, and do checking for delays. This is necessary for slower
  99.  * devices.
  100.  */
  101. static inline int sclhi(struct i2c_algo_bit_data *adap)
  102. {
  103. int start=jiffies;
  105. setscl(adap,1);
  107. udelay(adap->udelay);
  109. /* Not all adapters have scl sense line... */
  110. if (adap->getscl == NULL )
  111. return 0;
  113.   while (! getscl(adap) ) {
  114.   /* the hw knows how to read the clock line,
  115.    * so we wait until it actually gets high.
  116.    * This is safer as some chips may hold it low
  117.    * while they are processing data internally. 
  118.    */
  119. setscl(adap,1);
  120. if (start+adap->timeout <= jiffies) {
  121. return -ETIMEDOUT;
  122. }
  123. if (current->need_resched)
  124. schedule();
  125. }
  126. DEBSTAT(printk("needed %ld jiffiesn", jiffies-start));
  127. #ifdef SLO_IO
  128. SLO_IO
  129. #endif
  130. return 0;
  131. } 
  134. /* --- other auxiliary functions -------------------------------------- */
  135. static void i2c_start(struct i2c_algo_bit_data *adap) 
  136. {
  137. /* assert: scl, sda are high */
  138. DEBPROTO(printk("S "));
  139. sdalo(adap);
  140. scllo(adap);
  141. }
  143. static void i2c_repstart(struct i2c_algo_bit_data *adap) 
  144. {
  145. /* scl, sda may not be high */
  146. DEBPROTO(printk(" Sr "));
  147. setsda(adap,1);
  148. setscl(adap,1);
  149. udelay(adap->udelay);
  151. sdalo(adap);
  152. scllo(adap);
  153. }
  156. static void i2c_stop(struct i2c_algo_bit_data *adap) 
  157. {
  158. DEBPROTO(printk("Pn"));
  159. /* assert: scl is low */
  160. sdalo(adap);
  161. sclhi(adap); 
  162. sdahi(adap);
  163. }
  167. /* send a byte without start cond., look for arbitration, 
  168.    check ackn. from slave */
  169. /* returns:
  170.  * 1 if the device acknowledged
  171.  * 0 if the device did not ack
  172.  * -ETIMEDOUT if an error occurred (while raising the scl line)
  173.  */
  174. static int i2c_outb(struct i2c_adapter *i2c_adap, char c)
  175. {
  176. int i;
  177. int sb;
  178. int ack;
  179. struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
  181. /* assert: scl is low */
  182. DEB2(printk(" i2c_outb:%2.2Xn",c&0xff));
  183. for ( i=7 ; i>=0 ; i-- ) {
  184. sb = c & ( 1 << i );
  185. setsda(adap,sb);
  186. udelay(adap->udelay);
  187. DEBPROTO(printk("%d",sb!=0));
  188. if (sclhi(adap)<0) { /* timed out */
  189. sdahi(adap); /* we don't want to block the net */
  190. return -ETIMEDOUT;
  191. };
  192. /* do arbitration here: 
  193.  * if ( sb && ! getsda(adap) ) -> ouch! Get out of here.
  194.  */
  195. setscl(adap, 0 );
  196. udelay(adap->udelay);
  197. }
  198. sdahi(adap);
  199. if (sclhi(adap)<0){ /* timeout */
  200. return -ETIMEDOUT;
  201. };
  202. /* read ack: SDA should be pulled down by slave */
  203. ack=getsda(adap); /* ack: sda is pulled low ->success.  */
  204. DEB2(printk(" i2c_outb: getsda() =  0x%2.2xn", ~ack ));
  206. DEBPROTO( printk("[%2.2x]",c&0xff) );
  207. DEBPROTO(if (0==ack){ printk(" A ");} else printk(" NA ") );
  208. scllo(adap);
  209. return 0==ack; /* return 1 if device acked  */
  210. /* assert: scl is low (sda undef) */
  211. }
  214. static int i2c_inb(struct i2c_adapter *i2c_adap) 
  215. {
  216. /* read byte via i2c port, without start/stop sequence */
  217. /* acknowledge is sent in i2c_read. */
  218. int i;
  219. unsigned char indata=0;
  220. struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
  222. /* assert: scl is low */
  223. DEB2(printk("i2c_inb.n"));
  225. sdahi(adap);
  226. for (i=0;i<8;i++) {
  227. if (sclhi(adap)<0) { /* timeout */
  228. return -ETIMEDOUT;
  229. };
  230. indata *= 2;
  231. if ( getsda(adap) ) 
  232. indata |= 0x01;
  233. scllo(adap);
  234. }
  235. /* assert: scl is low */
  236. DEBPROTO(printk(" %2.2x", indata & 0xff));
  237. return (int) (indata & 0xff);
  238. }
  240. /*
  241.  * Sanity check for the adapter hardware - check the reaction of
  242.  * the bus lines only if it seems to be idle.
  243.  */
  244. static int test_bus(struct i2c_algo_bit_data *adap, char* name) {
  245. int scl,sda;
  246. sda=getsda(adap);
  247. if (adap->getscl==NULL) {
  248. printk("i2c-algo-bit.o: Warning: Adapter can't read from clock line - skipping test.n");
  249. return 0;
  250. }
  251. scl=getscl(adap);
  252. printk("i2c-algo-bit.o: Adapter: %s scl: %d  sda: %d -- testing...n",
  253.        name,getscl(adap),getsda(adap));
  254. if (!scl || !sda ) {
  255. printk("i2c-algo-bit.o: %s seems to be busy.n",name);
  256. goto bailout;
  257. }
  258. sdalo(adap);
  259. printk("i2c-algo-bit.o:1 scl: %d  sda: %d n",getscl(adap),
  260.        getsda(adap));
  261. if ( 0 != getsda(adap) ) {
  262. printk("i2c-algo-bit.o: %s SDA stuck high!n",name);
  263. sdahi(adap);
  264. goto bailout;
  265. }
  266. if ( 0 == getscl(adap) ) {
  267. printk("i2c-algo-bit.o: %s SCL unexpected low while pulling SDA low!n",
  268. name);
  269. goto bailout;
  270. }
  271. sdahi(adap);
  272. printk("i2c-algo-bit.o:2 scl: %d  sda: %d n",getscl(adap),
  273.        getsda(adap));
  274. if ( 0 == getsda(adap) ) {
  275. printk("i2c-algo-bit.o: %s SDA stuck low!n",name);
  276. sdahi(adap);
  277. goto bailout;
  278. }
  279. if ( 0 == getscl(adap) ) {
  280. printk("i2c-algo-bit.o: %s SCL unexpected low while SDA high!n",
  281.        name);
  282. goto bailout;
  283. }
  284. scllo(adap);
  285. printk("i2c-algo-bit.o:3 scl: %d  sda: %d n",getscl(adap),
  286.        getsda(adap));
  287. if ( 0 != getscl(adap) ) {
  288. printk("i2c-algo-bit.o: %s SCL stuck high!n",name);
  289. sclhi(adap);
  290. goto bailout;
  291. }
  292. if ( 0 == getsda(adap) ) {
  293. printk("i2c-algo-bit.o: %s SDA unexpected low while pulling SCL low!n",
  294. name);
  295. goto bailout;
  296. }
  297. sclhi(adap);
  298. printk("i2c-algo-bit.o:4 scl: %d  sda: %d n",getscl(adap),
  299.        getsda(adap));
  300. if ( 0 == getscl(adap) ) {
  301. printk("i2c-algo-bit.o: %s SCL stuck low!n",name);
  302. sclhi(adap);
  303. goto bailout;
  304. }
  305. if ( 0 == getsda(adap) ) {
  306. printk("i2c-algo-bit.o: %s SDA unexpected low while SCL high!n",
  307. name);
  308. goto bailout;
  309. }
  310. printk("i2c-algo-bit.o: %s passed test.n",name);
  311. return 0;
  312. bailout:
  313. sdahi(adap);
  314. sclhi(adap);
  315. return -ENODEV;
  316. }
  318. /* ----- Utility functions
  319.  */
  321. /* try_address tries to contact a chip for a number of
  322.  * times before it gives up.
  323.  * return values:
  324.  * 1 chip answered
  325.  * 0 chip did not answer
  326.  * -x transmission error
  327.  */
  328. static inline int try_address(struct i2c_adapter *i2c_adap,
  329.        unsigned char addr, int retries)
  330. {
  331. struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
  332. int i,ret = -1;
  333. for (i=0;i<=retries;i++) {
  334. ret = i2c_outb(i2c_adap,addr);
  335. if (ret==1)
  336. break; /* success! */
  337. i2c_stop(adap);
  338. udelay(5/*adap->udelay*/);
  339. if (i==retries)  /* no success */
  340. break;
  341. i2c_start(adap);
  342. udelay(adap->udelay);
  343. }
  344. DEB2(if (i) printk("i2c-algo-bit.o: needed %d retries for %dn",
  345.                    i,addr));
  346. return ret;
  347. }
  349. static int sendbytes(struct i2c_adapter *i2c_adap,const char *buf, int count)
  350. {
  351. struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
  352. char c;
  353. const char *temp = buf;
  354. int retval;
  355. int wrcount=0;
  357. while (count > 0) {
  358. c = *temp;
  359. DEB2(printk("i2c-algo-bit.o: %s i2c_write: writing %2.2Xn",
  360.     i2c_adap->name, c&0xff));
  361. retval = i2c_outb(i2c_adap,c);
  362. if (retval>0) {
  363. count--; 
  364. temp++;
  365. wrcount++;
  366. } else { /* arbitration or no acknowledge */
  367. printk("i2c-algo-bit.o: %s i2c_write: error - bailout.n",
  368.        i2c_adap->name);
  369. i2c_stop(adap);
  370. return (retval<0)? retval : -EFAULT;
  371.         /* got a better one ?? */
  372. }
  373. #if 0
  374. /* from asm/delay.h */
  375. __delay(adap->mdelay * (loops_per_sec / 1000) );
  376. #endif
  377. }
  378. return wrcount;
  379. }
  381. static inline int readbytes(struct i2c_adapter *i2c_adap,char *buf,int count)
  382. {
  383. char *temp = buf;
  384. int inval;
  385. int rdcount=0;    /* counts bytes read */
  386. struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
  388. while (count > 0) {
  389. inval = i2c_inb(i2c_adap);
  390. /*printk("%#02x ",inval); if ( ! (count % 16) ) printk("n"); */
  391. if (inval>=0) {
  392. *temp = inval;
  393. rdcount++;
  394. } else {   /* read timed out */
  395. printk("i2c-algo-bit.o: i2c_read: i2c_inb timed out.n");
  396. break;
  397. }
  399. if ( count > 1 ) { /* send ack */
  400. sdalo(adap);
  401. DEBPROTO(printk(" Am "));
  402. } else {
  403. sdahi(adap); /* neg. ack on last byte */
  404. DEBPROTO(printk(" NAm "));
  405. }
  406. if (sclhi(adap)<0) { /* timeout */
  407. sdahi(adap);
  408. printk("i2c-algo-bit.o: i2c_read: Timeout at ackn");
  409. return -ETIMEDOUT;
  410. };
  411. scllo(adap);
  412. sdahi(adap);
  413. temp++;
  414. count--;
  415. }
  416. return rdcount;
  417. }
  419. /* doAddress initiates the transfer by generating the start condition (in
  420.  * try_address) and transmits the address in the necessary format to handle
  421.  * reads, writes as well as 10bit-addresses.
  422.  * returns:
  423.  *  0 everything went okay, the chip ack'ed
  424.  * -x an error occurred (like: -EREMOTEIO if the device did not answer, or
  425.  * -ETIMEDOUT, for example if the lines are stuck...) 
  426.  */
  427. static inline int bit_doAddress(struct i2c_adapter *i2c_adap,
  428.                                 struct i2c_msg *msg, int retries) 
  429. {
  430. unsigned short flags = msg->flags;
  431. struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
  433. unsigned char addr;
  434. int ret;
  435. if ( (flags & I2C_M_TEN)  ) { 
  436. /* a ten bit address */
  437. addr = 0xf0 | (( msg->addr >> 7) & 0x03);
  438. DEB2(printk("addr0: %dn",addr));
  439. /* try extended address code...*/
  440. ret = try_address(i2c_adap, addr, retries);
  441. if (ret!=1) {
  442. printk("died at extended address code.n");
  443. return -EREMOTEIO;
  444. }
  445. /* the remaining 8 bit address */
  446. ret = i2c_outb(i2c_adap,msg->addr & 0x7f);
  447. if (ret != 1) {
  448. /* the chip did not ack / xmission error occurred */
  449. printk("died at 2nd address code.n");
  450. return -EREMOTEIO;
  451. }
  452. if ( flags & I2C_M_RD ) {
  453. i2c_repstart(adap);
  454. /* okay, now switch into reading mode */
  455. addr |= 0x01;
  456. ret = try_address(i2c_adap, addr, retries);
  457. if (ret!=1) {
  458. printk("died at extended address code.n");
  459. return -EREMOTEIO;
  460. }
  461. }
  462. } else { /* normal 7bit address */
  463. addr = ( msg->addr << 1 );
  464. if (flags & I2C_M_RD )
  465. addr |= 1;
  466. if (flags & I2C_M_REV_DIR_ADDR )
  467. addr ^= 1;
  468. ret = try_address(i2c_adap, addr, retries);
  469. if (ret!=1) {
  470. return -EREMOTEIO;
  471. }
  472. }
  473. return 0;
  474. }
  476. static int bit_xfer(struct i2c_adapter *i2c_adap,
  477.     struct i2c_msg msgs[], int num)
  478. {
  479. struct i2c_msg *pmsg;
  480. struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
  482. int i,ret;
  484. i2c_start(adap);
  485. for (i=0;i<num;i++) {
  486. pmsg = &msgs[i];
  487. if (!(pmsg->flags & I2C_M_NOSTART)) {
  488. if (i) {
  489. i2c_repstart(adap);
  490. }
  491. ret = bit_doAddress(i2c_adap,pmsg,i2c_adap->retries);
  492. if (ret != 0) {
  493. DEB2(printk("i2c-algo-bit.o: NAK from device adr %#2x msg #%dn"
  494.        ,msgs[i].addr,i));
  495. return (ret<0) ? ret : -EREMOTEIO;
  496. }
  497. }
  498. if (pmsg->flags & I2C_M_RD ) {
  499. /* read bytes into buffer*/
  500. ret = readbytes(i2c_adap,pmsg->buf,pmsg->len);
  501. DEB2(printk("i2c-algo-bit.o: read %d bytes.n",ret));
  502. if (ret < pmsg->len ) {
  503. return (ret<0)? ret : -EREMOTEIO;
  504. }
  505. } else {
  506. /* write bytes from buffer */
  507. ret = sendbytes(i2c_adap,pmsg->buf,pmsg->len);
  508. DEB2(printk("i2c-algo-bit.o: wrote %d bytes.n",ret));
  509. if (ret < pmsg->len ) {
  510. return (ret<0) ? ret : -EREMOTEIO;
  511. }
  512. }
  513. }
  514. i2c_stop(adap);
  515. return num;
  516. }
  518. static int algo_control(struct i2c_adapter *adapter, 
  519. unsigned int cmd, unsigned long arg)
  520. {
  521. return 0;
  522. }
  524. static u32 bit_func(struct i2c_adapter *adap)
  525. {
  526. return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR | 
  527.        I2C_FUNC_PROTOCOL_MANGLING;
  528. }
  531. /* -----exported algorithm data: ------------------------------------- */
  533. static struct i2c_algorithm i2c_bit_algo = {
  534. "Bit-shift algorithm",
  535. I2C_ALGO_BIT,
  536. bit_xfer,
  537. NULL,
  538. NULL, /* slave_xmit */
  539. NULL, /* slave_recv */
  540. algo_control, /* ioctl */
  541. bit_func, /* functionality */
  542. };
  544. /* 
  545.  * registering functions to load algorithms at runtime 
  546.  */
  547. int i2c_bit_add_bus(struct i2c_adapter *adap)
  548. {
  549. int i;
  550. struct i2c_algo_bit_data *bit_adap = adap->algo_data;
  552. if (bit_test) {
  553. int ret = test_bus(bit_adap, adap->name);
  554. if (ret<0)
  555. return -ENODEV;
  556. }
  558. DEB2(printk("i2c-algo-bit.o: hw routines for %s registered.n",
  559.             adap->name));
  561. /* register new adapter to i2c module... */
  563. adap->id |= i2c_bit_algo.id;
  564. adap->algo = &i2c_bit_algo;
  566. adap->timeout = 100; /* default values, should */
  567. adap->retries = 3; /* be replaced by defines */
  569. /* scan bus */
  570. if (bit_scan) {
  571. int ack;
  572. printk(KERN_INFO " i2c-algo-bit.o: scanning bus %s.n",
  573.        adap->name);
  574. for (i = 0x00; i < 0xff; i+=2) {
  575. i2c_start(bit_adap);
  576. ack = i2c_outb(adap,i);
  577. i2c_stop(bit_adap);
  578. if (ack>0) {
  579. printk("(%02x)",i>>1); 
  580. } else 
  581. printk("."); 
  582. }
  583. printk("n");
  584. }
  586. MOD_INC_USE_COUNT;
  587. i2c_add_adapter(adap);
  589. return 0;
  590. }
  593. int i2c_bit_del_bus(struct i2c_adapter *adap)
  594. {
  595. int res;
  597. if ((res = i2c_del_adapter(adap)) < 0)
  598. return res;
  600. DEB2(printk("i2c-algo-bit.o: adapter unregistered: %sn",adap->name));
  602. MOD_DEC_USE_COUNT;
  603. return 0;
  604. }
  606. static int __init i2c_algo_bit_init (void)
  607. {
  608. printk(KERN_DEBUG "i2c-algo-bit.o: i2c bit algorithm modulen");
  609. return 0;
  610. }
  614. EXPORT_SYMBOL(i2c_bit_add_bus);
  615. EXPORT_SYMBOL(i2c_bit_del_bus);
  617. MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
  618. MODULE_DESCRIPTION("I2C-Bus bit-banging algorithm");
  619. MODULE_LICENSE("GPL");
  621. MODULE_PARM(bit_test, "i");
  622. MODULE_PARM(bit_scan, "i");
  623. MODULE_PARM(i2c_debug,"i");
  625. MODULE_PARM_DESC(bit_test, "Test the lines of the bus to see if it is stuck");
  626. MODULE_PARM_DESC(bit_scan, "Scan for active chips on the bus");
  627. MODULE_PARM_DESC(i2c_debug,
  628.             "debug level - 0 off; 1 normal; 2,3 more verbose; 9 bit-protocol");
  630. module_init(i2c_algo_bit_init);