?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fs: use kmem_cache_zalloc instead
[pv_ops_mirror.git] / drivers / i2c / busses / i2c-i801.c
blobac27e5f84ebe2ef60aef3fb40427ec7232ef744a
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)
30 82801EB 24D3 (HW PEC supported)
31 6300ESB 25A4
32 ICH6 266A
33 ICH7 27DA
34 ESB2 269B
35 ICH8 283E
36 ICH9 2930
37 Tolapai 5032
38 This driver supports several versions of Intel's I/O Controller Hubs (ICH).
39 For SMBus support, they are similar to the PIIX4 and are part
40 of Intel's '810' and other chipsets.
41 See the file Documentation/i2c/busses/i2c-i801 for details.
42 I2C Block Read and Process Call are not supported.
43 */
44
45 /* Note: we assume there can only be one I801, with one SMBus interface */
46
47 #include <linux/module.h>
48 #include <linux/pci.h>
49 #include <linux/kernel.h>
50 #include <linux/stddef.h>
51 #include <linux/delay.h>
52 #include <linux/ioport.h>
53 #include <linux/init.h>
54 #include <linux/i2c.h>
55 #include <asm/io.h>
56
57 /* I801 SMBus address offsets */
58 #define SMBHSTSTS (0 + i801_smba)
59 #define SMBHSTCNT (2 + i801_smba)
60 #define SMBHSTCMD (3 + i801_smba)
61 #define SMBHSTADD (4 + i801_smba)
62 #define SMBHSTDAT0 (5 + i801_smba)
63 #define SMBHSTDAT1 (6 + i801_smba)
64 #define SMBBLKDAT (7 + i801_smba)
65 #define SMBPEC (8 + i801_smba) /* ICH4 only */
66 #define SMBAUXSTS (12 + i801_smba) /* ICH4 only */
67 #define SMBAUXCTL (13 + i801_smba) /* ICH4 only */
68
69 /* PCI Address Constants */
70 #define SMBBAR 4
71 #define SMBHSTCFG 0x040
72
73 /* Host configuration bits for SMBHSTCFG */
74 #define SMBHSTCFG_HST_EN 1
75 #define SMBHSTCFG_SMB_SMI_EN 2
76 #define SMBHSTCFG_I2C_EN 4
77
78 /* Auxillary control register bits, ICH4+ only */
79 #define SMBAUXCTL_CRC 1
80 #define SMBAUXCTL_E32B 2
81
82 /* kill bit for SMBHSTCNT */
83 #define SMBHSTCNT_KILL 2
84
85 /* Other settings */
86 #define MAX_TIMEOUT 100
87 #define ENABLE_INT9 0 /* set to 0x01 to enable - untested */
88
89 /* I801 command constants */
90 #define I801_QUICK 0x00
91 #define I801_BYTE 0x04
92 #define I801_BYTE_DATA 0x08
93 #define I801_WORD_DATA 0x0C
94 #define I801_PROC_CALL 0x10 /* later chips only, unimplemented */
95 #define I801_BLOCK_DATA 0x14
96 #define I801_I2C_BLOCK_DATA 0x18 /* unimplemented */
97 #define I801_BLOCK_LAST 0x34
98 #define I801_I2C_BLOCK_LAST 0x38 /* unimplemented */
99 #define I801_START 0x40
100 #define I801_PEC_EN 0x80 /* ICH4 only */
101
102 /* I801 Hosts Status register bits */
103 #define SMBHSTSTS_BYTE_DONE 0x80
104 #define SMBHSTSTS_INUSE_STS 0x40
105 #define SMBHSTSTS_SMBALERT_STS 0x20
106 #define SMBHSTSTS_FAILED 0x10
107 #define SMBHSTSTS_BUS_ERR 0x08
108 #define SMBHSTSTS_DEV_ERR 0x04
109 #define SMBHSTSTS_INTR 0x02
110 #define SMBHSTSTS_HOST_BUSY 0x01
111
112 static unsigned long i801_smba;
113 static unsigned char i801_original_hstcfg;
114 static struct pci_driver i801_driver;
115 static struct pci_dev *I801_dev;
116 static int isich4;
117
118 static int i801_transaction(int xact)
119 {
120 int temp;
121 int result = 0;
122 int timeout = 0;
123
124 dev_dbg(&I801_dev->dev, "Transaction (pre): CNT=%02x, CMD=%02x, "
125 "ADD=%02x, DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTCNT),
126 inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
127 inb_p(SMBHSTDAT1));
128
129 /* Make sure the SMBus host is ready to start transmitting */
130 /* 0x1f = Failed, Bus_Err, Dev_Err, Intr, Host_Busy */
131 if ((temp = (0x1f & inb_p(SMBHSTSTS))) != 0x00) {
132 dev_dbg(&I801_dev->dev, "SMBus busy (%02x). Resetting...\n",
133 temp);
134 outb_p(temp, SMBHSTSTS);
135 if ((temp = (0x1f & inb_p(SMBHSTSTS))) != 0x00) {
136 dev_dbg(&I801_dev->dev, "Failed! (%02x)\n", temp);
137 return -1;
138 } else {
139 dev_dbg(&I801_dev->dev, "Successful!\n");
140 }
141 }
142
143 /* the current contents of SMBHSTCNT can be overwritten, since PEC,
144 * INTREN, SMBSCMD are passed in xact */
145 outb_p(xact | I801_START, SMBHSTCNT);
146
147 /* We will always wait for a fraction of a second! */
148 do {
149 msleep(1);
150 temp = inb_p(SMBHSTSTS);
151 } while ((temp & SMBHSTSTS_HOST_BUSY) && (timeout++ < MAX_TIMEOUT));
152
153 /* If the SMBus is still busy, we give up */
154 if (timeout >= MAX_TIMEOUT) {
155 dev_dbg(&I801_dev->dev, "SMBus Timeout!\n");
156 result = -1;
157 /* try to stop the current command */
158 dev_dbg(&I801_dev->dev, "Terminating the current operation\n");
159 outb_p(inb_p(SMBHSTCNT) | SMBHSTCNT_KILL, SMBHSTCNT);
160 msleep(1);
161 outb_p(inb_p(SMBHSTCNT) & (~SMBHSTCNT_KILL), SMBHSTCNT);
162 }
163
164 if (temp & SMBHSTSTS_FAILED) {
165 result = -1;
166 dev_dbg(&I801_dev->dev, "Error: Failed bus transaction\n");
167 }
168
169 if (temp & SMBHSTSTS_BUS_ERR) {
170 result = -1;
171 dev_err(&I801_dev->dev, "Bus collision! SMBus may be locked "
172 "until next hard reset. (sorry!)\n");
173 /* Clock stops and slave is stuck in mid-transmission */
174 }
175
176 if (temp & SMBHSTSTS_DEV_ERR) {
177 result = -1;
178 dev_dbg(&I801_dev->dev, "Error: no response!\n");
179 }
180
181 if ((inb_p(SMBHSTSTS) & 0x1f) != 0x00)
182 outb_p(inb(SMBHSTSTS), SMBHSTSTS);
183
184 if ((temp = (0x1f & inb_p(SMBHSTSTS))) != 0x00) {
185 dev_dbg(&I801_dev->dev, "Failed reset at end of transaction "
186 "(%02x)\n", temp);
187 }
188 dev_dbg(&I801_dev->dev, "Transaction (post): CNT=%02x, CMD=%02x, "
189 "ADD=%02x, DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTCNT),
190 inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
191 inb_p(SMBHSTDAT1));
192 return result;
193 }
194
195 /* wait for INTR bit as advised by Intel */
196 static void i801_wait_hwpec(void)
197 {
198 int timeout = 0;
199 int temp;
200
201 do {
202 msleep(1);
203 temp = inb_p(SMBHSTSTS);
204 } while ((!(temp & SMBHSTSTS_INTR))
205 && (timeout++ < MAX_TIMEOUT));
206
207 if (timeout >= MAX_TIMEOUT) {
208 dev_dbg(&I801_dev->dev, "PEC Timeout!\n");
209 }
210 outb_p(temp, SMBHSTSTS);
211 }
212
213 static int i801_block_transaction_by_block(union i2c_smbus_data *data,
214 char read_write, int hwpec)
215 {
216 int i, len;
217
218 inb_p(SMBHSTCNT); /* reset the data buffer index */
219
220 /* Use 32-byte buffer to process this transaction */
221 if (read_write == I2C_SMBUS_WRITE) {
222 len = data->block[0];
223 outb_p(len, SMBHSTDAT0);
224 for (i = 0; i < len; i++)
225 outb_p(data->block[i+1], SMBBLKDAT);
226 }
227
228 if (i801_transaction(I801_BLOCK_DATA | ENABLE_INT9 |
229 I801_PEC_EN * hwpec))
230 return -1;
231
232 if (read_write == I2C_SMBUS_READ) {
233 len = inb_p(SMBHSTDAT0);
234 if (len < 1 || len > I2C_SMBUS_BLOCK_MAX)
235 return -1;
236
237 data->block[0] = len;
238 for (i = 0; i < len; i++)
239 data->block[i + 1] = inb_p(SMBBLKDAT);
240 }
241 return 0;
242 }
243
244 static int i801_block_transaction_byte_by_byte(union i2c_smbus_data *data,
245 char read_write, int hwpec)
246 {
247 int i, len;
248 int smbcmd;
249 int temp;
250 int result = 0;
251 int timeout;
252 unsigned char errmask;
253
254 len = data->block[0];
255
256 if (read_write == I2C_SMBUS_WRITE) {
257 outb_p(len, SMBHSTDAT0);
258 outb_p(data->block[1], SMBBLKDAT);
259 }
260
261 for (i = 1; i <= len; i++) {
262 if (i == len && read_write == I2C_SMBUS_READ)
263 smbcmd = I801_BLOCK_LAST;
264 else
265 smbcmd = I801_BLOCK_DATA;
266 outb_p(smbcmd | ENABLE_INT9, SMBHSTCNT);
267
268 dev_dbg(&I801_dev->dev, "Block (pre %d): CNT=%02x, CMD=%02x, "
269 "ADD=%02x, DAT0=%02x, BLKDAT=%02x\n", i,
270 inb_p(SMBHSTCNT), inb_p(SMBHSTCMD), inb_p(SMBHSTADD),
271 inb_p(SMBHSTDAT0), inb_p(SMBBLKDAT));
272
273 /* Make sure the SMBus host is ready to start transmitting */
274 temp = inb_p(SMBHSTSTS);
275 if (i == 1) {
276 /* Erroneous conditions before transaction:
277 * Byte_Done, Failed, Bus_Err, Dev_Err, Intr, Host_Busy */
278 errmask = 0x9f;
279 } else {
280 /* Erroneous conditions during transaction:
281 * Failed, Bus_Err, Dev_Err, Intr */
282 errmask = 0x1e;
283 }
284 if (temp & errmask) {
285 dev_dbg(&I801_dev->dev, "SMBus busy (%02x). "
286 "Resetting...\n", temp);
287 outb_p(temp, SMBHSTSTS);
288 if (((temp = inb_p(SMBHSTSTS)) & errmask) != 0x00) {
289 dev_err(&I801_dev->dev,
290 "Reset failed! (%02x)\n", temp);
291 return -1;
292 }
293 if (i != 1)
294 /* if die in middle of block transaction, fail */
295 return -1;
296 }
297
298 if (i == 1)
299 outb_p(inb(SMBHSTCNT) | I801_START, SMBHSTCNT);
300
301 /* We will always wait for a fraction of a second! */
302 timeout = 0;
303 do {
304 msleep(1);
305 temp = inb_p(SMBHSTSTS);
306 }
307 while ((!(temp & SMBHSTSTS_BYTE_DONE))
308 && (timeout++ < MAX_TIMEOUT));
309
310 /* If the SMBus is still busy, we give up */
311 if (timeout >= MAX_TIMEOUT) {
312 /* try to stop the current command */
313 dev_dbg(&I801_dev->dev, "Terminating the current "
314 "operation\n");
315 outb_p(inb_p(SMBHSTCNT) | SMBHSTCNT_KILL, SMBHSTCNT);
316 msleep(1);
317 outb_p(inb_p(SMBHSTCNT) & (~SMBHSTCNT_KILL),
318 SMBHSTCNT);
319 result = -1;
320 dev_dbg(&I801_dev->dev, "SMBus Timeout!\n");
321 }
322
323 if (temp & SMBHSTSTS_FAILED) {
324 result = -1;
325 dev_dbg(&I801_dev->dev,
326 "Error: Failed bus transaction\n");
327 } else if (temp & SMBHSTSTS_BUS_ERR) {
328 result = -1;
329 dev_err(&I801_dev->dev, "Bus collision!\n");
330 } else if (temp & SMBHSTSTS_DEV_ERR) {
331 result = -1;
332 dev_dbg(&I801_dev->dev, "Error: no response!\n");
333 }
334
335 if (i == 1 && read_write == I2C_SMBUS_READ) {
336 len = inb_p(SMBHSTDAT0);
337 if (len < 1 || len > I2C_SMBUS_BLOCK_MAX)
338 return -1;
339 data->block[0] = len;
340 }
341
342 /* Retrieve/store value in SMBBLKDAT */
343 if (read_write == I2C_SMBUS_READ)
344 data->block[i] = inb_p(SMBBLKDAT);
345 if (read_write == I2C_SMBUS_WRITE && i+1 <= len)
346 outb_p(data->block[i+1], SMBBLKDAT);
347 if ((temp & 0x9e) != 0x00)
348 outb_p(temp, SMBHSTSTS); /* signals SMBBLKDAT ready */
349
350 if ((temp = (0x1e & inb_p(SMBHSTSTS))) != 0x00) {
351 dev_dbg(&I801_dev->dev,
352 "Bad status (%02x) at end of transaction\n",
353 temp);
354 }
355 dev_dbg(&I801_dev->dev, "Block (post %d): CNT=%02x, CMD=%02x, "
356 "ADD=%02x, DAT0=%02x, BLKDAT=%02x\n", i,
357 inb_p(SMBHSTCNT), inb_p(SMBHSTCMD), inb_p(SMBHSTADD),
358 inb_p(SMBHSTDAT0), inb_p(SMBBLKDAT));
359
360 if (result < 0)
361 return result;
362 }
363 return result;
364 }
365
366 static int i801_set_block_buffer_mode(void)
367 {
368 outb_p(inb_p(SMBAUXCTL) | SMBAUXCTL_E32B, SMBAUXCTL);
369 if ((inb_p(SMBAUXCTL) & SMBAUXCTL_E32B) == 0)
370 return -1;
371 return 0;
372 }
373
374 /* Block transaction function */
375 static int i801_block_transaction(union i2c_smbus_data *data, char read_write,
376 int command, int hwpec)
377 {
378 int result = 0;
379 unsigned char hostc;
380
381 if (command == I2C_SMBUS_I2C_BLOCK_DATA) {
382 if (read_write == I2C_SMBUS_WRITE) {
383 /* set I2C_EN bit in configuration register */
384 pci_read_config_byte(I801_dev, SMBHSTCFG, &hostc);
385 pci_write_config_byte(I801_dev, SMBHSTCFG,
386 hostc | SMBHSTCFG_I2C_EN);
387 } else {
388 dev_err(&I801_dev->dev,
389 "I2C_SMBUS_I2C_BLOCK_READ not DB!\n");
390 return -1;
391 }
392 }
393
394 if (read_write == I2C_SMBUS_WRITE) {
395 if (data->block[0] < 1)
396 data->block[0] = 1;
397 if (data->block[0] > I2C_SMBUS_BLOCK_MAX)
398 data->block[0] = I2C_SMBUS_BLOCK_MAX;
399 } else {
400 data->block[0] = 32; /* max for reads */
401 }
402
403 if (isich4 && i801_set_block_buffer_mode() == 0 )
404 result = i801_block_transaction_by_block(data, read_write,
405 hwpec);
406 else
407 result = i801_block_transaction_byte_by_byte(data, read_write,
408 hwpec);
409
410 if (result == 0 && hwpec)
411 i801_wait_hwpec();
412
413 if (command == I2C_SMBUS_I2C_BLOCK_DATA) {
414 /* restore saved configuration register value */
415 pci_write_config_byte(I801_dev, SMBHSTCFG, hostc);
416 }
417 return result;
418 }
419
420 /* Return -1 on error. */
421 static s32 i801_access(struct i2c_adapter * adap, u16 addr,
422 unsigned short flags, char read_write, u8 command,
423 int size, union i2c_smbus_data * data)
424 {
425 int hwpec;
426 int block = 0;
427 int ret, xact = 0;
428
429 hwpec = isich4 && (flags & I2C_CLIENT_PEC)
430 && size != I2C_SMBUS_QUICK
431 && size != I2C_SMBUS_I2C_BLOCK_DATA;
432
433 switch (size) {
434 case I2C_SMBUS_QUICK:
435 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
436 SMBHSTADD);
437 xact = I801_QUICK;
438 break;
439 case I2C_SMBUS_BYTE:
440 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
441 SMBHSTADD);
442 if (read_write == I2C_SMBUS_WRITE)
443 outb_p(command, SMBHSTCMD);
444 xact = I801_BYTE;
445 break;
446 case I2C_SMBUS_BYTE_DATA:
447 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
448 SMBHSTADD);
449 outb_p(command, SMBHSTCMD);
450 if (read_write == I2C_SMBUS_WRITE)
451 outb_p(data->byte, SMBHSTDAT0);
452 xact = I801_BYTE_DATA;
453 break;
454 case I2C_SMBUS_WORD_DATA:
455 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
456 SMBHSTADD);
457 outb_p(command, SMBHSTCMD);
458 if (read_write == I2C_SMBUS_WRITE) {
459 outb_p(data->word & 0xff, SMBHSTDAT0);
460 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
461 }
462 xact = I801_WORD_DATA;
463 break;
464 case I2C_SMBUS_BLOCK_DATA:
465 case I2C_SMBUS_I2C_BLOCK_DATA:
466 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
467 SMBHSTADD);
468 outb_p(command, SMBHSTCMD);
469 block = 1;
470 break;
471 case I2C_SMBUS_PROC_CALL:
472 default:
473 dev_err(&I801_dev->dev, "Unsupported transaction %d\n", size);
474 return -1;
475 }
476
477 if (hwpec) /* enable/disable hardware PEC */
478 outb_p(inb_p(SMBAUXCTL) | SMBAUXCTL_CRC, SMBAUXCTL);
479 else
480 outb_p(inb_p(SMBAUXCTL) & (~SMBAUXCTL_CRC), SMBAUXCTL);
481
482 if(block)
483 ret = i801_block_transaction(data, read_write, size, hwpec);
484 else
485 ret = i801_transaction(xact | ENABLE_INT9);
486
487 /* Some BIOSes don't like it when PEC is enabled at reboot or resume
488 time, so we forcibly disable it after every transaction. Turn off
489 E32B for the same reason. */
490 if (hwpec)
491 outb_p(inb_p(SMBAUXCTL) & ~(SMBAUXCTL_CRC | SMBAUXCTL_E32B),
492 SMBAUXCTL);
493
494 if(block)
495 return ret;
496 if(ret)
497 return -1;
498 if ((read_write == I2C_SMBUS_WRITE) || (xact == I801_QUICK))
499 return 0;
500
501 switch (xact & 0x7f) {
502 case I801_BYTE: /* Result put in SMBHSTDAT0 */
503 case I801_BYTE_DATA:
504 data->byte = inb_p(SMBHSTDAT0);
505 break;
506 case I801_WORD_DATA:
507 data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
508 break;
509 }
510 return 0;
511 }
512
513
514 static u32 i801_func(struct i2c_adapter *adapter)
515 {
516 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
517 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
518 I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_WRITE_I2C_BLOCK
519 | (isich4 ? I2C_FUNC_SMBUS_PEC : 0);
520 }
521
522 static const struct i2c_algorithm smbus_algorithm = {
523 .smbus_xfer = i801_access,
524 .functionality = i801_func,
525 };
526
527 static struct i2c_adapter i801_adapter = {
528 .owner = THIS_MODULE,
529 .id = I2C_HW_SMBUS_I801,
530 .class = I2C_CLASS_HWMON,
531 .algo = &smbus_algorithm,
532 };
533
534 static struct pci_device_id i801_ids[] = {
535 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_3) },
536 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_3) },
537 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_2) },
538 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_3) },
539 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_3) },
540 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_3) },
541 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_4) },
542 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_16) },
543 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_17) },
544 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB2_17) },
545 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_5) },
546 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH9_6) },
547 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TOLAPAI_1) },
548 { 0, }
549 };
550
551 MODULE_DEVICE_TABLE (pci, i801_ids);
552
553 static int __devinit i801_probe(struct pci_dev *dev, const struct pci_device_id *id)
554 {
555 unsigned char temp;
556 int err;
557
558 I801_dev = dev;
559 switch (dev->device) {
560 case PCI_DEVICE_ID_INTEL_82801DB_3:
561 case PCI_DEVICE_ID_INTEL_82801EB_3:
562 case PCI_DEVICE_ID_INTEL_ESB_4:
563 case PCI_DEVICE_ID_INTEL_ICH6_16:
564 case PCI_DEVICE_ID_INTEL_ICH7_17:
565 case PCI_DEVICE_ID_INTEL_ESB2_17:
566 case PCI_DEVICE_ID_INTEL_ICH8_5:
567 case PCI_DEVICE_ID_INTEL_ICH9_6:
568 case PCI_DEVICE_ID_INTEL_TOLAPAI_1:
569 isich4 = 1;
570 break;
571 default:
572 isich4 = 0;
573 }
574
575 err = pci_enable_device(dev);
576 if (err) {
577 dev_err(&dev->dev, "Failed to enable SMBus PCI device (%d)\n",
578 err);
579 goto exit;
580 }
581
582 /* Determine the address of the SMBus area */
583 i801_smba = pci_resource_start(dev, SMBBAR);
584 if (!i801_smba) {
585 dev_err(&dev->dev, "SMBus base address uninitialized, "
586 "upgrade BIOS\n");
587 err = -ENODEV;
588 goto exit;
589 }
590
591 err = pci_request_region(dev, SMBBAR, i801_driver.name);
592 if (err) {
593 dev_err(&dev->dev, "Failed to request SMBus region "
594 "0x%lx-0x%Lx\n", i801_smba,
595 (unsigned long long)pci_resource_end(dev, SMBBAR));
596 goto exit;
597 }
598
599 pci_read_config_byte(I801_dev, SMBHSTCFG, &temp);
600 i801_original_hstcfg = temp;
601 temp &= ~SMBHSTCFG_I2C_EN; /* SMBus timing */
602 if (!(temp & SMBHSTCFG_HST_EN)) {
603 dev_info(&dev->dev, "Enabling SMBus device\n");
604 temp |= SMBHSTCFG_HST_EN;
605 }
606 pci_write_config_byte(I801_dev, SMBHSTCFG, temp);
607
608 if (temp & SMBHSTCFG_SMB_SMI_EN)
609 dev_dbg(&dev->dev, "SMBus using interrupt SMI#\n");
610 else
611 dev_dbg(&dev->dev, "SMBus using PCI Interrupt\n");
612
613 /* set up the sysfs linkage to our parent device */
614 i801_adapter.dev.parent = &dev->dev;
615
616 snprintf(i801_adapter.name, sizeof(i801_adapter.name),
617 "SMBus I801 adapter at %04lx", i801_smba);
618 err = i2c_add_adapter(&i801_adapter);
619 if (err) {
620 dev_err(&dev->dev, "Failed to add SMBus adapter\n");
621 goto exit_release;
622 }
623 return 0;
624
625 exit_release:
626 pci_release_region(dev, SMBBAR);
627 exit:
628 return err;
629 }
630
631 static void __devexit i801_remove(struct pci_dev *dev)
632 {
633 i2c_del_adapter(&i801_adapter);
634 pci_write_config_byte(I801_dev, SMBHSTCFG, i801_original_hstcfg);
635 pci_release_region(dev, SMBBAR);
636 /*
637 * do not call pci_disable_device(dev) since it can cause hard hangs on
638 * some systems during power-off (eg. Fujitsu-Siemens Lifebook E8010)
639 */
640 }
641
642 #ifdef CONFIG_PM
643 static int i801_suspend(struct pci_dev *dev, pm_message_t mesg)
644 {
645 pci_save_state(dev);
646 pci_write_config_byte(dev, SMBHSTCFG, i801_original_hstcfg);
647 pci_set_power_state(dev, pci_choose_state(dev, mesg));
648 return 0;
649 }
650
651 static int i801_resume(struct pci_dev *dev)
652 {
653 pci_set_power_state(dev, PCI_D0);
654 pci_restore_state(dev);
655 return pci_enable_device(dev);
656 }
657 #else
658 #define i801_suspend NULL
659 #define i801_resume NULL
660 #endif
661
662 static struct pci_driver i801_driver = {
663 .name = "i801_smbus",
664 .id_table = i801_ids,
665 .probe = i801_probe,
666 .remove = __devexit_p(i801_remove),
667 .suspend = i801_suspend,
668 .resume = i801_resume,
669 };
670
671 static int __init i2c_i801_init(void)
672 {
673 return pci_register_driver(&i801_driver);
674 }
675
676 static void __exit i2c_i801_exit(void)
677 {
678 pci_unregister_driver(&i801_driver);
679 }
680
681 MODULE_AUTHOR ("Frodo Looijaard <frodol@dds.nl>, "
682 "Philip Edelbrock <phil@netroedge.com>, "
683 "and Mark D. Studebaker <mdsxyz123@yahoo.com>");
684 MODULE_DESCRIPTION("I801 SMBus driver");
685 MODULE_LICENSE("GPL");
686
687 module_init(i2c_i801_init);
688 module_exit(i2c_i801_exit);
Mirror for ia64_pv_ops.git