EEPROM AT24C02 的 I2C 驱动问题

chengdot

小弟我要使用 AT24C02 存点数据，

- 编译了 2.6.30.4 中的 at24.c 文件，at24_init() 中调用 i2c_add_driver();
- i2c_add_driver() 依次调用以下函数：
   i2c_register_driver() -> class_for_each_device() -> __attach_adapter() -> i2c_detect():
- 在 i2c_detect() 中，运行到以下语句，
  if (!driver->detect || !address_data) { return 0; }
   函数返回为 0，

最后的结果是 i2c_add_driver() 运行成功（返回0），
但 at24_probe() 却未被执行，后续的 write/read 也全部没有被执行，
系统提示：
- s3c2440-i2c s3c2440-i2c: cannot get bus (error -110)

请问各位大哥这是怎么回事？

T-Bagwell

I2C总线上挂载这个设备了吗？
或者说供电了没？

sep

我写了一个内核调用i2c的驱动模块，加载这个模块后，可以在你的驱动中直接调用api即可
http://blog.csdn.net/sepnic/archive/2011/02/11/6178657.aspx
我当时写这个东东就因为我平台很多地方要用到i2c，这样每个地方都要i2c_register_driver，太麻烦了

chengdot

I2C总线上挂载这个设备了吗？
或者说供电了没？
T-Bagwell 发表于 2011-02-21 18:09

谢谢关注；
在同样一块板，在 Bootloader 中测试，是正常的，硬件应该没有问题。

我感觉这个 at24.c 好像没有完成，detect 和 address_data 这两个字段均没有填充，
导致 i2c_detect 根本没有真正执行；在 eeprom.c 中倒是实现了，但这个设备我的机器却没有；

T-Bagwell

代码方便贴出来不？

chengdot

我写了一个内核调用i2c的驱动模块，加载这个模块后，可以在你的驱动中直接调用api即可

我当时写这个东东 ...
sep 发表于 2011-02-21 19:32

谢谢，我先试试，
这个驱动要如何调用呢？ i2c_api_do_send  / i2c_api_do_recv 的前几个参数要如何写？
如果可以，是否能再贴一段调用的例子？

chengdot

代码方便贴出来不？
T-Bagwell 发表于 2011-02-22 09:27

代码是 2.6.30.4 中自带的，如下：

1. /*
   
2. * at24.c - handle most I2C EEPROMs
   
3. *
   
4. * Copyright (C) 2005-2007 David Brownell
   
5. * Copyright (C) 2008 Wolfram Sang, Pengutronix
   
6. *
   
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.
    
11. */
    
12. #include <linux/kernel.h>
    
13. #include <linux/init.h>
    
14. #include <linux/module.h>
    
15. #include <linux/slab.h>
    
16. #include <linux/delay.h>
    
17. #include <linux/mutex.h>
    
18. #include <linux/sysfs.h>
    
19. #include <linux/mod_devicetable.h>
    
20. #include <linux/log2.h>
    
21. #include <linux/bitops.h>
    
22. #include <linux/jiffies.h>
    
23. #include <linux/i2c.h>
    
24. #include <linux/i2c/at24.h>
    
25. 
    
26. static int debug = 1;
    
27. #define dprintk(msg...)        if (debug) { printk(KERN_DEBUG "at24: " msg); }
    
28. 
    
29. /*
    
30. * I2C EEPROMs from most vendors are inexpensive and mostly interchangeable.
    
31. * Differences between different vendor product lines (like Atmel AT24C or
    
32. * MicroChip 24LC, etc) won't much matter for typical read/write access.
    
33. * There are also I2C RAM chips, likewise interchangeable. One example
    
34. * would be the PCF8570, which acts like a 24c02 EEPROM (256 bytes).
    
35. *
    
36. * However, misconfiguration can lose data. "Set 16-bit memory address"
    
37. * to a part with 8-bit addressing will overwrite data. Writing with too
    
38. * big a page size also loses data. And it's not safe to assume that the
    
39. * conventional addresses 0x50..0x57 only hold eeproms; a PCF8563 RTC
    
40. * uses 0x51, for just one example.
    
41. *
    
42. * Accordingly, explicit board-specific configuration data should be used
    
43. * in almost all cases. (One partial exception is an SMBus used to access
    
44. * "SPD" data for DRAM sticks. Those only use 24c02 EEPROMs.)
    
45. *
    
46. * So this driver uses "new style" I2C driver binding, expecting to be
    
47. * told what devices exist. That may be in arch/X/mach-Y/board-Z.c or
    
48. * similar kernel-resident tables; or, configuration data coming from
    
49. * a bootloader.
    
50. *
    
51. * Other than binding model, current differences from "eeprom" driver are
    
52. * that this one handles write access and isn't restricted to 24c02 devices.
    
53. * It also handles larger devices (32 kbit and up) with two-byte addresses,
    
54. * which won't work on pure SMBus systems.
    
55. */
    
