1/*  $OpenBSD: i2c_scan.c,v 1.147 2024/09/04 07:54:52 mglocker 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.  We apologize in advance for the massive overuse of 0x.
21 */
22
23#include "ipmi.h"
24
25#include <sys/param.h>
26#include <sys/systm.h>
27#include <sys/device.h>
28
29#define _I2C_PRIVATE
30#include <dev/i2c/i2cvar.h>
31
32#undef I2C_DEBUG
33#define I2C_VERBOSE
34
35#define MAX_IGNORE 8
36u_int8_t ignore_addrs[MAX_IGNORE];
37
38struct iicprobelist {
39    u_int8_t start, end;
40};
41
42/*
43 * Addresses at which to probe for sensors.  Skip address 0x4f, since
44 * probing it seems to crash at least one Sony VAIO laptop.  Only a
45 * few chips can actually sit at that address, and vendors seem to
46 * place those at other addresses, so this isn't a big loss.
47 */
48struct iicprobelist probe_addrs_sensor[] = {
49    { 0x18, 0x1f },
50    { 0x20, 0x2f },
51    { 0x48, 0x4e },
52    { 0, 0 }
53};
54
55/*
56 * Addresses at which to probe for eeprom devices.
57 */
58struct iicprobelist probe_addrs_eeprom[] = {
59    { 0x50, 0x57 },
60    { 0, 0 }
61};
62
63char    *iic_probe_sensor(struct device *, u_int8_t);
64char    *iic_probe_eeprom(struct device *, u_int8_t);
65
66#define PFLAG_SENSOR    1
67static struct {
68    struct iicprobelist *pl;
69    char    *(*probe)(struct device *, u_int8_t);
70    int flags;
71} probes[] = {
72    { probe_addrs_sensor, iic_probe_sensor, PFLAG_SENSOR },
73    { probe_addrs_eeprom, iic_probe_eeprom, 0 },
74    { NULL, NULL }
75};
76
77/*
78 * Some Maxim 1617 clones MAY NOT even read cmd 0xfc!  When it is
79 * read, they will power-on-reset.  Their default condition
80 * (control register bit 0x80) therefore will be that they assert
81 * /ALERT for the 5 potential errors that may occur.  One of those
82 * errors is that the external temperature diode is missing.  This
83 * is unfortunately a common choice of system designers, except
84 * suddenly now we get a /ALERT, which may on some chipsets cause
85 * us to receive an entirely unexpected SMI .. and then an NMI.
86 *
87 * As we probe each device, if we hit something which looks suspiciously
88 * like it may potentially be a 1617 or clone, we immediately set this
89 * variable to avoid reading that register offset.
90 */
91int skip_fc;
92
93static i2c_tag_t probe_ic;
94static u_int8_t probe_addr;
95static u_int8_t probe_val[256];
96
97void        iicprobeinit(struct i2cbus_attach_args *, u_int8_t);
98u_int8_t    iicprobenc(u_int8_t);
99u_int8_t    iicprobe(u_int8_t);
100u_int16_t   iicprobew(u_int8_t);
101char        *lm75probe(void);
102char        *adm1032cloneprobe(u_int8_t);
103void        iic_dump(struct device *, u_int8_t, char *);
104
105void
106iicprobeinit(struct i2cbus_attach_args *iba, u_int8_t addr)
107{
108    probe_ic = iba->iba_tag;
109    probe_addr = addr;
110    memset(probe_val, 0xff, sizeof probe_val);
111}
112
113u_int8_t
114iicprobenc(u_int8_t cmd)
115{
116    u_int8_t data;
117
118    /*
119     * If we think we are talking to an evil Maxim 1617 or clone,
120     * avoid accessing this register because it is death.
121     */
122    if (skip_fc && cmd == 0xfc)
123        return (0xff);
124    iic_acquire_bus(probe_ic, 0);
125    if (iic_exec(probe_ic, I2C_OP_READ_WITH_STOP,
126        probe_addr, &cmd, sizeof cmd, &data, sizeof data, 0) != 0)
127        data = 0xff;
128    iic_release_bus(probe_ic, 0);
129    return (data);
130}
131
132u_int16_t
133iicprobew(u_int8_t cmd)
134{
135    u_int16_t data;
136
137    /*
138     * If we think we are talking to an evil Maxim 1617 or clone,
139     * avoid accessing this register because it is death.
140     */
141    if (skip_fc && cmd == 0xfc)
142        return (0xffff);
143    iic_acquire_bus(probe_ic, 0);
144    if (iic_exec(probe_ic, I2C_OP_READ_WITH_STOP,
145        probe_addr, &cmd, sizeof cmd, &data, sizeof data, 0) != 0)
146        data = 0xffff;
147    iic_release_bus(probe_ic, 0);
148    return betoh16(data);
149}
150
151u_int8_t
152iicprobe(u_int8_t cmd)
153{
154    if (probe_val[cmd] != 0xff)
155        return probe_val[cmd];
156    probe_val[cmd] = iicprobenc(cmd);
157    return (probe_val[cmd]);
158}
159
160#define LM75TEMP    0x00
161#define LM75CONF    0x01
162#define LM75Thyst   0x02
163#define LM75Tos     0x03
164#define LM77Tlow    0x04
165#define LM77Thigh   0x05
166#define LM75TMASK   0xff80  /* 9 bits in temperature registers */
167#define LM77TMASK   0xfff8  /* 13 bits in temperature registers */
168
169/*
170 * The LM75/LM75A/LM77 family are very hard to detect.  Thus, we check
171 * for all other possible chips first.  These chips do not have an
172 * ID register.  They do have a few quirks though:
173 * -  on the LM75 and LM77, registers 0x06 and 0x07 return whatever
174 *    value was read before
175 * -  the LM75 lacks registers 0x04 and 0x05, so those act as above
176 * -  the LM75A returns 0xffff for registers 0x04, 0x05, 0x06 and 0x07
177 * -  the chip registers loop every 8 registers
178 * The downside is that we must read almost every register to guess
179 * if this is an LM75, LM75A or LM77.
180 */
181char *
182lm75probe(void)
183{
184    u_int16_t temp, thyst, tos, tlow, thigh, mask = LM75TMASK;
185    u_int8_t conf;
186    int i, echocount, ffffcount, score;
187    int echoreg67, echoreg45, ffffreg67, ffffreg45;
188
189    temp = iicprobew(LM75TEMP);
190
191    /*
192     * Sometimes the other probes can upset the chip, if we get 0xffff
193     * the first time, try it once more.
194     */
195    if (temp == 0xffff)
196        temp = iicprobew(LM75TEMP);
197
198    conf = iicprobenc(LM75CONF);
199    thyst = iicprobew(LM75Thyst);
200    tos = iicprobew(LM75Tos);
201
202    /* totally bogus data */
203    if (conf == 0xff && temp == 0xffff && thyst == 0xffff)
204        return (NULL);
205
206    temp &= mask;
207    thyst &= mask;
208    tos &= mask;
209
210    /* All values the same?  Very unlikely */
211    if (temp == thyst && thyst == tos)
212        return (NULL);
213
214#if notsure
215    /* more register aliasing effects that indicate not a lm75 */
216    if ((temp >> 8) == conf)
217        return (NULL);
218#endif
219
220    /*
221     * LM77/LM75 registers 6, 7
222     * echo whatever was read just before them from reg 0, 1, or 2
223     *
224     * LM75A doesn't appear to do this, but does appear to reliably
225     * return 0xffff
226     */
227    for (i = 6, echocount = 2, ffffcount = 0; i <= 7; i++) {
228        if ((iicprobew(LM75TEMP) & mask) != (iicprobew(i) & mask) ||
229            (iicprobew(LM75Thyst) & mask) != (iicprobew(i) & mask) ||
230            (iicprobew(LM75Tos) & mask) != (iicprobew(i) & mask))
231            echocount--;
232        if (iicprobew(i) == 0xffff)
233            ffffcount++;
234    }
235
236    /* Make sure either both registers echo, or neither does */
237    if (echocount == 1 || ffffcount == 1)
238        return (NULL);
239
240    echoreg67 = (echocount == 0) ? 0 : 1;
241    ffffreg67 = (ffffcount == 0) ? 0 : 1;
242
243    /*
244     * LM75 has no registers 4 or 5, and they will act as echos too
245     *
246     * LM75A doesn't appear to do this either, but does appear to
247     * reliably return 0xffff
248     */
249    for (i = 4, echocount = 2, ffffcount = 0; i <= 5; i++) {
250        if ((iicprobew(LM75TEMP) & mask) != (iicprobew(i) & mask) ||
251            (iicprobew(LM75Thyst) & mask) != (iicprobew(i) & mask) ||
252            (iicprobew(LM75Tos) & mask) != (iicprobew(i) & mask))
253            echocount--;
254        if (iicprobew(i) == 0xffff)
255            ffffcount++;
256    }
257
258    /* Make sure either both registers echo, or neither does */
259    if (echocount == 1 || ffffcount == 1)
260        return (NULL);
261
262    echoreg45 = (echocount == 0) ? 0 : 1;
263    ffffreg45 = (ffffcount == 0) ? 0 : 1;
264
265    /*
266     * If we find that 4 and 5 are not echos, and don't return 0xffff
267     * then based on whether the echo test of registers 6 and 7
268     * succeeded or not, we may have an LM77
269     */
270    if (echoreg45 == 0 && ffffreg45 == 0 && echoreg67 == 1) {
271        mask = LM77TMASK;
272
273        /* mask size changed, must re-read for the next checks */
274        thyst = iicprobew(LM75Thyst) & mask;
275        tos = iicprobew(LM75Tos) & mask;
276        tlow = iicprobew(LM77Tlow) & mask;
277        thigh = iicprobew(LM77Thigh) & mask;
278    }
279
280    /* a real LM75/LM75A/LM77 repeats its registers.... */
281    for (i = 0x08; i <= 0xf8; i += 8) {
282        if (conf != iicprobenc(LM75CONF + i) ||
283            thyst != (iicprobew(LM75Thyst + i) & mask) ||
284            tos != (iicprobew(LM75Tos + i) & mask))
285            return (NULL);
286
287        /*
288         * Check that the repeated registers 0x06 and 0x07 still
289         * either echo or return 0xffff
290         */
291        if (echoreg67 == 1) {
292            tos = iicprobew(LM75Tos) & mask;
293            if (tos != (iicprobew(0x06 + i) & mask) ||
294                tos != (iicprobew(0x07 + i) & mask))
295                return (NULL);
296        } else if (ffffreg67 == 1)
297            if (iicprobew(0x06 + i) != 0xffff ||
298                iicprobew(0x07 + i) != 0xffff)
299                return (NULL);
300
301        /*
302         * Check that the repeated registers 0x04 and 0x05 still
303         * either echo or return 0xffff. If they do neither, and
304         * registers 0x06 and 0x07 echo, then we will be probing
305         * for an LM77, so make sure those still repeat
306         */
307        if (echoreg45 == 1) {
308            tos = iicprobew(LM75Tos) & mask;
309            if (tos != (iicprobew(LM77Tlow + i) & mask) ||
310                tos != (iicprobew(LM77Thigh + i) & mask))
311                return (NULL);
312        } else if (ffffreg45 == 1) {
313            if (iicprobew(LM77Tlow + i) != 0xffff ||
314                iicprobew(LM77Thigh + i) != 0xffff)
315                return (NULL);
316        } else if (echoreg67 == 1)
317            if (tlow != (iicprobew(LM77Tlow + i) & mask) ||
318                thigh != (iicprobew(LM77Thigh + i) & mask))
319                return (NULL);
320    }
321
322    /*
323     * Given that we now know how the first eight registers behave and
324     * that this behaviour is consistently repeated, we can now use
325     * the following table:
326     *
327     * echoreg67 | echoreg45 | ffffreg67 | ffffreg45 | chip
328     * ----------+-----------+-----------+-----------+------
329     *     1     |     1     |     0     |     0     | LM75
330     *     1     |     0     |     0     |     0     | LM77
331     *     0     |     0     |     1     |     1     | LM75A
332     */
333
334    /* Convert the various flags into a single score */
335    score = (echoreg67 << 3) + (echoreg45 << 2) + (ffffreg67 << 1) +
336        ffffreg45;
337
338    switch (score) {
339    case 12:
340        return ("lm75");
341    case 8:
342        return ("lm77");
343    case 3:
344        return ("lm75a");
345    default:
346#if defined(I2C_DEBUG)
347        printf("lm75probe: unknown chip, scored %d\n", score);
348#endif /* defined(I2C_DEBUG) */
349        return (NULL);
350    }
351}
352
353char *
354adm1032cloneprobe(u_int8_t addr)
355{
356    if (addr == 0x18 || addr == 0x1a || addr == 0x29 ||
357        addr == 0x2b || addr == 0x4c || addr == 0x4e) {
358        u_int8_t reg, val;
359        int zero = 0, copy = 0;
360
361        val = iicprobe(0x00);
362        for (reg = 0x00; reg < 0x09; reg++) {
363            if (iicprobe(reg) == 0xff)
364                return (NULL);
365            if (iicprobe(reg) == 0x00)
366                zero++;
367            if (val == iicprobe(reg))
368                copy++;
369        }
370        if (zero > 6 || copy > 6)
371            return (NULL);
372        val = iicprobe(0x09);
373        for (reg = 0x0a; reg < 0xfc; reg++) {
374            if (iicprobe(reg) != val)
375                return (NULL);
376        }
377        /* 0xfe may be Maxim, or some other vendor */
378        if (iicprobe(0xfe) == 0x4d)
379            return ("max1617");
380        /*
381         * "xeontemp" is the name we choose for clone chips
382         * which have all sorts of buggy bus interactions, such
383         * as those we just probed.  Why?
384         * Intel is partly to blame for this situation.
385         */
386        return ("xeontemp");
387    }
388    return (NULL);
389}
390
391void
392iic_ignore_addr(u_int8_t addr)
393{
394    int i;
395
396    for (i = 0; i < sizeof(ignore_addrs); i++)
397        if (ignore_addrs[i] == 0) {
398            ignore_addrs[i] = addr;
399            return;
400        }
401}
402
403#ifdef I2C_VERBOSE
404void
405iic_dump(struct device *dv, u_int8_t addr, char *name)
406{
407    static u_int8_t iicvalcnt[256];
408    u_int8_t val, val2, max;
409    int i, cnt = 0;
410
411    /*
412     * Don't bother printing the most often repeated register
413     * value, since it is often weird devices that respond
414     * incorrectly, busted controller driver, or in the worst
415     * case, it in mosts cases, the value 0xff.
416     */
417    bzero(iicvalcnt, sizeof iicvalcnt);
418    val = iicprobe(0);
419    iicvalcnt[val]++;
420    for (i = 1; i <= 0xff; i++) {
421        val2 = iicprobe(i);
422        iicvalcnt[val2]++;
423        if (val == val2)
424            cnt++;
425    }
426
427    for (val = max = i = 0; i <= 0xff; i++)
428        if (max < iicvalcnt[i]) {
429            max = iicvalcnt[i];
430            val = i;
431        }
432
433    if (cnt == 255)
434        return;
435
436    printf("%s: addr 0x%x", dv->dv_xname, addr);
437    for (i = 0; i <= 0xff; i++) {
438        if (iicprobe(i) != val)
439            printf(" %02x=%02x", i, iicprobe(i));
440    }
441    printf(" words");
442    for (i = 0; i < 8; i++)
443        printf(" %02x=%04x", i, iicprobew(i));
444    if (name)
445        printf(": %s", name);
446    printf("\n");
447}
448#endif /* I2C_VERBOSE */
449
450char *
451iic_probe_sensor(struct device *self, u_int8_t addr)
452{
453    char *name = NULL;
454
455    skip_fc = 0;
456
457    /*
458     * Many I2C/SMBus devices use register 0x3e as a vendor ID
459     * register.
460     */
461    switch (iicprobe(0x3e)) {
462    case 0x01:      /* National Semiconductor */
463        /*
464         * Some newer National products use a vendor code at
465         * 0x3e of 0x01, and then 0x3f contains a product code
466         * But some older products are missing a product code,
467         * and contain who knows what in that register.  We assume
468         * that some employee was smart enough to keep the numbers
469         * unique.
470         */
471        if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
472            (iicprobe(0x3f) == 0x73 || iicprobe(0x3f) == 0x72) &&
473            iicprobe(0x00) == 0x00)
474            name = "lm93";  /* product 0x72 is the prototype */
475        else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
476            iicprobe(0x3f) == 0x68)
477            name = "lm96000";   /* adt7460 compat? */
478        else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
479            (iicprobe(0x3f) == 0x60 || iicprobe(0x3f) == 0x62))
480            name = "lm85";      /* lm85C/B == adt7460 compat */
481        else if ((addr & 0x7c) == 0x2c &&   /* addr 0b01011xx */
482            iicprobe(0x48) == addr &&
483            (iicprobe(0x3f) == 0x03 || iicprobe(0x3f) == 0x04) &&
484            (iicprobe(0x40) & 0x80) == 0x00)
485            name = "lm81";
486        break;
487    case 0x02:      /* National Semiconductor? */
488        if ((iicprobe(0x3f) & 0xfc) == 0x04)
489            name = "lm87";      /* complete check */
490        break;
491    case 0x23:      /* Analog Devices? */
492        if (iicprobe(0x48) == addr &&
493            (iicprobe(0x40) & 0x80) == 0x00 &&
494            (addr & 0x7c) == 0x2c)
495            name = "adm9240";   /* lm87 clone */
496        break;
497    case 0x41:      /* Analog Devices */
498        /*
499         * Newer chips have a valid 0x3d product number, while
500         * older ones sometimes encoded the product into the
501         * upper half of the "step register" at 0x3f.
502         */
503        if ((addr == 0x2c || addr == 0x2e || addr == 0x2f) &&
504            iicprobe(0x3d) == 0x70)
505            name = "adt7470";
506        else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
507            iicprobe(0x3d) == 0x76)
508            name = "adt7476"; /* or adt7476a */
509        else if (addr == 0x2e && iicprobe(0x3d) == 0x75)
510            name = "adt7475";
511        else if (iicprobe(0x3d) == 0x27 &&
512            (iicprobe(0x3f) == 0x60 || iicprobe(0x3f) == 0x6a))
513            name = "adm1027";   /* or adt7463 */
514        else if (iicprobe(0x3d) == 0x27 &&
515            (iicprobe(0x3f) == 0x62 || iicprobe(0x3f) == 0x6a))
516            name = "adt7460";   /* complete check */
517        else if ((addr == 0x2c || addr == 0x2e) &&
518            iicprobe(0x3d) == 0x62 && iicprobe(0x3f) == 0x04)
519            name = "adt7462";
520        else if (addr == 0x4c &&
521            iicprobe(0x3d) == 0x66 && iicprobe(0x3f) == 0x02)
522            name = "adt7466";
523        else if (addr == 0x2e &&
524            iicprobe(0x3d) == 0x68 && (iicprobe(0x3f) & 0xf0) == 0x70)
525            name = "adt7467"; /* or adt7468 */
526        else if (iicprobe(0x3d) == 0x33 && iicprobe(0x3f) == 0x02)
527            name = "adm1033";
528        else if (iicprobe(0x3d) == 0x34 && iicprobe(0x3f) == 0x02)
529            name = "adm1034";
530        else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
531            iicprobe(0x3d) == 0x30 &&
532            (iicprobe(0x01) & 0x80) == 0x00 &&
533            (iicprobe(0x0d) & 0x70) == 0x00 &&
534            (iicprobe(0x0e) & 0x70) == 0x00)
535            /*
536             * Revision 3 seems to be an adm1031 with
537             * remote diode 2 shorted.  Therefore we
538             * cannot assume the reserved/unused bits of
539             * register 0x03 and 0x06 are set to zero.
540             */
541            name = "adm1030";   /* complete check */
542        else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
543            iicprobe(0x3d) == 0x31 &&
544            (iicprobe(0x01) & 0x80) == 0x00 &&
545            (iicprobe(0x0d) & 0x70) == 0x00 &&
546            (iicprobe(0x0e) & 0x70) == 0x00 &&
547            (iicprobe(0x0f) & 0x70) == 0x00)
548            name = "adm1031";   /* complete check */
549        else if ((addr & 0x7c) == 0x2c &&   /* addr 0b01011xx */
550            (iicprobe(0x3f) & 0xf0) == 0x20 &&
551            (iicprobe(0x40) & 0x80) == 0x00 &&
552            (iicprobe(0x41) & 0xc0) == 0x00 &&
553            (iicprobe(0x42) & 0xbc) == 0x00)
554            name = "adm1025";   /* complete check */
555        else if ((addr & 0x7c) == 0x2c &&   /* addr 0b01011xx */
556            (iicprobe(0x3f) & 0xf0) == 0x10 &&
557            (iicprobe(0x40) & 0x80) == 0x00)
558            name = "adm1024";   /* complete check */
559        else if ((iicprobe(0xff) & 0xf0) == 0x30)
560            name = "adm1023";
561        else if (addr == 0x2e &&
562            (iicprobe(0x3f) & 0xf0) == 0xd0 &&
563            (iicprobe(0x40) & 0x80) == 0x00)
564            name = "adm1028";   /* adm1022 clone? */
565        else if ((addr == 0x2c || addr == 0x2e || addr == 0x2f) &&
566            (iicprobe(0x3f) & 0xf0) == 0xc0 &&
567            (iicprobe(0x40) & 0x80) == 0x00)
568            name = "adm1022";
569        break;
570    case 0x49:      /* Texas Instruments */
571        if ((addr == 0x2c || addr == 0x2e || addr == 0x2f) &&
572            (iicprobe(0x3f) & 0xf0) == 0xc0 &&
573            (iicprobe(0x40) & 0x80) == 0x00)
574            name = "thmc50";    /* adm1022 clone */
575        break;
576    case 0x55:      /* SMSC */
577        if ((addr & 0x7c) == 0x2c &&        /* addr 0b01011xx */
578            iicprobe(0x3f) == 0x20 &&
579            (iicprobe(0x47) & 0x70) == 0x00 &&
580            (iicprobe(0x49) & 0xfe) == 0x80)
581            name = "47m192";    /* adm1025 compat */
582        break;
583    case 0x5c:      /* SMSC */
584        if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
585            (iicprobe(0x3f) == 0x69))
586            name = "sch5027";
587        else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
588            (iicprobe(0x3f) & 0xf0) == 0x60)
589            name = "emc6d100";   /* emc6d101, emc6d102, emc6d103 */
590        else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
591            (iicprobe(0x3f) & 0xf0) == 0x80)
592            name = "sch5017";
593        else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
594            (iicprobe(0x3f) & 0xf0) == 0xb0)
595            name = "emc6w201";
596        break;
597    case 0x61:      /* Andigilog */
598        if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
599            iicprobe(0x3f) == 0x69 &&
600            iicprobe(0x22) >= 0xaf &&       /* Vdd */
601            (iicprobe(0x09) & 0xbf) == 0x00 && iicprobe(0x0f) == 0x00 &&
602            (iicprobe(0x40) & 0xf0) == 0x00)
603            name = "asc7611";
604        else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
605            iicprobe(0x3f) == 0x6c &&
606            iicprobe(0x22) >= 0xae)     /* Vdd */
607            name = "asc7621";
608        break;
609    case 0xa1:      /* Philips */
610        if ((iicprobe(0x3f) & 0xf0) == 0x20 &&
611            (iicprobe(0x40) & 0x80) == 0x00 &&
612            (iicprobe(0x41) & 0xc0) == 0x00 &&
613            (iicprobe(0x42) & 0xbc) == 0x00)
614            name = "ne1619";    /* adm1025 compat */
615        break;
616    case 0xda:      /* Dallas Semiconductor */
617        if (iicprobe(0x3f) == 0x01 && iicprobe(0x48) == addr &&
618            (iicprobe(0x40) & 0x80) == 0x00)
619            name = "ds1780";    /* lm87 clones */
620        break;
621    }
622
623    switch (iicprobe(0x4e)) {
624    case 0x41:      /* Analog Devices */
625        if ((addr == 0x48 || addr == 0x4a || addr == 0x4b) &&
626            (iicprobe(0x4d) == 0x03 || iicprobe(0x4d) == 0x08 ||
627            iicprobe(0x4d) == 0x07))
628            name = "adt7516";   /* adt7517, adt7519 */
629        break;
630    }
631
632    switch (iicprobe(0xfe)) {
633    case 0x01:      /* National Semiconductor */
634        if (addr == 0x4c &&
635            iicprobe(0xff) == 0x41 && (iicprobe(0x03) & 0x18) == 0 &&
636            iicprobe(0x04) <= 0x0f && (iicprobe(0xbf) & 0xf8) == 0)
637            name = "lm63";
638        else if (addr == 0x4c &&
639            iicprobe(0xff) == 0x11 && (iicprobe(0x03) & 0x2a) == 0 &&
640            iicprobe(0x04) <= 0x09 && (iicprobe(0xbf) & 0xf8) == 0)
641            name = "lm86";
642        else if (addr == 0x4c &&
643            iicprobe(0xff) == 0x31 && (iicprobe(0x03) & 0x2a) == 0 &&
644            iicprobe(0x04) <= 0x09 && (iicprobe(0xbf) & 0xf8) == 0)
645            name = "lm89";      /* or lm99 */
646        else if (addr == 0x4d &&
647            iicprobe(0xff) == 0x34 && (iicprobe(0x03) & 0x2a) == 0 &&
648            iicprobe(0x04) <= 0x09 && (iicprobe(0xbf) & 0xf8) == 0)
649            name = "lm89-1";    /* or lm99-1 */
650        else if (addr == 0x4c &&
651            iicprobe(0xff) == 0x21 && (iicprobe(0x03) & 0x2a) == 0 &&
652            iicprobe(0x04) <= 0x09 && (iicprobe(0xbf) & 0xf8) == 0)
653            name = "lm90";
654        break;
655    case 0x23:      /* Genesys Logic? */
656        if ((addr == 0x4c) &&
657            (iicprobe(0x03) & 0x3f) == 0x00 && iicprobe(0x04) <= 0x08)
658            /*
659             * Genesys Logic doesn't make the datasheet
660             * for the GL523SM publicly available, so
661             * the checks above are nothing more than a
662             * (conservative) educated guess.
663             */
664            name = "gl523sm";
665        break;
666    case 0x41:      /* Analog Devices */
667        if ((addr == 0x4c || addr == 0x4d) &&
668            iicprobe(0xff) == 0x51 &&
669            (iicprobe(0x03) & 0x1f) == 0x04 &&
670            iicprobe(0x04) <= 0x0a) {
671            /* If not in adm1032 compatibility mode. */
672            name = "adt7461";
673        } else if ((addr == 0x18 || addr == 0x19 || addr == 0x1a ||
674            addr == 0x29 || addr == 0x2a || addr == 0x2b ||
675            addr == 0x4c || addr == 0x4d || addr == 0x4e) &&
676            (iicprobe(0xff) & 0xf0) == 0x00 &&
677            (iicprobe(0x03) & 0x3f) == 0x00 &&
678            iicprobe(0x04) <= 0x07) {
679            name = "adm1021";
680            skip_fc = 1;
681        } else if ((addr == 0x18 || addr == 0x19 || addr == 0x1a ||
682            addr == 0x29 || addr == 0x2a || addr == 0x2b ||
683            addr == 0x4c || addr == 0x4d || addr == 0x4e) &&
684            (iicprobe(0xff) & 0xf0) == 0x30 &&
685            (iicprobe(0x03) & 0x3f) == 0x00 &&
686            iicprobe(0x04) <= 0x07) {
687            name = "adm1023";   /* or adm1021a */
688            skip_fc = 1;
689        } else if ((addr == 0x4c || addr == 0x4d || addr == 0x4e) &&
690            (iicprobe(0x03) & 0x3f) == 0x00 &&
691            iicprobe(0x04) <= 0x0a) {
692            name = "adm1032";   /* or adm1020 */
693            skip_fc = 1;
694        }
695        break;
696    case 0x47:      /* Global Mixed-mode Technology */
697        if (addr == 0x4c && iicprobe(0xff) == 0x01 &&
698            (iicprobe(0x03) & 0x3f) == 0x00 && iicprobe(0x04) <= 0x08)
699            name = "g781";
700        if (addr == 0x4d && iicprobe(0xff) == 0x03 &&
701            (iicprobe(0x03) & 0x3f) == 0x00 && iicprobe(0x04) <= 0x08)
702            name = "g781-1";
703        break;
704    case 0x4d:      /* Maxim */
705        if ((addr == 0x18 || addr == 0x19 || addr == 0x1a ||
706             addr == 0x29 || addr == 0x2a || addr == 0x2b ||
707             addr == 0x4c || addr == 0x4d || addr == 0x4e) &&
708            iicprobe(0xff) == 0x08 && (iicprobe(0x02) & 0x03) == 0 &&
709            (iicprobe(0x03) & 0x07) == 0 && iicprobe(0x04) <= 0x08)
710            name = "max6690";
711        else if ((addr == 0x4c || addr == 0x4d || addr == 0x4e) &&
712            iicprobe(0xff) == 0x59 && (iicprobe(0x03) & 0x1f) == 0 &&
713            iicprobe(0x04) <= 0x07)
714            name = "max6646";   /* max6647/8/9, max6692 */
715        else if ((addr == 0x4c || addr == 0x4d || addr == 0x4e) &&
716            (iicprobe(0x02) & 0x2b) == 0 &&
717            (iicprobe(0x03) & 0x0f) == 0 && iicprobe(0x04) <= 0x09) {
718            name = "max6657";   /* max6658, max6659 */
719            skip_fc = 1;
720        } else if ((addr >= 0x48 && addr <= 0x4f) &&
721            (iicprobe(0x02) & 0x2b) == 0 &&
722            (iicprobe(0x03) & 0x0f) == 0)
723            name = "max6642";
724        break;
725    case 0x55:      /* Texas Instruments */
726        if (addr == 0x4c && iicprobe(0xff) == 0x11 &&
727            (iicprobe(0x03) & 0x1b) == 0x00 &&
728            (iicprobe(0x04) & 0xf0) == 0x00 &&
729            (iicprobe(0x10) & 0x0f) == 0x00 &&
730            (iicprobe(0x13) & 0x0f) == 0x00 &&
731            (iicprobe(0x14) & 0x0f) == 0x00 &&
732            (iicprobe(0x15) & 0x0f) == 0x00 &&
733            (iicprobe(0x16) & 0x0f) == 0x00 &&
734            (iicprobe(0x17) & 0x0f) == 0x00)
735            name = "tmp401";
736        break;
737    case 0xa1:
738        if ((addr >= 0x48 && addr <= 0x4f) &&
739            iicprobe(0xff) == 0x00 &&
740            (iicprobe(0x03) & 0xf8) == 0x00 &&
741            iicprobe(0x04) <= 0x09) {
742            name = "sa56004x";  /* NXP sa56004x */
743            skip_fc = 1;
744        }
745        break;
746    }
747
748    if (addr == iicprobe(0x48) &&
749        ((iicprobe(0x4f) == 0x5c && (iicprobe(0x4e) & 0x80)) ||
750        (iicprobe(0x4f) == 0xa3 && !(iicprobe(0x4e) & 0x80)))) {
751        /*
752         * We could toggle 0x4e bit 0x80, then re-read 0x4f to
753         * see if the value changes to 0xa3 (indicating Winbond).
754         * But we are trying to avoid writes.
755         */
756        if ((iicprobe(0x4e) & 0x07) == 0) {
757            switch (iicprobe(0x58)) {
758            case 0x10:
759            case 0x11:          /* rev 2? */
760                name = "w83781d";
761                break;
762            case 0x21:
763                name = "w83627hf";
764                break;
765            case 0x30:
766                name = "w83782d";
767                break;
768            case 0x31:
769                name = "as99127f";  /* rev 2 */
770                break;
771            case 0x40:
772                name = "w83783s";
773                break;
774            case 0x71:
775                name = "w83791d";
776                break;
777            case 0x72:
778                name = "w83791sd";
779                break;
780            case 0x7a:
781                name = "w83792d";
782                break;
783            case 0xc1:
784                name = "w83627dhg";
785                break;
786            }
787        } else {
788            /*
789             * The BIOS left the chip in a non-zero
790             * register bank.  Assume it's a W83781D and
791             * let lm(4) sort out the real model.
792             */
793            name = "w83781d";
794        }
795    } else if (addr == (iicprobe(0xfc) & 0x7f) &&
796        iicprobe(0xfe) == 0x79 && iicprobe(0xfb) == 0x51 &&
797        ((iicprobe(0xfd) == 0x5c && (iicprobe(0x00) & 0x80)) ||
798        (iicprobe(0xfd) == 0xa3 && !(iicprobe(0x00) & 0x80)))) {
799        /*
800         * We could toggle 0x00 bit 0x80, then re-read 0xfd to
801         * see if the value changes to 0xa3 (indicating Nuvoton).
802         * But we are trying to avoid writes.
803         */
804        name = "w83795g";
805    } else if (addr == iicprobe(0x4a) && iicprobe(0x4e) == 0x50 &&
806        iicprobe(0x4c) == 0xa3 && iicprobe(0x4d) == 0x5c) {
807        name = "w83l784r";
808    } else if (addr == 0x2d && iicprobe(0x4e) == 0x60 &&
809        iicprobe(0x4c) == 0xa3 && iicprobe(0x4d) == 0x5c) {
810        name = "w83l785r";
811    } else if (addr == 0x2e && iicprobe(0x4e) == 0x70 &&
812        iicprobe(0x4c) == 0xa3 && iicprobe(0x4d) == 0x5c) {
813        name = "w83l785ts-l";
814    } else if (addr >= 0x2c && addr <= 0x2f &&
815        ((iicprobe(0x00) & 0x07) != 0x0 ||
816        ((iicprobe(0x00) & 0x07) == 0x0 && addr * 2 == iicprobe(0x0b) &&
817        (iicprobe(0x0c) & 0x40) && !(iicprobe(0x0c) & 0x04))) &&
818        iicprobe(0x0e) == 0x7b &&
819        (iicprobe(0x0f) & 0xf0) == 0x10 &&
820        ((iicprobe(0x0d) == 0x5c && (iicprobe(0x00) & 0x80)) ||
821        (iicprobe(0x0d) == 0xa3 && !(iicprobe(0x00) & 0x80)))) {
822        name = "w83793g";
823    } else if (addr >= 0x28 && addr <= 0x2f &&
824        iicprobe(0x4f) == 0x12 && (iicprobe(0x4e) & 0x80)) {
825        /*
826         * We could toggle 0x4e bit 0x80, then re-read 0x4f to
827         * see if the value changes to 0xc3 (indicating ASUS).
828         * But we are trying to avoid writes.
829         */
830        if (iicprobe(0x58) == 0x31)
831            name = "as99127f";  /* rev 1 */
832    } else if ((addr == 0x2d || addr == 0x2e) &&
833        addr * 2 == iicprobe(0x04) &&
834        iicprobe(0x5d) == 0x19 && iicprobe(0x5e) == 0x34 &&
835        iicprobe(0x5a) == 0x03 && iicprobe(0x5b) == 0x06) {
836        name = "f75375";    /* Fintek */
837    } else if (addr == 0x2d &&
838        ((iicprobe(0x4f) == 0x06 && (iicprobe(0x4e) & 0x80)) ||
839        (iicprobe(0x4f) == 0x94 && !(iicprobe(0x4e) & 0x80)))) {
840        /*
841         * We could toggle 0x4e bit 0x80, then re-read 0x4f to
842         * see if the value changes to 0x94 (indicating ASUS).
843         * But we are trying to avoid writes.
844         *
845         * NB. we won't match if the BIOS has selected a non-zero
846         * register bank (set via 0x4e). We could select bank 0 so
847         * we see the right registers, but that would require a
848         * write.  In general though, we bet no BIOS would leave us
849         * in the wrong state.
850         */
851        if ((iicprobe(0x58) & 0x7f) == 0x31 &&
852            (iicprobe(0x4e) & 0xf) == 0x00)
853            name = "asb100";
854    } else if ((addr == 0x2c || addr == 0x2d) &&
855        iicprobe(0x00) == 0x80 &&
856        (iicprobe(0x01) == 0x00 || iicprobe(0x01) == 0x80) &&
857        iicprobe(0x02) == 0x00 && (iicprobe(0x03) & 0x83) == 0x00 &&
858        (iicprobe(0x0f) & 0x07) == 0x00 &&
859        (iicprobe(0x11) & 0x80) == 0x00 &&
860        (iicprobe(0x12) & 0x80) == 0x00) {
861        /*
862         * The GL518SM is really crappy.  It has both byte and
863         * word registers, and reading a word register with a
864         * byte read command will make the device crap out and
865         * hang the bus.  This has nasty consequences on some
866         * machines, like preventing warm reboots.  The word
867         * registers are 0x07 through 0x0c, so make sure the
868         * checks above don't access those registers.  We
869         * don't want to do this check right up front though
870         * since this chip is somewhat hard to detect (which
871         * is why we check for every single fixed bit it has).
872         */
873        name = "gl518sm";
874    } else if ((addr == 0x2c || addr == 0x2d || addr == 0x2e) &&
875        iicprobe(0x16) == 0x41 && ((iicprobe(0x17) & 0xf0) == 0x40)) {
876        name = "adm1026";
877    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x1131 &&
878        (iicprobew(0x07) & 0xfffc) == 0xa200) {
879        name = "se97";      /* or se97b */
880    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x1131 &&
881        (iicprobew(0x07) & 0xfffc) == 0xa100 &&
882        (iicprobew(0x00) & 0xfff0) == 0x0010) {
883        name = "se98";
884    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x004d &&
885        iicprobew(0x07) == 0x3e00 &&
886        (iicprobew(0x00) & 0xffe0) == 0x0000) {
887        name = "max6604";
888    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x0054 &&
889        (iicprobew(0x07) & 0xfffc) == 0x0200 &&
890        (iicprobew(0x00) & 0xffe0) == 0x0000) {
891        name = "mcp9804";
892    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x0054 &&
893        (iicprobew(0x07) & 0xff00) == 0x0000 &&
894        (iicprobew(0x00) & 0xffe0) == 0x0000) {
895        name = "mcp9805";       /* or mcp9843 */
896    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x0054 &&
897        (iicprobew(0x07) & 0xfffc) == 0x2000 &&
898        (iicprobew(0x00) & 0xffe0) == 0x0000) {
899        name = "mcp98242";
900    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x0054 &&
901        (iicprobew(0x07) & 0xff00) == 0x2100 &&
902        (iicprobew(0x00) & 0xff00) == 0x0000) {
903        name = "mcp98243";
904    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x0054 &&
905        (iicprobew(0x07) & 0xfffc) == 0x2200 &&
906        (iicprobew(0x00) & 0xff00) == 0x0000) {
907        name = "mcp98244";
908    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x11d4 &&
909        iicprobew(0x07) == 0x0800 &&
910        iicprobew(0x00) == 0x001d) {
911        name = "adt7408";
912    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x104a &&
913        (iicprobew(0x07) & 0xfffe) == 0x0000 &&
914        (iicprobew(0x00) == 0x002d || iicprobew(0x00) == 0x002f)) {
915        name = "stts424e02";
916    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x104a &&
917        (iicprobew(0x07) & 0xfffe) == 0x0300 &&
918        (iicprobew(0x00) == 0x006f)) {
919        name = "stts2002";
920    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x104a &&
921        (iicprobew(0x07) & 0xffff) == 0x2201 &&
922        (iicprobew(0x00) == 0x00ef)) {
923        name = "stts2004";
924    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x104a &&
925        (iicprobew(0x07) & 0xffff) == 0x0200 &&
926        (iicprobew(0x00) == 0x006f)) {
927        name = "stts3000";
928    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x104a &&
929        (iicprobew(0x07) & 0xffff) == 0x0101 &&
930        (iicprobew(0x00) == 0x002d || iicprobew(0x00) == 0x002f)) {
931        name = "stts424";
932    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x1b09 &&
933        (iicprobew(0x07) & 0xffe0) == 0x0800 &&
934        (iicprobew(0x00) & 0x001f) == 0x001f) {
935        name = "cat34ts02";     /* or cat6095, prod 0x0813 */
936    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x1b09 &&
937        (iicprobew(0x07) & 0xffff) == 0x0a00 &&
938        (iicprobew(0x00) & 0x001f) == 0x001f) {
939        name = "cat34ts02c";
940    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x1b09 &&
941        (iicprobew(0x07) & 0xffff) == 0x2200 &&
942        (iicprobew(0x00) == 0x007f)) {
943        name = "cat34ts04";
944    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x00b3 &&
945        (iicprobew(0x07) & 0xffff) == 0x2903 &&
946        (iicprobew(0x00) == 0x004f)) {
947        name = "ts3000b3";      /* or tse2002b3 */
948    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x00b3 &&
949        (iicprobew(0x07) & 0xffff) == 0x2912 &&
950        (iicprobew(0x00) == 0x006f)) {
951        name = "ts3000gb2";     /* or tse2002gb2 */
952    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x00b3 &&
953        (iicprobew(0x07) & 0xffff) == 0x2913 &&
954        (iicprobew(0x00) == 0x0077)) {
955        name = "ts3000gb0";
956    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x00b3 &&
957        (iicprobew(0x07) & 0xffff) == 0x3001 &&
958        (iicprobew(0x00) == 0x006f)) {
959        name = "ts3001gb2";
960    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x00b3 &&
961        (iicprobew(0x07) & 0xffff) == 0x2214 &&
962        (iicprobew(0x00) == 0x00ff)) {
963        name = "tse2004gb2";
964    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x001f &&
965        (iicprobew(0x07) & 0xffff) == 0x8201 &&
966        (iicprobew(0x00) & 0xff00) == 0x0000) {
967        name = "at30ts00";      /* or at30tse002 */
968    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x1114 &&
969        (iicprobew(0x07) & 0xffff) == 0x2200 &&
970        (iicprobew(0x00) & 0xff00) == 0x0000) {
971        name = "at30tse004";
972    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x1c68 &&
973        (iicprobew(0x07) & 0xffff) == 0x2201 &&
974        (iicprobew(0x00) & 0xff00) == 0x0000) {
975        name = "gt30ts00";
976    } else if ((addr & 0x78) == 0x18 && iicprobew(0x06) == 0x132d &&
977        (iicprobew(0x07) & 0xffff) == 0x3300 &&
978        (iicprobew(0x00) & 0x001f) == 0x001f) {
979        name = "gt34ts02";
980    } else if ((addr & 0x7e) == 0x1c && iicprobe(0x0f) == 0x3b &&
981        (iicprobe(0x21) & 0x60) == 0x00 &&
982        iicprobe(0x0f) == iicprobe(0x8f) && /* registers address is 7 bits */
983        iicprobe(0x20) == iicprobe(0xa0) &&
984        iicprobe(0x21) == iicprobe(0xa1) &&
985        iicprobe(0x22) == iicprobe(0xa2) &&
986        iicprobe(0x07) == 0x00) {       /* 0x00 to 0x0e are reserved */
987        name = "lis331dl";
988    } else if (name == NULL &&
989        (addr & 0x78) == 0x48) {        /* addr 0b1001xxx */
990        name = lm75probe();
991    }
992#if 0
993    /*
994     * XXX This probe needs to be improved; the driver does some
995     * dangerous writes.
996     */
997    if (name == NULL && (addr & 0x7c) == 0x48 &&    /* addr 0b1001xxx */
998        (iicprobew(0xaa) & 0x0007) == 0x0000 &&
999        (iicprobew(0xa1) & 0x0007) == 0x0000 &&
1000        (iicprobew(0xa2) & 0x0007) == 0x0000 &&
1001        (iicprobe(0xac) & 0x10) == 0x00) {
1002        if ((iicprobe(0xac) & 0x7e) == 0x0a &&
1003            iicprobe(0xab) == 0x00 && iicprobe(0xa8) == 0x00)
1004            name = "ds1624";
1005        else if ((iicprobe(0xac) & 0x7e) == 0x0c)
1006            name = "ds1631";    /* terrible probe */
1007        else if ((iicprobe(0xac) & 0x2e) == 0x2e)
1008            name = "ds1721";    /* terrible probe */
1009    }
1010#endif
1011    if (name == NULL && (addr & 0xf8) == 0x28 && iicprobe(0x48) == addr &&
1012        (iicprobe(0x00) & 0x90) == 0x10 && iicprobe(0x58) == 0x90) {
1013        if (iicprobe(0x5b) == 0x12)
1014            name = "it8712";
1015        else if (iicprobe(0x5b) == 0x00)
1016            name = "it8712f-a";     /* sis950 too */
1017    }
1018
1019    if (name == NULL && iicprobe(0x48) == addr &&
1020        (iicprobe(0x40) & 0x80) == 0x00 && iicprobe(0x58) == 0xac)
1021        name = "mtp008";
1022
1023    if (name == NULL) {
1024        name = adm1032cloneprobe(addr);
1025        if (name)
1026            skip_fc = 1;
1027    }
1028
1029    return (name);
1030}
1031
1032char *
1033iic_probe_eeprom(struct device *self, u_int8_t addr)
1034{
1035    u_int8_t type;
1036    char *name = NULL;
1037
1038    type = iicprobe(0x02);
1039    /* limit to SPD types seen in the wild */
1040    if (type < 4 || type > 16)
1041        return (name);
1042
1043    /* more matching in driver(s) */
1044    name = "eeprom";
1045
1046    return (name);
1047}
1048
1049void
1050iic_scan(struct device *self, struct i2cbus_attach_args *iba)
1051{
1052    i2c_tag_t ic = iba->iba_tag;
1053    struct i2c_attach_args ia;
1054    struct iicprobelist *pl;
1055    u_int8_t cmd = 0, addr;
1056    char *name;
1057    int i, j, k;
1058
1059    bzero(ignore_addrs, sizeof(ignore_addrs));
1060
1061    for (i = 0; probes[i].probe; i++) {
1062#if NIPMI > 0
1063        extern int ipmi_enabled;
1064
1065        if ((probes[i].flags & PFLAG_SENSOR) && ipmi_enabled) {
1066            printf("%s: skipping sensors to avoid ipmi0 interactions\n",
1067                self->dv_xname);
1068            continue;
1069        }
1070#endif
1071        pl = probes[i].pl;
1072        for (j = 0; pl[j].start && pl[j].end; j++) {
1073            for (addr = pl[j].start; addr <= pl[j].end; addr++) {
1074                for (k = 0; k < sizeof(ignore_addrs); k++)
1075                    if (ignore_addrs[k] == addr)
1076                        break;
1077                if (k < sizeof(ignore_addrs))
1078                    continue;
1079
1080                /* Perform RECEIVE BYTE command */
1081                iic_acquire_bus(ic, 0);
1082                if (iic_exec(ic, I2C_OP_READ_WITH_STOP, addr,
1083                    &cmd, sizeof cmd, NULL, 0, 0) == 0) {
1084                    iic_release_bus(ic, 0);
1085
1086                    /* Some device exists */
1087                    iicprobeinit(iba, addr);
1088                    name = (*probes[i].probe)(self, addr);
1089#ifndef I2C_VERBOSE
1090                    if (name == NULL)
1091                        name = "unknown";
1092#endif /* !I2C_VERBOSE */
1093                    if (name) {
1094                        memset(&ia, 0, sizeof(ia));
1095                        ia.ia_tag = iba->iba_tag;
1096                        ia.ia_addr = addr;
1097                        ia.ia_size = 1;
1098                        ia.ia_name = name;
1099                        if (config_found(self,
1100                            &ia, iic_print))
1101                            continue;
1102                    }
1103#ifdef I2C_VERBOSE
1104                    if ((probes[i].flags & PFLAG_SENSOR))
1105                        iic_dump(self, addr, name);
1106#endif /* I2C_VERBOSE */
1107                } else
1108                    iic_release_bus(ic, 0);
1109            }
1110        }
1111    }
1112}
1113