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