1 /*
2 Copyright (c) 1998 - 2002 Frodo Looijaard <frodol@dds.nl>,
3 Philip Edelbrock <phil@netroedge.com>, Kyösti Mälkki <kmalkki@cc.hut.fi>,
4 Mark D. Studebaker <mdsxyz123@yahoo.com>
5 Copyright (C) 2005 - 2008 Jean Delvare <jdelvare@suse.de>
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16 */
17
18 /*
19 Supports the following VIA south bridges:
20
21 Chip name PCI ID REV I2C block
22 VT82C596A 0x3050 no
23 VT82C596B 0x3051 no
24 VT82C686A 0x3057 0x30 no
25 VT82C686B 0x3057 0x40 yes
26 VT8231 0x8235 no?
27 VT8233 0x3074 yes
28 VT8233A 0x3147 yes?
29 VT8235 0x3177 yes
30 VT8237R 0x3227 yes
31 VT8237A 0x3337 yes
32 VT8237S 0x3372 yes
33 VT8251 0x3287 yes
34 CX700 0x8324 yes
35 VX800/VX820 0x8353 yes
36 VX855/VX875 0x8409 yes
37
38 Note: we assume there can only be one device, with one SMBus interface.
39 */
40
41 #include <linux/module.h>
42 #include <linux/delay.h>
43 #include <linux/pci.h>
44 #include <linux/kernel.h>
45 #include <linux/stddef.h>
46 #include <linux/ioport.h>
47 #include <linux/i2c.h>
48 #include <linux/init.h>
49 #include <linux/acpi.h>
50 #include <linux/io.h>
51
52 static struct pci_dev *vt596_pdev;
53
54 #define SMBBA1 0x90
55 #define SMBBA2 0x80
56 #define SMBBA3 0xD0
57
58 /* SMBus address offsets */
59 static unsigned short vt596_smba;
60 #define SMBHSTSTS (vt596_smba + 0)
61 #define SMBHSTCNT (vt596_smba + 2)
62 #define SMBHSTCMD (vt596_smba + 3)
63 #define SMBHSTADD (vt596_smba + 4)
64 #define SMBHSTDAT0 (vt596_smba + 5)
65 #define SMBHSTDAT1 (vt596_smba + 6)
66 #define SMBBLKDAT (vt596_smba + 7)
67
68 /* PCI Address Constants */
69
70 /* SMBus data in configuration space can be found in two places,
71 We try to select the better one */
72
73 static unsigned short SMBHSTCFG = 0xD2;
74
75 /* Other settings */
76 #define MAX_TIMEOUT 500
77
78 /* VT82C596 constants */
79 #define VT596_QUICK 0x00
80 #define VT596_BYTE 0x04
81 #define VT596_BYTE_DATA 0x08
82 #define VT596_WORD_DATA 0x0C
83 #define VT596_PROC_CALL 0x10
84 #define VT596_BLOCK_DATA 0x14
85 #define VT596_I2C_BLOCK_DATA 0x34
86
87
88 /* If force is set to anything different from 0, we forcibly enable the
89 VT596. DANGEROUS! */
90 static bool force;
91 module_param(force, bool, 0);
92 MODULE_PARM_DESC(force, "Forcibly enable the SMBus. DANGEROUS!");
93
94 /* If force_addr is set to anything different from 0, we forcibly enable
95 the VT596 at the given address. VERY DANGEROUS! */
96 static u16 force_addr;
97 module_param_hw(force_addr, ushort, ioport, 0);
98 MODULE_PARM_DESC(force_addr,
99 "Forcibly enable the SMBus at the given address. "
100 "EXTREMELY DANGEROUS!");
101
102
103 static struct pci_driver vt596_driver;
104 static struct i2c_adapter vt596_adapter;
105
106 #define FEATURE_I2CBLOCK (1<<0)
107 static unsigned int vt596_features;
108
109 #ifdef DEBUG
vt596_dump_regs(const char * msg,u8 size)110 static void vt596_dump_regs(const char *msg, u8 size)
111 {
112 dev_dbg(&vt596_adapter.dev, "%s: STS=%02x CNT=%02x CMD=%02x ADD=%02x "
113 "DAT=%02x,%02x\n", msg, inb_p(SMBHSTSTS), inb_p(SMBHSTCNT),
114 inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
115 inb_p(SMBHSTDAT1));
116
117 if (size == VT596_BLOCK_DATA
118 || size == VT596_I2C_BLOCK_DATA) {
119 int i;
120
121 dev_dbg(&vt596_adapter.dev, "BLK=");
122 for (i = 0; i < I2C_SMBUS_BLOCK_MAX / 2; i++)
123 printk("%02x,", inb_p(SMBBLKDAT));
124 printk("\n");
125 dev_dbg(&vt596_adapter.dev, " ");
126 for (; i < I2C_SMBUS_BLOCK_MAX - 1; i++)
127 printk("%02x,", inb_p(SMBBLKDAT));
128 printk("%02x\n", inb_p(SMBBLKDAT));
129 }
130 }
131 #else
vt596_dump_regs(const char * msg,u8 size)132 static inline void vt596_dump_regs(const char *msg, u8 size) { }
133 #endif
134
135 /* Return -1 on error, 0 on success */
vt596_transaction(u8 size)136 static int vt596_transaction(u8 size)
137 {
138 int temp;
139 int result = 0;
140 int timeout = 0;
141
142 vt596_dump_regs("Transaction (pre)", size);
143
144 /* Make sure the SMBus host is ready to start transmitting */
145 if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
146 dev_dbg(&vt596_adapter.dev, "SMBus busy (0x%02x). "
147 "Resetting...\n", temp);
148
149 outb_p(temp, SMBHSTSTS);
150 if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
151 dev_err(&vt596_adapter.dev, "SMBus reset failed! "
152 "(0x%02x)\n", temp);
153 return -EBUSY;
154 }
155 }
156
157 /* Start the transaction by setting bit 6 */
158 outb_p(0x40 | size, SMBHSTCNT);
159
160 /* We will always wait for a fraction of a second */
161 do {
162 msleep(1);
163 temp = inb_p(SMBHSTSTS);
164 } while ((temp & 0x01) && (++timeout < MAX_TIMEOUT));
165
166 /* If the SMBus is still busy, we give up */
167 if (timeout == MAX_TIMEOUT) {
168 result = -ETIMEDOUT;
169 dev_err(&vt596_adapter.dev, "SMBus timeout!\n");
170 }
171
172 if (temp & 0x10) {
173 result = -EIO;
174 dev_err(&vt596_adapter.dev, "Transaction failed (0x%02x)\n",
175 size);
176 }
177
178 if (temp & 0x08) {
179 result = -EIO;
180 dev_err(&vt596_adapter.dev, "SMBus collision!\n");
181 }
182
183 if (temp & 0x04) {
184 result = -ENXIO;
185 dev_dbg(&vt596_adapter.dev, "No response\n");
186 }
187
188 /* Resetting status register */
189 if (temp & 0x1F)
190 outb_p(temp, SMBHSTSTS);
191
192 vt596_dump_regs("Transaction (post)", size);
193
194 return result;
195 }
196
197 /* Return negative errno on error, 0 on success */
vt596_access(struct i2c_adapter * adap,u16 addr,unsigned short flags,char read_write,u8 command,int size,union i2c_smbus_data * data)198 static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
199 unsigned short flags, char read_write, u8 command,
200 int size, union i2c_smbus_data *data)
201 {
202 int i;
203 int status;
204
205 switch (size) {
206 case I2C_SMBUS_QUICK:
207 size = VT596_QUICK;
208 break;
209 case I2C_SMBUS_BYTE:
210 if (read_write == I2C_SMBUS_WRITE)
211 outb_p(command, SMBHSTCMD);
212 size = VT596_BYTE;
213 break;
214 case I2C_SMBUS_BYTE_DATA:
215 outb_p(command, SMBHSTCMD);
216 if (read_write == I2C_SMBUS_WRITE)
217 outb_p(data->byte, SMBHSTDAT0);
218 size = VT596_BYTE_DATA;
219 break;
220 case I2C_SMBUS_WORD_DATA:
221 outb_p(command, SMBHSTCMD);
222 if (read_write == I2C_SMBUS_WRITE) {
223 outb_p(data->word & 0xff, SMBHSTDAT0);
224 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
225 }
226 size = VT596_WORD_DATA;
227 break;
228 case I2C_SMBUS_PROC_CALL:
229 outb_p(command, SMBHSTCMD);
230 outb_p(data->word & 0xff, SMBHSTDAT0);
231 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
232 size = VT596_PROC_CALL;
233 break;
234 case I2C_SMBUS_I2C_BLOCK_DATA:
235 if (!(vt596_features & FEATURE_I2CBLOCK))
236 goto exit_unsupported;
237 if (read_write == I2C_SMBUS_READ)
238 outb_p(data->block[0], SMBHSTDAT0);
239 /* Fall through */
240 case I2C_SMBUS_BLOCK_DATA:
241 outb_p(command, SMBHSTCMD);
242 if (read_write == I2C_SMBUS_WRITE) {
243 u8 len = data->block[0];
244 if (len > I2C_SMBUS_BLOCK_MAX)
245 len = I2C_SMBUS_BLOCK_MAX;
246 outb_p(len, SMBHSTDAT0);
247 inb_p(SMBHSTCNT); /* Reset SMBBLKDAT */
248 for (i = 1; i <= len; i++)
249 outb_p(data->block[i], SMBBLKDAT);
250 }
251 size = (size == I2C_SMBUS_I2C_BLOCK_DATA) ?
252 VT596_I2C_BLOCK_DATA : VT596_BLOCK_DATA;
253 break;
254 default:
255 goto exit_unsupported;
256 }
257
258 outb_p(((addr & 0x7f) << 1) | read_write, SMBHSTADD);
259
260 status = vt596_transaction(size);
261 if (status)
262 return status;
263
264 if (size == VT596_PROC_CALL)
265 read_write = I2C_SMBUS_READ;
266
267 if ((read_write == I2C_SMBUS_WRITE) || (size == VT596_QUICK))
268 return 0;
269
270 switch (size) {
271 case VT596_BYTE:
272 case VT596_BYTE_DATA:
273 data->byte = inb_p(SMBHSTDAT0);
274 break;
275 case VT596_WORD_DATA:
276 case VT596_PROC_CALL:
277 data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
278 break;
279 case VT596_I2C_BLOCK_DATA:
280 case VT596_BLOCK_DATA:
281 data->block[0] = inb_p(SMBHSTDAT0);
282 if (data->block[0] > I2C_SMBUS_BLOCK_MAX)
283 data->block[0] = I2C_SMBUS_BLOCK_MAX;
284 inb_p(SMBHSTCNT); /* Reset SMBBLKDAT */
285 for (i = 1; i <= data->block[0]; i++)
286 data->block[i] = inb_p(SMBBLKDAT);
287 break;
288 }
289 return 0;
290
291 exit_unsupported:
292 dev_warn(&vt596_adapter.dev, "Unsupported transaction %d\n",
293 size);
294 return -EOPNOTSUPP;
295 }
296
vt596_func(struct i2c_adapter * adapter)297 static u32 vt596_func(struct i2c_adapter *adapter)
298 {
299 u32 func = I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
300 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
301 I2C_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_BLOCK_DATA;
302
303 if (vt596_features & FEATURE_I2CBLOCK)
304 func |= I2C_FUNC_SMBUS_I2C_BLOCK;
305 return func;
306 }
307
308 static const struct i2c_algorithm smbus_algorithm = {
309 .smbus_xfer = vt596_access,
310 .functionality = vt596_func,
311 };
312
313 static struct i2c_adapter vt596_adapter = {
314 .owner = THIS_MODULE,
315 .class = I2C_CLASS_HWMON | I2C_CLASS_SPD,
316 .algo = &smbus_algorithm,
317 };
318
vt596_probe(struct pci_dev * pdev,const struct pci_device_id * id)319 static int vt596_probe(struct pci_dev *pdev,
320 const struct pci_device_id *id)
321 {
322 unsigned char temp;
323 int error;
324
325 /* Determine the address of the SMBus areas */
326 if (force_addr) {
327 vt596_smba = force_addr & 0xfff0;
328 force = 0;
329 goto found;
330 }
331
332 if ((pci_read_config_word(pdev, id->driver_data, &vt596_smba)) ||
333 !(vt596_smba & 0x0001)) {
334 /* try 2nd address and config reg. for 596 */
335 if (id->device == PCI_DEVICE_ID_VIA_82C596_3 &&
336 !pci_read_config_word(pdev, SMBBA2, &vt596_smba) &&
337 (vt596_smba & 0x0001)) {
338 SMBHSTCFG = 0x84;
339 } else {
340 /* no matches at all */
341 dev_err(&pdev->dev, "Cannot configure "
342 "SMBus I/O Base address\n");
343 return -ENODEV;
344 }
345 }
346
347 vt596_smba &= 0xfff0;
348 if (vt596_smba == 0) {
349 dev_err(&pdev->dev, "SMBus base address "
350 "uninitialized - upgrade BIOS or use "
351 "force_addr=0xaddr\n");
352 return -ENODEV;
353 }
354
355 found:
356 error = acpi_check_region(vt596_smba, 8, vt596_driver.name);
357 if (error)
358 return -ENODEV;
359
360 if (!request_region(vt596_smba, 8, vt596_driver.name)) {
361 dev_err(&pdev->dev, "SMBus region 0x%x already in use!\n",
362 vt596_smba);
363 return -ENODEV;
364 }
365
366 pci_read_config_byte(pdev, SMBHSTCFG, &temp);
367 /* If force_addr is set, we program the new address here. Just to make
368 sure, we disable the VT596 first. */
369 if (force_addr) {
370 pci_write_config_byte(pdev, SMBHSTCFG, temp & 0xfe);
371 pci_write_config_word(pdev, id->driver_data, vt596_smba);
372 pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
373 dev_warn(&pdev->dev, "WARNING: SMBus interface set to new "
374 "address 0x%04x!\n", vt596_smba);
375 } else if (!(temp & 0x01)) {
376 if (force) {
377 /* NOTE: This assumes I/O space and other allocations
378 * WERE done by the Bios! Don't complain if your
379 * hardware does weird things after enabling this.
380 * :') Check for Bios updates before resorting to
381 * this.
382 */
383 pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
384 dev_info(&pdev->dev, "Enabling SMBus device\n");
385 } else {
386 dev_err(&pdev->dev, "SMBUS: Error: Host SMBus "
387 "controller not enabled! - upgrade BIOS or "
388 "use force=1\n");
389 error = -ENODEV;
390 goto release_region;
391 }
392 }
393
394 dev_dbg(&pdev->dev, "VT596_smba = 0x%X\n", vt596_smba);
395
396 switch (pdev->device) {
397 case PCI_DEVICE_ID_VIA_CX700:
398 case PCI_DEVICE_ID_VIA_VX800:
399 case PCI_DEVICE_ID_VIA_VX855:
400 case PCI_DEVICE_ID_VIA_VX900:
401 case PCI_DEVICE_ID_VIA_8251:
402 case PCI_DEVICE_ID_VIA_8237:
403 case PCI_DEVICE_ID_VIA_8237A:
404 case PCI_DEVICE_ID_VIA_8237S:
405 case PCI_DEVICE_ID_VIA_8235:
406 case PCI_DEVICE_ID_VIA_8233A:
407 case PCI_DEVICE_ID_VIA_8233_0:
408 vt596_features |= FEATURE_I2CBLOCK;
409 break;
410 case PCI_DEVICE_ID_VIA_82C686_4:
411 /* The VT82C686B (rev 0x40) does support I2C block
412 transactions, but the VT82C686A (rev 0x30) doesn't */
413 if (pdev->revision >= 0x40)
414 vt596_features |= FEATURE_I2CBLOCK;
415 break;
416 }
417
418 vt596_adapter.dev.parent = &pdev->dev;
419 snprintf(vt596_adapter.name, sizeof(vt596_adapter.name),
420 "SMBus Via Pro adapter at %04x", vt596_smba);
421
422 vt596_pdev = pci_dev_get(pdev);
423 error = i2c_add_adapter(&vt596_adapter);
424 if (error) {
425 pci_dev_put(vt596_pdev);
426 vt596_pdev = NULL;
427 goto release_region;
428 }
429
430 /* Always return failure here. This is to allow other drivers to bind
431 * to this pci device. We don't really want to have control over the
432 * pci device, we only wanted to read as few register values from it.
433 */
434 return -ENODEV;
435
436 release_region:
437 release_region(vt596_smba, 8);
438 return error;
439 }
440
441 static const struct pci_device_id vt596_ids[] = {
442 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596_3),
443 .driver_data = SMBBA1 },
444 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596B_3),
445 .driver_data = SMBBA1 },
446 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4),
447 .driver_data = SMBBA1 },
448 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233_0),
449 .driver_data = SMBBA3 },
450 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233A),
451 .driver_data = SMBBA3 },
452 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235),
453 .driver_data = SMBBA3 },
454 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237),
455 .driver_data = SMBBA3 },
456 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237A),
457 .driver_data = SMBBA3 },
458 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237S),
459 .driver_data = SMBBA3 },
460 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4),
461 .driver_data = SMBBA1 },
462 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8251),
463 .driver_data = SMBBA3 },
464 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_CX700),
465 .driver_data = SMBBA3 },
466 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX800),
467 .driver_data = SMBBA3 },
468 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX855),
469 .driver_data = SMBBA3 },
470 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX900),
471 .driver_data = SMBBA3 },
472 { 0, }
473 };
474
475 MODULE_DEVICE_TABLE(pci, vt596_ids);
476
477 static struct pci_driver vt596_driver = {
478 .name = "vt596_smbus",
479 .id_table = vt596_ids,
480 .probe = vt596_probe,
481 };
482
i2c_vt596_init(void)483 static int __init i2c_vt596_init(void)
484 {
485 return pci_register_driver(&vt596_driver);
486 }
487
488
i2c_vt596_exit(void)489 static void __exit i2c_vt596_exit(void)
490 {
491 pci_unregister_driver(&vt596_driver);
492 if (vt596_pdev != NULL) {
493 i2c_del_adapter(&vt596_adapter);
494 release_region(vt596_smba, 8);
495 pci_dev_put(vt596_pdev);
496 vt596_pdev = NULL;
497 }
498 }
499
500 MODULE_AUTHOR("Kyosti Malkki <kmalkki@cc.hut.fi>, "
501 "Mark D. Studebaker <mdsxyz123@yahoo.com> and "
502 "Jean Delvare <jdelvare@suse.de>");
503 MODULE_DESCRIPTION("vt82c596 SMBus driver");
504 MODULE_LICENSE("GPL");
505
506 module_init(i2c_vt596_init);
507 module_exit(i2c_vt596_exit);
508
