1 /*
2 i2c-viapro.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring
4 Copyright (c) 1998 - 2002 Frodo Looijaard <frodol@dds.nl>,
5 Philip Edelbrock <phil@netroedge.com>, Kyösti Mälkki <kmalkki@cc.hut.fi>,
6 Mark D. Studebaker <mdsxyz123@yahoo.com>
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 /*
24 Supports Via devices:
25 82C596A/B (0x3050)
26 82C596B (0x3051)
27 82C686A/B
28 8231
29 8233
30 8233A (0x3147 and 0x3177)
31 8235
32 8237
33 Note: we assume there can only be one device, with one SMBus interface.
34 */
35
36 #include <linux/config.h>
37 #include <linux/module.h>
38 #include <linux/delay.h>
39 #include <linux/pci.h>
40 #include <linux/kernel.h>
41 #include <linux/stddef.h>
42 #include <linux/sched.h>
43 #include <linux/ioport.h>
44 #include <linux/i2c.h>
45 #include <linux/init.h>
46 #include <asm/io.h>
47
48 static struct pci_dev *vt596_pdev;
49
50 #define SMBBA1 0x90
51 #define SMBBA2 0x80
52 #define SMBBA3 0xD0
53
54 /* SMBus address offsets */
55 static unsigned short vt596_smba;
56 #define SMBHSTSTS (vt596_smba + 0)
57 #define SMBHSLVSTS (vt596_smba + 1)
58 #define SMBHSTCNT (vt596_smba + 2)
59 #define SMBHSTCMD (vt596_smba + 3)
60 #define SMBHSTADD (vt596_smba + 4)
61 #define SMBHSTDAT0 (vt596_smba + 5)
62 #define SMBHSTDAT1 (vt596_smba + 6)
63 #define SMBBLKDAT (vt596_smba + 7)
64 #define SMBSLVCNT (vt596_smba + 8)
65 #define SMBSHDWCMD (vt596_smba + 9)
66 #define SMBSLVEVT (vt596_smba + 0xA)
67 #define SMBSLVDAT (vt596_smba + 0xC)
68
69 /* PCI Address Constants */
70
71 /* SMBus data in configuration space can be found in two places,
72 We try to select the better one*/
73
74 static unsigned short smb_cf_hstcfg = 0xD2;
75
76 #define SMBHSTCFG (smb_cf_hstcfg)
77 #define SMBSLVC (smb_cf_hstcfg + 1)
78 #define SMBSHDW1 (smb_cf_hstcfg + 2)
79 #define SMBSHDW2 (smb_cf_hstcfg + 3)
80 #define SMBREV (smb_cf_hstcfg + 4)
81
82 /* Other settings */
83 #define MAX_TIMEOUT 500
84 #define ENABLE_INT9 0
85
86 /* VT82C596 constants */
87 #define VT596_QUICK 0x00
88 #define VT596_BYTE 0x04
89 #define VT596_BYTE_DATA 0x08
90 #define VT596_WORD_DATA 0x0C
91 #define VT596_BLOCK_DATA 0x14
92
93
94 /* If force is set to anything different from 0, we forcibly enable the
95 VT596. DANGEROUS! */
96 static int force;
97 module_param(force, bool, 0);
98 MODULE_PARM_DESC(force, "Forcibly enable the SMBus. DANGEROUS!");
99
100 /* If force_addr is set to anything different from 0, we forcibly enable
101 the VT596 at the given address. VERY DANGEROUS! */
102 static u16 force_addr;
103 module_param(force_addr, ushort, 0);
104 MODULE_PARM_DESC(force_addr,
105 "Forcibly enable the SMBus at the given address. "
106 "EXTREMELY DANGEROUS!");
107
108
109 static struct i2c_adapter vt596_adapter;
110
111 /* Another internally used function */
112 static int vt596_transaction(void)
113 {
114 int temp;
115 int result = 0;
116 int timeout = 0;
117
118 dev_dbg(&vt596_adapter.dev, "Transaction (pre): CNT=%02x, CMD=%02x, "
119 "ADD=%02x, DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTCNT),
120 inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
121 inb_p(SMBHSTDAT1));
122
123 /* Make sure the SMBus host is ready to start transmitting */
124 if ((temp = inb_p(SMBHSTSTS)) != 0x00) {
125 dev_dbg(&vt596_adapter.dev, "SMBus busy (0x%02x). "
126 "Resetting...\n", temp);
127
128 outb_p(temp, SMBHSTSTS);
129 if ((temp = inb_p(SMBHSTSTS)) != 0x00) {
130 dev_dbg(&vt596_adapter.dev, "Failed! (0x%02x)\n", temp);
131
132 return -1;
133 } else {
134 dev_dbg(&vt596_adapter.dev, "Successfull!\n");
135 }
136 }
137
138 /* start the transaction by setting bit 6 */
139 outb_p(inb(SMBHSTCNT) | 0x040, SMBHSTCNT);
140
141 /* We will always wait for a fraction of a second!
142 I don't know if VIA needs this, Intel did */
143 do {
144 msleep(1);
145 temp = inb_p(SMBHSTSTS);
146 } while ((temp & 0x01) && (timeout++ < MAX_TIMEOUT));
147
148 /* If the SMBus is still busy, we give up */
149 if (timeout >= MAX_TIMEOUT) {
150 result = -1;
151 dev_dbg(&vt596_adapter.dev, "SMBus Timeout!\n");
152 }
153
154 if (temp & 0x10) {
155 result = -1;
156 dev_dbg(&vt596_adapter.dev, "Error: Failed bus transaction\n");
157 }
158
159 if (temp & 0x08) {
160 result = -1;
161 dev_info(&vt596_adapter.dev, "Bus collision! SMBus may be "
162 "locked until next hard\nreset. (sorry!)\n");
163 /* Clock stops and slave is stuck in mid-transmission */
164 }
165
166 if (temp & 0x04) {
167 result = -1;
168 dev_dbg(&vt596_adapter.dev, "Error: no response!\n");
169 }
170
171 if (inb_p(SMBHSTSTS) != 0x00)
172 outb_p(inb(SMBHSTSTS), SMBHSTSTS);
173
174 if ((temp = inb_p(SMBHSTSTS)) != 0x00) {
175 dev_dbg(&vt596_adapter.dev, "Failed reset at end of "
176 "transaction (%02x)\n", temp);
177 }
178 dev_dbg(&vt596_adapter.dev, "Transaction (post): CNT=%02x, CMD=%02x, "
179 "ADD=%02x, DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTCNT),
180 inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
181 inb_p(SMBHSTDAT1));
182
183 return result;
184 }
185
186 /* Return -1 on error. */
187 static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
188 unsigned short flags, char read_write, u8 command,
189 int size, union i2c_smbus_data *data)
190 {
191 int i, len;
192
193 switch (size) {
194 case I2C_SMBUS_PROC_CALL:
195 dev_info(&vt596_adapter.dev,
196 "I2C_SMBUS_PROC_CALL not supported!\n");
197 return -1;
198 case I2C_SMBUS_QUICK:
199 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
200 SMBHSTADD);
201 size = VT596_QUICK;
202 break;
203 case I2C_SMBUS_BYTE:
204 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
205 SMBHSTADD);
206 if (read_write == I2C_SMBUS_WRITE)
207 outb_p(command, SMBHSTCMD);
208 size = VT596_BYTE;
209 break;
210 case I2C_SMBUS_BYTE_DATA:
211 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
212 SMBHSTADD);
213 outb_p(command, SMBHSTCMD);
214 if (read_write == I2C_SMBUS_WRITE)
215 outb_p(data->byte, SMBHSTDAT0);
216 size = VT596_BYTE_DATA;
217 break;
218 case I2C_SMBUS_WORD_DATA:
219 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
220 SMBHSTADD);
221 outb_p(command, SMBHSTCMD);
222 if (read_write == I2C_SMBUS_WRITE) {
223 outb_p(data->word & 0xff, SMBHSTDAT0);
224 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
225 }
226 size = VT596_WORD_DATA;
227 break;
228 case I2C_SMBUS_BLOCK_DATA:
229 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
230 SMBHSTADD);
231 outb_p(command, SMBHSTCMD);
232 if (read_write == I2C_SMBUS_WRITE) {
233 len = data->block[0];
234 if (len < 0)
235 len = 0;
236 if (len > I2C_SMBUS_BLOCK_MAX)
237 len = I2C_SMBUS_BLOCK_MAX;
238 outb_p(len, SMBHSTDAT0);
239 i = inb_p(SMBHSTCNT); /* Reset SMBBLKDAT */
240 for (i = 1; i <= len; i++)
241 outb_p(data->block[i], SMBBLKDAT);
242 }
243 size = VT596_BLOCK_DATA;
244 break;
245 }
246
247 outb_p((size & 0x1C) + (ENABLE_INT9 & 1), SMBHSTCNT);
248
249 if (vt596_transaction()) /* Error in transaction */
250 return -1;
251
252 if ((read_write == I2C_SMBUS_WRITE) || (size == VT596_QUICK))
253 return 0;
254
255 switch (size) {
256 case VT596_BYTE:
257 /* Where is the result put? I assume here it is in
258 * SMBHSTDAT0 but it might just as well be in the
259 * SMBHSTCMD. No clue in the docs
260 */
261 data->byte = inb_p(SMBHSTDAT0);
262 break;
263 case VT596_BYTE_DATA:
264 data->byte = inb_p(SMBHSTDAT0);
265 break;
266 case VT596_WORD_DATA:
267 data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
268 break;
269 case VT596_BLOCK_DATA:
270 data->block[0] = inb_p(SMBHSTDAT0);
271 if (data->block[0] > I2C_SMBUS_BLOCK_MAX)
272 data->block[0] = I2C_SMBUS_BLOCK_MAX;
273 i = inb_p(SMBHSTCNT); /* Reset SMBBLKDAT */
274 for (i = 1; i <= data->block[0]; i++)
275 data->block[i] = inb_p(SMBBLKDAT);
276 break;
277 }
278 return 0;
279 }
280
281 static u32 vt596_func(struct i2c_adapter *adapter)
282 {
283 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
284 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
285 I2C_FUNC_SMBUS_BLOCK_DATA;
286 }
287
288 static struct i2c_algorithm smbus_algorithm = {
289 .name = "Non-I2C SMBus adapter",
290 .id = I2C_ALGO_SMBUS,
291 .smbus_xfer = vt596_access,
292 .functionality = vt596_func,
293 };
294
295 static struct i2c_adapter vt596_adapter = {
296 .owner = THIS_MODULE,
297 .class = I2C_CLASS_HWMON,
298 .algo = &smbus_algorithm,
299 .name = "unset",
300 };
301
302 static int __devinit vt596_probe(struct pci_dev *pdev,
303 const struct pci_device_id *id)
304 {
305 unsigned char temp;
306 int error = -ENODEV;
307
308 /* Determine the address of the SMBus areas */
309 if (force_addr) {
310 vt596_smba = force_addr & 0xfff0;
311 force = 0;
312 goto found;
313 }
314
315 if ((pci_read_config_word(pdev, id->driver_data, &vt596_smba)) ||
316 !(vt596_smba & 0x1)) {
317 /* try 2nd address and config reg. for 596 */
318 if (id->device == PCI_DEVICE_ID_VIA_82C596_3 &&
319 !pci_read_config_word(pdev, SMBBA2, &vt596_smba) &&
320 (vt596_smba & 0x1)) {
321 smb_cf_hstcfg = 0x84;
322 } else {
323 /* no matches at all */
324 dev_err(&pdev->dev, "Cannot configure "
325 "SMBus I/O Base address\n");
326 return -ENODEV;
327 }
328 }
329
330 vt596_smba &= 0xfff0;
331 if (vt596_smba == 0) {
332 dev_err(&pdev->dev, "SMBus base address "
333 "uninitialized - upgrade BIOS or use "
334 "force_addr=0xaddr\n");
335 return -ENODEV;
336 }
337
338 found:
339 if (!request_region(vt596_smba, 8, "viapro-smbus")) {
340 dev_err(&pdev->dev, "SMBus region 0x%x already in use!\n",
341 vt596_smba);
342 return -ENODEV;
343 }
344
345 pci_read_config_byte(pdev, SMBHSTCFG, &temp);
346 /* If force_addr is set, we program the new address here. Just to make
347 sure, we disable the VT596 first. */
348 if (force_addr) {
349 pci_write_config_byte(pdev, SMBHSTCFG, temp & 0xfe);
350 pci_write_config_word(pdev, id->driver_data, vt596_smba);
351 pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
352 dev_warn(&pdev->dev, "WARNING: SMBus interface set to new "
353 "address 0x%04x!\n", vt596_smba);
354 } else if ((temp & 1) == 0) {
355 if (force) {
356 /* NOTE: This assumes I/O space and other allocations
357 * WERE done by the Bios! Don't complain if your
358 * hardware does weird things after enabling this.
359 * :') Check for Bios updates before resorting to
360 * this.
361 */
362 pci_write_config_byte(pdev, SMBHSTCFG, temp | 1);
363 dev_info(&pdev->dev, "Enabling SMBus device\n");
364 } else {
365 dev_err(&pdev->dev, "SMBUS: Error: Host SMBus "
366 "controller not enabled! - upgrade BIOS or "
367 "use force=1\n");
368 goto release_region;
369 }
370 }
371
372 if ((temp & 0x0E) == 8)
373 dev_dbg(&pdev->dev, "using Interrupt 9 for SMBus.\n");
374 else if ((temp & 0x0E) == 0)
375 dev_dbg(&pdev->dev, "using Interrupt SMI# for SMBus.\n");
376 else
377 dev_dbg(&pdev->dev, "Illegal Interrupt configuration "
378 "(or code out of date)!\n");
379
380 pci_read_config_byte(pdev, SMBREV, &temp);
381 dev_dbg(&pdev->dev, "SMBREV = 0x%X\n", temp);
382 dev_dbg(&pdev->dev, "VT596_smba = 0x%X\n", vt596_smba);
383
384 vt596_adapter.dev.parent = &pdev->dev;
385 snprintf(vt596_adapter.name, I2C_NAME_SIZE,
386 "SMBus Via Pro adapter at %04x", vt596_smba);
387
388 vt596_pdev = pci_dev_get(pdev);
389 if (i2c_add_adapter(&vt596_adapter)) {
390 pci_dev_put(vt596_pdev);
391 vt596_pdev = NULL;
392 }
393
394 /* Always return failure here. This is to allow other drivers to bind
395 * to this pci device. We don't really want to have control over the
396 * pci device, we only wanted to read as few register values from it.
397 */
398 return -ENODEV;
399
400 release_region:
401 release_region(vt596_smba, 8);
402 return error;
403 }
404
405 static struct pci_device_id vt596_ids[] = {
406 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596_3),
407 .driver_data = SMBBA1 },
408 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596B_3),
409 .driver_data = SMBBA1 },
410 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4),
411 .driver_data = SMBBA1 },
412 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233_0),
413 .driver_data = SMBBA3 },
414 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8233A),
415 .driver_data = SMBBA3 },
416 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235),
417 .driver_data = SMBBA3 },
418 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237),
419 .driver_data = SMBBA3 },
420 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4),
421 .driver_data = SMBBA1 },
422 { 0, }
423 };
424
425 MODULE_DEVICE_TABLE (pci, vt596_ids);
426
427 static struct pci_driver vt596_driver = {
428 .name = "vt596_smbus",
429 .id_table = vt596_ids,
430 .probe = vt596_probe,
431 };
432
433 static int __init i2c_vt596_init(void)
434 {
435 return pci_register_driver(&vt596_driver);
436 }
437
438
439 static void __exit i2c_vt596_exit(void)
440 {
441 pci_unregister_driver(&vt596_driver);
442 if (vt596_pdev != NULL) {
443 i2c_del_adapter(&vt596_adapter);
444 release_region(vt596_smba, 8);
445 pci_dev_put(vt596_pdev);
446 vt596_pdev = NULL;
447 }
448 }
449
450 MODULE_AUTHOR(
451 "Frodo Looijaard <frodol@dds.nl> and "
452 "Philip Edelbrock <phil@netroedge.com>");
453 MODULE_DESCRIPTION("vt82c596 SMBus driver");
454 MODULE_LICENSE("GPL");
455
456 module_init(i2c_vt596_init);
457 module_exit(i2c_vt596_exit);
458
|
This page was automatically generated by the
LXR engine.
|