xref: /openbmc/linux/drivers/i2c/busses/i2c-sis630.c (revision fdf23c62)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3     Copyright (c) 2002,2003 Alexander Malysh <amalysh@web.de>
4 
5 */
6 
7 /*
8    Status: beta
9 
10    Supports:
11 	SIS 630
12 	SIS 730
13 	SIS 964
14 
15    Notable differences between chips:
16 	+------------------------+--------------------+-------------------+
17 	|                        |     SIS630/730     |      SIS964       |
18 	+------------------------+--------------------+-------------------+
19 	| Clock                  | 14kHz/56kHz        | 55.56kHz/27.78kHz |
20 	| SMBus registers offset | 0x80               | 0xE0              |
21 	| SMB_CNT                | Bit 1 = Slave Busy | Bit 1 = Bus probe |
22 	|         (not used yet) | Bit 3 is reserved  | Bit 3 = Last byte |
23 	| SMB_PCOUNT		 | Offset + 0x06      | Offset + 0x14     |
24 	| SMB_COUNT              | 4:0 bits           | 5:0 bits          |
25 	+------------------------+--------------------+-------------------+
26 	(Other differences don't affect the functions provided by the driver)
27 
28    Note: we assume there can only be one device, with one SMBus interface.
29 */
30 
31 #include <linux/kernel.h>
32 #include <linux/module.h>
33 #include <linux/delay.h>
34 #include <linux/pci.h>
35 #include <linux/ioport.h>
36 #include <linux/i2c.h>
37 #include <linux/acpi.h>
38 #include <linux/io.h>
39 
40 /* SIS964 id is defined here as we are the only file using it */
41 #define PCI_DEVICE_ID_SI_964	0x0964
42 
43 /* SIS630/730/964 SMBus registers */
44 #define SMB_STS			0x00	/* status */
45 #define SMB_CNT			0x02	/* control */
46 #define SMBHOST_CNT		0x03	/* host control */
47 #define SMB_ADDR		0x04	/* address */
48 #define SMB_CMD			0x05	/* command */
49 #define SMB_COUNT		0x07	/* byte count */
50 #define SMB_BYTE		0x08	/* ~0x8F data byte field */
51 
52 /* SMB_STS register */
53 #define BYTE_DONE_STS		0x10	/* Byte Done Status / Block Array */
54 #define SMBCOL_STS		0x04	/* Collision */
55 #define SMBERR_STS		0x02	/* Device error */
56 
57 /* SMB_CNT register */
58 #define MSTO_EN			0x40	/* Host Master Timeout Enable */
59 #define SMBCLK_SEL		0x20	/* Host master clock selection */
60 #define SMB_PROBE		0x02	/* Bus Probe/Slave busy */
61 #define SMB_HOSTBUSY		0x01	/* Host Busy */
62 
63 /* SMBHOST_CNT register */
64 #define SMB_KILL		0x20	/* Kill */
65 #define SMB_START		0x10	/* Start */
66 
67 /* register count for request_region
68  * As we don't use SMB_PCOUNT, 20 is ok for SiS630 and SiS964
69  */
70 #define SIS630_SMB_IOREGION	20
71 
72 /* PCI address constants */
73 /* acpi base address register  */
74 #define SIS630_ACPI_BASE_REG	0x74
75 /* bios control register */
76 #define SIS630_BIOS_CTL_REG	0x40
77 
78 /* Other settings */
79 #define MAX_TIMEOUT		500
80 
81 /* SIS630 constants */
82 #define SIS630_QUICK		0x00
83 #define SIS630_BYTE		0x01
84 #define SIS630_BYTE_DATA	0x02
85 #define SIS630_WORD_DATA	0x03
86 #define SIS630_PCALL		0x04
87 #define SIS630_BLOCK_DATA	0x05
88 
89 static struct pci_driver sis630_driver;
90 
91 /* insmod parameters */
92 static bool high_clock;
93 static bool force;
94 module_param(high_clock, bool, 0);
95 MODULE_PARM_DESC(high_clock,
96 	"Set Host Master Clock to 56KHz (default 14KHz) (SIS630/730 only).");
97 module_param(force, bool, 0);
98 MODULE_PARM_DESC(force, "Forcibly enable the SIS630. DANGEROUS!");
99 
100 /* SMBus base address */
101 static unsigned short smbus_base;
102 
103 /* supported chips */
104 static int supported[] = {
105 	PCI_DEVICE_ID_SI_630,
106 	PCI_DEVICE_ID_SI_730,
107 	PCI_DEVICE_ID_SI_760,
108 	0 /* terminates the list */
109 };
110 
sis630_read(u8 reg)111 static inline u8 sis630_read(u8 reg)
112 {
113 	return inb(smbus_base + reg);
114 }
115 
sis630_write(u8 reg,u8 data)116 static inline void sis630_write(u8 reg, u8 data)
117 {
118 	outb(data, smbus_base + reg);
119 }
120 
sis630_transaction_start(struct i2c_adapter * adap,int size,u8 * oldclock)121 static int sis630_transaction_start(struct i2c_adapter *adap, int size,
122 				    u8 *oldclock)
123 {
124 	int temp;
125 
126 	/* Make sure the SMBus host is ready to start transmitting. */
127 	temp = sis630_read(SMB_CNT);
128 	if ((temp & (SMB_PROBE | SMB_HOSTBUSY)) != 0x00) {
129 		dev_dbg(&adap->dev, "SMBus busy (%02x). Resetting...\n", temp);
130 		/* kill smbus transaction */
131 		sis630_write(SMBHOST_CNT, SMB_KILL);
132 
133 		temp = sis630_read(SMB_CNT);
134 		if (temp & (SMB_PROBE | SMB_HOSTBUSY)) {
135 			dev_dbg(&adap->dev, "Failed! (%02x)\n", temp);
136 			return -EBUSY;
137 		} else {
138 			dev_dbg(&adap->dev, "Successful!\n");
139 		}
140 	}
141 
142 	/* save old clock, so we can prevent machine for hung */
143 	*oldclock = sis630_read(SMB_CNT);
144 
145 	dev_dbg(&adap->dev, "saved clock 0x%02x\n", *oldclock);
146 
147 	/* disable timeout interrupt,
148 	 * set Host Master Clock to 56KHz if requested */
149 	if (high_clock)
150 		sis630_write(SMB_CNT, SMBCLK_SEL);
151 	else
152 		sis630_write(SMB_CNT, (*oldclock & ~MSTO_EN));
153 
154 	/* clear all sticky bits */
155 	temp = sis630_read(SMB_STS);
156 	sis630_write(SMB_STS, temp & 0x1e);
157 
158 	/* start the transaction by setting bit 4 and size */
159 	sis630_write(SMBHOST_CNT, SMB_START | (size & 0x07));
160 
161 	return 0;
162 }
163 
sis630_transaction_wait(struct i2c_adapter * adap,int size)164 static int sis630_transaction_wait(struct i2c_adapter *adap, int size)
165 {
166 	int temp, result = 0, timeout = 0;
167 
168 	/* We will always wait for a fraction of a second! */
169 	do {
170 		msleep(1);
171 		temp = sis630_read(SMB_STS);
172 		/* check if block transmitted */
173 		if (size == SIS630_BLOCK_DATA && (temp & BYTE_DONE_STS))
174 			break;
175 	} while (!(temp & 0x0e) && (timeout++ < MAX_TIMEOUT));
176 
177 	/* If the SMBus is still busy, we give up */
178 	if (timeout > MAX_TIMEOUT) {
179 		dev_dbg(&adap->dev, "SMBus Timeout!\n");
180 		result = -ETIMEDOUT;
181 	}
182 
183 	if (temp & SMBERR_STS) {
184 		dev_dbg(&adap->dev, "Error: Failed bus transaction\n");
185 		result = -ENXIO;
186 	}
187 
188 	if (temp & SMBCOL_STS) {
189 		dev_err(&adap->dev, "Bus collision!\n");
190 		result = -EAGAIN;
191 	}
192 
193 	return result;
194 }
195 
sis630_transaction_end(struct i2c_adapter * adap,u8 oldclock)196 static void sis630_transaction_end(struct i2c_adapter *adap, u8 oldclock)
197 {
198 	/* clear all status "sticky" bits */
199 	sis630_write(SMB_STS, 0xFF);
200 
201 	dev_dbg(&adap->dev,
202 		"SMB_CNT before clock restore 0x%02x\n", sis630_read(SMB_CNT));
203 
204 	/*
205 	 * restore old Host Master Clock if high_clock is set
206 	 * and oldclock was not 56KHz
207 	 */
208 	if (high_clock && !(oldclock & SMBCLK_SEL))
209 		sis630_write(SMB_CNT, sis630_read(SMB_CNT) & ~SMBCLK_SEL);
210 
211 	dev_dbg(&adap->dev,
212 		"SMB_CNT after clock restore 0x%02x\n", sis630_read(SMB_CNT));
213 }
214 
sis630_transaction(struct i2c_adapter * adap,int size)215 static int sis630_transaction(struct i2c_adapter *adap, int size)
216 {
217 	int result = 0;
218 	u8 oldclock = 0;
219 
220 	result = sis630_transaction_start(adap, size, &oldclock);
221 	if (!result) {
222 		result = sis630_transaction_wait(adap, size);
223 		sis630_transaction_end(adap, oldclock);
224 	}
225 
226 	return result;
227 }
228 
sis630_block_data(struct i2c_adapter * adap,union i2c_smbus_data * data,int read_write)229 static int sis630_block_data(struct i2c_adapter *adap,
230 			     union i2c_smbus_data *data, int read_write)
231 {
232 	int i, len = 0, rc = 0;
233 	u8 oldclock = 0;
234 
235 	if (read_write == I2C_SMBUS_WRITE) {
236 		len = data->block[0];
237 		if (len < 0)
238 			len = 0;
239 		else if (len > 32)
240 			len = 32;
241 		sis630_write(SMB_COUNT, len);
242 		for (i = 1; i <= len; i++) {
243 			dev_dbg(&adap->dev,
244 				"set data 0x%02x\n", data->block[i]);
245 			/* set data */
246 			sis630_write(SMB_BYTE + (i - 1) % 8, data->block[i]);
247 			if (i == 8 || (len < 8 && i == len)) {
248 				dev_dbg(&adap->dev,
249 					"start trans len=%d i=%d\n", len, i);
250 				/* first transaction */
251 				rc = sis630_transaction_start(adap,
252 						SIS630_BLOCK_DATA, &oldclock);
253 				if (rc)
254 					return rc;
255 			} else if ((i - 1) % 8 == 7 || i == len) {
256 				dev_dbg(&adap->dev,
257 					"trans_wait len=%d i=%d\n", len, i);
258 				if (i > 8) {
259 					dev_dbg(&adap->dev,
260 						"clear smbary_sts"
261 						" len=%d i=%d\n", len, i);
262 					/*
263 					   If this is not first transaction,
264 					   we must clear sticky bit.
265 					   clear SMBARY_STS
266 					*/
267 					sis630_write(SMB_STS, BYTE_DONE_STS);
268 				}
269 				rc = sis630_transaction_wait(adap,
270 						SIS630_BLOCK_DATA);
271 				if (rc) {
272 					dev_dbg(&adap->dev,
273 						"trans_wait failed\n");
274 					break;
275 				}
276 			}
277 		}
278 	} else {
279 		/* read request */
280 		data->block[0] = len = 0;
281 		rc = sis630_transaction_start(adap,
282 				SIS630_BLOCK_DATA, &oldclock);
283 		if (rc)
284 			return rc;
285 		do {
286 			rc = sis630_transaction_wait(adap, SIS630_BLOCK_DATA);
287 			if (rc) {
288 				dev_dbg(&adap->dev, "trans_wait failed\n");
289 				break;
290 			}
291 			/* if this first transaction then read byte count */
292 			if (len == 0)
293 				data->block[0] = sis630_read(SMB_COUNT);
294 
295 			/* just to be sure */
296 			if (data->block[0] > 32)
297 				data->block[0] = 32;
298 
299 			dev_dbg(&adap->dev,
300 				"block data read len=0x%x\n", data->block[0]);
301 
302 			for (i = 0; i < 8 && len < data->block[0]; i++, len++) {
303 				dev_dbg(&adap->dev,
304 					"read i=%d len=%d\n", i, len);
305 				data->block[len + 1] = sis630_read(SMB_BYTE +
306 								   i);
307 			}
308 
309 			dev_dbg(&adap->dev,
310 				"clear smbary_sts len=%d i=%d\n", len, i);
311 
312 			/* clear SMBARY_STS */
313 			sis630_write(SMB_STS, BYTE_DONE_STS);
314 		} while (len < data->block[0]);
315 	}
316 
317 	sis630_transaction_end(adap, oldclock);
318 
319 	return rc;
320 }
321 
322 /* Return negative errno on error. */
sis630_access(struct i2c_adapter * adap,u16 addr,unsigned short flags,char read_write,u8 command,int size,union i2c_smbus_data * data)323 static s32 sis630_access(struct i2c_adapter *adap, u16 addr,
324 			 unsigned short flags, char read_write,
325 			 u8 command, int size, union i2c_smbus_data *data)
326 {
327 	int status;
328 
329 	switch (size) {
330 	case I2C_SMBUS_QUICK:
331 		sis630_write(SMB_ADDR,
332 			     ((addr & 0x7f) << 1) | (read_write & 0x01));
333 		size = SIS630_QUICK;
334 		break;
335 	case I2C_SMBUS_BYTE:
336 		sis630_write(SMB_ADDR,
337 			     ((addr & 0x7f) << 1) | (read_write & 0x01));
338 		if (read_write == I2C_SMBUS_WRITE)
339 			sis630_write(SMB_CMD, command);
340 		size = SIS630_BYTE;
341 		break;
342 	case I2C_SMBUS_BYTE_DATA:
343 		sis630_write(SMB_ADDR,
344 			     ((addr & 0x7f) << 1) | (read_write & 0x01));
345 		sis630_write(SMB_CMD, command);
346 		if (read_write == I2C_SMBUS_WRITE)
347 			sis630_write(SMB_BYTE, data->byte);
348 		size = SIS630_BYTE_DATA;
349 		break;
350 	case I2C_SMBUS_PROC_CALL:
351 	case I2C_SMBUS_WORD_DATA:
352 		sis630_write(SMB_ADDR,
353 			     ((addr & 0x7f) << 1) | (read_write & 0x01));
354 		sis630_write(SMB_CMD, command);
355 		if (read_write == I2C_SMBUS_WRITE) {
356 			sis630_write(SMB_BYTE, data->word & 0xff);
357 			sis630_write(SMB_BYTE + 1, (data->word & 0xff00) >> 8);
358 		}
359 		size = (size == I2C_SMBUS_PROC_CALL ?
360 			SIS630_PCALL : SIS630_WORD_DATA);
361 		break;
362 	case I2C_SMBUS_BLOCK_DATA:
363 		sis630_write(SMB_ADDR,
364 			     ((addr & 0x7f) << 1) | (read_write & 0x01));
365 		sis630_write(SMB_CMD, command);
366 		size = SIS630_BLOCK_DATA;
367 		return sis630_block_data(adap, data, read_write);
368 	default:
369 		dev_warn(&adap->dev, "Unsupported transaction %d\n", size);
370 		return -EOPNOTSUPP;
371 	}
372 
373 	status = sis630_transaction(adap, size);
374 	if (status)
375 		return status;
376 
377 	if ((size != SIS630_PCALL) &&
378 		((read_write == I2C_SMBUS_WRITE) || (size == SIS630_QUICK))) {
379 		return 0;
380 	}
381 
382 	switch (size) {
383 	case SIS630_BYTE:
384 	case SIS630_BYTE_DATA:
385 		data->byte = sis630_read(SMB_BYTE);
386 		break;
387 	case SIS630_PCALL:
388 	case SIS630_WORD_DATA:
389 		data->word = sis630_read(SMB_BYTE) +
390 			     (sis630_read(SMB_BYTE + 1) << 8);
391 		break;
392 	}
393 
394 	return 0;
395 }
396 
sis630_func(struct i2c_adapter * adapter)397 static u32 sis630_func(struct i2c_adapter *adapter)
398 {
399 	return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
400 		I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
401 		I2C_FUNC_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_BLOCK_DATA;
402 }
403 
sis630_setup(struct pci_dev * sis630_dev)404 static int sis630_setup(struct pci_dev *sis630_dev)
405 {
406 	unsigned char b;
407 	struct pci_dev *dummy = NULL;
408 	int retval, i;
409 	/* acpi base address */
410 	unsigned short acpi_base;
411 
412 	/* check for supported SiS devices */
413 	for (i = 0; supported[i] > 0; i++) {
414 		dummy = pci_get_device(PCI_VENDOR_ID_SI, supported[i], dummy);
415 		if (dummy)
416 			break; /* found */
417 	}
418 
419 	if (dummy) {
420 		pci_dev_put(dummy);
421 	} else if (force) {
422 		dev_err(&sis630_dev->dev,
423 			"WARNING: Can't detect SIS630 compatible device, but "
424 			"loading because of force option enabled\n");
425 	} else {
426 		return -ENODEV;
427 	}
428 
429 	/*
430 	   Enable ACPI first , so we can accsess reg 74-75
431 	   in acpi io space and read acpi base addr
432 	*/
433 	if (pci_read_config_byte(sis630_dev, SIS630_BIOS_CTL_REG, &b)) {
434 		dev_err(&sis630_dev->dev, "Error: Can't read bios ctl reg\n");
435 		retval = -ENODEV;
436 		goto exit;
437 	}
438 	/* if ACPI already enabled , do nothing */
439 	if (!(b & 0x80) &&
440 	    pci_write_config_byte(sis630_dev, SIS630_BIOS_CTL_REG, b | 0x80)) {
441 		dev_err(&sis630_dev->dev, "Error: Can't enable ACPI\n");
442 		retval = -ENODEV;
443 		goto exit;
444 	}
445 
446 	/* Determine the ACPI base address */
447 	if (pci_read_config_word(sis630_dev,
448 				 SIS630_ACPI_BASE_REG, &acpi_base)) {
449 		dev_err(&sis630_dev->dev,
450 			"Error: Can't determine ACPI base address\n");
451 		retval = -ENODEV;
452 		goto exit;
453 	}
454 
455 	dev_dbg(&sis630_dev->dev, "ACPI base at 0x%04hx\n", acpi_base);
456 
457 	if (supported[i] == PCI_DEVICE_ID_SI_760)
458 		smbus_base = acpi_base + 0xE0;
459 	else
460 		smbus_base = acpi_base + 0x80;
461 
462 	dev_dbg(&sis630_dev->dev, "SMBus base at 0x%04hx\n", smbus_base);
463 
464 	retval = acpi_check_region(smbus_base + SMB_STS, SIS630_SMB_IOREGION,
465 				   sis630_driver.name);
466 	if (retval)
467 		goto exit;
468 
469 	/* Everything is happy, let's grab the memory and set things up. */
470 	if (!request_region(smbus_base + SMB_STS, SIS630_SMB_IOREGION,
471 			    sis630_driver.name)) {
472 		dev_err(&sis630_dev->dev,
473 			"I/O Region 0x%04x-0x%04x for SMBus already in use.\n",
474 			smbus_base + SMB_STS,
475 			smbus_base + SMB_STS + SIS630_SMB_IOREGION - 1);
476 		retval = -EBUSY;
477 		goto exit;
478 	}
479 
480 	retval = 0;
481 
482 exit:
483 	if (retval)
484 		smbus_base = 0;
485 	return retval;
486 }
487 
488 
489 static const struct i2c_algorithm smbus_algorithm = {
490 	.smbus_xfer	= sis630_access,
491 	.functionality	= sis630_func,
492 };
493 
494 static struct i2c_adapter sis630_adapter = {
495 	.owner		= THIS_MODULE,
496 	.class		= I2C_CLASS_HWMON | I2C_CLASS_SPD,
497 	.algo		= &smbus_algorithm,
498 	.retries	= 3
499 };
500 
501 static const struct pci_device_id sis630_ids[] = {
502 	{ PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
503 	{ PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_LPC) },
504 	{ PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_964) },
505 	{ 0, }
506 };
507 
508 MODULE_DEVICE_TABLE(pci, sis630_ids);
509 
sis630_probe(struct pci_dev * dev,const struct pci_device_id * id)510 static int sis630_probe(struct pci_dev *dev, const struct pci_device_id *id)
511 {
512 	if (sis630_setup(dev)) {
513 		dev_err(&dev->dev,
514 			"SIS630 compatible bus not detected, "
515 			"module not inserted.\n");
516 		return -ENODEV;
517 	}
518 
519 	/* set up the sysfs linkage to our parent device */
520 	sis630_adapter.dev.parent = &dev->dev;
521 
522 	snprintf(sis630_adapter.name, sizeof(sis630_adapter.name),
523 		 "SMBus SIS630 adapter at %04x", smbus_base + SMB_STS);
524 
525 	return i2c_add_adapter(&sis630_adapter);
526 }
527 
sis630_remove(struct pci_dev * dev)528 static void sis630_remove(struct pci_dev *dev)
529 {
530 	if (smbus_base) {
531 		i2c_del_adapter(&sis630_adapter);
532 		release_region(smbus_base + SMB_STS, SIS630_SMB_IOREGION);
533 		smbus_base = 0;
534 	}
535 }
536 
537 
538 static struct pci_driver sis630_driver = {
539 	.name		= "sis630_smbus",
540 	.id_table	= sis630_ids,
541 	.probe		= sis630_probe,
542 	.remove		= sis630_remove,
543 };
544 
545 module_pci_driver(sis630_driver);
546 
547 MODULE_LICENSE("GPL");
548 MODULE_AUTHOR("Alexander Malysh <amalysh@web.de>");
549 MODULE_DESCRIPTION("SIS630 SMBus driver");
550