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