1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44#include <linux/module.h>
45#include <linux/delay.h>
46#include <linux/pci.h>
47#include <linux/kernel.h>
48#include <linux/stddef.h>
49#include <linux/ioport.h>
50#include <linux/i2c.h>
51#include <linux/init.h>
52#include <linux/acpi.h>
53#include <asm/io.h>
54
55static struct pci_dev *vt596_pdev;
56
57#define SMBBA1 0x90
58#define SMBBA2 0x80
59#define SMBBA3 0xD0
60
61
62static unsigned short vt596_smba;
63#define SMBHSTSTS (vt596_smba + 0)
64#define SMBHSTCNT (vt596_smba + 2)
65#define SMBHSTCMD (vt596_smba + 3)
66#define SMBHSTADD (vt596_smba + 4)
67#define SMBHSTDAT0 (vt596_smba + 5)
68#define SMBHSTDAT1 (vt596_smba + 6)
69#define SMBBLKDAT (vt596_smba + 7)
70
71
72
73
74
75
76static unsigned short SMBHSTCFG = 0xD2;
77
78
79#define MAX_TIMEOUT 500
80
81
82#define VT596_QUICK 0x00
83#define VT596_BYTE 0x04
84#define VT596_BYTE_DATA 0x08
85#define VT596_WORD_DATA 0x0C
86#define VT596_PROC_CALL 0x10
87#define VT596_BLOCK_DATA 0x14
88#define VT596_I2C_BLOCK_DATA 0x34
89
90
91
92
93static int force;
94module_param(force, bool, 0);
95MODULE_PARM_DESC(force, "Forcibly enable the SMBus. DANGEROUS!");
96
97
98
99static u16 force_addr;
100module_param(force_addr, ushort, 0);
101MODULE_PARM_DESC(force_addr,
102 "Forcibly enable the SMBus at the given address. "
103 "EXTREMELY DANGEROUS!");
104
105
106static struct pci_driver vt596_driver;
107static struct i2c_adapter vt596_adapter;
108
109#define FEATURE_I2CBLOCK (1<<0)
110static unsigned int vt596_features;
111
112#ifdef DEBUG
113static void vt596_dump_regs(const char *msg, u8 size)
114{
115 dev_dbg(&vt596_adapter.dev, "%s: STS=%02x CNT=%02x CMD=%02x ADD=%02x "
116 "DAT=%02x,%02x\n", msg, inb_p(SMBHSTSTS), inb_p(SMBHSTCNT),
117 inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
118 inb_p(SMBHSTDAT1));
119
120 if (size == VT596_BLOCK_DATA
121 || size == VT596_I2C_BLOCK_DATA) {
122 int i;
123
124 dev_dbg(&vt596_adapter.dev, "BLK=");
125 for (i = 0; i < I2C_SMBUS_BLOCK_MAX / 2; i++)
126 printk("%02x,", inb_p(SMBBLKDAT));
127 printk("\n");
128 dev_dbg(&vt596_adapter.dev, " ");
129 for (; i < I2C_SMBUS_BLOCK_MAX - 1; i++)
130 printk("%02x,", inb_p(SMBBLKDAT));
131 printk("%02x\n", inb_p(SMBBLKDAT));
132 }
133}
134#else
135static inline void vt596_dump_regs(const char *msg, u8 size) { }
136#endif
137
138
139static int vt596_transaction(u8 size)
140{
141 int temp;
142 int result = 0;
143 int timeout = 0;
144
145 vt596_dump_regs("Transaction (pre)", size);
146
147
148 if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
149 dev_dbg(&vt596_adapter.dev, "SMBus busy (0x%02x). "
150 "Resetting...\n", temp);
151
152 outb_p(temp, SMBHSTSTS);
153 if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
154 dev_err(&vt596_adapter.dev, "SMBus reset failed! "
155 "(0x%02x)\n", temp);
156 return -EBUSY;
157 }
158 }
159
160
161 outb_p(0x40 | size, SMBHSTCNT);
162
163
164 do {
165 msleep(1);
166 temp = inb_p(SMBHSTSTS);
167 } while ((temp & 0x01) && (timeout++ < MAX_TIMEOUT));
168
169
170 if (timeout >= MAX_TIMEOUT) {
171 result = -ETIMEDOUT;
172 dev_err(&vt596_adapter.dev, "SMBus timeout!\n");
173 }
174
175 if (temp & 0x10) {
176 result = -EIO;
177 dev_err(&vt596_adapter.dev, "Transaction failed (0x%02x)\n",
178 size);
179 }
180
181 if (temp & 0x08) {
182 result = -EIO;
183 dev_err(&vt596_adapter.dev, "SMBus collision!\n");
184 }
185
186 if (temp & 0x04) {
187 int read = inb_p(SMBHSTADD) & 0x01;
188 result = -ENXIO;
189
190
191
192 if (!((size == VT596_QUICK && !read) ||
193 (size == VT596_BYTE && read)))
194 dev_err(&vt596_adapter.dev, "Transaction error!\n");
195 }
196
197
198 if (temp & 0x1F)
199 outb_p(temp, SMBHSTSTS);
200
201 vt596_dump_regs("Transaction (post)", size);
202
203 return result;
204}
205
206
207static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
208 unsigned short flags, char read_write, u8 command,
209 int size, union i2c_smbus_data *data)
210{
211 int i;
212 int status;
213
214 switch (size) {
215 case I2C_SMBUS_QUICK:
216 size = VT596_QUICK;
217 break;
218 case I2C_SMBUS_BYTE:
219 if (read_write == I2C_SMBUS_WRITE)
220 outb_p(command, SMBHSTCMD);
221 size = VT596_BYTE;
222 break;
223 case I2C_SMBUS_BYTE_DATA:
224 outb_p(command, SMBHSTCMD);
225 if (read_write == I2C_SMBUS_WRITE)
226 outb_p(data->byte, SMBHSTDAT0);
227 size = VT596_BYTE_DATA;
228 break;
229 case I2C_SMBUS_WORD_DATA:
230 outb_p(command, SMBHSTCMD);
231 if (read_write == I2C_SMBUS_WRITE) {
232 outb_p(data->word & 0xff, SMBHSTDAT0);
233 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
234 }
235 size = VT596_WORD_DATA;
236 break;
237 case I2C_SMBUS_PROC_CALL:
238 outb_p(command, SMBHSTCMD);
239 outb_p(data->word & 0xff, SMBHSTDAT0);
240 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
241 size = VT596_PROC_CALL;
242 break;
243 case I2C_SMBUS_I2C_BLOCK_DATA:
244 if (!(vt596_features & FEATURE_I2CBLOCK))
245 goto exit_unsupported;
246 if (read_write == I2C_SMBUS_READ)
247 outb_p(data->block[0], SMBHSTDAT0);
248
249 case I2C_SMBUS_BLOCK_DATA:
250 outb_p(command, SMBHSTCMD);
251 if (read_write == I2C_SMBUS_WRITE) {
252 u8 len = data->block[0];
253 if (len > I2C_SMBUS_BLOCK_MAX)
254 len = I2C_SMBUS_BLOCK_MAX;
255 outb_p(len, SMBHSTDAT0);
256 inb_p(SMBHSTCNT);
257 for (i = 1; i <= len; i++)
258 outb_p(data->block[i], SMBBLKDAT);
259 }
260 size = (size == I2C_SMBUS_I2C_BLOCK_DATA) ?
261 VT596_I2C_BLOCK_DATA : VT596_BLOCK_DATA;
262 break;
263 default:
264 goto exit_unsupported;
265 }
266
267 outb_p(((addr & 0x7f) << 1) | read_write, SMBHSTADD);
268
269 status = vt596_transaction(size);
270 if (status)
271 return status;
272
273 if (size == VT596_PROC_CALL)
274 read_write = I2C_SMBUS_READ;
275
276 if ((read_write == I2C_SMBUS_WRITE) || (size == VT596_QUICK))
277 return 0;
278
279 switch (size) {
280 case VT596_BYTE:
281 case VT596_BYTE_DATA:
282 data->byte = inb_p(SMBHSTDAT0);
283 break;
284 case VT596_WORD_DATA:
285 case VT596_PROC_CALL:
286 data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
287 break;
288 case VT596_I2C_BLOCK_DATA:
289 case VT596_BLOCK_DATA:
290 data->block[0] = inb_p(SMBHSTDAT0);
291 if (data->block[0] > I2C_SMBUS_BLOCK_MAX)
292 data->block[0] = I2C_SMBUS_BLOCK_MAX;
293 inb_p(SMBHSTCNT);
294 for (i = 1; i <= data->block[0]; i++)
295 data->block[i] = inb_p(SMBBLKDAT);
296 break;
297 }
298 return 0;
299
300exit_unsupported:
301 dev_warn(&vt596_adapter.dev, "Unsupported transaction %d\n",
302 size);
303 return -EOPNOTSUPP;
304}
305
306static u32 vt596_func(struct i2c_adapter *adapter)
307{
308 u32 func = I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
309 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
310 I2C_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_BLOCK_DATA;
311
312 if (vt596_features & FEATURE_I2CBLOCK)
313 func |= I2C_FUNC_SMBUS_I2C_BLOCK;
314 return func;
315}
316
317static const struct i2c_algorithm smbus_algorithm = {
318 .smbus_xfer = vt596_access,
319 .functionality = vt596_func,
320};
321
322static struct i2c_adapter vt596_adapter = {
323 .owner = THIS_MODULE,
324 .id = I2C_HW_SMBUS_VIA2,
325 .class = I2C_CLASS_HWMON | I2C_CLASS_SPD,
326 .algo = &smbus_algorithm,
327};
328
329static int __devinit vt596_probe(struct pci_dev *pdev,
330 const struct pci_device_id *id)
331{
332 unsigned char temp;
333 int error = -ENODEV;
334
335
336 if (force_addr) {
337 vt596_smba = force_addr & 0xfff0;
338 force = 0;
339 goto found;
340 }
341
342 if ((pci_read_config_word(pdev, id->driver_data, &vt596_smba)) ||
343 !(vt596_smba & 0x0001)) {
344
345 if (id->device == PCI_DEVICE_ID_VIA_82C596_3 &&
346 !pci_read_config_word(pdev, SMBBA2, &vt596_smba) &&
347 (vt596_smba & 0x0001)) {
348 SMBHSTCFG = 0x84;
349 } else {
350
351 dev_err(&pdev->dev, "Cannot configure "
352 "SMBus I/O Base address\n");
353 return -ENODEV;
354 }
355 }
356
357 vt596_smba &= 0xfff0;
358 if (vt596_smba == 0) {
359 dev_err(&pdev->dev, "SMBus base address "
360 "uninitialized - upgrade BIOS or use "
361 "force_addr=0xaddr\n");
362 return -ENODEV;
363 }
364
365found:
366 error = acpi_check_region(vt596_smba, 8, vt596_driver.name);
367 if (error)
368 return error;
369
370 if (!request_region(vt596_smba, 8, vt596_driver.name)) {
371 dev_err(&pdev->dev, "SMBus region 0x%x already in use!\n",
372 vt596_smba);
373 return -ENODEV;
374 }
375
376 pci_read_config_byte(pdev, SMBHSTCFG, &temp);
377
378
379 if (force_addr) {
380 pci_write_config_byte(pdev, SMBHSTCFG, temp & 0xfe);
381 pci_write_config_word(pdev, id->driver_data, vt596_smba);
382 pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
383 dev_warn(&pdev->dev, "WARNING: SMBus interface set to new "
384 "address 0x%04x!\n", vt596_smba);
385 } else if (!(temp & 0x01)) {
386 if (force) {
387
388
389
390
391
392
393 pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
394 dev_info(&pdev->dev, "Enabling SMBus device\n");
395 } else {
396 dev_err(&pdev->dev, "SMBUS: Error: Host SMBus "
397 "controller not enabled! - upgrade BIOS or "
398 "use force=1\n");
399 goto release_region;
400 }
401 }
402
403 dev_dbg(&pdev->dev, "VT596_smba = 0x%X\n", vt596_smba);
404
405 switch (pdev->device) {
406 case PCI_DEVICE_ID_VIA_CX700:
407 case PCI_DEVICE_ID_VIA_VX800:
408 case PCI_DEVICE_ID_VIA_8251:
409 case PCI_DEVICE_ID_VIA_8237:
410 case PCI_DEVICE_ID_VIA_8237A:
411 case PCI_DEVICE_ID_VIA_8237S:
412 case PCI_DEVICE_ID_VIA_8235:
413 case PCI_DEVICE_ID_VIA_8233A:
414 case PCI_DEVICE_ID_VIA_8233_0:
415 vt596_features |= FEATURE_I2CBLOCK;
416 break;
417 case PCI_DEVICE_ID_VIA_82C686_4:
418
419
420 if (pdev->revision >= 0x40)
421 vt596_features |= FEATURE_I2CBLOCK;
422 break;
423 }
424
425 vt596_adapter.dev.parent = &pdev->dev;
426 snprintf(vt596_adapter.name, sizeof(vt596_adapter.name),
427 "SMBus Via Pro adapter at %04x", vt596_smba);
428
429 vt596_pdev = pci_dev_get(pdev);
430 if (i2c_add_adapter(&vt596_adapter)) {
431 pci_dev_put(vt596_pdev);
432 vt596_pdev = NULL;
433 }
434
435
436
437
438
439 return -ENODEV;
440
441release_region:
442 release_region(vt596_smba, 8);
443 return error;
444}
445
446static struct pci_device_id vt596_ids[] = {
447 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596_3),
448 .driver_data = SMBBA1 },
449 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596B_3),
450 .driver_data = SMBBA1 },
451 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4),
452 .driver_data = SMBBA1 },
453 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233_0),
454 .driver_data = SMBBA3 },
455 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233A),
456 .driver_data = SMBBA3 },
457 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235),
458 .driver_data = SMBBA3 },
459 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237),
460 .driver_data = SMBBA3 },
461 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237A),
462 .driver_data = SMBBA3 },
463 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237S),
464 .driver_data = SMBBA3 },
465 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4),
466 .driver_data = SMBBA1 },
467 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8251),
468 .driver_data = SMBBA3 },
469 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_CX700),
470 .driver_data = SMBBA3 },
471 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX800),
472 .driver_data = SMBBA3 },
473 { 0, }
474};
475
476MODULE_DEVICE_TABLE(pci, vt596_ids);
477
478static struct pci_driver vt596_driver = {
479 .name = "vt596_smbus",
480 .id_table = vt596_ids,
481 .probe = vt596_probe,
482};
483
484static int __init i2c_vt596_init(void)
485{
486 return pci_register_driver(&vt596_driver);
487}
488
489
490static void __exit i2c_vt596_exit(void)
491{
492 pci_unregister_driver(&vt596_driver);
493 if (vt596_pdev != NULL) {
494 i2c_del_adapter(&vt596_adapter);
495 release_region(vt596_smba, 8);
496 pci_dev_put(vt596_pdev);
497 vt596_pdev = NULL;
498 }
499}
500
501MODULE_AUTHOR("Kyosti Malkki <kmalkki@cc.hut.fi>, "
502 "Mark D. Studebaker <mdsxyz123@yahoo.com> and "
503 "Jean Delvare <khali@linux-fr.org>");
504MODULE_DESCRIPTION("vt82c596 SMBus driver");
505MODULE_LICENSE("GPL");
506
507module_init(i2c_vt596_init);
508module_exit(i2c_vt596_exit);