Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
i2c-viapro.c
Go to the documentation of this file.
1 /*
2  Copyright (c) 1998 - 2002 Frodo Looijaard <[email protected]>,
3  Philip Edelbrock <[email protected]>, Kyösti Mälkki <[email protected]>,
4  Mark D. Studebaker <[email protected]>
5  Copyright (C) 2005 - 2008 Jean Delvare <[email protected]>
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 __devinit 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 DEFINE_PCI_DEVICE_TABLE(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 <[email protected]>, "
505  "Mark D. Studebaker <[email protected]> and "
506  "Jean Delvare <[email protected]>");
507 MODULE_DESCRIPTION("vt82c596 SMBus driver");
508 MODULE_LICENSE("GPL");
509 
510 module_init(i2c_vt596_init);
511 module_exit(i2c_vt596_exit);
Generated on Thu Jan 10 2013 13:35:50 for Linux Kernel by   doxygen 1.8.2