blob: 0b012f1f8ac5791ba9a4aa7926f75fbe97c57567 [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
Rudolf Marekb806a712008-10-14 17:30:03 +020039 VX800/VX820 0x8353 yes
Harald Weltea2315912009-06-15 18:01:49 +020040 VX855/VX875 0x8409 yes
Jean Delvareaaf7f142005-09-22 22:09:07 +020041
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 Note: we assume there can only be one device, with one SMBus interface.
43*/
44
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <linux/module.h>
46#include <linux/delay.h>
47#include <linux/pci.h>
48#include <linux/kernel.h>
49#include <linux/stddef.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include <linux/ioport.h>
51#include <linux/i2c.h>
52#include <linux/init.h>
Jean Delvare54fb4a052008-07-14 22:38:33 +020053#include <linux/acpi.h>
H Hartley Sweeten21782182010-05-21 18:41:01 +020054#include <linux/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56static struct pci_dev *vt596_pdev;
57
Jean Delvare5f49ef82005-09-22 21:50:47 +020058#define SMBBA1 0x90
59#define SMBBA2 0x80
60#define SMBBA3 0xD0
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62/* SMBus address offsets */
63static unsigned short vt596_smba;
64#define SMBHSTSTS (vt596_smba + 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070065#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)
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
72/* PCI Address Constants */
73
74/* SMBus data in configuration space can be found in two places,
Jean Delvare5f49ef82005-09-22 21:50:47 +020075 We try to select the better one */
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Jean Delvarec2f559d2005-09-22 22:01:07 +020077static unsigned short SMBHSTCFG = 0xD2;
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
79/* Other settings */
80#define MAX_TIMEOUT 500
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
82/* VT82C596 constants */
Jean Delvare5f49ef82005-09-22 21:50:47 +020083#define VT596_QUICK 0x00
84#define VT596_BYTE 0x04
85#define VT596_BYTE_DATA 0x08
86#define VT596_WORD_DATA 0x0C
Prakash Morthaa05f2c52008-10-14 17:30:06 +020087#define VT596_PROC_CALL 0x10
Jean Delvare5f49ef82005-09-22 21:50:47 +020088#define VT596_BLOCK_DATA 0x14
Jean Delvaref1183012005-09-22 21:58:41 +020089#define VT596_I2C_BLOCK_DATA 0x34
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
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
Jean Delvarec2f559d2005-09-22 22:01:07 +0200107static struct pci_driver vt596_driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108static struct i2c_adapter vt596_adapter;
109
Jean Delvaref1183012005-09-22 21:58:41 +0200110#define FEATURE_I2CBLOCK (1<<0)
111static unsigned int vt596_features;
112
Jean Delvareed5453e2005-09-22 22:23:32 +0200113#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}
Greg KHca68f112005-09-22 22:23:32 +0200135#else
136static inline void vt596_dump_regs(const char *msg, u8 size) { }
Jean Delvareed5453e2005-09-22 22:23:32 +0200137#endif
138
Jean Delvarec2f559d2005-09-22 22:01:07 +0200139/* Return -1 on error, 0 on success */
Jean Delvare50c1cc32005-09-22 22:15:53 +0200140static int vt596_transaction(u8 size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141{
142 int temp;
143 int result = 0;
144 int timeout = 0;
145
Jean Delvareed5453e2005-09-22 22:23:32 +0200146 vt596_dump_regs("Transaction (pre)", size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
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). "
Jean Delvare87501972005-10-31 18:51:21 +0100151 "Resetting...\n", temp);
Jean Delvare5f49ef82005-09-22 21:50:47 +0200152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 outb_p(temp, SMBHSTSTS);
154 if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
Jean Delvare87501972005-10-31 18:51:21 +0100155 dev_err(&vt596_adapter.dev, "SMBus reset failed! "
156 "(0x%02x)\n", temp);
David Brownell97140342008-07-14 22:38:25 +0200157 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 }
159 }
160
Jean Delvarec2f559d2005-09-22 22:01:07 +0200161 /* Start the transaction by setting bit 6 */
Jean Delvare87501972005-10-31 18:51:21 +0100162 outb_p(0x40 | size, SMBHSTCNT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
Jean Delvarec2f559d2005-09-22 22:01:07 +0200164 /* We will always wait for a fraction of a second */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 do {
166 msleep(1);
167 temp = inb_p(SMBHSTSTS);
Roel Kluinb6a31952010-01-16 20:43:12 +0100168 } while ((temp & 0x01) && (++timeout < MAX_TIMEOUT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
170 /* If the SMBus is still busy, we give up */
Roel Kluinb6a31952010-01-16 20:43:12 +0100171 if (timeout == MAX_TIMEOUT) {
David Brownell97140342008-07-14 22:38:25 +0200172 result = -ETIMEDOUT;
Jean Delvarec2f559d2005-09-22 22:01:07 +0200173 dev_err(&vt596_adapter.dev, "SMBus timeout!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 }
175
176 if (temp & 0x10) {
David Brownell97140342008-07-14 22:38:25 +0200177 result = -EIO;
Jean Delvarec2f559d2005-09-22 22:01:07 +0200178 dev_err(&vt596_adapter.dev, "Transaction failed (0x%02x)\n",
Jean Delvare87501972005-10-31 18:51:21 +0100179 size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 }
181
182 if (temp & 0x08) {
David Brownell97140342008-07-14 22:38:25 +0200183 result = -EIO;
Jean Delvarec2f559d2005-09-22 22:01:07 +0200184 dev_err(&vt596_adapter.dev, "SMBus collision!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 }
186
187 if (temp & 0x04) {
David Brownell97140342008-07-14 22:38:25 +0200188 result = -ENXIO;
Jean Delvarebf5d95c2010-10-24 18:16:59 +0200189 dev_dbg(&vt596_adapter.dev, "No response\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 }
191
Jean Delvarec2f559d2005-09-22 22:01:07 +0200192 /* Resetting status register */
193 if (temp & 0x1F)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 outb_p(temp, SMBHSTSTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
Jean Delvareed5453e2005-09-22 22:23:32 +0200196 vt596_dump_regs("Transaction (post)", size);
Jean Delvare5f49ef82005-09-22 21:50:47 +0200197
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 return result;
199}
200
David Brownell97140342008-07-14 22:38:25 +0200201/* Return negative errno on error, 0 on success */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
Jean Delvare5f49ef82005-09-22 21:50:47 +0200203 unsigned short flags, char read_write, u8 command,
204 int size, union i2c_smbus_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205{
Jean Delvarec2f559d2005-09-22 22:01:07 +0200206 int i;
David Brownell97140342008-07-14 22:38:25 +0200207 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208
209 switch (size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 case I2C_SMBUS_QUICK:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 size = VT596_QUICK;
212 break;
213 case I2C_SMBUS_BYTE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 if (read_write == I2C_SMBUS_WRITE)
215 outb_p(command, SMBHSTCMD);
216 size = VT596_BYTE;
217 break;
218 case I2C_SMBUS_BYTE_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 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:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 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;
Prakash Morthaa05f2c52008-10-14 17:30:06 +0200232 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;
Jean Delvaref1183012005-09-22 21:58:41 +0200238 case I2C_SMBUS_I2C_BLOCK_DATA:
239 if (!(vt596_features & FEATURE_I2CBLOCK))
Jean Delvarec2f559d2005-09-22 22:01:07 +0200240 goto exit_unsupported;
Jean Delvaref1183012005-09-22 21:58:41 +0200241 if (read_write == I2C_SMBUS_READ)
Jean Delvare4b2643d2007-07-12 14:12:29 +0200242 outb_p(data->block[0], SMBHSTDAT0);
Jean Delvaref1183012005-09-22 21:58:41 +0200243 /* Fall through */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 case I2C_SMBUS_BLOCK_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 outb_p(command, SMBHSTCMD);
246 if (read_write == I2C_SMBUS_WRITE) {
Jean Delvarec2f559d2005-09-22 22:01:07 +0200247 u8 len = data->block[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 if (len > I2C_SMBUS_BLOCK_MAX)
249 len = I2C_SMBUS_BLOCK_MAX;
250 outb_p(len, SMBHSTDAT0);
Jean Delvarec2f559d2005-09-22 22:01:07 +0200251 inb_p(SMBHSTCNT); /* Reset SMBBLKDAT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 for (i = 1; i <= len; i++)
253 outb_p(data->block[i], SMBBLKDAT);
254 }
Jean Delvaref1183012005-09-22 21:58:41 +0200255 size = (size == I2C_SMBUS_I2C_BLOCK_DATA) ?
256 VT596_I2C_BLOCK_DATA : VT596_BLOCK_DATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 break;
Jean Delvarec2f559d2005-09-22 22:01:07 +0200258 default:
259 goto exit_unsupported;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 }
261
Jean Delvarec2f559d2005-09-22 22:01:07 +0200262 outb_p(((addr & 0x7f) << 1) | read_write, SMBHSTADD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
David Brownell97140342008-07-14 22:38:25 +0200264 status = vt596_transaction(size);
265 if (status)
266 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
Prakash Morthaa05f2c52008-10-14 17:30:06 +0200268 if (size == VT596_PROC_CALL)
269 read_write = I2C_SMBUS_READ;
270
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 if ((read_write == I2C_SMBUS_WRITE) || (size == VT596_QUICK))
272 return 0;
273
274 switch (size) {
275 case VT596_BYTE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 case VT596_BYTE_DATA:
277 data->byte = inb_p(SMBHSTDAT0);
278 break;
279 case VT596_WORD_DATA:
Prakash Morthaa05f2c52008-10-14 17:30:06 +0200280 case VT596_PROC_CALL:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
282 break;
Jean Delvaref1183012005-09-22 21:58:41 +0200283 case VT596_I2C_BLOCK_DATA:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 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;
Jean Delvarec2f559d2005-09-22 22:01:07 +0200288 inb_p(SMBHSTCNT); /* Reset SMBBLKDAT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 for (i = 1; i <= data->block[0]; i++)
290 data->block[i] = inb_p(SMBBLKDAT);
291 break;
292 }
293 return 0;
Jean Delvarec2f559d2005-09-22 22:01:07 +0200294
295exit_unsupported:
Jean Delvareac7fc4f2008-07-14 22:38:25 +0200296 dev_warn(&vt596_adapter.dev, "Unsupported transaction %d\n",
Jean Delvarec2f559d2005-09-22 22:01:07 +0200297 size);
David Brownell97140342008-07-14 22:38:25 +0200298 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299}
300
301static u32 vt596_func(struct i2c_adapter *adapter)
302{
Jean Delvaref1183012005-09-22 21:58:41 +0200303 u32 func = I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
Prakash Morthaa05f2c52008-10-14 17:30:06 +0200305 I2C_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_BLOCK_DATA;
Jean Delvaref1183012005-09-22 21:58:41 +0200306
307 if (vt596_features & FEATURE_I2CBLOCK)
308 func |= I2C_FUNC_SMBUS_I2C_BLOCK;
309 return func;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310}
311
Jean Delvare8f9082c2006-09-03 22:39:46 +0200312static const struct i2c_algorithm smbus_algorithm = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 .smbus_xfer = vt596_access,
314 .functionality = vt596_func,
315};
316
317static struct i2c_adapter vt596_adapter = {
318 .owner = THIS_MODULE,
Jean Delvare3401b2f2008-07-14 22:38:29 +0200319 .class = I2C_CLASS_HWMON | I2C_CLASS_SPD,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 .algo = &smbus_algorithm,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321};
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;
Jean Delvare5f49ef82005-09-22 21:50:47 +0200328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 /* 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)) ||
Jean Delvarec2f559d2005-09-22 22:01:07 +0200337 !(vt596_smba & 0x0001)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 /* 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) &&
Jean Delvarec2f559d2005-09-22 22:01:07 +0200341 (vt596_smba & 0x0001)) {
342 SMBHSTCFG = 0x84;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 } 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
Jean Delvare5f49ef82005-09-22 21:50:47 +0200359found:
Jean Delvare54fb4a052008-07-14 22:38:33 +0200360 error = acpi_check_region(vt596_smba, 8, vt596_driver.name);
361 if (error)
Jean Delvare18669ea2009-10-04 22:53:45 +0200362 return -ENODEV;
Jean Delvare54fb4a052008-07-14 22:38:33 +0200363
Jean Delvarec2f559d2005-09-22 22:01:07 +0200364 if (!request_region(vt596_smba, 8, vt596_driver.name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 dev_err(&pdev->dev, "SMBus region 0x%x already in use!\n",
Jean Delvare5f49ef82005-09-22 21:50:47 +0200366 vt596_smba);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 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 "
Jean Delvare5f49ef82005-09-22 21:50:47 +0200378 "address 0x%04x!\n", vt596_smba);
Jean Delvarec2f559d2005-09-22 22:01:07 +0200379 } else if (!(temp & 0x01)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 if (force) {
Jean Delvare5f49ef82005-09-22 21:50:47 +0200381 /* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 * this.
386 */
Jean Delvarec2f559d2005-09-22 22:01:07 +0200387 pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 dev_dbg(&pdev->dev, "VT596_smba = 0x%X\n", vt596_smba);
398
Jean Delvaref1183012005-09-22 21:58:41 +0200399 switch (pdev->device) {
Jean Delvareab6a6ed2007-02-13 22:09:02 +0100400 case PCI_DEVICE_ID_VIA_CX700:
Rudolf Marekb806a712008-10-14 17:30:03 +0200401 case PCI_DEVICE_ID_VIA_VX800:
Harald Weltea2315912009-06-15 18:01:49 +0200402 case PCI_DEVICE_ID_VIA_VX855:
Rudolf Marekc2433532006-09-03 22:35:21 +0200403 case PCI_DEVICE_ID_VIA_8251:
Jean Delvaref1183012005-09-22 21:58:41 +0200404 case PCI_DEVICE_ID_VIA_8237:
Rudolf Marekc2433532006-09-03 22:35:21 +0200405 case PCI_DEVICE_ID_VIA_8237A:
Jean Delvare0d227a72008-01-27 18:14:51 +0100406 case PCI_DEVICE_ID_VIA_8237S:
Jean Delvaref1183012005-09-22 21:58:41 +0200407 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 */
Auke Kok44c10132007-06-08 15:46:36 -0700415 if (pdev->revision >= 0x40)
Jean Delvaref1183012005-09-22 21:58:41 +0200416 vt596_features |= FEATURE_I2CBLOCK;
417 break;
418 }
419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 vt596_adapter.dev.parent = &pdev->dev;
David Brownell2096b952007-05-01 23:26:28 +0200421 snprintf(vt596_adapter.name, sizeof(vt596_adapter.name),
Jean Delvare5f49ef82005-09-22 21:50:47 +0200422 "SMBus Via Pro adapter at %04x", vt596_smba);
423
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 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
Jean Delvare5f49ef82005-09-22 21:50:47 +0200436release_region:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 release_region(vt596_smba, 8);
438 return error;
439}
440
Márton Németh4111ecd2010-03-02 12:23:37 +0100441static const struct pci_device_id vt596_ids[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 { 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 },
Rudolf Marekc2433532006-09-03 22:35:21 +0200456 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237A),
457 .driver_data = SMBBA3 },
Jean Delvare0d227a72008-01-27 18:14:51 +0100458 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237S),
459 .driver_data = SMBBA3 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4),
461 .driver_data = SMBBA1 },
Rudolf Marekc2433532006-09-03 22:35:21 +0200462 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8251),
463 .driver_data = SMBBA3 },
Jean Delvareab6a6ed2007-02-13 22:09:02 +0100464 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_CX700),
465 .driver_data = SMBBA3 },
Rudolf Marekb806a712008-10-14 17:30:03 +0200466 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX800),
467 .driver_data = SMBBA3 },
Harald Weltea2315912009-06-15 18:01:49 +0200468 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX855),
469 .driver_data = SMBBA3 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 { 0, }
471};
472
Jean Delvare5f49ef82005-09-22 21:50:47 +0200473MODULE_DEVICE_TABLE(pci, vt596_ids);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
475static struct pci_driver vt596_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 .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
Jean Delvare87501972005-10-31 18:51:21 +0100498MODULE_AUTHOR("Kyosti Malkki <kmalkki@cc.hut.fi>, "
499 "Mark D. Studebaker <mdsxyz123@yahoo.com> and "
500 "Jean Delvare <khali@linux-fr.org>");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501MODULE_DESCRIPTION("vt82c596 SMBus driver");
502MODULE_LICENSE("GPL");
503
504module_init(i2c_vt596_init);
505module_exit(i2c_vt596_exit);