root/lm-sensors/trunk/kernel/busses/i2c-i801.c @ 5306

Revision 5306, 18.5 KB (checked in by khali, 6 years ago)

Dumping the register values before and after every transaction was
useful during driver development but now it's only spamming the log.
Backport from Linux 2.6.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*
2    i2c-i801.c - Part of lm_sensors, Linux kernel modules for hardware
3              monitoring
4    Copyright (c) 1998 - 2002  Frodo Looijaard <frodol@dds.nl>,
5    Philip Edelbrock <phil@netroedge.com>, and Mark D. Studebaker
6    <mdsxyz123@yahoo.com>
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21*/
22
23/*
24    SUPPORTED DEVICES   PCI ID
25    82801AA             2413
26    82801AB             2423
27    82801BA             2443
28    82801CA/CAM         2483
29    82801DB             24C3   (HW PEC supported, 32 byte buffer not supported)
30    82801EB             24D3   (HW PEC supported, 32 byte buffer not supported)
31    6300ESB             25A4   ("")
32    ICH6                266A   ("")
33    ICH7                27DA   ("")
34    ESB2                269B   ("")
35    ICH8                283E   ("")
36    ICH9                2930   ("")
37    Tolapai             5032   ("")
38    ICH10               3A30   ("")
39    ICH10               3A60   ("")
40
41    This driver supports several versions of Intel's I/O Controller Hubs (ICH).
42    For SMBus support, they are similar to the PIIX4 and are part
43    of Intel's '810' and other chipsets.
44    See the doc/busses/i2c-i801 file for details.
45    I2C Block Read not supported.
46    Block Process Call are not supported.
47*/
48
49/* Note: we assume there can only be one I801, with one SMBus interface */
50
51/* #define DEBUG 1 */
52
53#include <linux/module.h>
54#include <linux/pci.h>
55#include <linux/kernel.h>
56#include <linux/stddef.h>
57#include <linux/sched.h>
58#include <linux/ioport.h>
59#include <linux/init.h>
60#include <linux/i2c.h>
61#include <asm/io.h>
62#include "version.h"
63#include "sensors_compat.h"
64
65/* 82801CA is undefined before kernel 2.4.13 */
66#ifndef PCI_DEVICE_ID_INTEL_82801CA_3
67#define PCI_DEVICE_ID_INTEL_82801CA_3   0x2483
68#endif
69
70/* 82801DB is undefined before kernel 2.4.19 */
71#ifndef PCI_DEVICE_ID_INTEL_82801DB_3
72#define PCI_DEVICE_ID_INTEL_82801DB_3   0x24c3
73#endif
74
75/* 82801EB is undefined before kernel 2.4.21 */
76#ifndef PCI_DEVICE_ID_INTEL_82801EB_3
77#define PCI_DEVICE_ID_INTEL_82801EB_3   0x24d3
78#endif
79
80/* ESB is undefined before kernel 2.4.22 */
81#ifndef PCI_DEVICE_ID_INTEL_ESB_4
82#define PCI_DEVICE_ID_INTEL_ESB_4       0x25a4
83#endif
84
85/* ESB2 - Enterprise Southbridge is undefined */
86#ifndef PCI_DEVICE_ID_INTEL_ESB2_17
87#define PCI_DEVICE_ID_INTEL_ESB2_17     0x269b
88#endif
89
90/* ICH6 is undefined */
91#ifndef PCI_DEVICE_ID_INTEL_ICH6_16
92#define PCI_DEVICE_ID_INTEL_ICH6_16     0x266a
93#endif
94
95/* ICH7 is undefined */
96#ifndef PCI_DEVICE_ID_INTEL_ICH7_17
97#define PCI_DEVICE_ID_INTEL_ICH7_17     0x27da
98#endif
99
100/* ICH8 is undefined */
101#ifndef PCI_DEVICE_ID_INTEL_ICH8_5
102#define PCI_DEVICE_ID_INTEL_ICH8_5      0x283e
103#endif
104
105/* ICH9 is undefined */
106#ifndef PCI_DEVICE_ID_INTEL_ICH9_6
107#define PCI_DEVICE_ID_INTEL_ICH9_6      0x2930
108#endif
109
110#ifndef PCI_DEVICE_ID_INTEL_TOLAPAI_1
111#define PCI_DEVICE_ID_INTEL_TOLAPAI_1   0x5032
112#endif
113
114#ifndef PCI_DEVICE_ID_INTEL_ICH10_4
115#define PCI_DEVICE_ID_INTEL_ICH10_4     0x3a30
116#endif
117
118#ifndef PCI_DEVICE_ID_INTEL_ICH10_5
119#define PCI_DEVICE_ID_INTEL_ICH10_5     0x3a60
120#endif
121
122#ifdef I2C_CLIENT_PEC
123#define HAVE_PEC
124#endif
125
126/* I801 SMBus address offsets */
127#define SMBHSTSTS       (0 + i801_smba)
128#define SMBHSTCNT       (2 + i801_smba)
129#define SMBHSTCMD       (3 + i801_smba)
130#define SMBHSTADD       (4 + i801_smba)
131#define SMBHSTDAT0      (5 + i801_smba)
132#define SMBHSTDAT1      (6 + i801_smba)
133#define SMBBLKDAT       (7 + i801_smba)
134#define SMBPEC          (8 + i801_smba) /* ICH4 only */
135#define SMBAUXSTS       (12 + i801_smba)        /* ICH4 only */
136#define SMBAUXCTL       (13 + i801_smba)        /* ICH4 only */
137
138/* PCI Address Constants */
139#define SMBBA           0x020
140#define SMBHSTCFG       0x040
141#define SMBREV          0x008
142
143/* Host configuration bits for SMBHSTCFG */
144#define SMBHSTCFG_HST_EN        1
145#define SMBHSTCFG_SMB_SMI_EN    2
146#define SMBHSTCFG_I2C_EN        4
147
148/* Other settings */
149#define MAX_TIMEOUT             100
150#define ENABLE_INT9             0       /* set to 0x01 to enable - untested */
151
152/* I801 command constants */
153#define I801_QUICK              0x00
154#define I801_BYTE               0x04
155#define I801_BYTE_DATA          0x08
156#define I801_WORD_DATA          0x0C
157#define I801_PROC_CALL          0x10    /* later chips only, unimplemented */
158#define I801_BLOCK_DATA         0x14
159#define I801_I2C_BLOCK_DATA     0x18    /* unimplemented */
160#define I801_BLOCK_LAST         0x34
161#define I801_I2C_BLOCK_LAST     0x38    /* unimplemented */
162#define I801_START              0x40
163#define I801_PEC_EN             0x80    /* ich4 and later */
164
165/* insmod parameters */
166
167/* If force_addr is set to anything different from 0, we forcibly enable
168   the I801 at the given address. VERY DANGEROUS! */
169static int force_addr = 0;
170MODULE_PARM(force_addr, "i");
171MODULE_PARM_DESC(force_addr,
172                 "Forcibly enable the I801 at the given address. "
173                 "EXTREMELY DANGEROUS!");
174
175static unsigned short i801_smba;
176static struct pci_driver i801_driver;
177static struct pci_dev *I801_dev;
178static int isich4;      /* is PEC supported? */
179
180static int __devinit i801_setup(struct pci_dev *dev)
181{
182        unsigned char temp;
183
184        I801_dev = dev;
185        if (dev->device == PCI_DEVICE_ID_INTEL_82801DB_3 ||
186            dev->device == PCI_DEVICE_ID_INTEL_82801EB_3 ||
187            dev->device == PCI_DEVICE_ID_INTEL_ESB_4 ||
188            dev->device == PCI_DEVICE_ID_INTEL_ESB2_17 ||
189            dev->device == PCI_DEVICE_ID_INTEL_ICH6_16 ||
190            dev->device == PCI_DEVICE_ID_INTEL_ICH7_17 ||
191            dev->device == PCI_DEVICE_ID_INTEL_ICH8_5 ||
192            dev->device == PCI_DEVICE_ID_INTEL_ICH9_6 ||
193            dev->device == PCI_DEVICE_ID_INTEL_TOLAPAI_1 ||
194            dev->device == PCI_DEVICE_ID_INTEL_ICH10_4 ||
195            dev->device == PCI_DEVICE_ID_INTEL_ICH10_5)
196                isich4 = 1;
197        else
198                isich4 = 0;
199
200        /* Determine the address of the SMBus area */
201        if (force_addr) {
202                i801_smba = force_addr & 0xfff0;
203        } else {
204                pci_read_config_word(I801_dev, SMBBA, &i801_smba);
205                i801_smba &= 0xfff0;
206                if(i801_smba == 0) {
207                        dev_err(dev, "SMB base address uninitialized "
208                                "- upgrade BIOS or use force_addr=0xaddr\n");
209                        return -ENODEV;
210                }
211        }
212
213        if (!request_region(i801_smba, (isich4 ? 16 : 8), i801_driver.name)) {
214                dev_err(dev, "I801_smb region 0x%x already in use!\n",
215                        i801_smba);
216                return -EBUSY;
217        }
218
219        pci_read_config_byte(I801_dev, SMBHSTCFG, &temp);
220        temp &= ~SMBHSTCFG_I2C_EN;      /* SMBus timing */
221        pci_write_config_byte(I801_dev, SMBHSTCFG, temp);
222
223        /* If force_addr is set, we program the new address here. Just to make
224           sure, we disable the device first. */
225        if (force_addr) {
226                pci_write_config_byte(I801_dev, SMBHSTCFG,
227                                      temp & ~SMBHSTCFG_HST_EN);
228                pci_write_config_word(I801_dev, SMBBA, i801_smba);
229                pci_write_config_byte(I801_dev, SMBHSTCFG,
230                                      temp | SMBHSTCFG_HST_EN);
231                dev_warn(dev, "WARNING: I801 SMBus interface set to "
232                        "new address %04x!\n", i801_smba);
233        } else if (!(temp & SMBHSTCFG_HST_EN)) {
234                pci_write_config_byte(I801_dev, SMBHSTCFG,
235                                      temp | SMBHSTCFG_HST_EN);
236                dev_warn(dev, "enabling SMBus device\n");
237        }
238
239        if (temp & SMBHSTCFG_SMB_SMI_EN)
240                dev_dbg(dev, "I801 using Interrupt SMI# for SMBus.\n");
241        else
242                dev_dbg(dev, "I801 using PCI Interrupt for SMBus.\n");
243
244        pci_read_config_byte(I801_dev, SMBREV, &temp);
245        dev_dbg(dev, "SMBREV = 0x%X\n", temp);
246        dev_dbg(dev, "I801_smba = 0x%X\n", i801_smba);
247
248        return 0;
249}
250
251
252static int i801_transaction(void)
253{
254        int temp;
255        int result = 0;
256        int timeout = 0;
257
258        /* Make sure the SMBus host is ready to start transmitting */
259        /* 0x1f = Failed, Bus_Err, Dev_Err, Intr, Host_Busy */
260        if ((temp = (0x1f & inb_p(SMBHSTSTS))) != 0x00) {
261                dev_dbg(I801_dev, "SMBus busy (%02x). Resetting...\n",
262                        temp);
263                outb_p(temp, SMBHSTSTS);
264                if ((temp = (0x1f & inb_p(SMBHSTSTS))) != 0x00) {
265                        dev_dbg(I801_dev, "Failed! (%02x)\n", temp);
266                        return -1;
267                } else {
268                        dev_dbg(I801_dev, "Successful!\n");
269                }
270        }
271
272        outb_p(inb(SMBHSTCNT) | I801_START, SMBHSTCNT);
273
274        /* We will always wait for a fraction of a second! */
275        do {
276                i2c_delay(1);
277                temp = inb_p(SMBHSTSTS);
278        } while ((temp & 0x01) && (timeout++ < MAX_TIMEOUT));
279
280        /* If the SMBus is still busy, we give up */
281        if (timeout >= MAX_TIMEOUT) {
282                dev_dbg(I801_dev, "SMBus Timeout!\n");
283                result = -1;
284        }
285
286        if (temp & 0x10) {
287                result = -1;
288                dev_dbg(I801_dev, "Error: Failed bus transaction\n");
289        }
290
291        if (temp & 0x08) {
292                result = -1;
293                dev_err(I801_dev, "Bus collision! SMBus may be locked "
294                        "until next hard reset. (sorry!)\n");
295                /* Clock stops and slave is stuck in mid-transmission */
296        }
297
298        if (temp & 0x04) {
299                result = -1;
300                dev_dbg(I801_dev, "Error: no response!\n");
301        }
302
303        if ((inb_p(SMBHSTSTS) & 0x1f) != 0x00)
304                outb_p(inb(SMBHSTSTS), SMBHSTSTS);
305
306        if ((temp = (0x1f & inb_p(SMBHSTSTS))) != 0x00) {
307                dev_dbg(I801_dev, "Failed reset at end of transaction "
308                        "(%02x)\n", temp);
309        }
310        return result;
311}
312
313/* All-inclusive block transaction function */
314static int i801_block_transaction(union i2c_smbus_data *data, char read_write,
315                                  int command, int hwpec)
316{
317        int i, len;
318        int smbcmd;
319        int temp;
320        int result = 0;
321        int timeout;
322        unsigned char hostc, errmask;
323
324        if (command == I2C_SMBUS_I2C_BLOCK_DATA) {
325                if (read_write == I2C_SMBUS_WRITE) {
326                        /* set I2C_EN bit in configuration register */
327                        pci_read_config_byte(I801_dev, SMBHSTCFG, &hostc);
328                        pci_write_config_byte(I801_dev, SMBHSTCFG,
329                                              hostc | SMBHSTCFG_I2C_EN);
330                } else {
331                        dev_err(I801_dev,
332                                "I2C_SMBUS_I2C_BLOCK_READ unsupported!\n");
333                        return -1;
334                }
335        }
336
337        if (read_write == I2C_SMBUS_WRITE) {
338                len = data->block[0];
339                if (len < 1)
340                        len = 1;
341                if (len > I2C_SMBUS_BLOCK_MAX)
342                        len = I2C_SMBUS_BLOCK_MAX;
343                outb_p(len, SMBHSTDAT0);
344                outb_p(data->block[1], SMBBLKDAT);
345        } else {
346                len = 32;       /* max for reads */
347        }
348
349        for (i = 1; i <= len; i++) {
350                if (i == len && read_write == I2C_SMBUS_READ)
351                        smbcmd = I801_BLOCK_LAST;
352                else
353                        smbcmd = I801_BLOCK_DATA;
354                outb_p(smbcmd | ENABLE_INT9, SMBHSTCNT);
355
356                /* Make sure the SMBus host is ready to start transmitting */
357                temp = inb_p(SMBHSTSTS);
358                if (i == 1) {
359                        /* Erroneous conditions before transaction:
360                         * Byte_Done, Failed, Bus_Err, Dev_Err, Intr, Host_Busy */
361                        errmask = 0x9f;
362                } else {
363                        /* Erroneous conditions during transaction:
364                         * Failed, Bus_Err, Dev_Err, Intr */
365                        errmask = 0x1e;
366                }
367                if (temp & errmask) {
368                        dev_dbg(I801_dev, "SMBus busy (%02x). "
369                                "Resetting...\n", temp);
370                        outb_p(temp, SMBHSTSTS);
371                        if (((temp = inb_p(SMBHSTSTS)) & errmask) != 0x00) {
372                                dev_err(I801_dev,
373                                        "Reset failed! (%02x)\n", temp);
374                                result = -1;
375                                goto END;
376                        }
377                        if (i != 1) {
378                                /* if die in middle of block transaction, fail */
379                                result = -1;
380                                goto END;
381                        }
382                }
383
384                if (i == 1)
385                        outb_p(inb(SMBHSTCNT) | I801_START, SMBHSTCNT);
386
387                /* We will always wait for a fraction of a second! */
388                timeout = 0;
389                do {
390                        i2c_delay(1);
391                        temp = inb_p(SMBHSTSTS);
392                }
393                while ((!(temp & 0x80))
394                       && (timeout++ < MAX_TIMEOUT));
395
396                /* If the SMBus is still busy, we give up */
397                if (timeout >= MAX_TIMEOUT) {
398                        result = -1;
399                        dev_dbg(I801_dev, "SMBus Timeout!\n");
400                }
401
402                if (temp & 0x10) {
403                        result = -1;
404                        dev_dbg(I801_dev,
405                                "Error: Failed bus transaction\n");
406                } else if (temp & 0x08) {
407                        result = -1;
408                        dev_err(I801_dev, "Bus collision!\n");
409                } else if (temp & 0x04) {
410                        result = -1;
411                        dev_dbg(I801_dev, "Error: no response!\n");
412                }
413
414                if (i == 1 && read_write == I2C_SMBUS_READ) {
415                        len = inb_p(SMBHSTDAT0);
416                        if (len < 1)
417                                len = 1;
418                        if (len > I2C_SMBUS_BLOCK_MAX)
419                                len = I2C_SMBUS_BLOCK_MAX;
420                        data->block[0] = len;
421                }
422
423                /* Retrieve/store value in SMBBLKDAT */
424                if (read_write == I2C_SMBUS_READ)
425                        data->block[i] = inb_p(SMBBLKDAT);
426                if (read_write == I2C_SMBUS_WRITE && i+1 <= len)
427                        outb_p(data->block[i+1], SMBBLKDAT);
428                if ((temp & 0x9e) != 0x00)
429                        outb_p(temp, SMBHSTSTS);  /* signals SMBBLKDAT ready */
430
431                if ((temp = (0x1e & inb_p(SMBHSTSTS))) != 0x00) {
432                        dev_dbg(I801_dev,
433                                "Bad status (%02x) at end of transaction\n",
434                                temp);
435                }
436
437                if (result < 0)
438                        goto END;
439        }
440
441        if (hwpec) {
442                /* wait for INTR bit as advised by Intel */
443                timeout = 0;
444                do {
445                        i2c_delay(1);
446                        temp = inb_p(SMBHSTSTS);
447                } while ((!(temp & 0x02))
448                           && (timeout++ < MAX_TIMEOUT));
449
450                if (timeout >= MAX_TIMEOUT) {
451                        dev_dbg(I801_dev, "PEC Timeout!\n");
452                }
453                outb_p(temp, SMBHSTSTS);
454        }
455        result = 0;
456END:
457        if (command == I2C_SMBUS_I2C_BLOCK_DATA &&
458            read_write == I2C_SMBUS_WRITE) {
459                /* restore saved configuration register value */
460                pci_write_config_byte(I801_dev, SMBHSTCFG, hostc);
461        }
462        return result;
463}
464
465/* Return -1 on error. */
466static s32 i801_access(struct i2c_adapter * adap, u16 addr,
467                       unsigned short flags, char read_write, u8 command,
468                       int size, union i2c_smbus_data * data)
469{
470        int hwpec = 0;
471        int block = 0;
472        int ret, xact = 0;
473
474#ifdef HAVE_PEC
475        hwpec = isich4 && (flags & I2C_CLIENT_PEC)
476                && size != I2C_SMBUS_QUICK
477                && size != I2C_SMBUS_I2C_BLOCK_DATA;
478#endif
479
480        switch (size) {
481        case I2C_SMBUS_QUICK:
482                outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
483                       SMBHSTADD);
484                xact = I801_QUICK;
485                break;
486        case I2C_SMBUS_BYTE:
487                outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
488                       SMBHSTADD);
489                if (read_write == I2C_SMBUS_WRITE)
490                        outb_p(command, SMBHSTCMD);
491                xact = I801_BYTE;
492                break;
493        case I2C_SMBUS_BYTE_DATA:
494                outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
495                       SMBHSTADD);
496                outb_p(command, SMBHSTCMD);
497                if (read_write == I2C_SMBUS_WRITE)
498                        outb_p(data->byte, SMBHSTDAT0);
499                xact = I801_BYTE_DATA;
500                break;
501        case I2C_SMBUS_WORD_DATA:
502                outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
503                       SMBHSTADD);
504                outb_p(command, SMBHSTCMD);
505                if (read_write == I2C_SMBUS_WRITE) {
506                        outb_p(data->word & 0xff, SMBHSTDAT0);
507                        outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
508                }
509                xact = I801_WORD_DATA;
510                break;
511        case I2C_SMBUS_BLOCK_DATA:
512        case I2C_SMBUS_I2C_BLOCK_DATA:
513                outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
514                       SMBHSTADD);
515                outb_p(command, SMBHSTCMD);
516                block = 1;
517                break;
518        case I2C_SMBUS_PROC_CALL:
519        default:
520                dev_err(I801_dev, "Unsupported transaction %d\n", size);
521                return -1;
522        }
523
524        outb_p(hwpec, SMBAUXCTL);       /* enable/disable hardware PEC */
525
526        if(block)
527                ret = i801_block_transaction(data, read_write, size, hwpec);
528        else {
529                outb_p(xact | ENABLE_INT9, SMBHSTCNT);
530                ret = i801_transaction();
531        }
532
533        /* Some BIOSes don't like it when PEC is enabled at reboot or resume
534           time, so we forcibly disable it after every transaction. */
535        if (hwpec)
536                outb_p(0, SMBAUXCTL);
537
538        if(block)
539                return ret;
540        if(ret)
541                return -1;
542        if ((read_write == I2C_SMBUS_WRITE) || (xact == I801_QUICK))
543                return 0;
544
545        switch (xact & 0x7f) {
546        case I801_BYTE: /* Result put in SMBHSTDAT0 */
547        case I801_BYTE_DATA:
548                data->byte = inb_p(SMBHSTDAT0);
549                break;
550        case I801_WORD_DATA:
551                data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
552                break;
553        }
554        return 0;
555}
556
557static void i801_inc(struct i2c_adapter *adapter)
558{
559#ifdef MODULE
560        MOD_INC_USE_COUNT;
561#endif
562}
563
564static void i801_dec(struct i2c_adapter *adapter)
565{
566#ifdef MODULE
567        MOD_DEC_USE_COUNT;
568#endif
569}
570
571static u32 i801_func(struct i2c_adapter *adapter)
572{
573        return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
574            I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
575            I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_WRITE_I2C_BLOCK
576#ifdef HAVE_PEC
577             | (isich4 ? I2C_FUNC_SMBUS_HWPEC_CALC : 0)
578#endif
579            ;
580}
581
582static struct i2c_algorithm smbus_algorithm = {
583        .name           = "Non-I2C SMBus adapter",
584        .id             = I2C_ALGO_SMBUS,
585        .smbus_xfer     = i801_access,
586        .functionality  = i801_func,
587};
588
589static struct i2c_adapter i801_adapter = {
590        .id             = I2C_ALGO_SMBUS | I2C_HW_SMBUS_I801,
591        .algo           = &smbus_algorithm,
592        .inc_use        = i801_inc,
593        .dec_use        = i801_dec,
594};
595
596static struct pci_device_id i801_ids[] __devinitdata = {
597        {
598                .vendor =       PCI_VENDOR_ID_INTEL,
599                .device =       PCI_DEVICE_ID_INTEL_82801AA_3,
600                .subvendor =    PCI_ANY_ID,
601                .subdevice =    PCI_ANY_ID,
602        },
603        {
604                .vendor =       PCI_VENDOR_ID_INTEL,
605                .device =       PCI_DEVICE_ID_INTEL_82801AB_3,
606                .subvendor =    PCI_ANY_ID,
607                .subdevice =    PCI_ANY_ID,
608        },
609        {
610                .vendor =       PCI_VENDOR_ID_INTEL,
611                .device =       PCI_DEVICE_ID_INTEL_82801BA_2,
612                .subvendor =    PCI_ANY_ID,
613                .subdevice =    PCI_ANY_ID,
614        },
615        {
616                .vendor =       PCI_VENDOR_ID_INTEL,
617                .device =       PCI_DEVICE_ID_INTEL_82801CA_3,
618                .subvendor =    PCI_ANY_ID,
619                .subdevice =    PCI_ANY_ID,
620        },
621        {
622                .vendor =       PCI_VENDOR_ID_INTEL,
623                .device =       PCI_DEVICE_ID_INTEL_82801DB_3,
624                .subvendor =    PCI_ANY_ID,
625                .subdevice =    PCI_ANY_ID,
626        },
627        {
628                .vendor =       PCI_VENDOR_ID_INTEL,
629                .device =       PCI_DEVICE_ID_INTEL_82801EB_3,
630                .subvendor =    PCI_ANY_ID,
631                .subdevice =    PCI_ANY_ID,
632        },
633        {
634                .vendor =       PCI_VENDOR_ID_INTEL,
635                .device =       PCI_DEVICE_ID_INTEL_ESB_4,
636                .subvendor =    PCI_ANY_ID,
637                .subdevice =    PCI_ANY_ID,
638        },
639        {
640                .vendor =       PCI_VENDOR_ID_INTEL,
641                .device =       PCI_DEVICE_ID_INTEL_ESB2_17,
642                .subvendor =    PCI_ANY_ID,
643                .subdevice =    PCI_ANY_ID,
644        },
645        {
646                .vendor =       PCI_VENDOR_ID_INTEL,
647                .device =       PCI_DEVICE_ID_INTEL_ICH6_16,
648                .subvendor =    PCI_ANY_ID,
649                .subdevice =    PCI_ANY_ID,
650        },
651        {
652                .vendor =       PCI_VENDOR_ID_INTEL,
653                .device =       PCI_DEVICE_ID_INTEL_ICH7_17,
654                .subvendor =    PCI_ANY_ID,
655                .subdevice =    PCI_ANY_ID,
656        },
657        {
658                .vendor =       PCI_VENDOR_ID_INTEL,
659                .device =       PCI_DEVICE_ID_INTEL_ICH8_5,
660                .subvendor =    PCI_ANY_ID,
661                .subdevice =    PCI_ANY_ID,
662        },
663        {
664                .vendor =       PCI_VENDOR_ID_INTEL,
665                .device =       PCI_DEVICE_ID_INTEL_ICH9_6,
666                .subvendor =    PCI_ANY_ID,
667                .subdevice =    PCI_ANY_ID,
668        },
669        {
670                .vendor =       PCI_VENDOR_ID_INTEL,
671                .device =       PCI_DEVICE_ID_INTEL_TOLAPAI_1,
672                .subvendor =    PCI_ANY_ID,
673                .subdevice =    PCI_ANY_ID,
674        },
675        {
676                .vendor =       PCI_VENDOR_ID_INTEL,
677                .device =       PCI_DEVICE_ID_INTEL_ICH10_4,
678                .subvendor =    PCI_ANY_ID,
679                .subdevice =    PCI_ANY_ID,
680        },
681        {
682                .vendor =       PCI_VENDOR_ID_INTEL,
683                .device =       PCI_DEVICE_ID_INTEL_ICH10_5,
684                .subvendor =    PCI_ANY_ID,
685                .subdevice =    PCI_ANY_ID,
686        },
687        { 0, }
688};
689
690static int __devinit i801_probe(struct pci_dev *dev, const struct pci_device_id *id)
691{
692        int err;
693
694        if ((err = i801_setup(dev)))
695                return err;
696
697        snprintf(i801_adapter.name, 32,
698                "SMBus I801 adapter at %04x", i801_smba);
699        return i2c_add_adapter(&i801_adapter);
700}
701
702static void __devexit i801_remove(struct pci_dev *dev)
703{
704        i2c_del_adapter(&i801_adapter);
705        release_region(i801_smba, (isich4 ? 16 : 8));
706}
707
708static struct pci_driver i801_driver = {
709        .name           = "i801 smbus",
710        .id_table       = i801_ids,
711        .probe          = i801_probe,
712        .remove         = __devexit_p(i801_remove),
713};
714
715static int __init i2c_i801_init(void)
716{
717        printk(KERN_INFO "i2c-i801 version %s (%s)\n", LM_VERSION, LM_DATE);
718        return pci_module_init(&i801_driver);
719}
720
721static void __exit i2c_i801_exit(void)
722{
723        pci_unregister_driver(&i801_driver);
724}
725
726MODULE_AUTHOR ("Frodo Looijaard <frodol@dds.nl>, "
727                "Philip Edelbrock <phil@netroedge.com>, "
728                "and Mark D. Studebaker <mdsxyz123@yahoo.com>");
729MODULE_DESCRIPTION("I801 SMBus driver");
730MODULE_LICENSE("GPL");
731
732module_init(i2c_i801_init);
733module_exit(i2c_i801_exit);
Note: See TracBrowser for help on using the browser.