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