blob: 862eb352a2d92b9708cdad16adfec687fdc4dece [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Jean Delvare5f49ef82005-09-22 21:50:47 +02002 Copyright (c) 1998 - 2002 Frodo Looijaard <frodol@dds.nl>,
Jan Engelhardt96de0e22007-10-19 23:21:04 +02003 Philip Edelbrock <phil@netroedge.com>, Kyösti Mälkki <kmalkki@cc.hut.fi>,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 Mark D. Studebaker <mdsxyz123@yahoo.com>
Jean Delvare0d227a72008-01-27 18:14:51 +01005 Copyright (C) 2005 - 2008 Jean Delvare <khali@linux-fr.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006
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/*
Jean Delvareaaf7f142005-09-22 22:09:07 +020023 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
Rudolf Marekc2433532006-09-03 22:35:21 +020035 VT8237A 0x3337 yes
Jean Delvare0d227a72008-01-27 18:14:51 +010036 VT8237S 0x3372 yes
Rudolf Marekc2433532006-09-03 22:35:21 +020037 VT8251 0x3287 yes
Jean Delvareab6a6ed2007-02-13 22:09:02 +010038 CX700 0x8324 yes
Jean Delvareaaf7f142005-09-22 22:09:07 +020039
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 Note: we assume there can only be one device, with one SMBus interface.
41*/
42
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/module.h>
44#include <linux/delay.h>
45#include <linux/pci.h>
46#include <linux/kernel.h>
47#include <linux/stddef.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include <linux/ioport.h>
49#include <linux/i2c.h>
50#include <linux/init.h>
Jean Delvare54fb4a052008-07-14 22:38:33 +020051#include <linux/acpi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#include <asm/io.h>
53
54static struct pci_dev *vt596_pdev;
55
Jean Delvare5f49ef82005-09-22 21:50:47 +020056#define SMBBA1 0x90
57#define SMBBA2 0x80
58#define SMBBA3 0xD0
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
60/* SMBus address offsets */
61static unsigned short vt596_smba;
62#define SMBHSTSTS (vt596_smba + 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070063#define SMBHSTCNT (vt596_smba + 2)
64#define SMBHSTCMD (vt596_smba + 3)
65#define SMBHSTADD (vt596_smba + 4)
66#define SMBHSTDAT0 (vt596_smba + 5)
67#define SMBHSTDAT1 (vt596_smba + 6)
68#define SMBBLKDAT (vt596_smba + 7)
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
70/* PCI Address Constants */
71
72/* SMBus data in configuration space can be found in two places,
Jean Delvare5f49ef82005-09-22 21:50:47 +020073 We try to select the better one */
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
Jean Delvarec2f559d2005-09-22 22:01:07 +020075static unsigned short SMBHSTCFG = 0xD2;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
77/* Other settings */
78#define MAX_TIMEOUT 500
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80/* VT82C596 constants */
Jean Delvare5f49ef82005-09-22 21:50:47 +020081#define VT596_QUICK 0x00
82#define VT596_BYTE 0x04
83#define VT596_BYTE_DATA 0x08
84#define VT596_WORD_DATA 0x0C
85#define VT596_BLOCK_DATA 0x14
Jean Delvaref1183012005-09-22 21:58:41 +020086#define VT596_I2C_BLOCK_DATA 0x34
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
88
89/* If force is set to anything different from 0, we forcibly enable the
90 VT596. DANGEROUS! */
91static int force;
92module_param(force, bool, 0);
93MODULE_PARM_DESC(force, "Forcibly enable the SMBus. DANGEROUS!");
94
95/* If force_addr is set to anything different from 0, we forcibly enable
96 the VT596 at the given address. VERY DANGEROUS! */
97static u16 force_addr;
98module_param(force_addr, ushort, 0);
99MODULE_PARM_DESC(force_addr,
100 "Forcibly enable the SMBus at the given address. "
101 "EXTREMELY DANGEROUS!");
102
103
Jean Delvarec2f559d2005-09-22 22:01:07 +0200104static struct pci_driver vt596_driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105static struct i2c_adapter vt596_adapter;
106
Jean Delvaref1183012005-09-22 21:58:41 +0200107#define FEATURE_I2CBLOCK (1<<0)
108static unsigned int vt596_features;
109
Jean Delvareed5453e2005-09-22 22:23:32 +0200110#ifdef DEBUG
111static void vt596_dump_regs(const char *msg, u8 size)
112{
113 dev_dbg(&vt596_adapter.dev, "%s: STS=%02x CNT=%02x CMD=%02x ADD=%02x "
114 "DAT=%02x,%02x\n", msg, inb_p(SMBHSTSTS), inb_p(SMBHSTCNT),
115 inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
116 inb_p(SMBHSTDAT1));
117
118 if (size == VT596_BLOCK_DATA
119 || size == VT596_I2C_BLOCK_DATA) {
120 int i;
121
122 dev_dbg(&vt596_adapter.dev, "BLK=");
123 for (i = 0; i < I2C_SMBUS_BLOCK_MAX / 2; i++)
124 printk("%02x,", inb_p(SMBBLKDAT));
125 printk("\n");
126 dev_dbg(&vt596_adapter.dev, " ");
127 for (; i < I2C_SMBUS_BLOCK_MAX - 1; i++)
128 printk("%02x,", inb_p(SMBBLKDAT));
129 printk("%02x\n", inb_p(SMBBLKDAT));
130 }
131}
Greg KHca68f112005-09-22 22:23:32 +0200132#else
133static inline void vt596_dump_regs(const char *msg, u8 size) { }
Jean Delvareed5453e2005-09-22 22:23:32 +0200134#endif
135
Jean Delvarec2f559d2005-09-22 22:01:07 +0200136/* Return -1 on error, 0 on success */
Jean Delvare50c1cc32005-09-22 22:15:53 +0200137static int vt596_transaction(u8 size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138{
139 int temp;
140 int result = 0;
141 int timeout = 0;
142
Jean Delvareed5453e2005-09-22 22:23:32 +0200143 vt596_dump_regs("Transaction (pre)", size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
145 /* Make sure the SMBus host is ready to start transmitting */
146 if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
147 dev_dbg(&vt596_adapter.dev, "SMBus busy (0x%02x). "
Jean Delvare87501972005-10-31 18:51:21 +0100148 "Resetting...\n", temp);
Jean Delvare5f49ef82005-09-22 21:50:47 +0200149
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 outb_p(temp, SMBHSTSTS);
151 if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
Jean Delvare87501972005-10-31 18:51:21 +0100152 dev_err(&vt596_adapter.dev, "SMBus reset failed! "
153 "(0x%02x)\n", temp);
David Brownell97140342008-07-14 22:38:25 +0200154 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 }
156 }
157
Jean Delvarec2f559d2005-09-22 22:01:07 +0200158 /* Start the transaction by setting bit 6 */
Jean Delvare87501972005-10-31 18:51:21 +0100159 outb_p(0x40 | size, SMBHSTCNT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
Jean Delvarec2f559d2005-09-22 22:01:07 +0200161 /* We will always wait for a fraction of a second */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 do {
163 msleep(1);
164 temp = inb_p(SMBHSTSTS);
165 } while ((temp & 0x01) && (timeout++ < MAX_TIMEOUT));
166
167 /* If the SMBus is still busy, we give up */
168 if (timeout >= MAX_TIMEOUT) {
David Brownell97140342008-07-14 22:38:25 +0200169 result = -ETIMEDOUT;
Jean Delvarec2f559d2005-09-22 22:01:07 +0200170 dev_err(&vt596_adapter.dev, "SMBus timeout!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 }
172
173 if (temp & 0x10) {
David Brownell97140342008-07-14 22:38:25 +0200174 result = -EIO;
Jean Delvarec2f559d2005-09-22 22:01:07 +0200175 dev_err(&vt596_adapter.dev, "Transaction failed (0x%02x)\n",
Jean Delvare87501972005-10-31 18:51:21 +0100176 size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 }
178
179 if (temp & 0x08) {
David Brownell97140342008-07-14 22:38:25 +0200180 result = -EIO;
Jean Delvarec2f559d2005-09-22 22:01:07 +0200181 dev_err(&vt596_adapter.dev, "SMBus collision!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 }
183
184 if (temp & 0x04) {
Jean Delvare87501972005-10-31 18:51:21 +0100185 int read = inb_p(SMBHSTADD) & 0x01;
David Brownell97140342008-07-14 22:38:25 +0200186 result = -ENXIO;
Jean Delvare87501972005-10-31 18:51:21 +0100187 /* The quick and receive byte commands are used to probe
188 for chips, so errors are expected, and we don't want
189 to frighten the user. */
190 if (!((size == VT596_QUICK && !read) ||
191 (size == VT596_BYTE && read)))
Jean Delvarec2f559d2005-09-22 22:01:07 +0200192 dev_err(&vt596_adapter.dev, "Transaction error!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 }
194
Jean Delvarec2f559d2005-09-22 22:01:07 +0200195 /* Resetting status register */
196 if (temp & 0x1F)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 outb_p(temp, SMBHSTSTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
Jean Delvareed5453e2005-09-22 22:23:32 +0200199 vt596_dump_regs("Transaction (post)", size);
Jean Delvare5f49ef82005-09-22 21:50:47 +0200200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 return result;
202}
203
David Brownell97140342008-07-14 22:38:25 +0200204/* Return negative errno on error, 0 on success */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
Jean Delvare5f49ef82005-09-22 21:50:47 +0200206 unsigned short flags, char read_write, u8 command,
207 int size, union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208{
Jean Delvarec2f559d2005-09-22 22:01:07 +0200209 int i;
David Brownell97140342008-07-14 22:38:25 +0200210 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
212 switch (size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 case I2C_SMBUS_QUICK:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 size = VT596_QUICK;
215 break;
216 case I2C_SMBUS_BYTE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 if (read_write == I2C_SMBUS_WRITE)
218 outb_p(command, SMBHSTCMD);
219 size = VT596_BYTE;
220 break;
221 case I2C_SMBUS_BYTE_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 outb_p(command, SMBHSTCMD);
223 if (read_write == I2C_SMBUS_WRITE)
224 outb_p(data->byte, SMBHSTDAT0);
225 size = VT596_BYTE_DATA;
226 break;
227 case I2C_SMBUS_WORD_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 outb_p(command, SMBHSTCMD);
229 if (read_write == I2C_SMBUS_WRITE) {
230 outb_p(data->word & 0xff, SMBHSTDAT0);
231 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
232 }
233 size = VT596_WORD_DATA;
234 break;
Jean Delvaref1183012005-09-22 21:58:41 +0200235 case I2C_SMBUS_I2C_BLOCK_DATA:
236 if (!(vt596_features & FEATURE_I2CBLOCK))
Jean Delvarec2f559d2005-09-22 22:01:07 +0200237 goto exit_unsupported;
Jean Delvaref1183012005-09-22 21:58:41 +0200238 if (read_write == I2C_SMBUS_READ)
Jean Delvare4b2643d2007-07-12 14:12:29 +0200239 outb_p(data->block[0], SMBHSTDAT0);
Jean Delvaref1183012005-09-22 21:58:41 +0200240 /* Fall through */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 case I2C_SMBUS_BLOCK_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 outb_p(command, SMBHSTCMD);
243 if (read_write == I2C_SMBUS_WRITE) {
Jean Delvarec2f559d2005-09-22 22:01:07 +0200244 u8 len = data->block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 if (len > I2C_SMBUS_BLOCK_MAX)
246 len = I2C_SMBUS_BLOCK_MAX;
247 outb_p(len, SMBHSTDAT0);
Jean Delvarec2f559d2005-09-22 22:01:07 +0200248 inb_p(SMBHSTCNT); /* Reset SMBBLKDAT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 for (i = 1; i <= len; i++)
250 outb_p(data->block[i], SMBBLKDAT);
251 }
Jean Delvaref1183012005-09-22 21:58:41 +0200252 size = (size == I2C_SMBUS_I2C_BLOCK_DATA) ?
253 VT596_I2C_BLOCK_DATA : VT596_BLOCK_DATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 break;
Jean Delvarec2f559d2005-09-22 22:01:07 +0200255 default:
256 goto exit_unsupported;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 }
258
Jean Delvarec2f559d2005-09-22 22:01:07 +0200259 outb_p(((addr & 0x7f) << 1) | read_write, SMBHSTADD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
David Brownell97140342008-07-14 22:38:25 +0200261 status = vt596_transaction(size);
262 if (status)
263 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264
265 if ((read_write == I2C_SMBUS_WRITE) || (size == VT596_QUICK))
266 return 0;
267
268 switch (size) {
269 case VT596_BYTE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 case VT596_BYTE_DATA:
271 data->byte = inb_p(SMBHSTDAT0);
272 break;
273 case VT596_WORD_DATA:
274 data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
275 break;
Jean Delvaref1183012005-09-22 21:58:41 +0200276 case VT596_I2C_BLOCK_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 case VT596_BLOCK_DATA:
278 data->block[0] = inb_p(SMBHSTDAT0);
279 if (data->block[0] > I2C_SMBUS_BLOCK_MAX)
280 data->block[0] = I2C_SMBUS_BLOCK_MAX;
Jean Delvarec2f559d2005-09-22 22:01:07 +0200281 inb_p(SMBHSTCNT); /* Reset SMBBLKDAT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 for (i = 1; i <= data->block[0]; i++)
283 data->block[i] = inb_p(SMBBLKDAT);
284 break;
285 }
286 return 0;
Jean Delvarec2f559d2005-09-22 22:01:07 +0200287
288exit_unsupported:
Jean Delvareac7fc4f2008-07-14 22:38:25 +0200289 dev_warn(&vt596_adapter.dev, "Unsupported transaction %d\n",
Jean Delvarec2f559d2005-09-22 22:01:07 +0200290 size);
David Brownell97140342008-07-14 22:38:25 +0200291 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292}
293
294static u32 vt596_func(struct i2c_adapter *adapter)
295{
Jean Delvaref1183012005-09-22 21:58:41 +0200296 u32 func = I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
298 I2C_FUNC_SMBUS_BLOCK_DATA;
Jean Delvaref1183012005-09-22 21:58:41 +0200299
300 if (vt596_features & FEATURE_I2CBLOCK)
301 func |= I2C_FUNC_SMBUS_I2C_BLOCK;
302 return func;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303}
304
Jean Delvare8f9082c2006-09-03 22:39:46 +0200305static const struct i2c_algorithm smbus_algorithm = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 .smbus_xfer = vt596_access,
307 .functionality = vt596_func,
308};
309
310static struct i2c_adapter vt596_adapter = {
311 .owner = THIS_MODULE,
Stephen Hemminger9ace5552007-02-13 22:09:01 +0100312 .id = I2C_HW_SMBUS_VIA2,
Jean Delvare3401b2f2008-07-14 22:38:29 +0200313 .class = I2C_CLASS_HWMON | I2C_CLASS_SPD,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 .algo = &smbus_algorithm,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315};
316
317static int __devinit vt596_probe(struct pci_dev *pdev,
318 const struct pci_device_id *id)
319{
320 unsigned char temp;
321 int error = -ENODEV;
Jean Delvare5f49ef82005-09-22 21:50:47 +0200322
Jean Delvare0f07a242008-01-27 18:14:51 +0100323 /* driver_data might come from user-space, so check it */
324 if (id->driver_data & 1 || id->driver_data > 0xff)
325 return -EINVAL;
326
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 /* Determine the address of the SMBus areas */
328 if (force_addr) {
329 vt596_smba = force_addr & 0xfff0;
330 force = 0;
331 goto found;
332 }
333
334 if ((pci_read_config_word(pdev, id->driver_data, &vt596_smba)) ||
Jean Delvarec2f559d2005-09-22 22:01:07 +0200335 !(vt596_smba & 0x0001)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 /* try 2nd address and config reg. for 596 */
337 if (id->device == PCI_DEVICE_ID_VIA_82C596_3 &&
338 !pci_read_config_word(pdev, SMBBA2, &vt596_smba) &&
Jean Delvarec2f559d2005-09-22 22:01:07 +0200339 (vt596_smba & 0x0001)) {
340 SMBHSTCFG = 0x84;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 } else {
342 /* no matches at all */
343 dev_err(&pdev->dev, "Cannot configure "
344 "SMBus I/O Base address\n");
345 return -ENODEV;
346 }
347 }
348
349 vt596_smba &= 0xfff0;
350 if (vt596_smba == 0) {
351 dev_err(&pdev->dev, "SMBus base address "
352 "uninitialized - upgrade BIOS or use "
353 "force_addr=0xaddr\n");
354 return -ENODEV;
355 }
356
Jean Delvare5f49ef82005-09-22 21:50:47 +0200357found:
Jean Delvare54fb4a052008-07-14 22:38:33 +0200358 error = acpi_check_region(vt596_smba, 8, vt596_driver.name);
359 if (error)
360 return error;
361
Jean Delvarec2f559d2005-09-22 22:01:07 +0200362 if (!request_region(vt596_smba, 8, vt596_driver.name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 dev_err(&pdev->dev, "SMBus region 0x%x already in use!\n",
Jean Delvare5f49ef82005-09-22 21:50:47 +0200364 vt596_smba);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 return -ENODEV;
366 }
367
368 pci_read_config_byte(pdev, SMBHSTCFG, &temp);
369 /* If force_addr is set, we program the new address here. Just to make
370 sure, we disable the VT596 first. */
371 if (force_addr) {
372 pci_write_config_byte(pdev, SMBHSTCFG, temp & 0xfe);
373 pci_write_config_word(pdev, id->driver_data, vt596_smba);
374 pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
375 dev_warn(&pdev->dev, "WARNING: SMBus interface set to new "
Jean Delvare5f49ef82005-09-22 21:50:47 +0200376 "address 0x%04x!\n", vt596_smba);
Jean Delvarec2f559d2005-09-22 22:01:07 +0200377 } else if (!(temp & 0x01)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 if (force) {
Jean Delvare5f49ef82005-09-22 21:50:47 +0200379 /* NOTE: This assumes I/O space and other allocations
380 * WERE done by the Bios! Don't complain if your
381 * hardware does weird things after enabling this.
382 * :') Check for Bios updates before resorting to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 * this.
384 */
Jean Delvarec2f559d2005-09-22 22:01:07 +0200385 pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 dev_info(&pdev->dev, "Enabling SMBus device\n");
387 } else {
388 dev_err(&pdev->dev, "SMBUS: Error: Host SMBus "
389 "controller not enabled! - upgrade BIOS or "
390 "use force=1\n");
391 goto release_region;
392 }
393 }
394
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 dev_dbg(&pdev->dev, "VT596_smba = 0x%X\n", vt596_smba);
396
Jean Delvaref1183012005-09-22 21:58:41 +0200397 switch (pdev->device) {
Jean Delvareab6a6ed2007-02-13 22:09:02 +0100398 case PCI_DEVICE_ID_VIA_CX700:
Rudolf Marekc2433532006-09-03 22:35:21 +0200399 case PCI_DEVICE_ID_VIA_8251:
Jean Delvaref1183012005-09-22 21:58:41 +0200400 case PCI_DEVICE_ID_VIA_8237:
Rudolf Marekc2433532006-09-03 22:35:21 +0200401 case PCI_DEVICE_ID_VIA_8237A:
Jean Delvare0d227a72008-01-27 18:14:51 +0100402 case PCI_DEVICE_ID_VIA_8237S:
Jean Delvaref1183012005-09-22 21:58:41 +0200403 case PCI_DEVICE_ID_VIA_8235:
404 case PCI_DEVICE_ID_VIA_8233A:
405 case PCI_DEVICE_ID_VIA_8233_0:
406 vt596_features |= FEATURE_I2CBLOCK;
407 break;
408 case PCI_DEVICE_ID_VIA_82C686_4:
409 /* The VT82C686B (rev 0x40) does support I2C block
410 transactions, but the VT82C686A (rev 0x30) doesn't */
Auke Kok44c10132007-06-08 15:46:36 -0700411 if (pdev->revision >= 0x40)
Jean Delvaref1183012005-09-22 21:58:41 +0200412 vt596_features |= FEATURE_I2CBLOCK;
413 break;
414 }
415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 vt596_adapter.dev.parent = &pdev->dev;
David Brownell2096b952007-05-01 23:26:28 +0200417 snprintf(vt596_adapter.name, sizeof(vt596_adapter.name),
Jean Delvare5f49ef82005-09-22 21:50:47 +0200418 "SMBus Via Pro adapter at %04x", vt596_smba);
419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 vt596_pdev = pci_dev_get(pdev);
421 if (i2c_add_adapter(&vt596_adapter)) {
422 pci_dev_put(vt596_pdev);
423 vt596_pdev = NULL;
424 }
425
426 /* Always return failure here. This is to allow other drivers to bind
427 * to this pci device. We don't really want to have control over the
428 * pci device, we only wanted to read as few register values from it.
429 */
430 return -ENODEV;
431
Jean Delvare5f49ef82005-09-22 21:50:47 +0200432release_region:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 release_region(vt596_smba, 8);
434 return error;
435}
436
437static struct pci_device_id vt596_ids[] = {
438 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596_3),
439 .driver_data = SMBBA1 },
440 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596B_3),
441 .driver_data = SMBBA1 },
442 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4),
443 .driver_data = SMBBA1 },
444 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233_0),
445 .driver_data = SMBBA3 },
446 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233A),
447 .driver_data = SMBBA3 },
448 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235),
449 .driver_data = SMBBA3 },
450 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237),
451 .driver_data = SMBBA3 },
Rudolf Marekc2433532006-09-03 22:35:21 +0200452 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237A),
453 .driver_data = SMBBA3 },
Jean Delvare0d227a72008-01-27 18:14:51 +0100454 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237S),
455 .driver_data = SMBBA3 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4),
457 .driver_data = SMBBA1 },
Rudolf Marekc2433532006-09-03 22:35:21 +0200458 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8251),
459 .driver_data = SMBBA3 },
Jean Delvareab6a6ed2007-02-13 22:09:02 +0100460 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_CX700),
461 .driver_data = SMBBA3 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 { 0, }
463};
464
Jean Delvare5f49ef82005-09-22 21:50:47 +0200465MODULE_DEVICE_TABLE(pci, vt596_ids);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466
467static struct pci_driver vt596_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 .name = "vt596_smbus",
469 .id_table = vt596_ids,
470 .probe = vt596_probe,
Jean Delvare0f07a242008-01-27 18:14:51 +0100471 .dynids.use_driver_data = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472};
473
474static int __init i2c_vt596_init(void)
475{
476 return pci_register_driver(&vt596_driver);
477}
478
479
480static void __exit i2c_vt596_exit(void)
481{
482 pci_unregister_driver(&vt596_driver);
483 if (vt596_pdev != NULL) {
484 i2c_del_adapter(&vt596_adapter);
485 release_region(vt596_smba, 8);
486 pci_dev_put(vt596_pdev);
487 vt596_pdev = NULL;
488 }
489}
490
Jean Delvare87501972005-10-31 18:51:21 +0100491MODULE_AUTHOR("Kyosti Malkki <kmalkki@cc.hut.fi>, "
492 "Mark D. Studebaker <mdsxyz123@yahoo.com> and "
493 "Jean Delvare <khali@linux-fr.org>");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494MODULE_DESCRIPTION("vt82c596 SMBus driver");
495MODULE_LICENSE("GPL");
496
497module_init(i2c_vt596_init);
498module_exit(i2c_vt596_exit);