56. 
    
57. struct at24_data {
    
58.         struct at24_platform_data chip;
    
59.         struct memory_accessor macc;
    
60.         bool use_smbus;
    
61. 
    
62.         /*
    
63.          * Lock protects against activities from other Linux tasks,
    
64.          * but not from changes by other I2C masters.
    
65.          */
    
66.         struct mutex lock;
    
67.         struct bin_attribute bin;
    
68. 
    
69.         u8 *writebuf;
    
70.         unsigned write_max;
    
71.         unsigned num_addresses;
    
72. 
    
73.         /*
    
74.          * Some chips tie up multiple I2C addresses; dummy devices reserve
    
75.          * them for us, and we'll use them with SMBus calls.
    
76.          */
    
77.         struct i2c_client *client[];
    
78. };
    
79. 
    
80. /*
    
81. * This parameter is to help this driver avoid blocking other drivers out
    
82. * of I2C for potentially troublesome amounts of time. With a 100 kHz I2C
    
83. * clock, one 256 byte read takes about 1/43 second which is excessive;
    
84. * but the 1/170 second it takes at 400 kHz may be quite reasonable; and
    
85. * at 1 MHz (Fm+) a 1/430 second delay could easily be invisible.
    
86. *
    
87. * This value is forced to be a power of two so that writes align on pages.
    
88. */
    
89. static unsigned io_limit = 128;
    
90. module_param(io_limit, uint, 0);
    
91. MODULE_PARM_DESC(io_limit, "Maximum bytes per I/O (default 128)");
    
92. 
    
93. /*
    
94. * Specs often allow 5 msec for a page write, sometimes 20 msec;
    
95. * it's important to recover from write timeouts.
    
96. */
    
97. static unsigned write_timeout = 25;
    
98. module_param(write_timeout, uint, 0);
    
99. MODULE_PARM_DESC(write_timeout, "Time (in ms) to try writes (default 25)");
    
100. 
     
101. #define AT24_SIZE_BYTELEN 5
     
102. #define AT24_SIZE_FLAGS 8
     
103. 
     
104. #define AT24_BITMASK(x) (BIT(x) - 1)
     
105. 
     
106. /* create non-zero magic value for given eeprom parameters */
     
107. #define AT24_DEVICE_MAGIC(_len, _flags)                 \
     
108.         ((1 << AT24_SIZE_FLAGS | (_flags))                 \
     
109.             << AT24_SIZE_BYTELEN | ilog2(_len))
     
110. 
     
111. static const struct i2c_device_id at24_ids[] = {
     
112.         /* needs 8 addresses as A0-A2 are ignored */
     
113.         { "24c00", AT24_DEVICE_MAGIC(128 / 8, AT24_FLAG_TAKE8ADDR) },
     
114.         /* old variants can't be handled with this generic entry! */
     
115.         { "24c01", AT24_DEVICE_MAGIC(1024 / 8, 0) },
     
116.         { "24c02", AT24_DEVICE_MAGIC(2048 / 8, 0) },
     
117.         /* spd is a 24c02 in memory DIMMs */
     
118.         { "spd", AT24_DEVICE_MAGIC(2048 / 8,
     
119.                 AT24_FLAG_READONLY | AT24_FLAG_IRUGO) },
     
120.         { "24c04", AT24_DEVICE_MAGIC(4096 / 8, 0) },
     
121.         /* 24rf08 quirk is handled at i2c-core */
     
122.         { "24c08", AT24_DEVICE_MAGIC(8192 / 8, 0) },
     
123.         { "24c16", AT24_DEVICE_MAGIC(16384 / 8, 0) },
     
124.         { "24c32", AT24_DEVICE_MAGIC(32768 / 8, AT24_FLAG_ADDR16) },
     
125.         { "24c64", AT24_DEVICE_MAGIC(65536 / 8, AT24_FLAG_ADDR16) },
     
126.         { "24c128", AT24_DEVICE_MAGIC(131072 / 8, AT24_FLAG_ADDR16) },
     
127.         { "24c256", AT24_DEVICE_MAGIC(262144 / 8, AT24_FLAG_ADDR16) },
     
128.         { "24c512", AT24_DEVICE_MAGIC(524288 / 8, AT24_FLAG_ADDR16) },
     
129.         { "24c1024", AT24_DEVICE_MAGIC(1048576 / 8, AT24_FLAG_ADDR16) },
     
130.         { "at24", 0 },
     
131.         { /* END OF LIST */ }
     
132. };
     
