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