i2c-viapro.c

  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,
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			return dev_err_probe(&pdev->dev, -ENODEV,
334					     "Cannot configure "
335					     "SMBus I/O Base address\n");
336		}
337	}
338
339	vt596_smba &= 0xfff0;
340	if (vt596_smba == 0)
341		return dev_err_probe(&pdev->dev, -ENODEV, "SMBus base address "
342				     "uninitialized - upgrade BIOS or use "
343				     "force_addr=0xaddr\n");
344
345found:
346	error = acpi_check_region(vt596_smba, 8, vt596_driver.name);
347	if (error)
348		return -ENODEV;
349
350	if (!request_region(vt596_smba, 8, vt596_driver.name))
351		return dev_err_probe(&pdev->dev, -ENODEV,
352				     "SMBus region 0x%x already in use!\n",
353				     vt596_smba);
354
355	pci_read_config_byte(pdev, SMBHSTCFG, &temp);
356	/* If force_addr is set, we program the new address here. Just to make
357	   sure, we disable the VT596 first. */
358	if (force_addr) {
359		pci_write_config_byte(pdev, SMBHSTCFG, temp & 0xfe);
360		pci_write_config_word(pdev, id->driver_data, vt596_smba);
361		pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
362		dev_warn(&pdev->dev, "WARNING: SMBus interface set to new "
363			 "address 0x%04x!\n", vt596_smba);
364	} else if (!(temp & 0x01)) {
365		if (force) {
366			/* NOTE: This assumes I/O space and other allocations
367			 * WERE done by the Bios!  Don't complain if your
368			 * hardware does weird things after enabling this.
369			 * :') Check for Bios updates before resorting to
370			 * this.
371			 */
372			pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
373			dev_info(&pdev->dev, "Enabling SMBus device\n");
374		} else {
375			error = dev_err_probe(&pdev->dev, -ENODEV,
376					      "SMBUS: Error: Host SMBus "
377					      "controller not enabled! - "
378					      "upgrade BIOS or use force=1\n");
379			goto release_region;
380		}
381	}
382
383	dev_dbg(&pdev->dev, "VT596_smba = 0x%X\n", vt596_smba);
384
385	switch (pdev->device) {
386	case PCI_DEVICE_ID_VIA_CX700:
387	case PCI_DEVICE_ID_VIA_VX800:
388	case PCI_DEVICE_ID_VIA_VX855:
389	case PCI_DEVICE_ID_VIA_VX900:
390	case PCI_DEVICE_ID_VIA_8251:
391	case PCI_DEVICE_ID_VIA_8237:
392	case PCI_DEVICE_ID_VIA_8237A:
393	case PCI_DEVICE_ID_VIA_8237S:
394	case PCI_DEVICE_ID_VIA_8235:
395	case PCI_DEVICE_ID_VIA_8233A:
396	case PCI_DEVICE_ID_VIA_8233_0:
397		vt596_features |= FEATURE_I2CBLOCK;
398		break;
399	case PCI_DEVICE_ID_VIA_82C686_4:
400		/* The VT82C686B (rev 0x40) does support I2C block
401		   transactions, but the VT82C686A (rev 0x30) doesn't */
402		if (pdev->revision >= 0x40)
403			vt596_features |= FEATURE_I2CBLOCK;
404		break;
405	}
406
407	vt596_adapter.dev.parent = &pdev->dev;
408	snprintf(vt596_adapter.name, sizeof(vt596_adapter.name),
409		 "SMBus Via Pro adapter at %04x", vt596_smba);
410
411	vt596_pdev = pci_dev_get(pdev);
412	error = i2c_add_adapter(&vt596_adapter);
413	if (error) {
414		pci_dev_put(vt596_pdev);
415		vt596_pdev = NULL;
416		goto release_region;
417	}
418
419	/* Always return failure here.  This is to allow other drivers to bind
420	 * to this pci device.  We don't really want to have control over the
421	 * pci device, we only wanted to read as few register values from it.
422	 */
423	return -ENODEV;
424
425release_region:
426	release_region(vt596_smba, 8);
427	return error;
428}
429
430static const struct pci_device_id vt596_ids[] = {
431	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596_3),
432	  .driver_data = SMBBA1 },
433	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596B_3),
434	  .driver_data = SMBBA1 },
435	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4),
436	  .driver_data = SMBBA1 },
437	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233_0),
438	  .driver_data = SMBBA3 },
439	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233A),
440	  .driver_data = SMBBA3 },
441	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235),
442	  .driver_data = SMBBA3 },
443	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237),
444	  .driver_data = SMBBA3 },
445	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237A),
446	  .driver_data = SMBBA3 },
447	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237S),
448	  .driver_data = SMBBA3 },
449	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4),
450	  .driver_data = SMBBA1 },
451	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8251),
452	  .driver_data = SMBBA3 },
453	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_CX700),
454	  .driver_data = SMBBA3 },
455	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX800),
456	  .driver_data = SMBBA3 },
457	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX855),
458	  .driver_data = SMBBA3 },
459	{ PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX900),
460	  .driver_data = SMBBA3 },
461	{ 0, }
462};
463
464MODULE_DEVICE_TABLE(pci, vt596_ids);
465
466static struct pci_driver vt596_driver = {
467	.name		= "vt596_smbus",
468	.id_table	= vt596_ids,
469	.probe		= vt596_probe,
470};
471
472static int __init i2c_vt596_init(void)
473{
474	return pci_register_driver(&vt596_driver);
475}
476
477
478static void __exit i2c_vt596_exit(void)
479{
480	pci_unregister_driver(&vt596_driver);
481	if (vt596_pdev != NULL) {
482		i2c_del_adapter(&vt596_adapter);
483		release_region(vt596_smba, 8);
484		pci_dev_put(vt596_pdev);
485		vt596_pdev = NULL;
486	}
487}
488
489MODULE_AUTHOR("Kyosti Malkki <kmalkki@cc.hut.fi>");
490MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
491MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
492MODULE_DESCRIPTION("vt82c596 SMBus driver");
493MODULE_LICENSE("GPL");
494
495module_init(i2c_vt596_init);
496module_exit(i2c_vt596_exit);