133. MODULE_DEVICE_TABLE(i2c, at24_ids);
     
134. 
     
135. /*-------------------------------------------------------------------------*/
     
136. 
     
137. /*
     
138. * This routine supports chips which consume multiple I2C addresses. It
     
139. * computes the addressing information to be used for a given r/w request.
     
140. * Assumes that sanity checks for offset happened at sysfs-layer.
     
141. */
     
142. static struct i2c_client *at24_translate_offset(struct at24_data *at24,
     
143.                 unsigned *offset)
     
144. {
     
145.         dprintk("%s(%d) \r\n", __FUNCTION__, __LINE__);
     
146.         unsigned i;
     
147. 
     
148.         if (at24->chip.flags & AT24_FLAG_ADDR16) {
     
149.                 i = *offset >> 16;
     
150.                 *offset &= 0xffff;
     
151.         } else {
     
152.                 i = *offset >> 8;
     
153.                 *offset &= 0xff;
     
154.         }
     
155. 
     
156.         return at24->client[i];
     
157. }
     
158. 
     
159. static ssize_t at24_eeprom_read(struct at24_data *at24, char *buf,
     
160.                 unsigned offset, size_t count)
     
161. {
     
162.         dprintk("%s(%d) \r\n", __FUNCTION__, __LINE__);
     
163.         struct i2c_msg msg[2];
     
164.         u8 msgbuf[2];
     
165.         struct i2c_client *client;
     
166.         int status, i;
     
167. 
     
168.         memset(msg, 0, sizeof(msg));
     
169. 
     
170.         /*
     
171.          * REVISIT some multi-address chips don't rollover page reads to
     
172.          * the next slave address, so we may need to truncate the count.
     
173.          * Those chips might need another quirk flag.
     
174.          *
     
175.          * If the real hardware used four adjacent 24c02 chips and that
     
176.          * were misconfigured as one 24c08, that would be a similar effect:
     
177.          * one "eeprom" file not four, but larger reads would fail when
     
178.          * they crossed certain pages.
     
179.          */
     
180. 
     
181.         /*
     
182.          * Slave address and byte offset derive from the offset. Always
     
183.          * set the byte address; on a multi-master board, another master
     
184.          * may have changed the chip's "current" address pointer.
     
185.          */
     
186.         client = at24_translate_offset(at24, &offset);
     
187. 
     
188.         if (count > io_limit)
     
189.                 count = io_limit;
     
190. 
     
191.         /* Smaller eeproms can work given some SMBus extension calls */
     
192.         if (at24->use_smbus) {
     
193.                 if (count > I2C_SMBUS_BLOCK_MAX)
     
194.                         count = I2C_SMBUS_BLOCK_MAX;
     
195.                 status = i2c_smbus_read_i2c_block_data(client, offset,
     
196.                                 count, buf);
     
197.                 dev_dbg(&client->dev, "smbus read %zu@%d --> %d\n",
     
198.                                 count, offset, status);
     
199.                 return (status < 0) ? -EIO : status;
     
200.         }
     
201. 
     
202.         /*
     
203.          * When we have a better choice than SMBus calls, use a combined
     
204.          * I2C message. Write address; then read up to io_limit data bytes.
     
205.          * Note that read page rollover helps us here (unlike writes).
     
206.          * msgbuf is u8 and will cast to our needs.
     
207.          */
     
208.         i = 0;
     
209.         if (at24->chip.flags & AT24_FLAG_ADDR16)
     
210.                 msgbuf[i++] = offset >> 8;
     
211.         msgbuf[i++] = offset;
     
212. 
     
213.         msg[0].addr = client->addr;
     
214.         msg[0].buf = msgbuf;
     
215.         msg[0].len = i;
     
216. 
     
217.         msg[1].addr = client->addr;
     
218.         msg[1].flags = I2C_M_RD;
     
219.         msg[1].buf = buf;
     
220.         msg[1].len = count;
     
221. 
     
222.         status = i2c_transfer(client->adapter, msg, 2);
     
223.         dev_dbg(&client->dev, "i2c read %zu@%d --> %d\n",
     
224.                         count, offset, status);
     
225. 
     
226.         if (status == 2)
     
227.                 return count;
     
228.         else if (status >= 0)
     
229.                 return -EIO;
     
230.         else
     
231.                 return status;
     
232. }
     
