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

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

嵌入式Linux

开发平台：

Unix_Linux

i2c-old.c：源码内容
  1. /*
  2.  * Generic i2c interface for linux
  3.  *
  4.  * (c) 1998 Gerd Knorr <kraxel@cs.tu-berlin.de>
  5.  *
  6.  */
  8. #include <linux/config.h>
  9. #include <linux/module.h>
  10. #include <linux/kernel.h>
  11. #include <linux/errno.h>
  12. #include <linux/types.h>
  13. #include <linux/string.h>
  14. #include <linux/delay.h>
  15. #include <linux/locks.h>
  16. #include <linux/sched.h>
  17. #include <linux/slab.h>
  18. #include <linux/i2c-old.h>
  20. #define REGPRINT(x)   if (verbose)   (x)
  21. #define I2C_DEBUG(x)  if (i2c_debug) (x)
  23. static int scan      = 0;
  24. static int verbose   = 0;
  25. static int i2c_debug = 0;
  27. #if LINUX_VERSION_CODE >= 0x020117
  28. MODULE_PARM(scan,"i");
  29. MODULE_PARM(verbose,"i");
  30. MODULE_PARM(i2c_debug,"i");
  31. #endif
  33. /* ----------------------------------------------------------------------- */
  35. static struct i2c_bus    *busses[I2C_BUS_MAX];
  36. static struct i2c_driver *drivers[I2C_DRIVER_MAX];
  37. static int bus_count = 0, driver_count = 0;
  39. extern int saa7111_init(void);
  40. extern int saa7185_init(void);
  41. extern int bt819_init(void);
  42. extern int bt856_init(void);
  44. int i2c_init(void)
  45. {
  46. printk(KERN_INFO "i2c: initialized%sn",
  47. scan ? " (i2c bus scan enabled)" : "");
  48. /* anything to do here ? */
  49. #if defined(CONFIG_VIDEO_BUZ) || defined(CONFIG_VIDEO_CYBERPRO)
  50. saa7111_init();
  51. #endif
  52. #ifdef CONFIG_VIDEO_BUZ
  53. saa7185_init();
  54. #endif
  55. #ifdef CONFIG_VIDEO_LML33
  56. bt819_init();
  57. bt856_init();
  58. #endif
  59. return 0;
  60. }
  62. /* ----------------------------------------------------------------------- */
  64. static void i2c_attach_device(struct i2c_bus *bus, struct i2c_driver *driver)
  65. {
  66. struct i2c_device *device;
  67. int i,j,ack=1;
  68. unsigned char addr;
  69. LOCK_FLAGS;
  70.     
  71. /* probe for device */
  72. LOCK_I2C_BUS(bus);
  73. for (addr = driver->addr_l; addr <= driver->addr_h; addr += 2) 
  74. {
  75. i2c_start(bus);
  76. ack = i2c_sendbyte(bus,addr,0);
  77. i2c_stop(bus);
  78. if (!ack)
  79. break;
  80. }
  81. UNLOCK_I2C_BUS(bus);
  82. if (ack)
  83. return;
  85. /* got answer */
  86. for (i = 0; i < I2C_DEVICE_MAX; i++)
  87. if (NULL == driver->devices[i])
  88. break;
  89. if (I2C_DEVICE_MAX == i)
  90. return;
  92. for (j = 0; j < I2C_DEVICE_MAX; j++)
  93. if (NULL == bus->devices[j])
  94. break;
  95. if (I2C_DEVICE_MAX == j)
  96. return;
  98. if (NULL == (device = kmalloc(sizeof(struct i2c_device),GFP_KERNEL)))
  99. return;
  100. device->bus = bus;
  101. device->driver = driver;
  102. device->addr = addr;
  104. /* Attach */
  106. if (driver->attach(device)!=0) 
  107. {
  108. kfree(device);
  109. return;
  110. }
  111. driver->devices[i] = device;
  112. driver->devcount++;
  113. bus->devices[j] = device;
  114. bus->devcount++;
  116. if (bus->attach_inform)
  117. bus->attach_inform(bus,driver->id);
  118. REGPRINT(printk("i2c: device attached: %s (addr=0x%02x, bus=%s, driver=%s)n",device->name,addr,bus->name,driver->name));
  119. }
  121. static void i2c_detach_device(struct i2c_device *device)
  122. {
  123. int i;
  125. if (device->bus->detach_inform)
  126. device->bus->detach_inform(device->bus,device->driver->id);
  127. device->driver->detach(device);
  129. for (i = 0; i < I2C_DEVICE_MAX; i++)
  130. if (device == device->driver->devices[i])
  131. break;
  132. if (I2C_DEVICE_MAX == i) 
  133. {
  134. printk(KERN_WARNING "i2c: detach_device #1: device not found: %sn",
  135. device->name);
  136. return;
  137. }
  138. device->driver->devices[i] = NULL;
  139. device->driver->devcount--;
  141. for (i = 0; i < I2C_DEVICE_MAX; i++)
  142. if (device == device->bus->devices[i])
  143. break;
  144. if (I2C_DEVICE_MAX == i) 
  145. {
  146. printk(KERN_WARNING "i2c: detach_device #2: device not found: %sn",
  147.        device->name);
  148. return;
  149. }
  150. device->bus->devices[i] = NULL;
  151. device->bus->devcount--;
  153. REGPRINT(printk("i2c: device detached: %s (addr=0x%02x, bus=%s, driver=%s)n",device->name,device->addr,device->bus->name,device->driver->name));
  154. kfree(device);
  155. }
  157. /* ----------------------------------------------------------------------- */
  159. int i2c_register_bus(struct i2c_bus *bus)
  160. {
  161. int i,ack;
  162. LOCK_FLAGS;
  164. memset(bus->devices,0,sizeof(bus->devices));
  165. bus->devcount = 0;
  167. for (i = 0; i < I2C_BUS_MAX; i++)
  168. if (NULL == busses[i])
  169. break;
  170. if (I2C_BUS_MAX == i)
  171. return -ENOMEM;
  173. busses[i] = bus;
  174. bus_count++;
  175. REGPRINT(printk("i2c: bus registered: %sn",bus->name));
  177. MOD_INC_USE_COUNT;
  179. if (scan) 
  180. {
  181. /* scan whole i2c bus */
  182. LOCK_I2C_BUS(bus);
  183. for (i = 0; i < 256; i+=2) 
  184. {
  185. i2c_start(bus);
  186. ack = i2c_sendbyte(bus,i,0);
  187. i2c_stop(bus);
  188. if (!ack) 
  189. {
  190. printk(KERN_INFO "i2c: scanning bus %s: found device at addr=0x%02xn",
  191. bus->name,i);
  192. }
  193. }
  194. UNLOCK_I2C_BUS(bus);
  195. }
  197. /* probe available drivers */
  198. for (i = 0; i < I2C_DRIVER_MAX; i++)
  199. if (drivers[i])
  200. i2c_attach_device(bus,drivers[i]);
  201. return 0;
  202. }
  204. int i2c_unregister_bus(struct i2c_bus *bus)
  205. {
  206. int i;
  208. /* detach devices */
  209. for (i = 0; i < I2C_DEVICE_MAX; i++)
  210. if (bus->devices[i])
  211. i2c_detach_device(bus->devices[i]);
  213. for (i = 0; i < I2C_BUS_MAX; i++)
  214. if (bus == busses[i])
  215. break;
  216. if (I2C_BUS_MAX == i) 
  217. {
  218. printk(KERN_WARNING "i2c: unregister_bus #1: bus not found: %sn",
  219. bus->name);
  220. return -ENODEV;
  221. }
  223. MOD_DEC_USE_COUNT;
  225. busses[i] = NULL;
  226. bus_count--;
  227. REGPRINT(printk("i2c: bus unregistered: %sn",bus->name));
  229. return 0;    
  230. }
  232. /* ----------------------------------------------------------------------- */
  234. int i2c_register_driver(struct i2c_driver *driver)
  235. {
  236. int i;
  238. memset(driver->devices,0,sizeof(driver->devices));
  239. driver->devcount = 0;
  241. for (i = 0; i < I2C_DRIVER_MAX; i++)
  242. if (NULL == drivers[i])
  243. break;
  244. if (I2C_DRIVER_MAX == i)
  245. return -ENOMEM;
  247. drivers[i] = driver;
  248. driver_count++;
  250. MOD_INC_USE_COUNT;
  252. REGPRINT(printk("i2c: driver registered: %sn",driver->name));
  254. /* Probe available busses */
  255. for (i = 0; i < I2C_BUS_MAX; i++)
  256. if (busses[i])
  257. i2c_attach_device(busses[i],driver);
  259. return 0;
  260. }
  262. int i2c_unregister_driver(struct i2c_driver *driver)
  263. {
  264. int i;
  266. /* detach devices */
  267. for (i = 0; i < I2C_DEVICE_MAX; i++)
  268. if (driver->devices[i])
  269. i2c_detach_device(driver->devices[i]);
  271. for (i = 0; i < I2C_DRIVER_MAX; i++)
  272. if (driver == drivers[i])
  273. break;
  274. if (I2C_DRIVER_MAX == i) 
  275. {
  276. printk(KERN_WARNING "i2c: unregister_driver: driver not found: %sn",
  277. driver->name);
  278. return -ENODEV;
  279. }
  281. MOD_DEC_USE_COUNT;
  283. drivers[i] = NULL;
  284. driver_count--;
  285. REGPRINT(printk("i2c: driver unregistered: %sn",driver->name));
  287. return 0;
  288. }
  290. /* ----------------------------------------------------------------------- */
  292. int i2c_control_device(struct i2c_bus *bus, int id,
  293.        unsigned int cmd, void *arg)
  294. {
  295. int i;
  297. for (i = 0; i < I2C_DEVICE_MAX; i++)
  298. if (bus->devices[i] && bus->devices[i]->driver->id == id)
  299. break;
  300. if (i == I2C_DEVICE_MAX)
  301. return -ENODEV;
  302. if (NULL == bus->devices[i]->driver->command)
  303. return -ENODEV;
  304. return bus->devices[i]->driver->command(bus->devices[i],cmd,arg);
  305. }
  307. /* ----------------------------------------------------------------------- */
  309. #define I2C_SET(bus,ctrl,data)  (bus->i2c_setlines(bus,ctrl,data))
  310. #define I2C_GET(bus)            (bus->i2c_getdataline(bus))
  312. void i2c_start(struct i2c_bus *bus)
  313. {
  314. I2C_SET(bus,0,1);
  315. I2C_SET(bus,1,1);
  316. I2C_SET(bus,1,0);
  317. I2C_SET(bus,0,0);
  318. I2C_DEBUG(printk("%s: < ",bus->name));
  319. }
  321. void i2c_stop(struct i2c_bus *bus)
  322. {
  323. I2C_SET(bus,0,0);
  324. I2C_SET(bus,1,0);
  325. I2C_SET(bus,1,1);
  326. I2C_DEBUG(printk(">n"));
  327. }
  329. void i2c_one(struct i2c_bus *bus)
  330. {
  331. I2C_SET(bus,0,1);
  332. I2C_SET(bus,1,1);
  333. I2C_SET(bus,0,1);
  334. }
  336. void i2c_zero(struct i2c_bus *bus)
  337. {
  338. I2C_SET(bus,0,0);
  339. I2C_SET(bus,1,0);
  340. I2C_SET(bus,0,0);
  341. }
  343. int i2c_ack(struct i2c_bus *bus)
  344. {
  345. int ack;
  346.     
  347. I2C_SET(bus,0,1);
  348. I2C_SET(bus,1,1);
  349. ack = I2C_GET(bus);
  350. I2C_SET(bus,0,1);
  351. return ack;
  352. }
  354. int i2c_sendbyte(struct i2c_bus *bus,unsigned char data,int wait_for_ack)
  355. {
  356. int i, ack;
  357.     
  358. I2C_SET(bus,0,0);
  359. for (i=7; i>=0; i--)
  360. (data&(1<<i)) ? i2c_one(bus) : i2c_zero(bus);
  361. if (wait_for_ack)
  362. udelay(wait_for_ack);
  363. ack=i2c_ack(bus);
  364. I2C_DEBUG(printk("%02x%c ",(int)data,ack?'-':'+'));
  365. return ack;
  366. }
  368. unsigned char i2c_readbyte(struct i2c_bus *bus,int last)
  369. {
  370. int i;
  371. unsigned char data=0;
  372.     
  373. I2C_SET(bus,0,1);
  374. for (i=7; i>=0; i--) 
  375. {
  376. I2C_SET(bus,1,1);
  377. if (I2C_GET(bus))
  378. data |= (1<<i);
  379. I2C_SET(bus,0,1);
  380. }
  381. last ? i2c_one(bus) : i2c_zero(bus);
  382. I2C_DEBUG(printk("=%02x%c ",(int)data,last?'-':'+'));
  383. return data;
  384. }
  386. /* ----------------------------------------------------------------------- */
  388. int i2c_read(struct i2c_bus *bus, unsigned char addr)
  389. {
  390. int ret;
  391.     
  392. if (bus->i2c_read)
  393. return bus->i2c_read(bus, addr);
  395. i2c_start(bus);
  396. i2c_sendbyte(bus,addr,0);
  397. ret = i2c_readbyte(bus,1);
  398. i2c_stop(bus);
  399. return ret;
  400. }
  402. int i2c_write(struct i2c_bus *bus, unsigned char addr,
  403.       unsigned char data1, unsigned char data2, int both)
  404. {
  405. int ack;
  407. if (bus->i2c_write)
  408. return bus->i2c_write(bus, addr, data1, data2, both);
  410. i2c_start(bus);
  411. i2c_sendbyte(bus,addr,0);
  412. ack = i2c_sendbyte(bus,data1,0);
  413. if (both)
  414. ack = i2c_sendbyte(bus,data2,0);
  415. i2c_stop(bus);
  416. return ack ? -1 : 0 ;
  417. }
  419. /* ----------------------------------------------------------------------- */
  421. #ifdef MODULE
  423. #if LINUX_VERSION_CODE >= 0x020100
  424. EXPORT_SYMBOL(i2c_register_bus);
  425. EXPORT_SYMBOL(i2c_unregister_bus);
  426. EXPORT_SYMBOL(i2c_register_driver);
  427. EXPORT_SYMBOL(i2c_unregister_driver);
  428. EXPORT_SYMBOL(i2c_control_device);
  429. EXPORT_SYMBOL(i2c_start);
  430. EXPORT_SYMBOL(i2c_stop);
  431. EXPORT_SYMBOL(i2c_one);
  432. EXPORT_SYMBOL(i2c_zero);
  433. EXPORT_SYMBOL(i2c_ack);
  434. EXPORT_SYMBOL(i2c_sendbyte);
  435. EXPORT_SYMBOL(i2c_readbyte);
  436. EXPORT_SYMBOL(i2c_read);
  437. EXPORT_SYMBOL(i2c_write);
  438. #endif
  440. int init_module(void)
  441. {
  442. return i2c_init();
  443. }
  445. void cleanup_module(void)
  446. {
  447. }
  448. #endif
  449. MODULE_LICENSE("GPL");