Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/drivers/i2c/busses/i2c-viapro.c

  1 /*
  2     Copyright (c) 1998 - 2002  Frodo Looijaard <frodol@dds.nl>,
  3     Philip Edelbrock <phil@netroedge.com>, Kyösti Mälkki <kmalkki@cc.hut.fi>,
  4     Mark D. Studebaker <mdsxyz123@yahoo.com>
  5     Copyright (C) 2005 - 2008  Jean Delvare <jdelvare@suse.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    Supports the following VIA south bridges:
 24 
 25    Chip name          PCI ID  REV     I2C block
 26    VT82C596A          0x3050             no
 27    VT82C596B          0x3051             no
 28    VT82C686A          0x3057  0x30       no
 29    VT82C686B          0x3057  0x40       yes
 30    VT8231             0x8235             no?
 31    VT8233             0x3074             yes
 32    VT8233A            0x3147             yes?
 33    VT8235             0x3177             yes
 34    VT8237R            0x3227             yes
 35    VT8237A            0x3337             yes
 36    VT8237S            0x3372             yes
 37    VT8251             0x3287             yes
 38    CX700              0x8324             yes
 39    VX800/VX820        0x8353             yes
 40    VX855/VX875        0x8409             yes
 41 
 42    Note: we assume there can only be one device, with one SMBus interface.
 43 */
 44 
 45 #include <linux/module.h>
 46 #include <linux/delay.h>
 47 #include <linux/pci.h>
 48 #include <linux/kernel.h>
 49 #include <linux/stddef.h>
 50 #include <linux/ioport.h>
 51 #include <linux/i2c.h>
 52 #include <linux/init.h>
 53 #include <linux/acpi.h>
 54 #include <linux/io.h>
 55 
 56 static struct pci_dev *vt596_pdev;
 57 
 58 #define SMBBA1          0x90
 59 #define SMBBA2          0x80
 60 #define SMBBA3          0xD0
 61 
 62 /* SMBus address offsets */
 63 static unsigned short vt596_smba;
 64 #define SMBHSTSTS       (vt596_smba + 0)
 65 #define SMBHSTCNT       (vt596_smba + 2)
 66 #define SMBHSTCMD       (vt596_smba + 3)
 67 #define SMBHSTADD       (vt596_smba + 4)
 68 #define SMBHSTDAT0      (vt596_smba + 5)
 69 #define SMBHSTDAT1      (vt596_smba + 6)
 70 #define SMBBLKDAT       (vt596_smba + 7)
 71 
 72 /* PCI Address Constants */
 73 
 74 /* SMBus data in configuration space can be found in two places,
 75    We try to select the better one */
 76 
 77 static unsigned short SMBHSTCFG = 0xD2;
 78 
 79 /* Other settings */
 80 #define MAX_TIMEOUT     500
 81 
 82 /* VT82C596 constants */
 83 #define VT596_QUICK             0x00
 84 #define VT596_BYTE              0x04
 85 #define VT596_BYTE_DATA         0x08
 86 #define VT596_WORD_DATA         0x0C
 87 #define VT596_PROC_CALL         0x10
 88 #define VT596_BLOCK_DATA        0x14
 89 #define VT596_I2C_BLOCK_DATA    0x34
 90 
 91 
 92 /* If force is set to anything different from 0, we forcibly enable the
 93    VT596. DANGEROUS! */
 94 static bool force;
 95 module_param(force, bool, 0);
 96 MODULE_PARM_DESC(force, "Forcibly enable the SMBus. DANGEROUS!");
 97 
 98 /* If force_addr is set to anything different from 0, we forcibly enable
 99    the VT596 at the given address. VERY DANGEROUS! */