233. 
     
234. static ssize_t at24_read(struct at24_data *at24,
     
235.                 char *buf, loff_t off, size_t count)
     
236. {
     
237.         dprintk("%s(%d) \r\n", __FUNCTION__, __LINE__);
     
238. 
     
239.         ssize_t retval = 0;
     
240. 
     
241.         if (unlikely(!count))
     
242.                 return count;
     
243. 
     
244.         /*
     
245.          * Read data from chip, protecting against concurrent updates
     
246.          * from this host, but not from other I2C masters.
     
247.          */
     
248.         mutex_lock(&at24->lock);
     
249. 
     
250.         while (count) {
     
251.                 ssize_t        status;
     
252. 
     
253.                 status = at24_eeprom_read(at24, buf, off, count);
     
254.                 if (status <= 0) {
     
255.                         if (retval == 0)
     
256.                                 retval = status;
     
257.                         break;
     
258.                 }
     
259.                 buf += status;
     
260.                 off += status;
     
261.                 count -= status;
     
262.                 retval += status;
     
263.         }
     
264. 
     
265.         mutex_unlock(&at24->lock);
     
266. 
     
267.         return retval;
     
268. }
     
269. 
     
270. static ssize_t at24_bin_read(struct kobject *kobj, struct bin_attribute *attr,
     
271.                 char *buf, loff_t off, size_t count)
     
272. {
     
273.         dprintk("%s(%d) \r\n", __FUNCTION__, __LINE__);
     
274.         struct at24_data *at24;
     
275. 
     
276.         at24 = dev_get_drvdata(container_of(kobj, struct device, kobj));
     
277.         return at24_read(at24, buf, off, count);
     
278. }
     
279. 
     
280. 
     
281. /*
     
282. * Note that if the hardware write-protect pin is pulled high, the whole
     
283. * chip is normally write protected. But there are plenty of product
     
284. * variants here, including OTP fuses and partial chip protect.
     
285. *
     
286. * We only use page mode writes; the alternative is sloooow. This routine
     
287. * writes at most one page.
     
288. */
     
289. static ssize_t at24_eeprom_write(struct at24_data *at24, const char *buf,
     
290.                 unsigned offset, size_t count)
     
