1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49#include <linux/module.h>
50#include <linux/pci.h>
51#include <linux/kernel.h>
52#include <linux/stddef.h>
53#include <linux/ioport.h>
54#include <linux/init.h>
55#include <linux/i2c.h>
56#include <linux/delay.h>
57#include <linux/dmi.h>
58#include <linux/acpi.h>
59#include <asm/io.h>
60
61MODULE_LICENSE("GPL");
62MODULE_AUTHOR ("Hans-Frieder Vogt <hfvogt@gmx.net>");
63MODULE_DESCRIPTION("nForce2/3/4/5xx SMBus driver");
64
65
66struct nforce2_smbus {
67 struct i2c_adapter adapter;
68 int base;
69 int size;
70 int blockops;
71 int can_abort;
72};
73
74
75
76
77
78
79#define NFORCE_PCI_SMB1 0x50
80#define NFORCE_PCI_SMB2 0x54
81
82
83
84
85
86#define NVIDIA_SMB_PRTCL (smbus->base + 0x00)
87#define NVIDIA_SMB_STS (smbus->base + 0x01)
88#define NVIDIA_SMB_ADDR (smbus->base + 0x02)
89#define NVIDIA_SMB_CMD (smbus->base + 0x03)
90#define NVIDIA_SMB_DATA (smbus->base + 0x04)
91#define NVIDIA_SMB_BCNT (smbus->base + 0x24)
92
93#define NVIDIA_SMB_STATUS_ABRT (smbus->base + 0x3c)
94
95
96#define NVIDIA_SMB_CTRL (smbus->base + 0x3e)
97
98#define NVIDIA_SMB_STATUS_ABRT_STS 0x01
99
100#define NVIDIA_SMB_CTRL_ABORT 0x20
101#define NVIDIA_SMB_STS_DONE 0x80
102#define NVIDIA_SMB_STS_ALRM 0x40
103#define NVIDIA_SMB_STS_RES 0x20
104#define NVIDIA_SMB_STS_STATUS 0x1f
105
106#define NVIDIA_SMB_PRTCL_WRITE 0x00
107#define NVIDIA_SMB_PRTCL_READ 0x01
108#define NVIDIA_SMB_PRTCL_QUICK 0x02
109#define NVIDIA_SMB_PRTCL_BYTE 0x04
110#define NVIDIA_SMB_PRTCL_BYTE_DATA 0x06
111#define NVIDIA_SMB_PRTCL_WORD_DATA 0x08
112#define NVIDIA_SMB_PRTCL_BLOCK_DATA 0x0a
113#define NVIDIA_SMB_PRTCL_PEC 0x80
114
115
116#define MAX_TIMEOUT 100
117
118
119static struct dmi_system_id __devinitdata nforce2_dmi_blacklist2[] = {
120 {
121 .ident = "DFI Lanparty NF4 Expert",
122 .matches = {
123 DMI_MATCH(DMI_BOARD_VENDOR, "DFI Corp,LTD"),
124 DMI_MATCH(DMI_BOARD_NAME, "LP UT NF4 Expert"),
125 },
126 },
127 { }
128};
129
130static struct pci_driver nforce2_driver;
131
132
133
134#if defined CONFIG_I2C_NFORCE2_S4985 || defined CONFIG_I2C_NFORCE2_S4985_MODULE
135struct i2c_adapter *nforce2_smbus;
136EXPORT_SYMBOL_GPL(nforce2_smbus);
137
138static void nforce2_set_reference(struct i2c_adapter *adap)
139{
140 nforce2_smbus = adap;
141}
142#else
143static inline void nforce2_set_reference(struct i2c_adapter *adap) { }
144#endif
145
146static void nforce2_abort(struct i2c_adapter *adap)
147{
148 struct nforce2_smbus *smbus = adap->algo_data;
149 int timeout = 0;
150 unsigned char temp;
151
152 dev_dbg(&adap->dev, "Aborting current transaction\n");
153
154 outb_p(NVIDIA_SMB_CTRL_ABORT, NVIDIA_SMB_CTRL);
155 do {
156 msleep(1);
157 temp = inb_p(NVIDIA_SMB_STATUS_ABRT);
158 } while (!(temp & NVIDIA_SMB_STATUS_ABRT_STS) &&
159 (timeout++ < MAX_TIMEOUT));
160 if (!(temp & NVIDIA_SMB_STATUS_ABRT_STS))
161 dev_err(&adap->dev, "Can't reset the smbus\n");
162 outb_p(NVIDIA_SMB_STATUS_ABRT_STS, NVIDIA_SMB_STATUS_ABRT);
163}
164
165static int nforce2_check_status(struct i2c_adapter *adap)
166{
167 struct nforce2_smbus *smbus = adap->algo_data;
168 int timeout = 0;
169 unsigned char temp;
170
171 do {
172 msleep(1);
173 temp = inb_p(NVIDIA_SMB_STS);
174 } while ((!temp) && (timeout++ < MAX_TIMEOUT));
175
176 if (timeout > MAX_TIMEOUT) {
177 dev_dbg(&adap->dev, "SMBus Timeout!\n");
178 if (smbus->can_abort)
179 nforce2_abort(adap);
180 return -ETIMEDOUT;
181 }
182 if (!(temp & NVIDIA_SMB_STS_DONE) || (temp & NVIDIA_SMB_STS_STATUS)) {
183 dev_dbg(&adap->dev, "Transaction failed (0x%02x)!\n", temp);
184 return -EIO;
185 }
186 return 0;
187}
188
189
190static s32 nforce2_access(struct i2c_adapter * adap, u16 addr,
191 unsigned short flags, char read_write,
192 u8 command, int size, union i2c_smbus_data * data)
193{
194 struct nforce2_smbus *smbus = adap->algo_data;
195 unsigned char protocol, pec;
196 u8 len;
197 int i, status;
198
199 protocol = (read_write == I2C_SMBUS_READ) ? NVIDIA_SMB_PRTCL_READ :
200 NVIDIA_SMB_PRTCL_WRITE;
201 pec = (flags & I2C_CLIENT_PEC) ? NVIDIA_SMB_PRTCL_PEC : 0;
202
203 switch (size) {
204
205 case I2C_SMBUS_QUICK:
206 protocol |= NVIDIA_SMB_PRTCL_QUICK;
207 read_write = I2C_SMBUS_WRITE;
208 break;
209
210 case I2C_SMBUS_BYTE:
211 if (read_write == I2C_SMBUS_WRITE)
212 outb_p(command, NVIDIA_SMB_CMD);
213 protocol |= NVIDIA_SMB_PRTCL_BYTE;
214 break;
215
216 case I2C_SMBUS_BYTE_DATA:
217 outb_p(command, NVIDIA_SMB_CMD);
218 if (read_write == I2C_SMBUS_WRITE)
219 outb_p(data->byte, NVIDIA_SMB_DATA);
220 protocol |= NVIDIA_SMB_PRTCL_BYTE_DATA;
221 break;
222
223 case I2C_SMBUS_WORD_DATA:
224 outb_p(command, NVIDIA_SMB_CMD);
225 if (read_write == I2C_SMBUS_WRITE) {
226 outb_p(data->word, NVIDIA_SMB_DATA);
227 outb_p(data->word >> 8, NVIDIA_SMB_DATA+1);
228 }
229 protocol |= NVIDIA_SMB_PRTCL_WORD_DATA | pec;
230 break;
231
232 case I2C_SMBUS_BLOCK_DATA:
233 outb_p(command, NVIDIA_SMB_CMD);
234 if (read_write == I2C_SMBUS_WRITE) {
235 len = data->block[0];
236 if ((len == 0) || (len > I2C_SMBUS_BLOCK_MAX)) {
237 dev_err(&adap->dev,
238 "Transaction failed "
239 "(requested block size: %d)\n",
240 len);
241 return -EINVAL;
242 }
243 outb_p(len, NVIDIA_SMB_BCNT);
244 for (i = 0; i < I2C_SMBUS_BLOCK_MAX; i++)
245 outb_p(data->block[i + 1],
246 NVIDIA_SMB_DATA+i);
247 }
248 protocol |= NVIDIA_SMB_PRTCL_BLOCK_DATA | pec;
249 break;
250
251 default:
252 dev_err(&adap->dev, "Unsupported transaction %d\n", size);
253 return -EOPNOTSUPP;
254 }
255
256 outb_p((addr & 0x7f) << 1, NVIDIA_SMB_ADDR);
257 outb_p(protocol, NVIDIA_SMB_PRTCL);
258
259 status = nforce2_check_status(adap);
260 if (status)
261 return status;
262
263 if (read_write == I2C_SMBUS_WRITE)
264 return 0;
265
266 switch (size) {
267
268 case I2C_SMBUS_BYTE:
269 case I2C_SMBUS_BYTE_DATA:
270 data->byte = inb_p(NVIDIA_SMB_DATA);
271 break;
272
273 case I2C_SMBUS_WORD_DATA:
274 data->word = inb_p(NVIDIA_SMB_DATA) | (inb_p(NVIDIA_SMB_DATA+1) << 8);
275 break;
276
277 case I2C_SMBUS_BLOCK_DATA:
278 len = inb_p(NVIDIA_SMB_BCNT);
279 if ((len <= 0) || (len > I2C_SMBUS_BLOCK_MAX)) {
280 dev_err(&adap->dev, "Transaction failed "
281 "(received block size: 0x%02x)\n",
282 len);
283 return -EPROTO;
284 }
285 for (i = 0; i < len; i++)
286 data->block[i+1] = inb_p(NVIDIA_SMB_DATA + i);
287 data->block[0] = len;
288 break;
289 }
290
291 return 0;
292}
293
294
295static u32 nforce2_func(struct i2c_adapter *adapter)
296{
297
298 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
299 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
300 I2C_FUNC_SMBUS_PEC |
301 (((struct nforce2_smbus*)adapter->algo_data)->blockops ?
302 I2C_FUNC_SMBUS_BLOCK_DATA : 0);
303}
304
305static struct i2c_algorithm smbus_algorithm = {
306 .smbus_xfer = nforce2_access,
307 .functionality = nforce2_func,
308};
309
310
311static struct pci_device_id nforce2_ids[] = {
312 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2_SMBUS) },
313 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2S_SMBUS) },
314 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3_SMBUS) },
315 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3S_SMBUS) },
316 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE4_SMBUS) },
317 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SMBUS) },
318 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SMBUS) },
319 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SMBUS) },
320 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SMBUS) },
321 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP65_SMBUS) },
322 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP67_SMBUS) },
323 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP73_SMBUS) },
324 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP78S_SMBUS) },
325 { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP79_SMBUS) },
326 { 0 }
327};
328
329MODULE_DEVICE_TABLE (pci, nforce2_ids);
330
331
332static int __devinit nforce2_probe_smb (struct pci_dev *dev, int bar,
333 int alt_reg, struct nforce2_smbus *smbus, const char *name)
334{
335 int error;
336
337 smbus->base = pci_resource_start(dev, bar);
338 if (smbus->base) {
339 smbus->size = pci_resource_len(dev, bar);
340 } else {
341
342 u16 iobase;
343
344 if (pci_read_config_word(dev, alt_reg, &iobase)
345 != PCIBIOS_SUCCESSFUL) {
346 dev_err(&dev->dev, "Error reading PCI config for %s\n",
347 name);
348 return -EIO;
349 }
350
351 smbus->base = iobase & PCI_BASE_ADDRESS_IO_MASK;
352 smbus->size = 64;
353 }
354
355 error = acpi_check_region(smbus->base, smbus->size,
356 nforce2_driver.name);
357 if (error)
358 return -1;
359
360 if (!request_region(smbus->base, smbus->size, nforce2_driver.name)) {
361 dev_err(&smbus->adapter.dev, "Error requesting region %02x .. %02X for %s\n",
362 smbus->base, smbus->base+smbus->size-1, name);
363 return -EBUSY;
364 }
365 smbus->adapter.owner = THIS_MODULE;
366 smbus->adapter.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
367 smbus->adapter.algo = &smbus_algorithm;
368 smbus->adapter.algo_data = smbus;
369 smbus->adapter.dev.parent = &dev->dev;
370 snprintf(smbus->adapter.name, sizeof(smbus->adapter.name),
371 "SMBus nForce2 adapter at %04x", smbus->base);
372
373 error = i2c_add_adapter(&smbus->adapter);
374 if (error) {
375 dev_err(&smbus->adapter.dev, "Failed to register adapter.\n");
376 release_region(smbus->base, smbus->size);
377 return error;
378 }
379 dev_info(&smbus->adapter.dev, "nForce2 SMBus adapter at %#x\n", smbus->base);
380 return 0;
381}
382
383
384static int __devinit nforce2_probe(struct pci_dev *dev, const struct pci_device_id *id)
385{
386 struct nforce2_smbus *smbuses;
387 int res1, res2;
388
389
390 if (!(smbuses = kzalloc(2*sizeof(struct nforce2_smbus), GFP_KERNEL)))
391 return -ENOMEM;
392 pci_set_drvdata(dev, smbuses);
393
394 switch(dev->device) {
395 case PCI_DEVICE_ID_NVIDIA_NFORCE2_SMBUS:
396 case PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SMBUS:
397 case PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SMBUS:
398 smbuses[0].blockops = 1;
399 smbuses[1].blockops = 1;
400 smbuses[0].can_abort = 1;
401 smbuses[1].can_abort = 1;
402 }
403
404
405 res1 = nforce2_probe_smb(dev, 4, NFORCE_PCI_SMB1, &smbuses[0], "SMB1");
406 if (res1 < 0) {
407 dev_err(&dev->dev, "Error probing SMB1.\n");
408 smbuses[0].base = 0;
409 }
410
411 if (dmi_check_system(nforce2_dmi_blacklist2)) {
412 dev_err(&dev->dev, "Disabling SMB2 for safety reasons.\n");
413 res2 = -EPERM;
414 smbuses[1].base = 0;
415 } else {
416 res2 = nforce2_probe_smb(dev, 5, NFORCE_PCI_SMB2, &smbuses[1],
417 "SMB2");
418 if (res2 < 0) {
419 dev_err(&dev->dev, "Error probing SMB2.\n");
420 smbuses[1].base = 0;
421 }
422 }
423 if ((res1 < 0) && (res2 < 0)) {
424
425 kfree(smbuses);
426 return -ENODEV;
427 }
428
429 nforce2_set_reference(&smbuses[0].adapter);
430 return 0;
431}
432
433
434static void __devexit nforce2_remove(struct pci_dev *dev)
435{
436 struct nforce2_smbus *smbuses = (void*) pci_get_drvdata(dev);
437
438 nforce2_set_reference(NULL);
439 if (smbuses[0].base) {
440 i2c_del_adapter(&smbuses[0].adapter);
441 release_region(smbuses[0].base, smbuses[0].size);
442 }
443 if (smbuses[1].base) {
444 i2c_del_adapter(&smbuses[1].adapter);
445 release_region(smbuses[1].base, smbuses[1].size);
446 }
447 kfree(smbuses);
448}
449
450static struct pci_driver nforce2_driver = {
451 .name = "nForce2_smbus",
452 .id_table = nforce2_ids,
453 .probe = nforce2_probe,
454 .remove = __devexit_p(nforce2_remove),
455};
456
457static int __init nforce2_init(void)
458{
459 return pci_register_driver(&nforce2_driver);
460}
461
462static void __exit nforce2_exit(void)
463{
464 pci_unregister_driver(&nforce2_driver);
465}
466
467module_init(nforce2_init);
468module_exit(nforce2_exit);
469
470
