1 /*
2     Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl> and
3     Philip Edelbrock <phil@netroedge.com>
4 
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9 
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU General Public License for more details.
14 */
15 
16 /* Note: we assume there can only be one SIS5595 with one SMBus interface */
17 
18 /*
19    Note: all have mfr. ID 0x1039.
20    SUPPORTED		PCI ID
21 	5595		0008
22 
23    Note: these chips contain a 0008 device which is incompatible with the
24          5595. We recognize these by the presence of the listed
25          "blacklist" PCI ID and refuse to load.
26 
27    NOT SUPPORTED	PCI ID		BLACKLIST PCI ID
28 	 540		0008		0540
29 	 550		0008		0550
30 	5513		0008		5511
31 	5581		0008		5597
32 	5582		0008		5597
33 	5597		0008		5597
34 	5598		0008		5597/5598
35 	 630		0008		0630
36 	 645		0008		0645
37 	 646		0008		0646
38 	 648		0008		0648
39 	 650		0008		0650
40 	 651		0008		0651
41 	 730		0008		0730
42 	 735		0008		0735
43 	 745		0008		0745
44 	 746		0008		0746
45 */
46 
47 /* TO DO:
48  * Add Block Transfers (ugly, but supported by the adapter)
49  * Add adapter resets
50  */
51 
52 #include <linux/kernel.h>
53 #include <linux/module.h>
54 #include <linux/delay.h>
55 #include <linux/pci.h>
56 #include <linux/ioport.h>
57 #include <linux/init.h>
58 #include <linux/i2c.h>
59 #include <linux/acpi.h>
60 #include <linux/io.h>
61 
62 static int blacklist[] = {
63 	PCI_DEVICE_ID_SI_540,
64 	PCI_DEVICE_ID_SI_550,
65 	PCI_DEVICE_ID_SI_630,
66 	PCI_DEVICE_ID_SI_645,
67 	PCI_DEVICE_ID_SI_646,
68 	PCI_DEVICE_ID_SI_648,
69 	PCI_DEVICE_ID_SI_650,
70 	PCI_DEVICE_ID_SI_651,
71 	PCI_DEVICE_ID_SI_730,
72 	PCI_DEVICE_ID_SI_735,
73 	PCI_DEVICE_ID_SI_745,
74 	PCI_DEVICE_ID_SI_746,
75 	PCI_DEVICE_ID_SI_5511,	/* 5513 chip has the 0008 device but that ID
76 				   shows up in other chips so we use the 5511
77 				   ID for recognition */
78 	PCI_DEVICE_ID_SI_5597,
79 	PCI_DEVICE_ID_SI_5598,
80 	0,			/* terminates the list */
81 };
82 
83 /* Length of ISA address segment */
84 #define SIS5595_EXTENT		8
85 /* SIS5595 SMBus registers */
86 #define SMB_STS_LO		0x00
87 #define SMB_STS_HI		0x01
88 #define SMB_CTL_LO		0x02
89 #define SMB_CTL_HI		0x03
90 #define SMB_ADDR		0x04
91 #define SMB_CMD			0x05
92 #define SMB_PCNT		0x06
93 #define SMB_CNT			0x07
94 #define SMB_BYTE		0x08
95 #define SMB_DEV			0x10
96 #define SMB_DB0			0x11
97 #define SMB_DB1			0x12
98 #define SMB_HAA			0x13
99 
100 /* PCI Address Constants */
101 #define SMB_INDEX		0x38
102 #define SMB_DAT			0x39
103 #define SIS5595_ENABLE_REG	0x40
104 #define ACPI_BASE		0x90
105 
106 /* Other settings */
107 #define MAX_TIMEOUT		500
108 
109 /* SIS5595 constants */
110 #define SIS5595_QUICK		0x00
111 #define SIS5595_BYTE		0x02
112 #define SIS5595_BYTE_DATA	0x04
113 #define SIS5595_WORD_DATA	0x06
114 #define SIS5595_PROC_CALL	0x08
115 #define SIS5595_BLOCK_DATA	0x0A
116 
117 /* insmod parameters */
118 
119 /* If force_addr is set to anything different from 0, we forcibly enable
120    the device at the given address. */
121 static u16 force_addr;
122 module_param_hw(force_addr, ushort, ioport, 0);
123 MODULE_PARM_DESC(force_addr, "Initialize the base address of the i2c controller");
124 
125 static struct pci_driver sis5595_driver;
126 static unsigned short sis5595_base;
127 static struct pci_dev *sis5595_pdev;
128 
sis5595_read(u8 reg)129 static u8 sis5595_read(u8 reg)
130 {
131 	outb(reg, sis5595_base + SMB_INDEX);
132 	return inb(sis5595_base + SMB_DAT);
133 }
134 
sis5595_write(u8 reg,u8 data)135 static void sis5595_write(u8 reg, u8 data)
136 {
137 	outb(reg, sis5595_base + SMB_INDEX);
138 	outb(data, sis5595_base + SMB_DAT);
139 }
140 
sis5595_setup(struct pci_dev * SIS5595_dev)141 static int sis5595_setup(struct pci_dev *SIS5595_dev)
142 {
143 	u16 a;
144 	u8 val;
145 	int *i;
146 	int retval;
147 
148 	/* Look for imposters */
149 	for (i = blacklist; *i != 0; i++) {
150 		struct pci_dev *dev;
151 		dev = pci_get_device(PCI_VENDOR_ID_SI, *i, NULL);
152 		if (dev) {
153 			dev_err(&SIS5595_dev->dev, "Looked for SIS5595 but found unsupported device %.4x\n", *i);
154 			pci_dev_put(dev);
155 			return -ENODEV;
156 		}
157 	}
158 
159 	/* Determine the address of the SMBus areas */
160 	pci_read_config_word(SIS5595_dev, ACPI_BASE, &sis5595_base);
161 	if (sis5595_base == 0 && force_addr == 0) {
162 		dev_err(&SIS5595_dev->dev, "ACPI base address uninitialized - upgrade BIOS or use force_addr=0xaddr\n");
163 		return -ENODEV;
164 	}
165 
166 	if (force_addr)
167 		sis5595_base = force_addr & ~(SIS5595_EXTENT - 1);
168 	dev_dbg(&SIS5595_dev->dev, "ACPI Base address: %04x\n", sis5595_base);
169 
170 	/* NB: We grab just the two SMBus registers here, but this may still
171 	 * interfere with ACPI :-(  */
172 	retval = acpi_check_region(sis5595_base + SMB_INDEX, 2,
173 				   sis5595_driver.name);
174 	if (retval)
175 		return retval;
176 
177 	if (!request_region(sis5595_base + SMB_INDEX, 2,
178 			    sis5595_driver.name)) {
179 		dev_err(&SIS5595_dev->dev, "SMBus registers 0x%04x-0x%04x already in use!\n",
180 			sis5595_base + SMB_INDEX, sis5595_base + SMB_INDEX + 1);
181 		return -ENODEV;
182 	}
183 
184 	if (force_addr) {
185 		dev_info(&SIS5595_dev->dev, "forcing ISA address 0x%04X\n", sis5595_base);
186 		if (pci_write_config_word(SIS5595_dev, ACPI_BASE, sis5595_base)
187 		    != PCIBIOS_SUCCESSFUL)
188 			goto error;
189 		if (pci_read_config_word(SIS5595_dev, ACPI_BASE, &a)
190 		    != PCIBIOS_SUCCESSFUL)
191 			goto error;
192 		if ((a & ~(SIS5595_EXTENT - 1)) != sis5595_base) {
193 			/* doesn't work for some chips! */
194 			dev_err(&SIS5595_dev->dev, "force address failed - not supported?\n");
195 			goto error;
196 		}
197 	}
198 
199 	if (pci_read_config_byte(SIS5595_dev, SIS5595_ENABLE_REG, &val)
200 	    != PCIBIOS_SUCCESSFUL)
201 		goto error;
202 	if ((val & 0x80) == 0) {
203 		dev_info(&SIS5595_dev->dev, "enabling ACPI\n");
204 		if (pci_write_config_byte(SIS5595_dev, SIS5595_ENABLE_REG, val | 0x80)
205 		    != PCIBIOS_SUCCESSFUL)
206 			goto error;
207 		if (pci_read_config_byte(SIS5595_dev, SIS5595_ENABLE_REG, &val)
208 		    != PCIBIOS_SUCCESSFUL)
209 			goto error;
210 		if ((val & 0x80) == 0) {
211 			/* doesn't work for some chips? */
212 			dev_err(&SIS5595_dev->dev, "ACPI enable failed - not supported?\n");
213 			goto error;
214 		}
215 	}
216 
217 	/* Everything is happy */
218 	return 0;
219 
220 error:
221 	release_region(sis5595_base + SMB_INDEX, 2);
222 	return -ENODEV;
223 }
224 
sis5595_transaction(struct i2c_adapter * adap)225 static int sis5595_transaction(struct i2c_adapter *adap)
226 {
227 	int temp;
228 	int result = 0;
229 	int timeout = 0;
230 
231 	/* Make sure the SMBus host is ready to start transmitting */
232 	temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8);
233 	if (temp != 0x00) {
234 		dev_dbg(&adap->dev, "SMBus busy (%04x). Resetting...\n", temp);
235 		sis5595_write(SMB_STS_LO, temp & 0xff);
236 		sis5595_write(SMB_STS_HI, temp >> 8);
237 		if ((temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8)) != 0x00) {
238 			dev_dbg(&adap->dev, "Failed! (%02x)\n", temp);
239 			return -EBUSY;
240 		} else {
241 			dev_dbg(&adap->dev, "Successful!\n");
242 		}
243 	}
244 
245 	/* start the transaction by setting bit 4 */
246 	sis5595_write(SMB_CTL_LO, sis5595_read(SMB_CTL_LO) | 0x10);
247 
248 	/* We will always wait for a fraction of a second! */
249 	do {
250 		msleep(1);
251 		temp = sis5595_read(SMB_STS_LO);
252 	} while (!(temp & 0x40) && (timeout++ < MAX_TIMEOUT));
253 
254 	/* If the SMBus is still busy, we give up */
255 	if (timeout > MAX_TIMEOUT) {
256 		dev_dbg(&adap->dev, "SMBus Timeout!\n");
257 		result = -ETIMEDOUT;
258 	}
259 
260 	if (temp & 0x10) {
261 		dev_dbg(&adap->dev, "Error: Failed bus transaction\n");
262 		result = -ENXIO;
263 	}
264 
265 	if (temp & 0x20) {
266 		dev_err(&adap->dev, "Bus collision! SMBus may be locked until "
267 			"next hard reset (or not...)\n");
268 		/* Clock stops and slave is stuck in mid-transmission */
269 		result = -EIO;
270 	}
271 
272 	temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8);
273 	if (temp != 0x00) {
274 		sis5595_write(SMB_STS_LO, temp & 0xff);
275 		sis5595_write(SMB_STS_HI, temp >> 8);
276 	}
277 
278 	temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8);
279 	if (temp != 0x00)
280 		dev_dbg(&adap->dev, "Failed reset at end of transaction (%02x)\n", temp);
281 
282 	return result;
283 }
284 
285 /* Return negative errno on error. */
sis5595_access(struct i2c_adapter * adap,u16 addr,unsigned short flags,char read_write,u8 command,int size,union i2c_smbus_data * data)286 static s32 sis5595_access(struct i2c_adapter *adap, u16 addr,
287 			  unsigned short flags, char read_write,
288 			  u8 command, int size, union i2c_smbus_data *data)
289 {
290 	int status;
291 
292 	switch (size) {
293 	case I2C_SMBUS_QUICK:
294 		sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
295 		size = SIS5595_QUICK;
296 		break;
297 	case I2C_SMBUS_BYTE:
298 		sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
299 		if (read_write == I2C_SMBUS_WRITE)
300 			sis5595_write(SMB_CMD, command);
301 		size = SIS5595_BYTE;
302 		break;
303 	case I2C_SMBUS_BYTE_DATA:
304 		sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
305 		sis5595_write(SMB_CMD, command);
306 		if (read_write == I2C_SMBUS_WRITE)
307 			sis5595_write(SMB_BYTE, data->byte);
308 		size = SIS5595_BYTE_DATA;
309 		break;
310 	case I2C_SMBUS_PROC_CALL:
311 	case I2C_SMBUS_WORD_DATA:
312 		sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
313 		sis5595_write(SMB_CMD, command);
314 		if (read_write == I2C_SMBUS_WRITE) {
315 			sis5595_write(SMB_BYTE, data->word & 0xff);
316 			sis5595_write(SMB_BYTE + 1,
317 				      (data->word & 0xff00) >> 8);
318 		}
319 		size = (size == I2C_SMBUS_PROC_CALL) ? SIS5595_PROC_CALL : SIS5595_WORD_DATA;
320 		break;
321 	default:
322 		dev_warn(&adap->dev, "Unsupported transaction %d\n", size);
323 		return -EOPNOTSUPP;
324 	}
325 
326 	sis5595_write(SMB_CTL_LO, ((size & 0x0E)));
327 
328 	status = sis5595_transaction(adap);
329 	if (status)
330 		return status;
331 
332 	if ((size != SIS5595_PROC_CALL) &&
333 	    ((read_write == I2C_SMBUS_WRITE) || (size == SIS5595_QUICK)))
334 		return 0;
335 
336 
337 	switch (size) {
338 	case SIS5595_BYTE:
339 	case SIS5595_BYTE_DATA:
340 		data->byte = sis5595_read(SMB_BYTE);
341 		break;
342 	case SIS5595_WORD_DATA:
343 	case SIS5595_PROC_CALL:
344 		data->word = sis5595_read(SMB_BYTE) + (sis5595_read(SMB_BYTE + 1) << 8);
345 		break;
346 	}
347 	return 0;
348 }
349 
sis5595_func(struct i2c_adapter * adapter)350 static u32 sis5595_func(struct i2c_adapter *adapter)
351 {
352 	return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
353 	    I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
354 	    I2C_FUNC_SMBUS_PROC_CALL;
355 }
356 
357 static const struct i2c_algorithm smbus_algorithm = {
358 	.smbus_xfer	= sis5595_access,
359 	.functionality	= sis5595_func,
360 };
361 
362 static struct i2c_adapter sis5595_adapter = {
363 	.owner		= THIS_MODULE,
364 	.class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
365 	.algo		= &smbus_algorithm,
366 };
367 
368 static const struct pci_device_id sis5595_ids[] = {
369 	{ PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
370 	{ 0, }
371 };
372 
373 MODULE_DEVICE_TABLE (pci, sis5595_ids);
374 
sis5595_probe(struct pci_dev * dev,const struct pci_device_id * id)375 static int sis5595_probe(struct pci_dev *dev, const struct pci_device_id *id)
376 {
377 	int err;
378 
379 	if (sis5595_setup(dev)) {
380 		dev_err(&dev->dev, "SIS5595 not detected, module not inserted.\n");
381 		return -ENODEV;
382 	}
383 
384 	/* set up the sysfs linkage to our parent device */
385 	sis5595_adapter.dev.parent = &dev->dev;
386 
387 	snprintf(sis5595_adapter.name, sizeof(sis5595_adapter.name),
388 		 "SMBus SIS5595 adapter at %04x", sis5595_base + SMB_INDEX);
389 	err = i2c_add_adapter(&sis5595_adapter);
390 	if (err) {
391 		release_region(sis5595_base + SMB_INDEX, 2);
392 		return err;
393 	}
394 
395 	/* Always return failure here.  This is to allow other drivers to bind
396 	 * to this pci device.  We don't really want to have control over the
397 	 * pci device, we only wanted to read as few register values from it.
398 	 */
399 	sis5595_pdev =  pci_dev_get(dev);
400 	return -ENODEV;
401 }
402 
403 static struct pci_driver sis5595_driver = {
404 	.name		= "sis5595_smbus",
405 	.id_table	= sis5595_ids,
406 	.probe		= sis5595_probe,
407 };
408 
i2c_sis5595_init(void)409 static int __init i2c_sis5595_init(void)
410 {
411 	return pci_register_driver(&sis5595_driver);
412 }
413 
i2c_sis5595_exit(void)414 static void __exit i2c_sis5595_exit(void)
415 {
416 	pci_unregister_driver(&sis5595_driver);
417 	if (sis5595_pdev) {
418 		i2c_del_adapter(&sis5595_adapter);
419 		release_region(sis5595_base + SMB_INDEX, 2);
420 		pci_dev_put(sis5595_pdev);
421 		sis5595_pdev = NULL;
422 	}
423 }
424 
425 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
426 MODULE_DESCRIPTION("SIS5595 SMBus driver");
427 MODULE_LICENSE("GPL");
428 
429 module_init(i2c_sis5595_init);
430 module_exit(i2c_sis5595_exit);
431