291. {
     
292.         dprintk("%s(%d) \r\n", __FUNCTION__, __LINE__);
     
293.         struct i2c_client *client;
     
294.         struct i2c_msg msg;
     
295.         ssize_t status;
     
296.         unsigned long timeout, write_time;
     
297.         unsigned next_page;
     
298. 
     
299.         /* Get corresponding I2C address and adjust offset */
     
300.         client = at24_translate_offset(at24, &offset);
     
301. 
     
302.         /* write_max is at most a page */
     
303.         if (count > at24->write_max)
     
304.                 count = at24->write_max;
     
305. 
     
306.         /* Never roll over backwards, to the start of this page */
     
307.         next_page = roundup(offset + 1, at24->chip.page_size);
     
308.         if (offset + count > next_page)
     
309.                 count = next_page - offset;
     
310. 
     
311.         /* If we'll use I2C calls for I/O, set up the message */
     
312.         if (!at24->use_smbus) {
     
313.                 int i = 0;
     
314. 
     
315.                 msg.addr = client->addr;
     
316.                 msg.flags = 0;
     
317. 
     
318.                 /* msg.buf is u8 and casts will mask the values */
     
319.                 msg.buf = at24->writebuf;
     
320.                 if (at24->chip.flags & AT24_FLAG_ADDR16)
     
321.                         msg.buf[i++] = offset >> 8;
     
322. 
     
323.                 msg.buf[i++] = offset;
     
324.                 memcpy(&msg.buf[i], buf, count);
     
325.                 msg.len = i + count;
     
326.         }
     
327. 
     
328.         /*
     
329.          * Writes fail if the previous one didn't complete yet. We may
     
330.          * loop a few times until this one succeeds, waiting at least
     
331.          * long enough for one entire page write to work.
     
332.          */
     
333.         timeout = jiffies + msecs_to_jiffies(write_timeout);
     
334.         do {
     
335.                 write_time = jiffies;
     
336.                 if (at24->use_smbus) {
     
337.                         status = i2c_smbus_write_i2c_block_data(client,
     
338.                                         offset, count, buf);
     
339.                         if (status == 0)
     
340.                                 status = count;
     
341.                 } else {
     
342.                         status = i2c_transfer(client->adapter, &msg, 1);
     
343.                         if (status == 1)
     
344.                                 status = count;
     
345.                 }
     
346.                 dev_dbg(&client->dev, "write %zu@%d --> %zd (%ld)\n",
     
347.                                 count, offset, status, jiffies);
     
348. 
     
349.                 if (status == count)
     
350.                         return count;
     
351. 
     
352.                 /* REVISIT: at HZ=100, this is sloooow */
     
353.                 msleep(1);
     
354.         } while (time_before(write_time, timeout));
     
355. 
     
356.         return -ETIMEDOUT;
     
357. }
     
358. 
     
359. static ssize_t at24_write(struct at24_data *at24, const char *buf, loff_t off,
     
360.                           size_t count)
     
361. {
     
362.         dprintk("%s(%d) \r\n", __FUNCTION__, __LINE__);
     
363.         ssize_t retval = 0;
     
364. 
     
365.         if (unlikely(!count))
     
366.                 return count;
     
367. 
     
368.         /*
     
369.          * Write data to chip, protecting against concurrent updates
     
370.          * from this host, but not from other I2C masters.
     
371.          */
     
372.         mutex_lock(&at24->lock);
     
373. 
     
374.         while (count) {
     
375.                 ssize_t        status;
     
376. 
     
377.                 status = at24_eeprom_write(at24, buf, off, count);
     
378.                 if (status <= 0) {
     
379.                         if (retval == 0)
     
380.                                 retval = status;
     
381.                         break;
     
382.                 }
     
383.                 buf += status;
     
384.                 off += status;
     
385.                 count -= status;
     
386.                 retval += status;
     
387.         }
     
388. 
     
389.         mutex_unlock(&at24->lock);
     
390. 
     
391.         return retval;
     
392. }
     
393. 
     
394. static ssize_t at24_bin_write(struct kobject *kobj, struct bin_attribute *attr,
     
395.                 char *buf, loff_t off, size_t count)
     
396. {
     
397.         dprintk("%s(%d) \r\n", __FUNCTION__, __LINE__);
     
398.         struct at24_data *at24;
     
399. 
     
400.         at24 = dev_get_drvdata(container_of(kobj, struct device, kobj));
     
401.         return at24_write(at24, buf, off, count);
     
402. }
     
403. 
     
404. /*-------------------------------------------------------------------------*/
     
405. 
     
406. /*
     
407. * This lets other kernel code access the eeprom data. For example, it
     
408. * might hold a board's Ethernet address, or board-specific calibration
     
409. * data generated on the manufacturing floor.
     
410. */
     
411. 
     
412. static ssize_t at24_macc_read(struct memory_accessor *macc, char *buf,
     
413.                          off_t offset, size_t count)
     
414. {
     
415.         dprintk("%s(%d) \r\n", __FUNCTION__, __LINE__);
     
416.         struct at24_data *at24 = container_of(macc, struct at24_data, macc);
     
417. 
     
418.         return at24_read(at24, buf, offset, count);
     
419. }
     
420. 
     
421. static ssize_t at24_macc_write(struct memory_accessor *macc, const char *buf,
     
422.                           off_t offset, size_t count)
     
