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

Revision 4059, 19.0 KB (checked in by khali, 8 years ago)

i2c-i801: Fix block transaction poll loops

Two of the three poll loops have the poll and sleep swapped,
causing an extra sleep to occur after the polled condition is
fulfilled. In practice, this doubles the amount of sleep time for
every block transaction.

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