Annotation of sys/dev/i2c/i2c_scan.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: i2c_scan.c,v 1.97 2007/04/10 17:47:55 miod Exp $ */
2:
3: /*
4: * Copyright (c) 2005 Theo de Raadt <deraadt@openbsd.org>
5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: /*
20: * I2C bus scanning.
21: */
22:
23: #include <sys/param.h>
24: #include <sys/systm.h>
25: #include <sys/device.h>
26:
27: #define _I2C_PRIVATE
28: #include <dev/i2c/i2cvar.h>
29:
30: #undef I2C_DEBUG
31: #define I2C_VERBOSE
32:
33: void iic_probe(struct device *, struct i2cbus_attach_args *, u_int8_t);
34:
35: /*
36: * Addresses at which to probe for sensors. Skip address 0x4f, since
37: * probing it seems to crash at least one Sony VAIO laptop. Only a
38: * few chips can actually sit at that address, and vendors seem to
39: * place those at other addresses, so this isn't a big loss.
40: */
41: struct {
42: u_int8_t start, end;
43: } probe_addrs[] = {
44: { 0x18, 0x18 },
45: { 0x1a, 0x1a },
46: { 0x20, 0x2f },
47: { 0x48, 0x4e }
48: };
49:
50: #define MAX_IGNORE 8
51: u_int8_t ignore_addrs[MAX_IGNORE];
52:
53: /*
54: * Some Maxim 1617 clones MAY NOT even read cmd 0xfc! When it is
55: * read, they will power-on-reset. Their default condition
56: * (control register bit 0x80) therefore will be that they assert
57: * /ALERT for the 5 potential errors that may occur. One of those
58: * errors is that the external temperature diode is missing. This
59: * is unfortunately a common choice of system designers, except
60: * suddenly now we get a /ALERT, which may on some chipsets cause
61: * us to receive an entirely unexpected SMI .. and then an NMI.
62: *
63: * As we probe each device, if we hit something which looks suspiciously
64: * like it may potentially be a 1617 or clone, we immediately set this
65: * variable to avoid reading that register offset.
66: */
67: int skip_fc;
68:
69: static i2c_tag_t probe_ic;
70: static u_int8_t probe_addr;
71: static u_int8_t probe_val[256];
72:
73: void iicprobeinit(struct i2cbus_attach_args *, u_int8_t);
74: u_int8_t iicprobenc(u_int8_t);
75: u_int8_t iicprobe(u_int8_t);
76: u_int16_t iicprobew(u_int8_t);
77: char *lm75probe(void);
78: char *adm1032cloneprobe(u_int8_t);
79: void iic_dump(struct device *, u_int8_t, char *);
80:
81: void
82: iicprobeinit(struct i2cbus_attach_args *iba, u_int8_t addr)
83: {
84: probe_ic = iba->iba_tag;
85: probe_addr = addr;
86: memset(probe_val, 0xff, sizeof probe_val);
87: }
88:
89: u_int8_t
90: iicprobenc(u_int8_t cmd)
91: {
92: u_int8_t data;
93:
94: /*
95: * If we think we are talking to an evil Maxim 1617 or clone,
96: * avoid accessing this register because it is death.
97: */
98: if (skip_fc && cmd == 0xfc)
99: return (0xff);
100: iic_acquire_bus(probe_ic, 0);
101: if (iic_exec(probe_ic, I2C_OP_READ_WITH_STOP,
102: probe_addr, &cmd, 1, &data, 1, 0) != 0)
103: data = 0xff;
104: iic_release_bus(probe_ic, 0);
105: return (data);
106: }
107:
108: u_int16_t
109: iicprobew(u_int8_t cmd)
110: {
111: u_int8_t data[2];
112:
113: /*
114: * If we think we are talking to an evil Maxim 1617 or clone,
115: * avoid accessing this register because it is death.
116: */
117: if (skip_fc && cmd == 0xfc)
118: return (0xffff);
119: iic_acquire_bus(probe_ic, 0);
120: if (iic_exec(probe_ic, I2C_OP_READ_WITH_STOP,
121: probe_addr, &cmd, 1, &data, 2, 0) != 0)
122: data[0] = data[1] = 0xff;
123: iic_release_bus(probe_ic, 0);
124: return ((data[0] << 8) | data[1]);
125: }
126:
127: u_int8_t
128: iicprobe(u_int8_t cmd)
129: {
130: if (probe_val[cmd] != 0xff)
131: return probe_val[cmd];
132: probe_val[cmd] = iicprobenc(cmd);
133: return (probe_val[cmd]);
134: }
135:
136: #define LM75TEMP 0x00
137: #define LM75CONF 0x01
138: #define LM75Thyst 0x02
139: #define LM75Tos 0x03
140: #define LM77Tlow 0x04
141: #define LM77Thigh 0x05
142: #define LM75TMASK 0xff80 /* 9 bits in temperature registers */
143: #define LM77TMASK 0xfff8 /* 13 bits in temperature registers */
144:
145: /*
146: * The LM75/LM75A/LM77 family are very hard to detect. Thus, we check
147: * for all other possible chips first. These chips do not have an
148: * ID register. They do have a few quirks though:
149: * - on the LM75 and LM77, registers 0x06 and 0x07 return whatever
150: * value was read before
151: * - the LM75 lacks registers 0x04 and 0x05, so those act as above
152: * - the LM75A returns 0xffff for registers 0x04, 0x05, 0x06 and 0x07
153: * - the chip registers loop every 8 registers
154: * The downside is that we must read almost every register to guess
155: * if this is an LM75, LM75A or LM77.
156: */
157: char *
158: lm75probe(void)
159: {
160: u_int16_t temp, thyst, tos, tlow, thigh, mask = LM75TMASK;
161: u_int8_t conf;
162: int i, echocount, ffffcount, score;
163: int echoreg67, echoreg45, ffffreg67, ffffreg45;
164:
165: temp = iicprobew(LM75TEMP);
166:
167: /*
168: * Sometimes the other probes can upset the chip, if we get 0xffff
169: * the first time, try it once more.
170: */
171: if (temp == 0xffff)
172: temp = iicprobew(LM75TEMP);
173:
174: conf = iicprobenc(LM75CONF);
175: thyst = iicprobew(LM75Thyst);
176: tos = iicprobew(LM75Tos);
177:
178: /* totally bogus data */
179: if (conf == 0xff && temp == 0xffff && thyst == 0xffff)
180: return (NULL);
181:
182: temp &= mask;
183: thyst &= mask;
184: tos &= mask;
185:
186: /* All values the same? Very unlikely */
187: if (temp == thyst && thyst == tos)
188: return (NULL);
189:
190: #if notsure
191: /* more register aliasing effects that indicate not a lm75 */
192: if ((temp >> 8) == conf)
193: return (NULL);
194: #endif
195:
196: /*
197: * LM77/LM75 registers 6, 7
198: * echo whatever was read just before them from reg 0, 1, or 2
199: *
200: * LM75A doesn't appear to do this, but does appear to reliably
201: * return 0xffff
202: */
203: for (i = 6, echocount = 2, ffffcount = 0; i <= 7; i++) {
204: if ((iicprobew(LM75TEMP) & mask) != (iicprobew(i) & mask) ||
205: (iicprobew(LM75Thyst) & mask) != (iicprobew(i) & mask) ||
206: (iicprobew(LM75Tos) & mask) != (iicprobew(i) & mask))
207: echocount--;
208: if (iicprobew(i) == 0xffff)
209: ffffcount++;
210: }
211:
212: /* Make sure either both registers echo, or neither does */
213: if (echocount == 1 || ffffcount == 1)
214: return (NULL);
215:
216: echoreg67 = (echocount == 0) ? 0 : 1;
217: ffffreg67 = (ffffcount == 0) ? 0 : 1;
218:
219: /*
220: * LM75 has no registers 4 or 5, and they will act as echos too
221: *
222: * LM75A doesn't appear to do this either, but does appear to
223: * reliably return 0xffff
224: */
225: for (i = 4, echocount = 2, ffffcount = 0; i <= 5; i++) {
226: if ((iicprobew(LM75TEMP) & mask) != (iicprobew(i) & mask) ||
227: (iicprobew(LM75Thyst) & mask) != (iicprobew(i) & mask) ||
228: (iicprobew(LM75Tos) & mask) != (iicprobew(i) & mask))
229: echocount--;
230: if (iicprobew(i) == 0xffff)
231: ffffcount++;
232: }
233:
234: /* Make sure either both registers echo, or neither does */
235: if (echocount == 1 || ffffcount == 1)
236: return (NULL);
237:
238: echoreg45 = (echocount == 0) ? 0 : 1;
239: ffffreg45 = (ffffcount == 0) ? 0 : 1;
240:
241: /*
242: * If we find that 4 and 5 are not echos, and don't return 0xffff
243: * then based on whether the echo test of registers 6 and 7
244: * succeeded or not, we may have an LM77
245: */
246: if (echoreg45 == 0 && ffffreg45 == 0 && echoreg67 == 1) {
247: mask = LM77TMASK;
248:
249: /* mask size changed, must re-read for the next checks */
250: thyst = iicprobew(LM75Thyst) & mask;
251: tos = iicprobew(LM75Tos) & mask;
252: tlow = iicprobew(LM77Tlow) & mask;
253: thigh = iicprobew(LM77Thigh) & mask;
254: }
255:
256: /* a real LM75/LM75A/LM77 repeats its registers.... */
257: for (i = 0x08; i <= 0xf8; i += 8) {
258: if (conf != iicprobenc(LM75CONF + i) ||
259: thyst != (iicprobew(LM75Thyst + i) & mask) ||
260: tos != (iicprobew(LM75Tos + i) & mask))
261: return (NULL);
262:
263: /*
264: * Check that the repeated registers 0x06 and 0x07 still
265: * either echo or return 0xffff
266: */
267: if (echoreg67 == 1) {
268: tos = iicprobew(LM75Tos) & mask;
269: if (tos != (iicprobew(0x06 + i) & mask) ||
270: tos != (iicprobew(0x07 + i) & mask))
271: return (NULL);
272: } else if (ffffreg67 == 1)
273: if (iicprobew(0x06 + i) != 0xffff ||
274: iicprobew(0x07 + i) != 0xffff)
275: return (NULL);
276:
277: /*
278: * Check that the repeated registers 0x04 and 0x05 still
279: * either echo or return 0xffff. If they do neither, and
280: * registers 0x06 and 0x07 echo, then we will be probing
281: * for an LM77, so make sure those still repeat
282: */
283: if (echoreg45 == 1) {
284: tos = iicprobew(LM75Tos) & mask;
285: if (tos != (iicprobew(LM77Tlow + i) & mask) ||
286: tos != (iicprobew(LM77Thigh + i) & mask))
287: return (NULL);
288: } else if (ffffreg45 == 1) {
289: if (iicprobew(LM77Tlow + i) != 0xffff ||
290: iicprobew(LM77Thigh + i) != 0xffff)
291: return (NULL);
292: } else if (echoreg67 == 1)
293: if (tlow != (iicprobew(LM77Tlow + i) & mask) ||
294: thigh != (iicprobew(LM77Thigh + i) & mask))
295: return (NULL);
296: }
297:
298: /*
299: * Given that we now know how the first eight registers behave and
300: * that this behaviour is consistently repeated, we can now use
301: * the following table:
302: *
303: * echoreg67 | echoreg45 | ffffreg67 | ffffreg45 | chip
304: * ----------+-----------+-----------+-----------+------
305: * 1 | 1 | 0 | 0 | LM75
306: * 1 | 0 | 0 | 0 | LM77
307: * 0 | 0 | 1 | 1 | LM75A
308: */
309:
310: /* Convert the various flags into a single score */
311: score = (echoreg67 << 3) + (echoreg45 << 2) + (ffffreg67 << 1) +
312: ffffreg45;
313:
314: switch (score) {
315: case 12:
316: return ("lm75");
317: case 8:
318: return ("lm77");
319: case 3:
320: return ("lm75a");
321: default:
322: #if defined(I2C_DEBUG)
323: printf("lm75probe: unknown chip, scored %d\n", score);
324: #endif /* defined(I2C_DEBUG) */
325: return (NULL);
326: }
327: }
328:
329: char *
330: adm1032cloneprobe(u_int8_t addr)
331: {
332: if (addr == 0x18 || addr == 0x1a || addr == 0x29 ||
333: addr == 0x2b || addr == 0x4c || addr == 0x4e) {
334: u_int8_t reg, val;
335: int zero = 0, copy = 0;
336:
337: val = iicprobe(0x00);
338: for (reg = 0x00; reg < 0x09; reg++) {
339: if (iicprobe(reg) == 0xff)
340: return (NULL);
341: if (iicprobe(reg) == 0x00)
342: zero++;
343: if (val == iicprobe(reg))
344: copy++;
345: }
346: if (zero > 6 || copy > 6)
347: return (NULL);
348: val = iicprobe(0x09);
349: for (reg = 0x0a; reg < 0xfc; reg++) {
350: if (iicprobe(reg) != val)
351: return (NULL);
352: }
353: /* 0xfe may be Maxim, or some other vendor */
354: if (iicprobe(0xfe) == 0x4d)
355: return ("max1617");
356: /*
357: * "xeontemp" is the name we choose for clone chips
358: * which have all sorts of buggy bus interactions, such
359: * as those we just probed. Why?
360: * Intel is partly to blame for this situation.
361: */
362: return ("xeontemp");
363: }
364: return (NULL);
365: }
366:
367: void
368: iic_ignore_addr(u_int8_t addr)
369: {
370: int i;
371:
372: for (i = 0; i < sizeof(ignore_addrs); i++)
373: if (ignore_addrs[i] == 0) {
374: ignore_addrs[i] = addr;
375: return;
376: }
377: }
378:
379: #if defined(I2C_DEBUG) || defined(I2C_VERBOSE)
380: void
381: iic_dump(struct device *dv, u_int8_t addr, char *name)
382: {
383: static u_int8_t iicvalcnt[256];
384: u_int8_t val, val2, max;
385: int i, cnt = 0;
386:
387: /*
388: * Don't bother printing the most often repeated register
389: * value, since it is often weird devices that respond
390: * incorrectly, busted controller driver, or in the worst
391: * case, it in mosts cases, the value 0xff.
392: */
393: bzero(iicvalcnt, sizeof iicvalcnt);
394: val = iicprobe(0);
395: iicvalcnt[val]++;
396: for (i = 1; i <= 0xff; i++) {
397: val2 = iicprobe(i);
398: iicvalcnt[val2]++;
399: if (val == val2)
400: cnt++;
401: }
402:
403: for (val = max = i = 0; i <= 0xff; i++)
404: if (max < iicvalcnt[i]) {
405: max = iicvalcnt[i];
406: val = i;
407: }
408:
409: if (cnt <= 254) {
410: printf("%s: addr 0x%x", dv->dv_xname, addr);
411: for (i = 0; i <= 0xff; i++) {
412: if (iicprobe(i) != val)
413: printf(" %02x=%02x", i, iicprobe(i));
414: }
415: if (name)
416: printf(": %s", name);
417: printf("\n");
418: }
419: }
420: #endif /* defined(I2C_DEBUG) || defined(I2C_VERBOSE) */
421:
422: void
423: iic_probe(struct device *self, struct i2cbus_attach_args *iba, u_int8_t addr)
424: {
425: struct i2c_attach_args ia;
426: char *name = NULL;
427: int i;
428:
429: for (i = 0; i < sizeof(ignore_addrs); i++)
430: if (ignore_addrs[i] == addr)
431: return;
432:
433: iicprobeinit(iba, addr);
434: skip_fc = 0;
435:
436: /*
437: * Many I2C/SMBus devices use register 0x3e as a vendor ID
438: * register.
439: */
440: switch (iicprobe(0x3e)) {
441: case 0x01: /* National Semiconductor */
442: /*
443: * Some newer National products use a vendor code at
444: * 0x3e of 0x01, and then 0x3f contains a product code
445: * But some older products are missing a product code,
446: * and contain who knows what in that register. We assume
447: * that some employee was smart enough to keep the numbers
448: * unique.
449: */
450: if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
451: iicprobe(0x3f) == 0x73)
452: name = "lm93";
453: else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
454: iicprobe(0x3f) == 0x68)
455: name = "lm96000"; /* adt7460 compat? */
456: else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
457: (iicprobe(0x3f) == 0x60 || iicprobe(0x3f) == 0x62))
458: name = "lm85"; /* lm85C/B == adt7460 compat */
459: else if ((addr & 0x7c) == 0x2c && /* addr 0b01011xx */
460: iicprobe(0x48) == addr &&
461: (iicprobe(0x3f) == 0x03 || iicprobe(0x3f) == 0x04) &&
462: (iicprobe(0x40) & 0x80) == 0x00)
463: name = "lm81";
464: break;
465: case 0x02: /* National Semiconductor? */
466: if ((iicprobe(0x3f) & 0xfc) == 0x04)
467: name = "lm87"; /* complete check */
468: break;
469: case 0x23: /* Analog Devices? */
470: if (iicprobe(0x48) == addr &&
471: (iicprobe(0x40) & 0x80) == 0x00 &&
472: (addr & 0x7c) == 0x2c)
473: name = "adm9240"; /* lm87 clone */
474: break;
475: case 0x41: /* Analog Devices */
476: /*
477: * Newer chips have a valid 0x3d product number, while
478: * older ones sometimes encoded the product into the
479: * upper half of the "step register" at 0x3f.
480: */
481: if ((addr == 0x2c || addr == 0x2e || addr == 0x2f) &&
482: iicprobe(0x3d) == 0x70)
483: name = "adt7470";
484: else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
485: iicprobe(0x3d) == 0x76)
486: name = "adt7476";
487: else if (addr == 0x2e && iicprobe(0x3d) == 0x75)
488: name = "adt7475";
489: else if (iicprobe(0x3d) == 0x27 &&
490: (iicprobe(0x3f) == 0x60 || iicprobe(0x3f) == 0x6a))
491: name = "adm1027"; /* complete check */
492: else if (iicprobe(0x3d) == 0x27 &&
493: (iicprobe(0x3f) == 0x62 || iicprobe(0x3f) == 0x6a))
494: name = "adt7460"; /* complete check */
495: else if (addr == 0x2e &&
496: iicprobe(0x3d) == 0x68 && (iicprobe(0x3f) & 0xf0) == 0x70)
497: name = "adt7467";
498: else if (iicprobe(0x3d) == 0x33)
499: name = "adm1033";
500: else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
501: iicprobe(0x3d) == 0x30 &&
502: (iicprobe(0x01) & 0x80) == 0x00 &&
503: (iicprobe(0x0d) & 0x70) == 0x00 &&
504: (iicprobe(0x0e) & 0x70) == 0x00)
505: /*
506: * Revision 3 seems to be an adm1031 with
507: * remote diode 2 shorted. Therefore we
508: * cannot assume the reserved/unused bits of
509: * register 0x03 and 0x06 are set to zero.
510: */
511: name = "adm1030"; /* complete check */
512: else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
513: iicprobe(0x3d) == 0x31 &&
514: (iicprobe(0x01) & 0x80) == 0x00 &&
515: (iicprobe(0x0d) & 0x70) == 0x00 &&
516: (iicprobe(0x0e) & 0x70) == 0x00 &&
517: (iicprobe(0x0f) & 0x70) == 0x00)
518: name = "adm1031"; /* complete check */
519: else if ((addr & 0x7c) == 0x2c && /* addr 0b01011xx */
520: (iicprobe(0x3f) & 0xf0) == 0x20 &&
521: (iicprobe(0x40) & 0x80) == 0x00 &&
522: (iicprobe(0x41) & 0xc0) == 0x00 &&
523: (iicprobe(0x42) & 0xbc) == 0x00)
524: name = "adm1025"; /* complete check */
525: else if ((addr & 0x7c) == 0x2c && /* addr 0b01011xx */
526: (iicprobe(0x3f) & 0xf0) == 0x10 &&
527: (iicprobe(0x40) & 0x80) == 0x00)
528: name = "adm1024"; /* complete check */
529: else if ((iicprobe(0xff) & 0xf0) == 0x30)
530: name = "adm1023";
531: else if (addr == 0x2e &&
532: (iicprobe(0x3f) & 0xf0) == 0xd0 &&
533: (iicprobe(0x40) & 0x80) == 0x00)
534: name = "adm1028"; /* adm1022 clone? */
535: else if ((addr == 0x2c || addr == 0x2e || addr == 0x2f) &&
536: (iicprobe(0x3f) & 0xf0) == 0xc0 &&
537: (iicprobe(0x40) & 0x80) == 0x00)
538: name = "adm1022";
539: break;
540: case 0x49: /* Texas Instruments */
541: if ((addr == 0x2c || addr == 0x2e || addr == 0x2f) &&
542: (iicprobe(0x3f) & 0xf0) == 0xc0 &&
543: (iicprobe(0x40) & 0x80) == 0x00)
544: name = "thmc50"; /* adm1022 clone */
545: break;
546: case 0x55: /* SMSC */
547: if ((addr & 0x7c) == 0x2c && /* addr 0b01011xx */
548: iicprobe(0x3f) == 0x20 &&
549: (iicprobe(0x47) & 0x70) == 0x00 &&
550: (iicprobe(0x49) & 0xfe) == 0x80)
551: name = "47m192"; /* adm1025 compat */
552: break;
553: case 0x5c: /* SMSC */
554: if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
555: (iicprobe(0x3f) & 0xf0) == 0x60)
556: name = "emc6d100"; /* emc6d101, emc6d102, emc6d103 */
557: else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
558: (iicprobe(0x3f) & 0xf0) == 0x80)
559: name = "sch5017";
560: else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
561: (iicprobe(0x3f) & 0xf0) == 0xb0)
562: name = "emc6w201";
563: break;
564: case 0xa1: /* Philips */
565: if ((iicprobe(0x3f) & 0xf0) == 0x20 &&
566: (iicprobe(0x40) & 0x80) == 0x00 &&
567: (iicprobe(0x41) & 0xc0) == 0x00 &&
568: (iicprobe(0x42) & 0xbc) == 0x00)
569: name = "ne1619"; /* adm1025 compat */
570: break;
571: case 0xda: /* Dallas Semiconductor */
572: if (iicprobe(0x3f) == 0x01 && iicprobe(0x48) == addr &&
573: (iicprobe(0x40) & 0x80) == 0x00)
574: name = "ds1780"; /* lm87 clones */
575: break;
576: }
577:
578: switch (iicprobe(0x4e)) {
579: case 0x41: /* Analog Devices */
580: if ((addr == 0x48 || addr == 0x4a || addr == 0x4b) &&
581: (iicprobe(0x4d) == 0x03 || iicprobe(0x4d) == 0x08 ||
582: iicprobe(0x4d) == 0x07))
583: name = "adt7516"; /* adt7517, adt7519 */
584: break;
585: }
586:
587: switch (iicprobe(0xfe)) {
588: case 0x01: /* National Semiconductor */
589: if (addr == 0x4c &&
590: iicprobe(0xff) == 0x41 && (iicprobe(0x03) & 0x18) == 0 &&
591: iicprobe(0x04) <= 0x0f && (iicprobe(0xbf) & 0xf8) == 0)
592: name = "lm63";
593: else if (addr == 0x4c &&
594: iicprobe(0xff) == 0x11 && (iicprobe(0x03) & 0x2a) == 0 &&
595: iicprobe(0x04) <= 0x09 && (iicprobe(0xbf) & 0xf8) == 0)
596: name = "lm86";
597: else if (addr == 0x4c &&
598: iicprobe(0xff) == 0x31 && (iicprobe(0x03) & 0x2a) == 0 &&
599: iicprobe(0x04) <= 0x09 && (iicprobe(0xbf) & 0xf8) == 0)
600: name = "lm89"; /* or lm99 */
601: else if (addr == 0x4d &&
602: iicprobe(0xff) == 0x34 && (iicprobe(0x03) & 0x2a) == 0 &&
603: iicprobe(0x04) <= 0x09 && (iicprobe(0xbf) & 0xf8) == 0)
604: name = "lm89-1"; /* or lm99-1 */
605: else if (addr == 0x4c &&
606: iicprobe(0xff) == 0x21 && (iicprobe(0x03) & 0x2a) == 0 &&
607: iicprobe(0x04) <= 0x09 && (iicprobe(0xbf) & 0xf8) == 0)
608: name = "lm90";
609: break;
610: case 0x23: /* Genesys Logic? */
611: if ((addr == 0x4c) &&
612: (iicprobe(0x03) & 0x3f) == 0x00 && iicprobe(0x04) <= 0x08)
613: /*
614: * Genesys Logic doesn't make the datasheet
615: * for the GL523SM publically available, so
616: * the checks above are nothing more than a
617: * (conservative) educated guess.
618: */
619: name = "gl523sm";
620: break;
621: case 0x41: /* Analog Devices */
622: if ((addr == 0x4c || addr == 0x4d) &&
623: iicprobe(0xff) == 0x51 &&
624: (iicprobe(0x03) & 0x1f) == 0x04 &&
625: iicprobe(0x04) <= 0x0a) {
626: /* If not in adm1032 compatibility mode. */
627: name = "adt7461";
628: } else if ((addr == 0x18 || addr == 0x19 || addr == 0x1a ||
629: addr == 0x29 || addr == 0x2a || addr == 0x2b ||
630: addr == 0x4c || addr == 0x4d || addr == 0x4e) &&
631: (iicprobe(0xff) & 0xf0) == 0x00 &&
632: (iicprobe(0x03) & 0x3f) == 0x00 &&
633: iicprobe(0x04) <= 0x07) {
634: name = "adm1021";
635: skip_fc = 1;
636: } else if ((addr == 0x18 || addr == 0x19 || addr == 0x1a ||
637: addr == 0x29 || addr == 0x2a || addr == 0x2b ||
638: addr == 0x4c || addr == 0x4d || addr == 0x4e) &&
639: (iicprobe(0xff) & 0xf0) == 0x30 &&
640: (iicprobe(0x03) & 0x3f) == 0x00 &&
641: iicprobe(0x04) <= 0x07) {
642: name = "adm1023"; /* or adm1021a */
643: skip_fc = 1;
644: } else if ((addr == 0x4c || addr == 0x4d || addr == 0x4e) &&
645: (iicprobe(0x03) & 0x3f) == 0x00 &&
646: iicprobe(0x04) <= 0x0a) {
647: name = "adm1032"; /* or adm1020 */
648: skip_fc = 1;
649: }
650: break;
651: case 0x47: /* Global Mixed-mode Technology */
652: if (addr == 0x4c && iicprobe(0xff) == 0x01 &&
653: (iicprobe(0x03) & 0x3f) == 0x00 && iicprobe(0x04) <= 0x08)
654: name = "g781";
655: if (addr == 0x4d && iicprobe(0xff) == 0x03 &&
656: (iicprobe(0x03) & 0x3f) == 0x00 && iicprobe(0x04) <= 0x08)
657: name = "g781-1";
658: break;
659: case 0x4d: /* Maxim */
660: if ((addr == 0x18 || addr == 0x19 || addr == 0x1a ||
661: addr == 0x29 || addr == 0x2a || addr == 0x2b ||
662: addr == 0x4c || addr == 0x4d || addr == 0x4e) &&
663: iicprobe(0xff) == 0x08 && (iicprobe(0x02) & 0x03) == 0 &&
664: (iicprobe(0x03) & 0x07) == 0 && iicprobe(0x04) <= 0x08)
665: name = "max6690";
666: else if ((addr == 0x4c || addr == 0x4d || addr == 0x4e) &&
667: iicprobe(0xff) == 0x59 && (iicprobe(0x03) & 0x1f) == 0 &&
668: iicprobe(0x04) <= 0x07)
669: name = "max6646"; /* max6647/8/9, max6692 */
670: else if ((addr == 0x4c || addr == 0x4d || addr == 0x4e) &&
671: (iicprobe(0x02) & 0x2b) == 0 &&
672: (iicprobe(0x03) & 0x0f) == 0 && iicprobe(0x04) <= 0x09) {
673: name = "max6657"; /* max6658, max6659 */
674: skip_fc = 1;
675: } else if ((addr >= 0x48 && addr <= 0x4f) &&
676: (iicprobe(0x02) & 0x2b) == 0 &&
677: (iicprobe(0x03) & 0x0f) == 0)
678: name = "max6642";
679: break;
680: }
681:
682: if (addr == iicprobe(0x48) &&
683: ((iicprobe(0x4f) == 0x5c && (iicprobe(0x4e) & 0x80)) ||
684: (iicprobe(0x4f) == 0xa3 && !(iicprobe(0x4e) & 0x80)))) {
685: /*
686: * We could toggle 0x4e bit 0x80, then re-read 0x4f to
687: * see if the value changes to 0xa3 (indicating Winbond).
688: * But we are trying to avoid writes.
689: */
690: if ((iicprobe(0x4e) & 0x07) == 0) {
691: switch (iicprobe(0x58)) {
692: case 0x10:
693: case 0x11: /* rev 2? */
694: name = "w83781d";
695: break;
696: case 0x21:
697: name = "w83627hf";
698: break;
699: case 0x30:
700: name = "w83782d";
701: break;
702: case 0x31:
703: name = "as99127f"; /* rev 2 */
704: break;
705: case 0x40:
706: name = "w83783s";
707: break;
708: case 0x71:
709: name = "w83791d";
710: break;
711: case 0x72:
712: name = "w83791sd";
713: break;
714: case 0x7a:
715: name = "w83792d";
716: break;
717: }
718: } else {
719: /*
720: * The BIOS left the chip in a non-zero
721: * register bank. Assume it's a W83781D and
722: * let lm(4) sort out the real model.
723: */
724: name = "w83781d";
725: }
726: } else if (addr == iicprobe (0x4a) && iicprobe(0x4e) == 0x50 &&
727: iicprobe(0x4c) == 0xa3 && iicprobe(0x4d) == 0x5c) {
728: name = "w83l784r";
729: } else if (addr == 0x2d && iicprobe(0x4e) == 0x60 &&
730: iicprobe(0x4c) == 0xa3 && iicprobe(0x4d) == 0x5c) {
731: name = "w83l785r";
732: } else if (addr == 0x2e && iicprobe(0x4e) == 0x70 &&
733: iicprobe(0x4c) == 0xa3 && iicprobe(0x4d) == 0x5c) {
734: name = "w83l785ts-l";
735: } else if (addr >= 0x28 && addr <= 0x2f &&
736: iicprobe(0x4f) == 0x12 && (iicprobe(0x4e) & 0x80)) {
737: /*
738: * We could toggle 0x4e bit 0x80, then re-read 0x4f to
739: * see if the value changes to 0xc3 (indicating ASUS).
740: * But we are trying to avoid writes.
741: */
742: if (iicprobe(0x58) == 0x31)
743: name = "as99127f"; /* rev 1 */
744: } else if ((addr == 0x2d || addr == 0x2e) &&
745: addr * 2 == iicprobe(0x04) &&
746: iicprobe(0x5d) == 0x19 && iicprobe(0x5e) == 0x34 &&
747: iicprobe(0x5a) == 0x03 && iicprobe(0x5b) == 0x06) {
748: name = "f75375"; /* Fintek */
749: } else if (addr == 0x2d &&
750: ((iicprobe(0x4f) == 0x06 && (iicprobe(0x4e) & 0x80)) ||
751: (iicprobe(0x4f) == 0x94 && !(iicprobe(0x4e) & 0x80)))) {
752: /*
753: * We could toggle 0x4e bit 0x80, then re-read 0x4f to
754: * see if the value changes to 0x94 (indicating ASUS).
755: * But we are trying to avoid writes.
756: *
757: * NB. we won't match if the BIOS has selected a non-zero
758: * register bank (set via 0x4e). We could select bank 0 so
759: * we see the right registers, but that would require a
760: * write. In general though, we bet no BIOS would leave us
761: * in the wrong state.
762: */
763: if ((iicprobe(0x58) & 0x7f) == 0x31 &&
764: (iicprobe(0x4e) & 0xf) == 0x00)
765: name = "asb100";
766: } else if ((addr == 0x2c || addr == 0x2d) &&
767: iicprobe(0x00) == 0x80 &&
768: (iicprobe(0x01) == 0x00 || iicprobe(0x01) == 0x80) &&
769: iicprobe(0x02) == 0x00 && (iicprobe(0x03) & 0x83) == 0x00 &&
770: (iicprobe(0x0f) & 0x07) == 0x00 &&
771: (iicprobe(0x11) & 0x80) == 0x00 &&
772: (iicprobe(0x12) & 0x80) == 0x00) {
773: /*
774: * The GL518SM is really crappy. It has both byte and
775: * word registers, and reading a word register with a
776: * byte read command will make the device crap out and
777: * hang the bus. This has nasty consequences on some
778: * machines, like preventing warm reboots. The word
779: * registers are 0x07 through 0x0c, so make sure the
780: * checks above don't access those registers. We
781: * don't want to do this check right up front though
782: * since this chip is somewhat hard to detect (which
783: * is why we check for every single fixed bit it has).
784: */
785: name = "gl518sm";
786: } else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
787: iicprobe(0x16) == 0x41 && ((iicprobe(0x17) & 0xf0) == 0x40)) {
788: name = "adm1026";
789: } else if (name == NULL &&
790: (addr & 0x78) == 0x48) { /* addr 0b1001xxx */
791: name = lm75probe();
792: }
793: #if 0
794: /*
795: * XXX This probe needs to be improved; the driver does some
796: * dangerous writes.
797: */
798: if (name == NULL && (addr & 0x7c) == 0x48 && /* addr 0b1001xxx */
799: (iicprobew(0xaa) & 0x0007) == 0x0000 &&
800: (iicprobew(0xa1) & 0x0007) == 0x0000 &&
801: (iicprobew(0xa2) & 0x0007) == 0x0000 &&
802: (iicprobe(0xac) & 0x10) == 0x00) {
803: if ((iicprobe(0xac) & 0x7e) == 0x0a &&
804: iicprobe(0xab) == 0x00 && iicprobe(0xa8) == 0x00)
805: name = "ds1624";
806: else if ((iicprobe(0xac) & 0x7e) == 0x0c)
807: name = "ds1631"; /* terrible probe */
808: else if ((iicprobe(0xac) & 0x2e) == 0x2e)
809: name = "ds1721"; /* terrible probe */
810: }
811: #endif
812: if (name == NULL && (addr & 0xf8) == 0x28 && iicprobe(0x48) == addr &&
813: (iicprobe(0x00) & 0x90) == 0x10 && iicprobe(0x58) == 0x90) {
814: if (iicprobe(0x5b) == 0x12)
815: name = "it8712";
816: else if (iicprobe(0x5b) == 0x00)
817: name = "it8712f-a"; /* sis950 too */
818: }
819:
820: if (name == NULL && iicprobe(0x48) == addr &&
821: (iicprobe(0x40) & 0x80) == 0x00 && iicprobe(0x58) == 0xac)
822: name = "mtp008";
823:
824: if (name == NULL) {
825: name = adm1032cloneprobe(addr);
826: if (name)
827: skip_fc = 1;
828: }
829:
830: #ifdef I2C_DEBUG
831: iic_dump(self, addr, name);
832: #endif /* I2C_DEBUG */
833:
834: #if !defined(I2C_VERBOSE) && !defined(I2C_DEBUG)
835: if (name == NULL)
836: name = "unknown";
837: #endif
838:
839: if (name) {
840: memset(&ia, 0, sizeof(ia));
841: ia.ia_tag = iba->iba_tag;
842: ia.ia_addr = addr;
843: ia.ia_size = 1;
844: ia.ia_name = name;
845: if (config_found(self, &ia, iic_print))
846: return;
847: }
848:
849: #if defined(I2C_VERBOSE) && !defined(I2C_DEBUG)
850: iic_dump(self, addr, name);
851: #endif /* defined(I2C_VERBOSE) && !defined(I2C_DEBUG) */
852: }
853:
854: void
855: iic_scan(struct device *self, struct i2cbus_attach_args *iba)
856: {
857: i2c_tag_t ic = iba->iba_tag;
858: u_int8_t cmd = 0, addr;
859: int i;
860:
861: bzero(ignore_addrs, sizeof(ignore_addrs));
862: for (i = 0; i < sizeof(probe_addrs)/sizeof(probe_addrs[0]); i++) {
863: for (addr = probe_addrs[i].start; addr <= probe_addrs[i].end;
864: addr++) {
865: /* Perform RECEIVE BYTE command */
866: iic_acquire_bus(ic, 0);
867: if (iic_exec(ic, I2C_OP_READ_WITH_STOP, addr,
868: &cmd, 1, NULL, 0, 0) == 0) {
869: iic_release_bus(ic, 0);
870:
871: /* Some device exists, so go scope it out */
872: iic_probe(self, iba, addr);
873:
874: iic_acquire_bus(ic, 0);
875:
876: }
877: iic_release_bus(ic, 0);
878: }
879: }
880: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to i2c_scan.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / i2c