423. {
     
424.         dprintk("%s(%d) \r\n", __FUNCTION__, __LINE__);
     
425.         struct at24_data *at24 = container_of(macc, struct at24_data, macc);
     
426. 
     
427.         return at24_write(at24, buf, offset, count);
     
428. }
     
429. 
     
430. static int at24_detect(struct i2c_client *, int kind, struct i2c_board_info *)
     
431. {
     
432.         dprintk("%s(%d) \r\n", __FUNCTION__, __LINE__);
     
433.         return 0;
     
434. }
     
435. 
     
436. /*-------------------------------------------------------------------------*/
     
437. 
     
438. static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id)
     
439. {
     
440.         dprintk("%s(%d) \r\n", __FUNCTION__, __LINE__);
     
441.         struct at24_platform_data chip;
     
442.         bool writable;
     
443.         bool use_smbus = false;
     
444.         struct at24_data *at24;
     
445.         int err;
     
446.         unsigned i, num_addresses;
     
447.         kernel_ulong_t magic;
     
448. 
     
449.         if (client->dev.platform_data) {
     
450.                 chip = *(struct at24_platform_data *)client->dev.platform_data;
     
451.         } else {
     
452.                 if (!id->driver_data) {
     
453.                         err = -ENODEV;
     
454.                         goto err_out;
     
455.                 }
     
456.                 magic = id->driver_data;
     
457.                 chip.byte_len = BIT(magic & AT24_BITMASK(AT24_SIZE_BYTELEN));
     
458.                 magic >>= AT24_SIZE_BYTELEN;
     
459.                 chip.flags = magic & AT24_BITMASK(AT24_SIZE_FLAGS);
     
460.                 /*
     
461.                  * This is slow, but we can't know all eeproms, so we better
     
462.                  * play safe. Specifying custom eeprom-types via platform_data
     
463.                  * is recommended anyhow.
     
464.                  */
     
465.                 chip.page_size = 1;
     
466. 
     
467.                 chip.setup = NULL;
     
468.                 chip.context = NULL;
     
469.         }
     
470. 
     
471.         if (!is_power_of_2(chip.byte_len))
     
472.                 dev_warn(&client->dev,
     
473.                         "byte_len looks suspicious (no power of 2)!\n");
     
474.         if (!is_power_of_2(chip.page_size))
     
475.                 dev_warn(&client->dev,
     
476.                         "page_size looks suspicious (no power of 2)!\n");
     
477. 
     
478.         /* Use I2C operations unless we're stuck with SMBus extensions. */
     
479.         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
     
480.                 if (chip.flags & AT24_FLAG_ADDR16) {
     
481.                         err = -EPFNOSUPPORT;
     
482.                         goto err_out;
     
483.                 }
     
484.                 if (!i2c_check_functionality(client->adapter,
     
485.                                 I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {
     
486.                         err = -EPFNOSUPPORT;
     
487.                         goto err_out;
     
488.                 }
     
489.                 use_smbus = true;
     
490.         }
     
491. 
     
492.         if (chip.flags & AT24_FLAG_TAKE8ADDR)
     
493.                 num_addresses = 8;
     
494.         else
     
495.                 num_addresses =        DIV_ROUND_UP(chip.byte_len,
     
496.                         (chip.flags & AT24_FLAG_ADDR16) ? 65536 : 256);
     
497. 
     
498.         at24 = kzalloc(sizeof(struct at24_data) +
     
499.                 num_addresses * sizeof(struct i2c_client *), GFP_KERNEL);
     
500.         if (!at24) {
     
501.                 err = -ENOMEM;
     
502.                 goto err_out;
     
503.         }
     
504. 
     
505.         mutex_init(&at24->lock);
     
506.         at24->use_smbus = use_smbus;
     
507.         at24->chip = chip;
     
508.         at24->num_addresses = num_addresses;
     
509. 
     
510.         /*
     
511.          * Export the EEPROM bytes through sysfs, since that's convenient.
     
512.          * By default, only root should see the data (maybe passwords etc)
     
513.          */
     
514.         at24->bin.attr.name = "eeprom";
     
515.         at24->bin.attr.mode = chip.flags & AT24_FLAG_IRUGO ? S_IRUGO : S_IRUSR;
     
516.         at24->bin.read = at24_bin_read;
     
517.         at24->bin.size = chip.byte_len;
     
518. 
     
519.         at24->macc.read = at24_macc_read;
     
520. 
     
521.         writable = !(chip.flags & AT24_FLAG_READONLY);
     
522.         if (writable) {
     
523.                 if (!use_smbus || i2c_check_functionality(client->adapter,
     
524.                                 I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) {
     
525. 
     
526.                         unsigned write_max = chip.page_size;
     
527. 
     
528.                         at24->macc.write = at24_macc_write;
     
529. 
     
530.                         at24->bin.write = at24_bin_write;
     
531.                         at24->bin.attr.mode |= S_IWUSR;
     
532. 
     
533.                         if (write_max > io_limit)
     
534.                                 write_max = io_limit;
     
535.                         if (use_smbus && write_max > I2C_SMBUS_BLOCK_MAX)
     
536.                                 write_max = I2C_SMBUS_BLOCK_MAX;
     
537.                         at24->write_max = write_max;
     
538. 
     
539.                         /* buffer (data + address at the beginning) */
     
540.                         at24->writebuf = kmalloc(write_max + 2, GFP_KERNEL);
     
541.                         if (!at24->writebuf) {
     
542.                                 err = -ENOMEM;
     
543.                                 goto err_struct;
     
544.                         }
     
545.                 } else {
     
546.                         dev_warn(&client->dev,
     
547.                                 "cannot write due to controller restrictions.");
     
548.                 }
     
549.         }
     
550. 
     
551.         at24->client[0] = client;
     
552. 
     
553.         /* use dummy devices for multiple-address chips */
     
554.         for (i = 1; i < num_addresses; i++) {
     
555.                 at24->client[i] = i2c_new_dummy(client->adapter,
     
556.                                         client->addr + i);
     
557.                 if (!at24->client[i]) {
     
558.                         dev_err(&client->dev, "address 0x%02x unavailable\n",
     
559.                                         client->addr + i);
     
560.                         err = -EADDRINUSE;
     
561.                         goto err_clients;
     
562.                 }
     
563.         }
     
564. 
     
565.         err = sysfs_create_bin_file(&client->dev.kobj, &at24->bin);
     
566.         if (err)
     
567.                 goto err_clients;
     
568. 
     
569.         i2c_set_clientdata(client, at24);
     
570. 
     
571.         dev_info(&client->dev, "%zu byte %s EEPROM %s\n",
     
572.                 at24->bin.size, client->name,
     
573.                 writable ? "(writable)" : "(read-only)");
     
574.         dev_dbg(&client->dev,
     
575.                 "page_size %d, num_addresses %d, write_max %d%s\n",
     
576.                 chip.page_size, num_addresses,
     
577.                 at24->write_max,
     
578.                 use_smbus ? ", use_smbus" : "");
     
579. 
     
580.         /* export data to kernel code */
     
581.         if (chip.setup)
     
582.                 chip.setup(&at24->macc, chip.context);
     
583. 
     
584.         return 0;
     
585. 
     
586. err_clients:
     
587.         for (i = 1; i < num_addresses; i++)
     
588.                 if (at24->client[i])
     
589.                         i2c_unregister_device(at24->client[i]);
     
590. 
     
591.         kfree(at24->writebuf);
     
592. err_struct:
     
593.         kfree(at24);
     
594. err_out:
     
595.         dev_dbg(&client->dev, "probe error %d\n", err);
     
596.         return err;
     
597. }
     
598. 
     
599. static int __devexit at24_remove(struct i2c_client *client)
     
600. {
     
601.         dprintk("%s(%d) \r\n", __FUNCTION__, __LINE__);
     
602.         struct at24_data *at24;
     
603.         int i;
     
604. 
     
605.         at24 = i2c_get_clientdata(client);
     
606.         sysfs_remove_bin_file(&client->dev.kobj, &at24->bin);
     
607. 
     
608.         for (i = 1; i < at24->num_addresses; i++)
     
609.                 i2c_unregister_device(at24->client[i]);
     
610. 
     
611.         kfree(at24->writebuf);
     
612.         kfree(at24);
     
613.         i2c_set_clientdata(client, NULL);
     
614.         return 0;
     
615. }
     
616. 
     
617. /*-------------------------------------------------------------------------*/
     
618. 
     
619. static struct i2c_driver at24_driver = {
     
620.         .driver = {
     
621.                 .name = "at24",
     
622.                 .owner = THIS_MODULE,
     
623.         },
     
624.         .probe = at24_probe,
     
625.         .remove = __devexit_p(at24_remove),
     
626.         .detect = at24_detect,
     
627.         .id_table = at24_ids,
     
628. };
     
629. 
     
630. static int __init at24_init(void)
     
631. {
     
632.         dprintk("at24_init: \r\n");
     
633.        
     
634.         io_limit = rounddown_pow_of_two(io_limit);
     
635.         int        nadd = i2c_add_driver(&at24_driver);
     
636.         dprintk("add = %d\r\n", nadd);
     
637.         return nadd;
     
638. }
     
639. module_init(at24_init);
     
640. 
     
641. static void __exit at24_exit(void)
     
642. {
     
643.         dprintk("at24_exit\r\n");
     
644.        
     
645.         i2c_del_driver(&at24_driver);
     
646. }
     
647. module_exit(at24_exit);
     
648. 
     
649. MODULE_DESCRIPTION("Driver for most I2C EEPROMs");
     
650. MODULE_AUTHOR("David Brownell and Wolfram Sang");
     
651. MODULE_LICENSE("GPL");
     

复制代码

chengdot

谢谢关注；
在同样一块板，在 Bootloader 中测试，是正常的，硬件应该没有问题。

我感觉这个 at2 ...
chengdot 发表于 2011-02-22 09:24

还有一点，原代码中，到我描述的 i2c_detect() 为止，还没有涉及到真正的硬件操作，
那句 if ((!detect) || (!address)) { return 0; } 纯粹由于代码不完成造成。

T-Bagwell

如果是linux自带的代码，不用验证了，没问题
我要问的是你写的那部分代码
能否详细说明一下
I2C设备没这么麻烦吧
如果probe不上，一般就是设备没供电造成的，导致控制器挂载不上设备，再就是根本就没有这个设备

这样，用示波器在你挂载I2C总线上的设备的供电pin脚上面测量一下，看看是否供电正常，再看看clock是否正常
如果没猜错，供电应该不正常

chengdot

如果是linux自带的代码，不用验证了，没问题
我要问的是你写的那部分代码
能否详细说明一下
I2C设备没这 ...
T-Bagwell 发表于 2011-02-22 09:52

驱动里，我并没写什么代码；
我是在应用程序里（见下）发现设备加载不成功，才去看的驱动，

1. 
   
2.         fd= open("/dev/i2c-0",  O_RDWR);
   
3.         if (fd < 0) {
   
4.                 printf( "Fail to open AT24C32!\n" );
   
5.                 exit(1);
   
6.         }
   
7.         res = ioctl(fd, I2C_TENBIT, 0);
   
8.         printf("I2C_TENBIT(0) = %d\n", res);
   
9.         res = ioctl(fd, I2C_SLAVE_FORCE, 0x50);        //        AT24C02
   
10.         printf("I2C_SLAVE_FORCE(0x51) = %d\n", res);
    
11.         res = ioctl(fd, I2C_BUS_MODE, 1);
    
12.         printf("I2C_BUS_MODE(1) = %d\n", res);
    
13.         res = ioctl(fd, I2C_TIMEOUT, 100);
    
14.         printf("I2C_TIMEOUT(100) = %d\n", res);
    
15.         res = ioctl(fd, I2C_RETRIES, 2);
    
16.         printf("I2C_RETRIES(2) = %d\n", res);
    
17. 
    
18.         //        read
    
19.         for (i = 2; i < 10; i++) {
    
20.                 memset(buf, 0xFF, sizeof(buf));
    
21.                 buf[0] = i;
    
22.                 res = write(fd, buf, 1); // 失败, 返回-1, dmesg: s3c2440-i2c s3c2440-i2c: cannot get bus (error -110)
    
23.                 printf("set read address to 0x%02x, result = %d\n", buf[0], res);
    
24.                 if (res != 1) {
    
25.                         continue;
    
26.                 }
    
27.                 usleep(1000);
    
28.                 res = read(fd, buf + 1, 1);
    
29.                 printf("read data from address 0x%02x, result = %d, value = 0x%02x\n", buf[0], res, buf[1]);
    
30.         }
    

复制代码

你说 linux 自带的代码没问题，那么请问 probe 根本没机会调用，这是怎么回事？