100 static u16 force_addr;
101 module_param(force_addr, ushort, 0);
102 MODULE_PARM_DESC(force_addr,
103                  "Forcibly enable the SMBus at the given address. "
104                  "EXTREMELY DANGEROUS!");
105 
106 
107 static struct pci_driver vt596_driver;
108 static struct i2c_adapter vt596_adapter;
109 
110 #define FEATURE_I2CBLOCK        (1<<0)
111 static unsigned int vt596_features;
112 
113 #ifdef DEBUG
114 static void vt596_dump_regs(const char *msg, u8 size)
115 {
116         dev_dbg(&vt596_adapter.dev, "%s: STS=%02x CNT=%02x CMD=%02x ADD=%02x "
117                 "DAT=%02x,%02x\n", msg, inb_p(SMBHSTSTS), inb_p(SMBHSTCNT),
118                 inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
119                 inb_p(SMBHSTDAT1));
120 
121         if (size == VT596_BLOCK_DATA
122          || size == VT596_I2C_BLOCK_DATA) {
123                 int i;
124 
125                 dev_dbg(&vt596_adapter.dev, "BLK=");
126                 for (i = 0; i < I2C_SMBUS_BLOCK_MAX / 2; i++)
127                         printk("%02x,", inb_p(SMBBLKDAT));
128                 printk("\n");
129                 dev_dbg(&vt596_adapter.dev, "    ");
130                 for (; i < I2C_SMBUS_BLOCK_MAX - 1; i++)
131                         printk("%02x,", inb_p(SMBBLKDAT));
132                 printk("%02x\n", inb_p(SMBBLKDAT));
133         }
134 }
135 #else
136 static inline void vt596_dump_regs(const char *msg, u8 size) { }
137 #endif
138 
139 /* Return -1 on error, 0 on success */
140 static int vt596_transaction(u8 size)
141 {
142         int temp;
143         int result = 0;
144         int timeout = 0;
145 
146         vt596_dump_regs("Transaction (pre)", size);
147 
148         /* Make sure the SMBus host is ready to start transmitting */
149         if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
150                 dev_dbg(&vt596_adapter.dev, "SMBus busy (0x%02x). "
151                         "Resetting...\n", temp);
152 
153                 outb_p(temp, SMBHSTSTS);
154                 if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
155                         dev_err(&vt596_adapter.dev, "SMBus reset failed! "
156                                 "(0x%02x)\n", temp);
157                         return -EBUSY;
158                 }
159         }
160 
161         /* Start the transaction by setting bit 6 */
162         outb_p(0x40 | size, SMBHSTCNT);
163 
164         /* We will always wait for a fraction of a second */
165         do {
166                 msleep(1);
167                 temp = inb_p(SMBHSTSTS);
168         } while ((temp & 0x01) && (++timeout < MAX_TIMEOUT));
169 
170         /* If the SMBus is still busy, we give up */
171         if (timeout == MAX_TIMEOUT) {
172                 result = -ETIMEDOUT;
173                 dev_err(&vt596_adapter.dev, "SMBus timeout!\n");
174         }
175 
176         if (temp & 0x10) {
177                 result = -EIO;
178                 dev_err(&vt596_adapter.dev, "Transaction failed (0x%02x)\n",
179                         size);
180         }
181 
182         if (temp & 0x08) {
183                 result = -EIO;
184                 dev_err(&vt596_adapter.dev, "SMBus collision!\n");
185         }
186 
187         if (temp & 0x04) {
188                 result = -ENXIO;
189                 dev_dbg(&vt596_adapter.dev, "No response\n");
190         }
191 
192         /* Resetting status register */
193         if (temp & 0x1F)
194                 outb_p(temp, SMBHSTSTS);
195 
196         vt596_dump_regs("Transaction (post)", size);
197 
198         return result;
199 }
200 
201 /* Return negative errno on error, 0 on success */
202 static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
203                 unsigned short flags, char read_write, u8 command,
204                 int size, union i2c_smbus_data *data)
205 {
206         int i;
207         int status;
208 
209         switch (size) {
210         case I2C_SMBUS_QUICK:
211                 size = VT596_QUICK;
212                 break;
213         case I2C_SMBUS_BYTE:
214                 if (read_write == I2C_SMBUS_WRITE)
215                         outb_p(command, SMBHSTCMD);
216                 size = VT596_BYTE;
217                 break;
218         case I2C_SMBUS_BYTE_DATA:
219                 outb_p(command, SMBHSTCMD);
220                 if (read_write == I2C_SMBUS_WRITE)
221                         outb_p(data->byte, SMBHSTDAT0);
222                 size = VT596_BYTE_DATA;
223                 break;
224         case I2C_SMBUS_WORD_DATA:
225                 outb_p(command, SMBHSTCMD);
226                 if (read_write == I2C_SMBUS_WRITE) {
227                         outb_p(data->word & 0xff, SMBHSTDAT0);
228                         outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
229                 }
230                 size = VT596_WORD_DATA;
231                 break;
232         case I2C_SMBUS_PROC_CALL:
233                 outb_p(command, SMBHSTCMD);
234                 outb_p(data->word & 0xff, SMBHSTDAT0);
235                 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
236                 size = VT596_PROC_CALL;
237                 break;
238         case I2C_SMBUS_I2C_BLOCK_DATA:
239                 if (!(vt596_features & FEATURE_I2CBLOCK))
240                         goto exit_unsupported;
241                 if (read_write == I2C_SMBUS_READ)
242                         outb_p(data->block[0], SMBHSTDAT0);
243                 /* Fall through */
244         case I2C_SMBUS_BLOCK_DATA:
245                 outb_p(command, SMBHSTCMD);
246                 if (read_write == I2C_SMBUS_WRITE) {
247                         u8 len = data->block[0];
248                         if (len > I2C_SMBUS_BLOCK_MAX)
249                                 len = I2C_SMBUS_BLOCK_MAX;
250                         outb_p(len, SMBHSTDAT0);
251                         inb_p(SMBHSTCNT);       /* Reset SMBBLKDAT */
252                         for (i = 1; i <= len; i++)
253                                 outb_p(data->block[i], SMBBLKDAT);
254                 }
255                 size = (size == I2C_SMBUS_I2C_BLOCK_DATA) ?
256                        VT596_I2C_BLOCK_DATA : VT596_BLOCK_DATA;
257                 break;
258         default:
259                 goto exit_unsupported;
260         }
261 
262         outb_p(((addr & 0x7f) << 1) | read_write, SMBHSTADD);
263 
264         status = vt596_transaction(size);
265         if (status)
266                 return status;
267 
268         if (size == VT596_PROC_CALL)
269                 read_write = I2C_SMBUS_READ;
270 
271         if ((read_write == I2C_SMBUS_WRITE) || (size == VT596_QUICK))
272                 return 0;
273 
274         switch (size) {
275         case VT596_BYTE:
276         case VT596_BYTE_DATA:
277                 data->byte = inb_p(SMBHSTDAT0);
278                 break;
279         case VT596_WORD_DATA:
280         case VT596_PROC_CALL:
281                 data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
282                 break;
283         case VT596_I2C_BLOCK_DATA:
284         case VT596_BLOCK_DATA:
285                 data->block[0] = inb_p(SMBHSTDAT0);
286                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX)
287                         data->block[0] = I2C_SMBUS_BLOCK_MAX;
288                 inb_p(SMBHSTCNT);       /* Reset SMBBLKDAT */
289                 for (i = 1; i <= data->block[0]; i++)
290                         data->block[i] = inb_p(SMBBLKDAT);
291                 break;
292         }
293         return 0;
294 
295 exit_unsupported:
296         dev_warn(&vt596_adapter.dev, "Unsupported transaction %d\n",
297                  size);
298         return -EOPNOTSUPP;
299 }
300 
301 static u32 vt596_func(struct i2c_adapter *adapter)
302 {
303         u32 func = I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
304             I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
305             I2C_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_BLOCK_DATA;
306 
307         if (vt596_features & FEATURE_I2CBLOCK)
308                 func |= I2C_FUNC_SMBUS_I2C_BLOCK;
309         return func;
310 }
311 
312 static const struct i2c_algorithm smbus_algorithm = {
313         .smbus_xfer     = vt596_access,
314         .functionality  = vt596_func,
315 };
316 
317 static struct i2c_adapter vt596_adapter = {
318         .owner          = THIS_MODULE,
319         .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
320         .algo           = &smbus_algorithm,
321 };
322 
323 static int vt596_probe(struct pci_dev *pdev,
324                        const struct pci_device_id *id)
325 {
326         unsigned char temp;
327         int error;
328 
329         /* Determine the address of the SMBus areas */
330         if (force_addr) {
331                 vt596_smba = force_addr & 0xfff0;
332                 force = 0;
333                 goto found;
334         }
335 
336         if ((pci_read_config_word(pdev, id->driver_data, &vt596_smba)) ||
337             !(vt596_smba & 0x0001)) {
338                 /* try 2nd address and config reg. for 596 */
339                 if (id->device == PCI_DEVICE_ID_VIA_82C596_3 &&
340                     !pci_read_config_word(pdev, SMBBA2, &vt596_smba) &&
341                     (vt596_smba & 0x0001)) {
342                         SMBHSTCFG = 0x84;
343                 } else {
344                         /* no matches at all */
345                         dev_err(&pdev->dev, "Cannot configure "
346                                 "SMBus I/O Base address\n");
347                         return -ENODEV;
348                 }
349         }
350 
351         vt596_smba &= 0xfff0;
352         if (vt596_smba == 0) {
353                 dev_err(&pdev->dev, "SMBus base address "
354                         "uninitialized - upgrade BIOS or use "
355                         "force_addr=0xaddr\n");
356                 return -ENODEV;
357         }
358 
359 found:
360         error = acpi_check_region(vt596_smba, 8, vt596_driver.name);
361         if (error)
362                 return -ENODEV;
363 
364         if (!request_region(vt596_smba, 8, vt596_driver.name)) {
365                 dev_err(&pdev->dev, "SMBus region 0x%x already in use!\n",
366                         vt596_smba);
367                 return -ENODEV;
368         }
369 
370         pci_read_config_byte(pdev, SMBHSTCFG, &temp);
371         /* If force_addr is set, we program the new address here. Just to make
372            sure, we disable the VT596 first. */
373         if (force_addr) {
374                 pci_write_config_byte(pdev, SMBHSTCFG, temp & 0xfe);
375                 pci_write_config_word(pdev, id->driver_data, vt596_smba);
376                 pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
377                 dev_warn(&pdev->dev, "WARNING: SMBus interface set to new "
378                          "address 0x%04x!\n", vt596_smba);
379         } else if (!(temp & 0x01)) {
380                 if (force) {
381                         /* NOTE: This assumes I/O space and other allocations
382                          * WERE done by the Bios!  Don't complain if your
383                          * hardware does weird things after enabling this.
384                          * :') Check for Bios updates before resorting to
385                          * this.
386                          */
387                         pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
388                         dev_info(&pdev->dev, "Enabling SMBus device\n");
389                 } else {
390                         dev_err(&pdev->dev, "SMBUS: Error: Host SMBus "
391                                 "controller not enabled! - upgrade BIOS or "
392                                 "use force=1\n");
393                         error = -ENODEV;
394                         goto release_region;
395                 }
396         }
397 
398         dev_dbg(&pdev->dev, "VT596_smba = 0x%X\n", vt596_smba);
399 
400         switch (pdev->device) {
401         case PCI_DEVICE_ID_VIA_CX700:
402         case PCI_DEVICE_ID_VIA_VX800:
403         case PCI_DEVICE_ID_VIA_VX855:
404         case PCI_DEVICE_ID_VIA_VX900:
405         case PCI_DEVICE_ID_VIA_8251:
406         case PCI_DEVICE_ID_VIA_8237:
407         case PCI_DEVICE_ID_VIA_8237A:
408         case PCI_DEVICE_ID_VIA_8237S:
409         case PCI_DEVICE_ID_VIA_8235:
410         case PCI_DEVICE_ID_VIA_8233A:
411         case PCI_DEVICE_ID_VIA_8233_0:
412                 vt596_features |= FEATURE_I2CBLOCK;
413                 break;
414         case PCI_DEVICE_ID_VIA_82C686_4:
415                 /* The VT82C686B (rev 0x40) does support I2C block
416                    transactions, but the VT82C686A (rev 0x30) doesn't */
417                 if (pdev->revision >= 0x40)
418                         vt596_features |= FEATURE_I2CBLOCK;
419                 break;
420         }
421 
422         vt596_adapter.dev.parent = &pdev->dev;
423         snprintf(vt596_adapter.name, sizeof(vt596_adapter.name),
424                  "SMBus Via Pro adapter at %04x", vt596_smba);
425 
426         vt596_pdev = pci_dev_get(pdev);
427         error = i2c_add_adapter(&vt596_adapter);
428         if (error) {
429                 pci_dev_put(vt596_pdev);
430                 vt596_pdev = NULL;
431                 goto release_region;
432         }
433 
434         /* Always return failure here.  This is to allow other drivers to bind
435          * to this pci device.  We don't really want to have control over the
436          * pci device, we only wanted to read as few register values from it.
437          */
438         return -ENODEV;
439 
440 release_region:
441         release_region(vt596_smba, 8);
442         return error;
443 }
444 
445 static const struct pci_device_id vt596_ids[] = {
446         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596_3),
447           .driver_data = SMBBA1 },
448         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596B_3),
449           .driver_data = SMBBA1 },
450         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4),
451           .driver_data = SMBBA1 },
452         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233_0),
453           .driver_data = SMBBA3 },
454         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233A),
455           .driver_data = SMBBA3 },
456         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235),
457           .driver_data = SMBBA3 },
458         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237),
459           .driver_data = SMBBA3 },
460         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237A),
461           .driver_data = SMBBA3 },
462         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237S),
463           .driver_data = SMBBA3 },
464         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4),
465           .driver_data = SMBBA1 },
466         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8251),
467           .driver_data = SMBBA3 },
468         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_CX700),
469           .driver_data = SMBBA3 },
470         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX800),
471           .driver_data = SMBBA3 },
472         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX855),
473           .driver_data = SMBBA3 },
474         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX900),
475           .driver_data = SMBBA3 },
476         { 0, }
477 };
478 
479 MODULE_DEVICE_TABLE(pci, vt596_ids);
480 
481 static struct pci_driver vt596_driver = {
482         .name           = "vt596_smbus",
483         .id_table       = vt596_ids,
484         .probe          = vt596_probe,
485 };
486 
487 static int __init i2c_vt596_init(void)
488 {
489         return pci_register_driver(&vt596_driver);
490 }
491 
492 
493 static void __exit i2c_vt596_exit(void)
494 {
495         pci_unregister_driver(&vt596_driver);
496         if (vt596_pdev != NULL) {
497                 i2c_del_adapter(&vt596_adapter);
498                 release_region(vt596_smba, 8);
499                 pci_dev_put(vt596_pdev);
500                 vt596_pdev = NULL;
501         }
502 }
503 
504 MODULE_AUTHOR("Kyosti Malkki <kmalkki@cc.hut.fi>, "
505               "Mark D. Studebaker <mdsxyz123@yahoo.com> and "
506               "Jean Delvare <jdelvare@suse.de>");
507 MODULE_DESCRIPTION("vt82c596 SMBus driver");
508 MODULE_LICENSE("GPL");
509 
510 module_init(i2c_vt596_init);
511 module_exit(i2c_vt596_exit);
512 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us