xref: /linux/drivers/i2c/busses/i2c-viapro.c (revision 06d07429858317ded2db7986113a9e0129cd599b)
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 
44 static struct pci_dev *vt596_pdev;
45 
46 #define SMBBA1		0x90
47 #define SMBBA2		0x80
48 #define SMBBA3		0xD0
49 
50 /* SMBus address offsets */
51 static 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 
65 static 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! */
82 static bool force;
83 module_param(force, bool, 0);
84 MODULE_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! */
88 static u16 force_addr;
89 module_param_hw(force_addr, ushort, ioport, 0);
90 MODULE_PARM_DESC(force_addr,
91 		 "Forcibly enable the SMBus at the given address. "
92 		 "EXTREMELY DANGEROUS!");
93 
94 
95 static struct pci_driver vt596_driver;
96 static struct i2c_adapter vt596_adapter;
97 
98 #define FEATURE_I2CBLOCK	(1<<0)
99 static unsigned int vt596_features;
100 
101 #ifdef DEBUG
vt596_dump_regs(const char * msg,u8 size)102 static 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
vt596_dump_regs(const char * msg,u8 size)124 static inline void vt596_dump_regs(const char *msg, u8 size) { }
125 #endif
126 
127 /* Return -1 on error, 0 on success */
vt596_transaction(u8 size)128 static 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 */
vt596_access(struct i2c_adapter * adap,u16 addr,unsigned short flags,char read_write,u8 command,int size,union i2c_smbus_data * data)190 static 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 
283 exit_unsupported:
284 	dev_warn(&vt596_adapter.dev, "Unsupported transaction %d\n",
285 		 size);
286 	return -EOPNOTSUPP;
287 }
288 
vt596_func(struct i2c_adapter * adapter)289 static 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 
300 static const struct i2c_algorithm smbus_algorithm = {
301 	.smbus_xfer	= vt596_access,
302 	.functionality	= vt596_func,
303 };
304 
305 static struct i2c_adapter vt596_adapter = {
306 	.owner		= THIS_MODULE,
307 	.class		= I2C_CLASS_HWMON,
308 	.algo		= &smbus_algorithm,
309 };
310 
vt596_probe(struct pci_dev * pdev,const struct pci_device_id * id)311 static 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 
347 found:
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 
428 release_region:
429 	release_region(vt596_smba, 8);
430 	return error;
431 }
432 
433 static 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 
467 MODULE_DEVICE_TABLE(pci, vt596_ids);
468 
469 static struct pci_driver vt596_driver = {
470 	.name		= "vt596_smbus",
471 	.id_table	= vt596_ids,
472 	.probe		= vt596_probe,
473 };
474 
i2c_vt596_init(void)475 static int __init i2c_vt596_init(void)
476 {
477 	return pci_register_driver(&vt596_driver);
478 }
479 
480 
i2c_vt596_exit(void)481 static 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 
492 MODULE_AUTHOR("Kyosti Malkki <kmalkki@cc.hut.fi>");
493 MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
494 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
495 MODULE_DESCRIPTION("vt82c596 SMBus driver");
496 MODULE_LICENSE("GPL");
497 
498 module_init(i2c_vt596_init);
499 module_exit(i2c_vt596_exit);
500