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
52static struct pci_dev *vt596_pdev;
53
54#define SMBBA1		0x90
55#define SMBBA2		0x80
56#define SMBBA3		0xD0
57
58/* SMBus address offsets */
59static 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
73static 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! */
90static bool force;
91module_param(force, bool, 0);
92MODULE_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! */
96static u16 force_addr;
97module_param(force_addr, ushort, 0);
98MODULE_PARM_DESC(force_addr,
99		 "Forcibly enable the SMBus at the given address. "
100		 "EXTREMELY DANGEROUS!");
101
102
103static struct pci_driver vt596_driver;
104static struct i2c_adapter vt596_adapter;
105
106#define FEATURE_I2CBLOCK	(1<<0)
107static unsigned int vt596_features;
108
109#ifdef DEBUG
110static 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
132static inline void vt596_dump_regs(const char *msg, u8 size) { }
133#endif
134
135/* Return -1 on error, 0 on success */
136static 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 */
198static 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
291exit_unsupported:
292	dev_warn(&vt596_adapter.dev, "Unsupported transaction %d\n",
293		 size);
294	return -EOPNOTSUPP;
295}
296
297static 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
308static const struct i2c_algorithm smbus_algorithm = {
309	.smbus_xfer	= vt596_access,
310	.functionality	= vt596_func,
311};
312
313static struct i2c_adapter vt596_adapter = {
314	.owner		= THIS_MODULE,
315	.class		= I2C_CLASS_HWMON | I2C_CLASS_SPD,
316	.algo		= &smbus_algorithm,
317};
318
319static 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
355found:
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
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	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX900),
471	  .driver_data = SMBBA3 },
472	{ 0, }
473};
474
475MODULE_DEVICE_TABLE(pci, vt596_ids);
476
477static struct pci_driver vt596_driver = {
478	.name		= "vt596_smbus",
479	.id_table	= vt596_ids,
480	.probe		= vt596_probe,
481};
482
483static int __init i2c_vt596_init(void)
484{
485	return pci_register_driver(&vt596_driver);
486}
487
488
489static 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
500MODULE_AUTHOR("Kyosti Malkki <kmalkki@cc.hut.fi>, "
501	      "Mark D. Studebaker <mdsxyz123@yahoo.com> and "
502	      "Jean Delvare <jdelvare@suse.de>");
503MODULE_DESCRIPTION("vt82c596 SMBus driver");
504MODULE_LICENSE("GPL");
505
506module_init(i2c_vt596_init);
507module_exit(i2c_vt596_exit);
508