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