blob: b00cd409822192ce6766aa68be4e5bb7637685dd [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 i2c-ali1535.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring
4 Copyright (c) 2000 Frodo Looijaard <frodol@dds.nl>,
5 Philip Edelbrock <phil@netroedge.com>,
6 Mark D. Studebaker <mdsxyz123@yahoo.com>,
7 Dan Eaton <dan.eaton@rocketlogix.com> and
8 Stephen Rousset<stephen.rousset@rocketlogix.com>
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23*/
24
25/*
26 This is the driver for the SMB Host controller on
27 Acer Labs Inc. (ALI) M1535 South Bridge.
28
29 The M1535 is a South bridge for portable systems.
30 It is very similar to the M15x3 South bridges also produced
31 by Acer Labs Inc. Some of the registers within the part
32 have moved and some have been redefined slightly. Additionally,
33 the sequencing of the SMBus transactions has been modified
34 to be more consistent with the sequencing recommended by
35 the manufacturer and observed through testing. These
36 changes are reflected in this driver and can be identified
37 by comparing this driver to the i2c-ali15x3 driver.
38 For an overview of these chips see http://www.acerlabs.com
39
40 The SMB controller is part of the 7101 device, which is an
41 ACPI-compliant Power Management Unit (PMU).
42
43 The whole 7101 device has to be enabled for the SMB to work.
44 You can't just enable the SMB alone.
45 The SMB and the ACPI have separate I/O spaces.
46 We make sure that the SMB is enabled. We leave the ACPI alone.
47
48 This driver controls the SMB Host only.
49
50 This driver does not use interrupts.
51*/
52
53
54/* Note: we assume there can only be one ALI1535, with one SMBus interface */
55
56#include <linux/config.h>
57#include <linux/module.h>
58#include <linux/pci.h>
59#include <linux/kernel.h>
60#include <linux/stddef.h>
61#include <linux/sched.h>
62#include <linux/delay.h>
63#include <linux/ioport.h>
64#include <linux/i2c.h>
65#include <linux/init.h>
66#include <asm/io.h>
67#include <asm/semaphore.h>
68
69
70/* ALI1535 SMBus address offsets */
71#define SMBHSTSTS (0 + ali1535_smba)
72#define SMBHSTTYP (1 + ali1535_smba)
73#define SMBHSTPORT (2 + ali1535_smba)
74#define SMBHSTCMD (7 + ali1535_smba)
75#define SMBHSTADD (3 + ali1535_smba)
76#define SMBHSTDAT0 (4 + ali1535_smba)
77#define SMBHSTDAT1 (5 + ali1535_smba)
78#define SMBBLKDAT (6 + ali1535_smba)
79
80/* PCI Address Constants */
81#define SMBCOM 0x004
82#define SMBREV 0x008
83#define SMBCFG 0x0D1
84#define SMBBA 0x0E2
85#define SMBHSTCFG 0x0F0
86#define SMBCLK 0x0F2
87
88/* Other settings */
89#define MAX_TIMEOUT 500 /* times 1/100 sec */
90#define ALI1535_SMB_IOSIZE 32
91
92#define ALI1535_SMB_DEFAULTBASE 0x8040
93
94/* ALI1535 address lock bits */
95#define ALI1535_LOCK 0x06 /* dwe */
96
97/* ALI1535 command constants */
98#define ALI1535_QUICK 0x00
99#define ALI1535_BYTE 0x10
100#define ALI1535_BYTE_DATA 0x20
101#define ALI1535_WORD_DATA 0x30
102#define ALI1535_BLOCK_DATA 0x40
103#define ALI1535_I2C_READ 0x60
104
105#define ALI1535_DEV10B_EN 0x80 /* Enable 10-bit addressing in */
106 /* I2C read */
107#define ALI1535_T_OUT 0x08 /* Time-out Command (write) */
108#define ALI1535_A_HIGH_BIT9 0x08 /* Bit 9 of 10-bit address in */
109 /* Alert-Response-Address */
110 /* (read) */
111#define ALI1535_KILL 0x04 /* Kill Command (write) */
112#define ALI1535_A_HIGH_BIT8 0x04 /* Bit 8 of 10-bit address in */
113 /* Alert-Response-Address */
114 /* (read) */
115
116#define ALI1535_D_HI_MASK 0x03 /* Mask for isolating bits 9-8 */
117 /* of 10-bit address in I2C */
118 /* Read Command */
119
120/* ALI1535 status register bits */
121#define ALI1535_STS_IDLE 0x04
122#define ALI1535_STS_BUSY 0x08 /* host busy */
123#define ALI1535_STS_DONE 0x10 /* transaction complete */
124#define ALI1535_STS_DEV 0x20 /* device error */
125#define ALI1535_STS_BUSERR 0x40 /* bus error */
126#define ALI1535_STS_FAIL 0x80 /* failed bus transaction */
127#define ALI1535_STS_ERR 0xE0 /* all the bad error bits */
128
129#define ALI1535_BLOCK_CLR 0x04 /* reset block data index */
130
131/* ALI1535 device address register bits */
132#define ALI1535_RD_ADDR 0x01 /* Read/Write Bit in Device */
133 /* Address field */
134 /* -> Write = 0 */
135 /* -> Read = 1 */
136#define ALI1535_SMBIO_EN 0x04 /* SMB I/O Space enable */
137
138
139static unsigned short ali1535_smba;
140static DECLARE_MUTEX(i2c_ali1535_sem);
141
142/* Detect whether a ALI1535 can be found, and initialize it, where necessary.
143 Note the differences between kernels with the old PCI BIOS interface and
144 newer kernels with the real PCI interface. In compat.h some things are
145 defined to make the transition easier. */
146static int ali1535_setup(struct pci_dev *dev)
147{
148 int retval = -ENODEV;
149 unsigned char temp;
150
151 /* Check the following things:
152 - SMB I/O address is initialized
153 - Device is enabled
154 - We can use the addresses
155 */
156
157 /* Determine the address of the SMBus area */
158 pci_read_config_word(dev, SMBBA, &ali1535_smba);
159 ali1535_smba &= (0xffff & ~(ALI1535_SMB_IOSIZE - 1));
160 if (ali1535_smba == 0) {
161 dev_warn(&dev->dev,
162 "ALI1535_smb region uninitialized - upgrade BIOS?\n");
163 goto exit;
164 }
165
166 if (!request_region(ali1535_smba, ALI1535_SMB_IOSIZE, "ali1535-smb")) {
167 dev_err(&dev->dev, "ALI1535_smb region 0x%x already in use!\n",
168 ali1535_smba);
169 goto exit;
170 }
171
172 /* check if whole device is enabled */
173 pci_read_config_byte(dev, SMBCFG, &temp);
174 if ((temp & ALI1535_SMBIO_EN) == 0) {
175 dev_err(&dev->dev, "SMB device not enabled - upgrade BIOS?\n");
176 goto exit_free;
177 }
178
179 /* Is SMB Host controller enabled? */
180 pci_read_config_byte(dev, SMBHSTCFG, &temp);
181 if ((temp & 1) == 0) {
182 dev_err(&dev->dev, "SMBus controller not enabled - upgrade BIOS?\n");
183 goto exit_free;
184 }
185
186 /* set SMB clock to 74KHz as recommended in data sheet */
187 pci_write_config_byte(dev, SMBCLK, 0x20);
188
189 /*
190 The interrupt routing for SMB is set up in register 0x77 in the
191 1533 ISA Bridge device, NOT in the 7101 device.
192 Don't bother with finding the 1533 device and reading the register.
193 if ((....... & 0x0F) == 1)
194 dev_dbg(&dev->dev, "ALI1535 using Interrupt 9 for SMBus.\n");
195 */
196 pci_read_config_byte(dev, SMBREV, &temp);
197 dev_dbg(&dev->dev, "SMBREV = 0x%X\n", temp);
198 dev_dbg(&dev->dev, "ALI1535_smba = 0x%X\n", ali1535_smba);
199
200 retval = 0;
201exit:
202 return retval;
203
204exit_free:
205 release_region(ali1535_smba, ALI1535_SMB_IOSIZE);
206 return retval;
207}
208
209static int ali1535_transaction(struct i2c_adapter *adap)
210{
211 int temp;
212 int result = 0;
213 int timeout = 0;
214
215 dev_dbg(&adap->dev, "Transaction (pre): STS=%02x, TYP=%02x, "
216 "CMD=%02x, ADD=%02x, DAT0=%02x, DAT1=%02x\n",
217 inb_p(SMBHSTSTS), inb_p(SMBHSTTYP), inb_p(SMBHSTCMD),
218 inb_p(SMBHSTADD), inb_p(SMBHSTDAT0), inb_p(SMBHSTDAT1));
219
220 /* get status */
221 temp = inb_p(SMBHSTSTS);
222
223 /* Make sure the SMBus host is ready to start transmitting */
224 /* Check the busy bit first */
225 if (temp & ALI1535_STS_BUSY) {
226 /* If the host controller is still busy, it may have timed out
227 * in the previous transaction, resulting in a "SMBus Timeout"
228 * printk. I've tried the following to reset a stuck busy bit.
229 * 1. Reset the controller with an KILL command. (this
230 * doesn't seem to clear the controller if an external
231 * device is hung)
232 * 2. Reset the controller and the other SMBus devices with a
233 * T_OUT command. (this clears the host busy bit if an
234 * external device is hung, but it comes back upon a new
235 * access to a device)
236 * 3. Disable and reenable the controller in SMBHSTCFG. Worst
237 * case, nothing seems to work except power reset.
238 */
239
240 /* Try resetting entire SMB bus, including other devices - This
241 * may not work either - it clears the BUSY bit but then the
242 * BUSY bit may come back on when you try and use the chip
243 * again. If that's the case you are stuck.
244 */
245 dev_info(&adap->dev,
246 "Resetting entire SMB Bus to clear busy condition (%02x)\n",
247 temp);
248 outb_p(ALI1535_T_OUT, SMBHSTTYP);
249 temp = inb_p(SMBHSTSTS);
250 }
251
252 /* now check the error bits and the busy bit */
253 if (temp & (ALI1535_STS_ERR | ALI1535_STS_BUSY)) {
254 /* do a clear-on-write */
255 outb_p(0xFF, SMBHSTSTS);
256 if ((temp = inb_p(SMBHSTSTS)) &
257 (ALI1535_STS_ERR | ALI1535_STS_BUSY)) {
258 /* This is probably going to be correctable only by a
259 * power reset as one of the bits now appears to be
260 * stuck */
261 /* This may be a bus or device with electrical problems. */
262 dev_err(&adap->dev,
263 "SMBus reset failed! (0x%02x) - controller or "
264 "device on bus is probably hung\n", temp);
265 return -1;
266 }
267 } else {
268 /* check and clear done bit */
269 if (temp & ALI1535_STS_DONE) {
270 outb_p(temp, SMBHSTSTS);
271 }
272 }
273
274 /* start the transaction by writing anything to the start register */
275 outb_p(0xFF, SMBHSTPORT);
276
277 /* We will always wait for a fraction of a second! */
278 timeout = 0;
279 do {
280 msleep(1);
281 temp = inb_p(SMBHSTSTS);
282 } while (((temp & ALI1535_STS_BUSY) && !(temp & ALI1535_STS_IDLE))
283 && (timeout++ < MAX_TIMEOUT));
284
285 /* If the SMBus is still busy, we give up */
286 if (timeout >= MAX_TIMEOUT) {
287 result = -1;
288 dev_err(&adap->dev, "SMBus Timeout!\n");
289 }
290
291 if (temp & ALI1535_STS_FAIL) {
292 result = -1;
293 dev_dbg(&adap->dev, "Error: Failed bus transaction\n");
294 }
295
296 /* Unfortunately the ALI SMB controller maps "no response" and "bus
297 * collision" into a single bit. No reponse is the usual case so don't
298 * do a printk. This means that bus collisions go unreported.
299 */
300 if (temp & ALI1535_STS_BUSERR) {
301 result = -1;
302 dev_dbg(&adap->dev,
303 "Error: no response or bus collision ADD=%02x\n",
304 inb_p(SMBHSTADD));
305 }
306
307 /* haven't ever seen this */
308 if (temp & ALI1535_STS_DEV) {
309 result = -1;
310 dev_err(&adap->dev, "Error: device error\n");
311 }
312
313 /* check to see if the "command complete" indication is set */
314 if (!(temp & ALI1535_STS_DONE)) {
315 result = -1;
316 dev_err(&adap->dev, "Error: command never completed\n");
317 }
318
319 dev_dbg(&adap->dev, "Transaction (post): STS=%02x, TYP=%02x, "
320 "CMD=%02x, ADD=%02x, DAT0=%02x, DAT1=%02x\n",
321 inb_p(SMBHSTSTS), inb_p(SMBHSTTYP), inb_p(SMBHSTCMD),
322 inb_p(SMBHSTADD), inb_p(SMBHSTDAT0), inb_p(SMBHSTDAT1));
323
324 /* take consequent actions for error conditions */
325 if (!(temp & ALI1535_STS_DONE)) {
326 /* issue "kill" to reset host controller */
327 outb_p(ALI1535_KILL,SMBHSTTYP);
328 outb_p(0xFF,SMBHSTSTS);
329 } else if (temp & ALI1535_STS_ERR) {
330 /* issue "timeout" to reset all devices on bus */
331 outb_p(ALI1535_T_OUT,SMBHSTTYP);
332 outb_p(0xFF,SMBHSTSTS);
333 }
334
335 return result;
336}
337
338/* Return -1 on error. */
339static s32 ali1535_access(struct i2c_adapter *adap, u16 addr,
340 unsigned short flags, char read_write, u8 command,
341 int size, union i2c_smbus_data *data)
342{
343 int i, len;
344 int temp;
345 int timeout;
346 s32 result = 0;
347
348 down(&i2c_ali1535_sem);
349 /* make sure SMBus is idle */
350 temp = inb_p(SMBHSTSTS);
351 for (timeout = 0;
352 (timeout < MAX_TIMEOUT) && !(temp & ALI1535_STS_IDLE);
353 timeout++) {
354 msleep(1);
355 temp = inb_p(SMBHSTSTS);
356 }
357 if (timeout >= MAX_TIMEOUT)
358 dev_warn(&adap->dev, "Idle wait Timeout! STS=0x%02x\n", temp);
359
360 /* clear status register (clear-on-write) */
361 outb_p(0xFF, SMBHSTSTS);
362
363 switch (size) {
364 case I2C_SMBUS_PROC_CALL:
365 dev_err(&adap->dev, "I2C_SMBUS_PROC_CALL not supported!\n");
366 result = -1;
367 goto EXIT;
368 case I2C_SMBUS_QUICK:
369 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
370 SMBHSTADD);
371 size = ALI1535_QUICK;
372 outb_p(size, SMBHSTTYP); /* output command */
373 break;
374 case I2C_SMBUS_BYTE:
375 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
376 SMBHSTADD);
377 size = ALI1535_BYTE;
378 outb_p(size, SMBHSTTYP); /* output command */
379 if (read_write == I2C_SMBUS_WRITE)
380 outb_p(command, SMBHSTCMD);
381 break;
382 case I2C_SMBUS_BYTE_DATA:
383 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
384 SMBHSTADD);
385 size = ALI1535_BYTE_DATA;
386 outb_p(size, SMBHSTTYP); /* output command */
387 outb_p(command, SMBHSTCMD);
388 if (read_write == I2C_SMBUS_WRITE)
389 outb_p(data->byte, SMBHSTDAT0);
390 break;
391 case I2C_SMBUS_WORD_DATA:
392 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
393 SMBHSTADD);
394 size = ALI1535_WORD_DATA;
395 outb_p(size, SMBHSTTYP); /* output command */
396 outb_p(command, SMBHSTCMD);
397 if (read_write == I2C_SMBUS_WRITE) {
398 outb_p(data->word & 0xff, SMBHSTDAT0);
399 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
400 }
401 break;
402 case I2C_SMBUS_BLOCK_DATA:
403 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
404 SMBHSTADD);
405 size = ALI1535_BLOCK_DATA;
406 outb_p(size, SMBHSTTYP); /* output command */
407 outb_p(command, SMBHSTCMD);
408 if (read_write == I2C_SMBUS_WRITE) {
409 len = data->block[0];
410 if (len < 0) {
411 len = 0;
412 data->block[0] = len;
413 }
414 if (len > 32) {
415 len = 32;
416 data->block[0] = len;
417 }
418 outb_p(len, SMBHSTDAT0);
419 /* Reset SMBBLKDAT */
420 outb_p(inb_p(SMBHSTTYP) | ALI1535_BLOCK_CLR, SMBHSTTYP);
421 for (i = 1; i <= len; i++)
422 outb_p(data->block[i], SMBBLKDAT);
423 }
424 break;
425 }
426
427 if (ali1535_transaction(adap)) {
428 /* Error in transaction */
429 result = -1;
430 goto EXIT;
431 }
432
433 if ((read_write == I2C_SMBUS_WRITE) || (size == ALI1535_QUICK)) {
434 result = 0;
435 goto EXIT;
436 }
437
438 switch (size) {
439 case ALI1535_BYTE: /* Result put in SMBHSTDAT0 */
440 data->byte = inb_p(SMBHSTDAT0);
441 break;
442 case ALI1535_BYTE_DATA:
443 data->byte = inb_p(SMBHSTDAT0);
444 break;
445 case ALI1535_WORD_DATA:
446 data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
447 break;
448 case ALI1535_BLOCK_DATA:
449 len = inb_p(SMBHSTDAT0);
450 if (len > 32)
451 len = 32;
452 data->block[0] = len;
453 /* Reset SMBBLKDAT */
454 outb_p(inb_p(SMBHSTTYP) | ALI1535_BLOCK_CLR, SMBHSTTYP);
455 for (i = 1; i <= data->block[0]; i++) {
456 data->block[i] = inb_p(SMBBLKDAT);
457 dev_dbg(&adap->dev, "Blk: len=%d, i=%d, data=%02x\n",
458 len, i, data->block[i]);
459 }
460 break;
461 }
462EXIT:
463 up(&i2c_ali1535_sem);
464 return result;
465}
466
467
468static u32 ali1535_func(struct i2c_adapter *adapter)
469{
470 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
471 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
472 I2C_FUNC_SMBUS_BLOCK_DATA;
473}
474
475static struct i2c_algorithm smbus_algorithm = {
476 .name = "Non-i2c SMBus adapter",
477 .id = I2C_ALGO_SMBUS,
478 .smbus_xfer = ali1535_access,
479 .functionality = ali1535_func,
480};
481
482static struct i2c_adapter ali1535_adapter = {
483 .owner = THIS_MODULE,
484 .class = I2C_CLASS_HWMON,
485 .algo = &smbus_algorithm,
486 .name = "unset",
487};
488
489static struct pci_device_id ali1535_ids[] = {
490 { PCI_DEVICE(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101) },
491 { },
492};
493
494MODULE_DEVICE_TABLE (pci, ali1535_ids);
495
496static int __devinit ali1535_probe(struct pci_dev *dev, const struct pci_device_id *id)
497{
498 if (ali1535_setup(dev)) {
499 dev_warn(&dev->dev,
500 "ALI1535 not detected, module not inserted.\n");
501 return -ENODEV;
502 }
503
504 /* set up the driverfs linkage to our parent device */
505 ali1535_adapter.dev.parent = &dev->dev;
506
507 snprintf(ali1535_adapter.name, I2C_NAME_SIZE,
508 "SMBus ALI1535 adapter at %04x", ali1535_smba);
509 return i2c_add_adapter(&ali1535_adapter);
510}
511
512static void __devexit ali1535_remove(struct pci_dev *dev)
513{
514 i2c_del_adapter(&ali1535_adapter);
515 release_region(ali1535_smba, ALI1535_SMB_IOSIZE);
516}
517
518static struct pci_driver ali1535_driver = {
519 .name = "ali1535_smbus",
520 .id_table = ali1535_ids,
521 .probe = ali1535_probe,
522 .remove = __devexit_p(ali1535_remove),
523};
524
525static int __init i2c_ali1535_init(void)
526{
527 return pci_register_driver(&ali1535_driver);
528}
529
530static void __exit i2c_ali1535_exit(void)
531{
532 pci_unregister_driver(&ali1535_driver);
533}
534
535MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
536 "Philip Edelbrock <phil@netroedge.com>, "
537 "Mark D. Studebaker <mdsxyz123@yahoo.com> "
538 "and Dan Eaton <dan.eaton@rocketlogix.com>");
539MODULE_DESCRIPTION("ALI1535 SMBus driver");
540MODULE_LICENSE("GPL");
541
542module_init(i2c_ali1535_init);
543module_exit(i2c_ali1535_exit);