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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83#include <linux/interrupt.h>
84#include <linux/module.h>
85#include <linux/pci.h>
86#include <linux/kernel.h>
87#include <linux/stddef.h>
88#include <linux/delay.h>
89#include <linux/ioport.h>
90#include <linux/init.h>
91#include <linux/i2c.h>
92#include <linux/i2c-smbus.h>
93#include <linux/acpi.h>
94#include <linux/io.h>
95#include <linux/dmi.h>
96#include <linux/slab.h>
97#include <linux/string.h>
98#include <linux/wait.h>
99#include <linux/err.h>
100#include <linux/platform_device.h>
101#include <linux/platform_data/itco_wdt.h>
102#include <linux/pm_runtime.h>
103
104#if IS_ENABLED(CONFIG_I2C_MUX_GPIO) && defined CONFIG_DMI
105#include <linux/gpio/machine.h>
106#include <linux/platform_data/i2c-mux-gpio.h>
107#endif
108
109
110#define SMBHSTSTS(p) (0 + (p)->smba)
111#define SMBHSTCNT(p) (2 + (p)->smba)
112#define SMBHSTCMD(p) (3 + (p)->smba)
113#define SMBHSTADD(p) (4 + (p)->smba)
114#define SMBHSTDAT0(p) (5 + (p)->smba)
115#define SMBHSTDAT1(p) (6 + (p)->smba)
116#define SMBBLKDAT(p) (7 + (p)->smba)
117#define SMBPEC(p) (8 + (p)->smba)
118#define SMBAUXSTS(p) (12 + (p)->smba)
119#define SMBAUXCTL(p) (13 + (p)->smba)
120#define SMBSLVSTS(p) (16 + (p)->smba)
121#define SMBSLVCMD(p) (17 + (p)->smba)
122#define SMBNTFDADD(p) (20 + (p)->smba)
123
124
125#define SMBBAR 4
126#define SMBPCICTL 0x004
127#define SMBPCISTS 0x006
128#define SMBHSTCFG 0x040
129#define TCOBASE 0x050
130#define TCOCTL 0x054
131
132#define ACPIBASE 0x040
133#define ACPIBASE_SMI_OFF 0x030
134#define ACPICTRL 0x044
135#define ACPICTRL_EN 0x080
136
137#define SBREG_BAR 0x10
138#define SBREG_SMBCTRL 0xc6000c
139#define SBREG_SMBCTRL_DNV 0xcf000c
140
141
142#define SMBPCISTS_INTS BIT(3)
143
144
145#define SMBPCICTL_INTDIS BIT(10)
146
147
148#define SMBHSTCFG_HST_EN BIT(0)
149#define SMBHSTCFG_SMB_SMI_EN BIT(1)
150#define SMBHSTCFG_I2C_EN BIT(2)
151#define SMBHSTCFG_SPD_WD BIT(4)
152
153
154#define TCOCTL_EN BIT(8)
155
156
157#define SMBAUXSTS_CRCE BIT(0)
158#define SMBAUXSTS_STCO BIT(1)
159
160
161#define SMBAUXCTL_CRC BIT(0)
162#define SMBAUXCTL_E32B BIT(1)
163
164
165#define MAX_RETRIES 400
166
167
168#define I801_QUICK 0x00
169#define I801_BYTE 0x04
170#define I801_BYTE_DATA 0x08
171#define I801_WORD_DATA 0x0C
172#define I801_PROC_CALL 0x10
173#define I801_BLOCK_DATA 0x14
174#define I801_I2C_BLOCK_DATA 0x18
175#define I801_BLOCK_PROC_CALL 0x1C
176
177
178#define SMBHSTCNT_INTREN BIT(0)
179#define SMBHSTCNT_KILL BIT(1)
180#define SMBHSTCNT_LAST_BYTE BIT(5)
181#define SMBHSTCNT_START BIT(6)
182#define SMBHSTCNT_PEC_EN BIT(7)
183
184
185#define SMBHSTSTS_BYTE_DONE BIT(7)
186#define SMBHSTSTS_INUSE_STS BIT(6)
187#define SMBHSTSTS_SMBALERT_STS BIT(5)
188#define SMBHSTSTS_FAILED BIT(4)
189#define SMBHSTSTS_BUS_ERR BIT(3)
190#define SMBHSTSTS_DEV_ERR BIT(2)
191#define SMBHSTSTS_INTR BIT(1)
192#define SMBHSTSTS_HOST_BUSY BIT(0)
193
194
195#define SMBSLVSTS_HST_NTFY_STS BIT(0)
196
197
198#define SMBSLVCMD_HST_NTFY_INTREN BIT(0)
199
200#define STATUS_ERROR_FLAGS (SMBHSTSTS_FAILED | SMBHSTSTS_BUS_ERR | \
201 SMBHSTSTS_DEV_ERR)
202
203#define STATUS_FLAGS (SMBHSTSTS_BYTE_DONE | SMBHSTSTS_INTR | \
204 STATUS_ERROR_FLAGS)
205
206
207#define PCI_DEVICE_ID_INTEL_COMETLAKE_SMBUS 0x02a3
208#define PCI_DEVICE_ID_INTEL_BAYTRAIL_SMBUS 0x0f12
209#define PCI_DEVICE_ID_INTEL_CDF_SMBUS 0x18df
210#define PCI_DEVICE_ID_INTEL_DNV_SMBUS 0x19df
211#define PCI_DEVICE_ID_INTEL_COUGARPOINT_SMBUS 0x1c22
212#define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS 0x1d22
213
214#define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF0 0x1d70
215#define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF1 0x1d71
216#define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF2 0x1d72
217#define PCI_DEVICE_ID_INTEL_PANTHERPOINT_SMBUS 0x1e22
218#define PCI_DEVICE_ID_INTEL_AVOTON_SMBUS 0x1f3c
219#define PCI_DEVICE_ID_INTEL_BRASWELL_SMBUS 0x2292
220#define PCI_DEVICE_ID_INTEL_DH89XXCC_SMBUS 0x2330
221#define PCI_DEVICE_ID_INTEL_COLETOCREEK_SMBUS 0x23b0
222#define PCI_DEVICE_ID_INTEL_GEMINILAKE_SMBUS 0x31d4
223#define PCI_DEVICE_ID_INTEL_ICELAKE_LP_SMBUS 0x34a3
224#define PCI_DEVICE_ID_INTEL_5_3400_SERIES_SMBUS 0x3b30
225#define PCI_DEVICE_ID_INTEL_ELKHART_LAKE_SMBUS 0x4b23
226#define PCI_DEVICE_ID_INTEL_BROXTON_SMBUS 0x5ad4
227#define PCI_DEVICE_ID_INTEL_LYNXPOINT_SMBUS 0x8c22
228#define PCI_DEVICE_ID_INTEL_WILDCATPOINT_SMBUS 0x8ca2
229#define PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS 0x8d22
230#define PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS0 0x8d7d
231#define PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS1 0x8d7e
232#define PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS2 0x8d7f
233#define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_SMBUS 0x9c22
234#define PCI_DEVICE_ID_INTEL_WILDCATPOINT_LP_SMBUS 0x9ca2
235#define PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_SMBUS 0x9d23
236#define PCI_DEVICE_ID_INTEL_CANNONLAKE_LP_SMBUS 0x9da3
237#define PCI_DEVICE_ID_INTEL_TIGERLAKE_LP_SMBUS 0xa0a3
238#define PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_SMBUS 0xa123
239#define PCI_DEVICE_ID_INTEL_LEWISBURG_SMBUS 0xa1a3
240#define PCI_DEVICE_ID_INTEL_LEWISBURG_SSKU_SMBUS 0xa223
241#define PCI_DEVICE_ID_INTEL_KABYLAKE_PCH_H_SMBUS 0xa2a3
242#define PCI_DEVICE_ID_INTEL_CANNONLAKE_H_SMBUS 0xa323
243
244struct i801_mux_config {
245 char *gpio_chip;
246 unsigned values[3];
247 int n_values;
248 unsigned classes[3];
249 unsigned gpios[2];
250 int n_gpios;
251};
252
253struct i801_priv {
254 struct i2c_adapter adapter;
255 unsigned long smba;
256 unsigned char original_hstcfg;
257 unsigned char original_slvcmd;
258 struct pci_dev *pci_dev;
259 unsigned int features;
260
261
262 wait_queue_head_t waitq;
263 u8 status;
264
265
266 u8 cmd;
267 bool is_read;
268 int count;
269 int len;
270 u8 *data;
271
272#if IS_ENABLED(CONFIG_I2C_MUX_GPIO) && defined CONFIG_DMI
273 const struct i801_mux_config *mux_drvdata;
274 struct platform_device *mux_pdev;
275 struct gpiod_lookup_table *lookup;
276#endif
277 struct platform_device *tco_pdev;
278
279
280
281
282
283 bool acpi_reserved;
284 struct mutex acpi_lock;
285};
286
287#define FEATURE_SMBUS_PEC BIT(0)
288#define FEATURE_BLOCK_BUFFER BIT(1)
289#define FEATURE_BLOCK_PROC BIT(2)
290#define FEATURE_I2C_BLOCK_READ BIT(3)
291#define FEATURE_IRQ BIT(4)
292#define FEATURE_HOST_NOTIFY BIT(5)
293
294#define FEATURE_IDF BIT(15)
295#define FEATURE_TCO BIT(16)
296
297static const char *i801_feature_names[] = {
298 "SMBus PEC",
299 "Block buffer",
300 "Block process call",
301 "I2C block read",
302 "Interrupt",
303 "SMBus Host Notify",
304};
305
306static unsigned int disable_features;
307module_param(disable_features, uint, S_IRUGO | S_IWUSR);
308MODULE_PARM_DESC(disable_features, "Disable selected driver features:\n"
309 "\t\t 0x01 disable SMBus PEC\n"
310 "\t\t 0x02 disable the block buffer\n"
311 "\t\t 0x08 disable the I2C block read functionality\n"
312 "\t\t 0x10 don't use interrupts\n"
313 "\t\t 0x20 disable SMBus Host Notify ");
314
315
316
317static int i801_check_pre(struct i801_priv *priv)
318{
319 int status;
320
321 status = inb_p(SMBHSTSTS(priv));
322 if (status & SMBHSTSTS_HOST_BUSY) {
323 dev_err(&priv->pci_dev->dev, "SMBus is busy, can't use it!\n");
324 return -EBUSY;
325 }
326
327 status &= STATUS_FLAGS;
328 if (status) {
329 dev_dbg(&priv->pci_dev->dev, "Clearing status flags (%02x)\n",
330 status);
331 outb_p(status, SMBHSTSTS(priv));
332 status = inb_p(SMBHSTSTS(priv)) & STATUS_FLAGS;
333 if (status) {
334 dev_err(&priv->pci_dev->dev,
335 "Failed clearing status flags (%02x)\n",
336 status);
337 return -EBUSY;
338 }
339 }
340
341
342
343
344
345
346
347
348 if (priv->features & FEATURE_SMBUS_PEC) {
349 status = inb_p(SMBAUXSTS(priv)) & SMBAUXSTS_CRCE;
350 if (status) {
351 dev_dbg(&priv->pci_dev->dev,
352 "Clearing aux status flags (%02x)\n", status);
353 outb_p(status, SMBAUXSTS(priv));
354 status = inb_p(SMBAUXSTS(priv)) & SMBAUXSTS_CRCE;
355 if (status) {
356 dev_err(&priv->pci_dev->dev,
357 "Failed clearing aux status flags (%02x)\n",
358 status);
359 return -EBUSY;
360 }
361 }
362 }
363
364 return 0;
365}
366
367
368
369
370
371
372static int i801_check_post(struct i801_priv *priv, int status)
373{
374 int result = 0;
375
376
377
378
379
380
381
382 if (unlikely(status < 0)) {
383 dev_err(&priv->pci_dev->dev, "Transaction timeout\n");
384
385 dev_dbg(&priv->pci_dev->dev, "Terminating the current operation\n");
386 outb_p(inb_p(SMBHSTCNT(priv)) | SMBHSTCNT_KILL,
387 SMBHSTCNT(priv));
388 usleep_range(1000, 2000);
389 outb_p(inb_p(SMBHSTCNT(priv)) & (~SMBHSTCNT_KILL),
390 SMBHSTCNT(priv));
391
392
393 status = inb_p(SMBHSTSTS(priv));
394 if ((status & SMBHSTSTS_HOST_BUSY) ||
395 !(status & SMBHSTSTS_FAILED))
396 dev_err(&priv->pci_dev->dev,
397 "Failed terminating the transaction\n");
398 outb_p(STATUS_FLAGS, SMBHSTSTS(priv));
399 return -ETIMEDOUT;
400 }
401
402 if (status & SMBHSTSTS_FAILED) {
403 result = -EIO;
404 dev_err(&priv->pci_dev->dev, "Transaction failed\n");
405 }
406 if (status & SMBHSTSTS_DEV_ERR) {
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422 if ((priv->features & FEATURE_SMBUS_PEC) &&
423 (inb_p(SMBAUXSTS(priv)) & SMBAUXSTS_CRCE)) {
424 outb_p(SMBAUXSTS_CRCE, SMBAUXSTS(priv));
425 result = -EBADMSG;
426 dev_dbg(&priv->pci_dev->dev, "PEC error\n");
427 } else {
428 result = -ENXIO;
429 dev_dbg(&priv->pci_dev->dev, "No response\n");
430 }
431 }
432 if (status & SMBHSTSTS_BUS_ERR) {
433 result = -EAGAIN;
434 dev_dbg(&priv->pci_dev->dev, "Lost arbitration\n");
435 }
436
437
438 outb_p(status, SMBHSTSTS(priv));
439
440 return result;
441}
442
443
444static int i801_wait_intr(struct i801_priv *priv)
445{
446 int timeout = 0;
447 int status;
448
449
450 do {
451 usleep_range(250, 500);
452 status = inb_p(SMBHSTSTS(priv));
453 } while (((status & SMBHSTSTS_HOST_BUSY) ||
454 !(status & (STATUS_ERROR_FLAGS | SMBHSTSTS_INTR))) &&
455 (timeout++ < MAX_RETRIES));
456
457 if (timeout > MAX_RETRIES) {
458 dev_dbg(&priv->pci_dev->dev, "INTR Timeout!\n");
459 return -ETIMEDOUT;
460 }
461 return status & (STATUS_ERROR_FLAGS | SMBHSTSTS_INTR);
462}
463
464
465static int i801_wait_byte_done(struct i801_priv *priv)
466{
467 int timeout = 0;
468 int status;
469
470
471 do {
472 usleep_range(250, 500);
473 status = inb_p(SMBHSTSTS(priv));
474 } while (!(status & (STATUS_ERROR_FLAGS | SMBHSTSTS_BYTE_DONE)) &&
475 (timeout++ < MAX_RETRIES));
476
477 if (timeout > MAX_RETRIES) {
478 dev_dbg(&priv->pci_dev->dev, "BYTE_DONE Timeout!\n");
479 return -ETIMEDOUT;
480 }
481 return status & STATUS_ERROR_FLAGS;
482}
483
484static int i801_transaction(struct i801_priv *priv, int xact)
485{
486 int status;
487 int result;
488 const struct i2c_adapter *adap = &priv->adapter;
489
490 result = i801_check_pre(priv);
491 if (result < 0)
492 return result;
493
494 if (priv->features & FEATURE_IRQ) {
495 outb_p(xact | SMBHSTCNT_INTREN | SMBHSTCNT_START,
496 SMBHSTCNT(priv));
497 result = wait_event_timeout(priv->waitq,
498 (status = priv->status),
499 adap->timeout);
500 if (!result) {
501 status = -ETIMEDOUT;
502 dev_warn(&priv->pci_dev->dev,
503 "Timeout waiting for interrupt!\n");
504 }
505 priv->status = 0;
506 return i801_check_post(priv, status);
507 }
508
509
510
511 outb_p(xact | SMBHSTCNT_START, SMBHSTCNT(priv));
512
513 status = i801_wait_intr(priv);
514 return i801_check_post(priv, status);
515}
516
517static int i801_block_transaction_by_block(struct i801_priv *priv,
518 union i2c_smbus_data *data,
519 char read_write, int command,
520 int hwpec)
521{
522 int i, len;
523 int status;
524 int xact = hwpec ? SMBHSTCNT_PEC_EN : 0;
525
526 switch (command) {
527 case I2C_SMBUS_BLOCK_PROC_CALL:
528 xact |= I801_BLOCK_PROC_CALL;
529 break;
530 case I2C_SMBUS_BLOCK_DATA:
531 xact |= I801_BLOCK_DATA;
532 break;
533 default:
534 return -EOPNOTSUPP;
535 }
536
537 inb_p(SMBHSTCNT(priv));
538
539
540 if (read_write == I2C_SMBUS_WRITE) {
541 len = data->block[0];
542 outb_p(len, SMBHSTDAT0(priv));
543 for (i = 0; i < len; i++)
544 outb_p(data->block[i+1], SMBBLKDAT(priv));
545 }
546
547 status = i801_transaction(priv, xact);
548 if (status)
549 return status;
550
551 if (read_write == I2C_SMBUS_READ ||
552 command == I2C_SMBUS_BLOCK_PROC_CALL) {
553 len = inb_p(SMBHSTDAT0(priv));
554 if (len < 1 || len > I2C_SMBUS_BLOCK_MAX)
555 return -EPROTO;
556
557 data->block[0] = len;
558 for (i = 0; i < len; i++)
559 data->block[i + 1] = inb_p(SMBBLKDAT(priv));
560 }
561 return 0;
562}
563
564static void i801_isr_byte_done(struct i801_priv *priv)
565{
566 if (priv->is_read) {
567
568 if (((priv->cmd & 0x1c) == I801_BLOCK_DATA) &&
569 (priv->count == 0)) {
570 priv->len = inb_p(SMBHSTDAT0(priv));
571 if (priv->len < 1 || priv->len > I2C_SMBUS_BLOCK_MAX) {
572 dev_err(&priv->pci_dev->dev,
573 "Illegal SMBus block read size %d\n",
574 priv->len);
575
576 priv->len = I2C_SMBUS_BLOCK_MAX;
577 } else {
578 dev_dbg(&priv->pci_dev->dev,
579 "SMBus block read size is %d\n",
580 priv->len);
581 }
582 priv->data[-1] = priv->len;
583 }
584
585
586 if (priv->count < priv->len)
587 priv->data[priv->count++] = inb(SMBBLKDAT(priv));
588 else
589 dev_dbg(&priv->pci_dev->dev,
590 "Discarding extra byte on block read\n");
591
592
593 if (priv->count == priv->len - 1)
594 outb_p(priv->cmd | SMBHSTCNT_LAST_BYTE,
595 SMBHSTCNT(priv));
596 } else if (priv->count < priv->len - 1) {
597
598 outb_p(priv->data[++priv->count], SMBBLKDAT(priv));
599 }
600
601
602 outb_p(SMBHSTSTS_BYTE_DONE, SMBHSTSTS(priv));
603}
604
605static irqreturn_t i801_host_notify_isr(struct i801_priv *priv)
606{
607 unsigned short addr;
608
609 addr = inb_p(SMBNTFDADD(priv)) >> 1;
610
611
612
613
614
615
616 i2c_handle_smbus_host_notify(&priv->adapter, addr);
617
618
619 outb_p(SMBSLVSTS_HST_NTFY_STS, SMBSLVSTS(priv));
620 return IRQ_HANDLED;
621}
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639static irqreturn_t i801_isr(int irq, void *dev_id)
640{
641 struct i801_priv *priv = dev_id;
642 u16 pcists;
643 u8 status;
644
645
646 pci_read_config_word(priv->pci_dev, SMBPCISTS, &pcists);
647 if (!(pcists & SMBPCISTS_INTS))
648 return IRQ_NONE;
649
650 if (priv->features & FEATURE_HOST_NOTIFY) {
651 status = inb_p(SMBSLVSTS(priv));
652 if (status & SMBSLVSTS_HST_NTFY_STS)
653 return i801_host_notify_isr(priv);
654 }
655
656 status = inb_p(SMBHSTSTS(priv));
657 if (status & SMBHSTSTS_BYTE_DONE)
658 i801_isr_byte_done(priv);
659
660
661
662
663
664 status &= SMBHSTSTS_INTR | STATUS_ERROR_FLAGS;
665 if (status) {
666 outb_p(status, SMBHSTSTS(priv));
667 priv->status = status;
668 wake_up(&priv->waitq);
669 }
670
671 return IRQ_HANDLED;
672}
673
674
675
676
677
678
679static int i801_block_transaction_byte_by_byte(struct i801_priv *priv,
680 union i2c_smbus_data *data,
681 char read_write, int command,
682 int hwpec)
683{
684 int i, len;
685 int smbcmd;
686 int status;
687 int result;
688 const struct i2c_adapter *adap = &priv->adapter;
689
690 if (command == I2C_SMBUS_BLOCK_PROC_CALL)
691 return -EOPNOTSUPP;
692
693 result = i801_check_pre(priv);
694 if (result < 0)
695 return result;
696
697 len = data->block[0];
698
699 if (read_write == I2C_SMBUS_WRITE) {
700 outb_p(len, SMBHSTDAT0(priv));
701 outb_p(data->block[1], SMBBLKDAT(priv));
702 }
703
704 if (command == I2C_SMBUS_I2C_BLOCK_DATA &&
705 read_write == I2C_SMBUS_READ)
706 smbcmd = I801_I2C_BLOCK_DATA;
707 else
708 smbcmd = I801_BLOCK_DATA;
709
710 if (priv->features & FEATURE_IRQ) {
711 priv->is_read = (read_write == I2C_SMBUS_READ);
712 if (len == 1 && priv->is_read)
713 smbcmd |= SMBHSTCNT_LAST_BYTE;
714 priv->cmd = smbcmd | SMBHSTCNT_INTREN;
715 priv->len = len;
716 priv->count = 0;
717 priv->data = &data->block[1];
718
719 outb_p(priv->cmd | SMBHSTCNT_START, SMBHSTCNT(priv));
720 result = wait_event_timeout(priv->waitq,
721 (status = priv->status),
722 adap->timeout);
723 if (!result) {
724 status = -ETIMEDOUT;
725 dev_warn(&priv->pci_dev->dev,
726 "Timeout waiting for interrupt!\n");
727 }
728 priv->status = 0;
729 return i801_check_post(priv, status);
730 }
731
732 for (i = 1; i <= len; i++) {
733 if (i == len && read_write == I2C_SMBUS_READ)
734 smbcmd |= SMBHSTCNT_LAST_BYTE;
735 outb_p(smbcmd, SMBHSTCNT(priv));
736
737 if (i == 1)
738 outb_p(inb(SMBHSTCNT(priv)) | SMBHSTCNT_START,
739 SMBHSTCNT(priv));
740
741 status = i801_wait_byte_done(priv);
742 if (status)
743 goto exit;
744
745 if (i == 1 && read_write == I2C_SMBUS_READ
746 && command != I2C_SMBUS_I2C_BLOCK_DATA) {
747 len = inb_p(SMBHSTDAT0(priv));
748 if (len < 1 || len > I2C_SMBUS_BLOCK_MAX) {
749 dev_err(&priv->pci_dev->dev,
750 "Illegal SMBus block read size %d\n",
751 len);
752
753 while (inb_p(SMBHSTSTS(priv)) &
754 SMBHSTSTS_HOST_BUSY)
755 outb_p(SMBHSTSTS_BYTE_DONE,
756 SMBHSTSTS(priv));
757 outb_p(SMBHSTSTS_INTR, SMBHSTSTS(priv));
758 return -EPROTO;
759 }
760 data->block[0] = len;
761 }
762
763
764 if (read_write == I2C_SMBUS_READ)
765 data->block[i] = inb_p(SMBBLKDAT(priv));
766 if (read_write == I2C_SMBUS_WRITE && i+1 <= len)
767 outb_p(data->block[i+1], SMBBLKDAT(priv));
768
769
770 outb_p(SMBHSTSTS_BYTE_DONE, SMBHSTSTS(priv));
771 }
772
773 status = i801_wait_intr(priv);
774exit:
775 return i801_check_post(priv, status);
776}
777
778static int i801_set_block_buffer_mode(struct i801_priv *priv)
779{
780 outb_p(inb_p(SMBAUXCTL(priv)) | SMBAUXCTL_E32B, SMBAUXCTL(priv));
781 if ((inb_p(SMBAUXCTL(priv)) & SMBAUXCTL_E32B) == 0)
782 return -EIO;
783 return 0;
784}
785
786
787static int i801_block_transaction(struct i801_priv *priv,
788 union i2c_smbus_data *data, char read_write,
789 int command, int hwpec)
790{
791 int result = 0;
792 unsigned char hostc;
793
794 if (command == I2C_SMBUS_I2C_BLOCK_DATA) {
795 if (read_write == I2C_SMBUS_WRITE) {
796
797 pci_read_config_byte(priv->pci_dev, SMBHSTCFG, &hostc);
798 pci_write_config_byte(priv->pci_dev, SMBHSTCFG,
799 hostc | SMBHSTCFG_I2C_EN);
800 } else if (!(priv->features & FEATURE_I2C_BLOCK_READ)) {
801 dev_err(&priv->pci_dev->dev,
802 "I2C block read is unsupported!\n");
803 return -EOPNOTSUPP;
804 }
805 }
806
807 if (read_write == I2C_SMBUS_WRITE
808 || command == I2C_SMBUS_I2C_BLOCK_DATA) {
809 if (data->block[0] < 1)
810 data->block[0] = 1;
811 if (data->block[0] > I2C_SMBUS_BLOCK_MAX)
812 data->block[0] = I2C_SMBUS_BLOCK_MAX;
813 } else {
814 data->block[0] = 32;
815 }
816
817
818
819
820 if ((priv->features & FEATURE_BLOCK_BUFFER)
821 && command != I2C_SMBUS_I2C_BLOCK_DATA
822 && i801_set_block_buffer_mode(priv) == 0)
823 result = i801_block_transaction_by_block(priv, data,
824 read_write,
825 command, hwpec);
826 else
827 result = i801_block_transaction_byte_by_byte(priv, data,
828 read_write,
829 command, hwpec);
830
831 if (command == I2C_SMBUS_I2C_BLOCK_DATA
832 && read_write == I2C_SMBUS_WRITE) {
833
834 pci_write_config_byte(priv->pci_dev, SMBHSTCFG, hostc);
835 }
836 return result;
837}
838
839
840static s32 i801_access(struct i2c_adapter *adap, u16 addr,
841 unsigned short flags, char read_write, u8 command,
842 int size, union i2c_smbus_data *data)
843{
844 int hwpec;
845 int block = 0;
846 int ret = 0, xact = 0;
847 struct i801_priv *priv = i2c_get_adapdata(adap);
848
849 mutex_lock(&priv->acpi_lock);
850 if (priv->acpi_reserved) {
851 mutex_unlock(&priv->acpi_lock);
852 return -EBUSY;
853 }
854
855 pm_runtime_get_sync(&priv->pci_dev->dev);
856
857 hwpec = (priv->features & FEATURE_SMBUS_PEC) && (flags & I2C_CLIENT_PEC)
858 && size != I2C_SMBUS_QUICK
859 && size != I2C_SMBUS_I2C_BLOCK_DATA;
860
861 switch (size) {
862 case I2C_SMBUS_QUICK:
863 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
864 SMBHSTADD(priv));
865 xact = I801_QUICK;
866 break;
867 case I2C_SMBUS_BYTE:
868 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
869 SMBHSTADD(priv));
870 if (read_write == I2C_SMBUS_WRITE)
871 outb_p(command, SMBHSTCMD(priv));
872 xact = I801_BYTE;
873 break;
874 case I2C_SMBUS_BYTE_DATA:
875 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
876 SMBHSTADD(priv));
877 outb_p(command, SMBHSTCMD(priv));
878 if (read_write == I2C_SMBUS_WRITE)
879 outb_p(data->byte, SMBHSTDAT0(priv));
880 xact = I801_BYTE_DATA;
881 break;
882 case I2C_SMBUS_WORD_DATA:
883 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
884 SMBHSTADD(priv));
885 outb_p(command, SMBHSTCMD(priv));
886 if (read_write == I2C_SMBUS_WRITE) {
887 outb_p(data->word & 0xff, SMBHSTDAT0(priv));
888 outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1(priv));
889 }
890 xact = I801_WORD_DATA;
891 break;
892 case I2C_SMBUS_BLOCK_DATA:
893 outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
894 SMBHSTADD(priv));
895 outb_p(command, SMBHSTCMD(priv));
896 block = 1;
897 break;
898 case I2C_SMBUS_I2C_BLOCK_DATA:
899
900
901
902
903
904
905 outb_p(((addr & 0x7f) << 1) |
906 ((priv->original_hstcfg & SMBHSTCFG_SPD_WD) ?
907 (read_write & 0x01) : 0),
908 SMBHSTADD(priv));
909 if (read_write == I2C_SMBUS_READ) {
910
911
912 outb_p(command, SMBHSTDAT1(priv));
913 } else
914 outb_p(command, SMBHSTCMD(priv));
915 block = 1;
916 break;
917 case I2C_SMBUS_BLOCK_PROC_CALL:
918
919
920
921
922 outb_p((addr & 0x7f) << 1, SMBHSTADD(priv));
923 outb_p(command, SMBHSTCMD(priv));
924 block = 1;
925 break;
926 default:
927 dev_err(&priv->pci_dev->dev, "Unsupported transaction %d\n",
928 size);
929 ret = -EOPNOTSUPP;
930 goto out;
931 }
932
933 if (hwpec)
934 outb_p(inb_p(SMBAUXCTL(priv)) | SMBAUXCTL_CRC, SMBAUXCTL(priv));
935 else
936 outb_p(inb_p(SMBAUXCTL(priv)) & (~SMBAUXCTL_CRC),
937 SMBAUXCTL(priv));
938
939 if (block)
940 ret = i801_block_transaction(priv, data, read_write, size,
941 hwpec);
942 else
943 ret = i801_transaction(priv, xact);
944
945
946
947
948 if (hwpec || block)
949 outb_p(inb_p(SMBAUXCTL(priv)) &
950 ~(SMBAUXCTL_CRC | SMBAUXCTL_E32B), SMBAUXCTL(priv));
951
952 if (block)
953 goto out;
954 if (ret)
955 goto out;
956 if ((read_write == I2C_SMBUS_WRITE) || (xact == I801_QUICK))
957 goto out;
958
959 switch (xact & 0x7f) {
960 case I801_BYTE:
961 case I801_BYTE_DATA:
962 data->byte = inb_p(SMBHSTDAT0(priv));
963 break;
964 case I801_WORD_DATA:
965 data->word = inb_p(SMBHSTDAT0(priv)) +
966 (inb_p(SMBHSTDAT1(priv)) << 8);
967 break;
968 }
969
970out:
971 pm_runtime_mark_last_busy(&priv->pci_dev->dev);
972 pm_runtime_put_autosuspend(&priv->pci_dev->dev);
973 mutex_unlock(&priv->acpi_lock);
974 return ret;
975}
976
977
978static u32 i801_func(struct i2c_adapter *adapter)
979{
980 struct i801_priv *priv = i2c_get_adapdata(adapter);
981
982 return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
983 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
984 I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_WRITE_I2C_BLOCK |
985 ((priv->features & FEATURE_SMBUS_PEC) ? I2C_FUNC_SMBUS_PEC : 0) |
986 ((priv->features & FEATURE_BLOCK_PROC) ?
987 I2C_FUNC_SMBUS_BLOCK_PROC_CALL : 0) |
988 ((priv->features & FEATURE_I2C_BLOCK_READ) ?
989 I2C_FUNC_SMBUS_READ_I2C_BLOCK : 0) |
990 ((priv->features & FEATURE_HOST_NOTIFY) ?
991 I2C_FUNC_SMBUS_HOST_NOTIFY : 0);
992}
993
994static void i801_enable_host_notify(struct i2c_adapter *adapter)
995{
996 struct i801_priv *priv = i2c_get_adapdata(adapter);
997
998 if (!(priv->features & FEATURE_HOST_NOTIFY))
999 return;
1000
1001 if (!(SMBSLVCMD_HST_NTFY_INTREN & priv->original_slvcmd))
1002 outb_p(SMBSLVCMD_HST_NTFY_INTREN | priv->original_slvcmd,
1003 SMBSLVCMD(priv));
1004
1005
1006 outb_p(SMBSLVSTS_HST_NTFY_STS, SMBSLVSTS(priv));
1007}
1008
1009static void i801_disable_host_notify(struct i801_priv *priv)
1010{
1011 if (!(priv->features & FEATURE_HOST_NOTIFY))
1012 return;
1013
1014 outb_p(priv->original_slvcmd, SMBSLVCMD(priv));
1015}
1016
1017static const struct i2c_algorithm smbus_algorithm = {
1018 .smbus_xfer = i801_access,
1019 .functionality = i801_func,
1020};
1021
1022static const struct pci_device_id i801_ids[] = {
1023 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_3) },
1024 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_3) },
1025 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_2) },
1026 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_3) },
1027 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_3) },
1028 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_3) },
1029 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_4) },
1030 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_16) },
1031 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_17) },
1032 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB2_17) },
1033 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_5) },
1034 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH9_6) },
1035 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_EP80579_1) },
1036 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH10_4) },
1037 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH10_5) },
1038 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_5_3400_SERIES_SMBUS) },
1039 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_COUGARPOINT_SMBUS) },
1040 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS) },
1041 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF0) },
1042 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF1) },
1043 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF2) },
1044 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_DH89XXCC_SMBUS) },
1045 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PANTHERPOINT_SMBUS) },
1046 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_LYNXPOINT_SMBUS) },
1047 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_SMBUS) },
1048 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_AVOTON_SMBUS) },
1049 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS) },
1050 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS0) },
1051 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS1) },
1052 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS2) },
1053 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_COLETOCREEK_SMBUS) },
1054 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_GEMINILAKE_SMBUS) },
1055 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_WILDCATPOINT_SMBUS) },
1056 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_WILDCATPOINT_LP_SMBUS) },
1057 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BAYTRAIL_SMBUS) },
1058 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BRASWELL_SMBUS) },
1059 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_SMBUS) },
1060 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_SMBUS) },
1061 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_CDF_SMBUS) },
1062 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_DNV_SMBUS) },
1063 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BROXTON_SMBUS) },
1064 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_LEWISBURG_SMBUS) },
1065 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_LEWISBURG_SSKU_SMBUS) },
1066 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_KABYLAKE_PCH_H_SMBUS) },
1067 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_CANNONLAKE_H_SMBUS) },
1068 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_CANNONLAKE_LP_SMBUS) },
1069 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICELAKE_LP_SMBUS) },
1070 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_COMETLAKE_SMBUS) },
1071 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ELKHART_LAKE_SMBUS) },
1072 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TIGERLAKE_LP_SMBUS) },
1073 { 0, }
1074};
1075
1076MODULE_DEVICE_TABLE(pci, i801_ids);
1077
1078#if defined CONFIG_X86 && defined CONFIG_DMI
1079static unsigned char apanel_addr;
1080
1081
1082static __init const void __iomem *bios_signature(const void __iomem *bios)
1083{
1084 ssize_t offset;
1085 const unsigned char signature[] = "FJKEYINF";
1086
1087 for (offset = 0; offset < 0x10000; offset += 0x10) {
1088 if (check_signature(bios + offset, signature,
1089 sizeof(signature)-1))
1090 return bios + offset;
1091 }
1092 return NULL;
1093}
1094
1095static void __init input_apanel_init(void)
1096{
1097 void __iomem *bios;
1098 const void __iomem *p;
1099
1100 bios = ioremap(0xF0000, 0x10000);
1101 p = bios_signature(bios);
1102 if (p) {
1103
1104 apanel_addr = readb(p + 8 + 3) >> 1;
1105 }
1106 iounmap(bios);
1107}
1108
1109struct dmi_onboard_device_info {
1110 const char *name;
1111 u8 type;
1112 unsigned short i2c_addr;
1113 const char *i2c_type;
1114};
1115
1116static const struct dmi_onboard_device_info dmi_devices[] = {
1117 { "Syleus", DMI_DEV_TYPE_OTHER, 0x73, "fscsyl" },
1118 { "Hermes", DMI_DEV_TYPE_OTHER, 0x73, "fscher" },
1119 { "Hades", DMI_DEV_TYPE_OTHER, 0x73, "fschds" },
1120};
1121
1122static void dmi_check_onboard_device(u8 type, const char *name,
1123 struct i2c_adapter *adap)
1124{
1125 int i;
1126 struct i2c_board_info info;
1127
1128 for (i = 0; i < ARRAY_SIZE(dmi_devices); i++) {
1129
1130 if ((type & ~0x80) != dmi_devices[i].type)
1131 continue;
1132 if (strcasecmp(name, dmi_devices[i].name))
1133 continue;
1134
1135 memset(&info, 0, sizeof(struct i2c_board_info));
1136 info.addr = dmi_devices[i].i2c_addr;
1137 strlcpy(info.type, dmi_devices[i].i2c_type, I2C_NAME_SIZE);
1138 i2c_new_device(adap, &info);
1139 break;
1140 }
1141}
1142
1143
1144
1145
1146static void dmi_check_onboard_devices(const struct dmi_header *dm, void *adap)
1147{
1148 int i, count;
1149
1150 if (dm->type != 10)
1151 return;
1152
1153 count = (dm->length - sizeof(struct dmi_header)) / 2;
1154 for (i = 0; i < count; i++) {
1155 const u8 *d = (char *)(dm + 1) + (i * 2);
1156 const char *name = ((char *) dm) + dm->length;
1157 u8 type = d[0];
1158 u8 s = d[1];
1159
1160 if (!s)
1161 continue;
1162 s--;
1163 while (s > 0 && name[0]) {
1164 name += strlen(name) + 1;
1165 s--;
1166 }
1167 if (name[0] == 0)
1168 continue;
1169
1170 dmi_check_onboard_device(type, name, adap);
1171 }
1172}
1173
1174
1175static const char *const acpi_smo8800_ids[] = {
1176 "SMO8800",
1177 "SMO8801",
1178 "SMO8810",
1179 "SMO8811",
1180 "SMO8820",
1181 "SMO8821",
1182 "SMO8830",
1183 "SMO8831",
1184};
1185
1186static acpi_status check_acpi_smo88xx_device(acpi_handle obj_handle,
1187 u32 nesting_level,
1188 void *context,
1189 void **return_value)
1190{
1191 struct acpi_device_info *info;
1192 acpi_status status;
1193 char *hid;
1194 int i;
1195
1196 status = acpi_get_object_info(obj_handle, &info);
1197 if (ACPI_FAILURE(status))
1198 return AE_OK;
1199
1200 if (!(info->valid & ACPI_VALID_HID))
1201 goto smo88xx_not_found;
1202
1203 hid = info->hardware_id.string;
1204 if (!hid)
1205 goto smo88xx_not_found;
1206
1207 i = match_string(acpi_smo8800_ids, ARRAY_SIZE(acpi_smo8800_ids), hid);
1208 if (i < 0)
1209 goto smo88xx_not_found;
1210
1211 kfree(info);
1212
1213 *((bool *)return_value) = true;
1214 return AE_CTRL_TERMINATE;
1215
1216smo88xx_not_found:
1217 kfree(info);
1218 return AE_OK;
1219}
1220
1221static bool is_dell_system_with_lis3lv02d(void)
1222{
1223 bool found;
1224 const char *vendor;
1225
1226 vendor = dmi_get_system_info(DMI_SYS_VENDOR);
1227 if (!vendor || strcmp(vendor, "Dell Inc."))
1228 return false;
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238 found = false;
1239 acpi_get_devices(NULL, check_acpi_smo88xx_device, NULL,
1240 (void **)&found);
1241
1242 return found;
1243}
1244
1245
1246
1247
1248
1249static const struct {
1250 const char *dmi_product_name;
1251 unsigned short i2c_addr;
1252} dell_lis3lv02d_devices[] = {
1253
1254
1255
1256
1257 { "Latitude E5250", 0x29 },
1258 { "Latitude E5450", 0x29 },
1259 { "Latitude E5550", 0x29 },
1260 { "Latitude E6440", 0x29 },
1261 { "Latitude E6440 ATG", 0x29 },
1262 { "Latitude E6540", 0x29 },
1263
1264
1265
1266 { "Vostro V131", 0x1d },
1267};
1268
1269static void register_dell_lis3lv02d_i2c_device(struct i801_priv *priv)
1270{
1271 struct i2c_board_info info;
1272 const char *dmi_product_name;
1273 int i;
1274
1275 dmi_product_name = dmi_get_system_info(DMI_PRODUCT_NAME);
1276 for (i = 0; i < ARRAY_SIZE(dell_lis3lv02d_devices); ++i) {
1277 if (strcmp(dmi_product_name,
1278 dell_lis3lv02d_devices[i].dmi_product_name) == 0)
1279 break;
1280 }
1281
1282 if (i == ARRAY_SIZE(dell_lis3lv02d_devices)) {
1283 dev_warn(&priv->pci_dev->dev,
1284 "Accelerometer lis3lv02d is present on SMBus but its"
1285 " address is unknown, skipping registration\n");
1286 return;
1287 }
1288
1289 memset(&info, 0, sizeof(struct i2c_board_info));
1290 info.addr = dell_lis3lv02d_devices[i].i2c_addr;
1291 strlcpy(info.type, "lis3lv02d", I2C_NAME_SIZE);
1292 i2c_new_device(&priv->adapter, &info);
1293}
1294
1295
1296static void i801_probe_optional_slaves(struct i801_priv *priv)
1297{
1298
1299 if (priv->features & FEATURE_IDF)
1300 return;
1301
1302 if (apanel_addr) {
1303 struct i2c_board_info info;
1304
1305 memset(&info, 0, sizeof(struct i2c_board_info));
1306 info.addr = apanel_addr;
1307 strlcpy(info.type, "fujitsu_apanel", I2C_NAME_SIZE);
1308 i2c_new_device(&priv->adapter, &info);
1309 }
1310
1311 if (dmi_name_in_vendors("FUJITSU"))
1312 dmi_walk(dmi_check_onboard_devices, &priv->adapter);
1313
1314 if (is_dell_system_with_lis3lv02d())
1315 register_dell_lis3lv02d_i2c_device(priv);
1316}
1317#else
1318static void __init input_apanel_init(void) {}
1319static void i801_probe_optional_slaves(struct i801_priv *priv) {}
1320#endif
1321
1322#if IS_ENABLED(CONFIG_I2C_MUX_GPIO) && defined CONFIG_DMI
1323static struct i801_mux_config i801_mux_config_asus_z8_d12 = {
1324 .gpio_chip = "gpio_ich",
1325 .values = { 0x02, 0x03 },
1326 .n_values = 2,
1327 .classes = { I2C_CLASS_SPD, I2C_CLASS_SPD },
1328 .gpios = { 52, 53 },
1329 .n_gpios = 2,
1330};
1331
1332static struct i801_mux_config i801_mux_config_asus_z8_d18 = {
1333 .gpio_chip = "gpio_ich",
1334 .values = { 0x02, 0x03, 0x01 },
1335 .n_values = 3,
1336 .classes = { I2C_CLASS_SPD, I2C_CLASS_SPD, I2C_CLASS_SPD },
1337 .gpios = { 52, 53 },
1338 .n_gpios = 2,
1339};
1340
1341static const struct dmi_system_id mux_dmi_table[] = {
1342 {
1343 .matches = {
1344 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
1345 DMI_MATCH(DMI_BOARD_NAME, "Z8NA-D6(C)"),
1346 },
1347 .driver_data = &i801_mux_config_asus_z8_d12,
1348 },
1349 {
1350 .matches = {
1351 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
1352 DMI_MATCH(DMI_BOARD_NAME, "Z8P(N)E-D12(X)"),
1353 },
1354 .driver_data = &i801_mux_config_asus_z8_d12,
1355 },
1356 {
1357 .matches = {
1358 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
1359 DMI_MATCH(DMI_BOARD_NAME, "Z8NH-D12"),
1360 },
1361 .driver_data = &i801_mux_config_asus_z8_d12,
1362 },
1363 {
1364 .matches = {
1365 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
1366 DMI_MATCH(DMI_BOARD_NAME, "Z8PH-D12/IFB"),
1367 },
1368 .driver_data = &i801_mux_config_asus_z8_d12,
1369 },
1370 {
1371 .matches = {
1372 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
1373 DMI_MATCH(DMI_BOARD_NAME, "Z8NR-D12"),
1374 },
1375 .driver_data = &i801_mux_config_asus_z8_d12,
1376 },
1377 {
1378 .matches = {
1379 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
1380 DMI_MATCH(DMI_BOARD_NAME, "Z8P(N)H-D12"),
1381 },
1382 .driver_data = &i801_mux_config_asus_z8_d12,
1383 },
1384 {
1385 .matches = {
1386 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
1387 DMI_MATCH(DMI_BOARD_NAME, "Z8PG-D18"),
1388 },
1389 .driver_data = &i801_mux_config_asus_z8_d18,
1390 },
1391 {
1392 .matches = {
1393 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
1394 DMI_MATCH(DMI_BOARD_NAME, "Z8PE-D18"),
1395 },
1396 .driver_data = &i801_mux_config_asus_z8_d18,
1397 },
1398 {
1399 .matches = {
1400 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
1401 DMI_MATCH(DMI_BOARD_NAME, "Z8PS-D12"),
1402 },
1403 .driver_data = &i801_mux_config_asus_z8_d12,
1404 },
1405 { }
1406};
1407
1408
1409static int i801_add_mux(struct i801_priv *priv)
1410{
1411 struct device *dev = &priv->adapter.dev;
1412 const struct i801_mux_config *mux_config;
1413 struct i2c_mux_gpio_platform_data gpio_data;
1414 struct gpiod_lookup_table *lookup;
1415 int err, i;
1416
1417 if (!priv->mux_drvdata)
1418 return 0;
1419 mux_config = priv->mux_drvdata;
1420
1421
1422 memset(&gpio_data, 0, sizeof(struct i2c_mux_gpio_platform_data));
1423 gpio_data.parent = priv->adapter.nr;
1424 gpio_data.values = mux_config->values;
1425 gpio_data.n_values = mux_config->n_values;
1426 gpio_data.classes = mux_config->classes;
1427 gpio_data.idle = I2C_MUX_GPIO_NO_IDLE;
1428
1429
1430 lookup = devm_kzalloc(dev,
1431 struct_size(lookup, table, mux_config->n_gpios),
1432 GFP_KERNEL);
1433 if (!lookup)
1434 return -ENOMEM;
1435 lookup->dev_id = "i2c-mux-gpio";
1436 for (i = 0; i < mux_config->n_gpios; i++) {
1437 lookup->table[i].chip_label = mux_config->gpio_chip;
1438 lookup->table[i].chip_hwnum = mux_config->gpios[i];
1439 lookup->table[i].con_id = "mux";
1440 }
1441 gpiod_add_lookup_table(lookup);
1442 priv->lookup = lookup;
1443
1444
1445
1446
1447
1448
1449
1450
1451 priv->mux_pdev = platform_device_register_data(dev, "i2c-mux-gpio",
1452 PLATFORM_DEVID_NONE, &gpio_data,
1453 sizeof(struct i2c_mux_gpio_platform_data));
1454 if (IS_ERR(priv->mux_pdev)) {
1455 err = PTR_ERR(priv->mux_pdev);
1456 gpiod_remove_lookup_table(lookup);
1457 priv->mux_pdev = NULL;
1458 dev_err(dev, "Failed to register i2c-mux-gpio device\n");
1459 return err;
1460 }
1461
1462 return 0;
1463}
1464
1465static void i801_del_mux(struct i801_priv *priv)
1466{
1467 if (priv->mux_pdev)
1468 platform_device_unregister(priv->mux_pdev);
1469 if (priv->lookup)
1470 gpiod_remove_lookup_table(priv->lookup);
1471}
1472
1473static unsigned int i801_get_adapter_class(struct i801_priv *priv)
1474{
1475 const struct dmi_system_id *id;
1476 const struct i801_mux_config *mux_config;
1477 unsigned int class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
1478 int i;
1479
1480 id = dmi_first_match(mux_dmi_table);
1481 if (id) {
1482
1483 mux_config = id->driver_data;
1484 for (i = 0; i < mux_config->n_values; i++)
1485 class &= ~mux_config->classes[i];
1486
1487
1488 priv->mux_drvdata = mux_config;
1489 }
1490
1491 return class;
1492}
1493#else
1494static inline int i801_add_mux(struct i801_priv *priv) { return 0; }
1495static inline void i801_del_mux(struct i801_priv *priv) { }
1496
1497static inline unsigned int i801_get_adapter_class(struct i801_priv *priv)
1498{
1499 return I2C_CLASS_HWMON | I2C_CLASS_SPD;
1500}
1501#endif
1502
1503static const struct itco_wdt_platform_data tco_platform_data = {
1504 .name = "Intel PCH",
1505 .version = 4,
1506};
1507
1508static DEFINE_SPINLOCK(p2sb_spinlock);
1509
1510static void i801_add_tco(struct i801_priv *priv)
1511{
1512 struct pci_dev *pci_dev = priv->pci_dev;
1513 struct resource tco_res[3], *res;
1514 struct platform_device *pdev;
1515 unsigned int devfn;
1516 u32 tco_base, tco_ctl;
1517 u32 base_addr, ctrl_val;
1518 u64 base64_addr;
1519 u8 hidden;
1520
1521 if (!(priv->features & FEATURE_TCO))
1522 return;
1523
1524 pci_read_config_dword(pci_dev, TCOBASE, &tco_base);
1525 pci_read_config_dword(pci_dev, TCOCTL, &tco_ctl);
1526 if (!(tco_ctl & TCOCTL_EN))
1527 return;
1528
1529 memset(tco_res, 0, sizeof(tco_res));
1530
1531 res = &tco_res[ICH_RES_IO_TCO];
1532 res->start = tco_base & ~1;
1533 res->end = res->start + 32 - 1;
1534 res->flags = IORESOURCE_IO;
1535
1536
1537
1538
1539 devfn = PCI_DEVFN(PCI_SLOT(pci_dev->devfn), 2);
1540 pci_bus_read_config_dword(pci_dev->bus, devfn, ACPIBASE, &base_addr);
1541
1542 res = &tco_res[ICH_RES_IO_SMI];
1543 res->start = (base_addr & ~1) + ACPIBASE_SMI_OFF;
1544 res->end = res->start + 3;
1545 res->flags = IORESOURCE_IO;
1546
1547
1548
1549
1550 pci_bus_read_config_dword(pci_dev->bus, devfn, ACPICTRL, &ctrl_val);
1551 ctrl_val |= ACPICTRL_EN;
1552 pci_bus_write_config_dword(pci_dev->bus, devfn, ACPICTRL, ctrl_val);
1553
1554
1555
1556
1557
1558
1559
1560 spin_lock(&p2sb_spinlock);
1561
1562 devfn = PCI_DEVFN(PCI_SLOT(pci_dev->devfn), 1);
1563
1564
1565 pci_bus_read_config_byte(pci_dev->bus, devfn, 0xe1, &hidden);
1566 if (hidden)
1567 pci_bus_write_config_byte(pci_dev->bus, devfn, 0xe1, 0x0);
1568
1569 pci_bus_read_config_dword(pci_dev->bus, devfn, SBREG_BAR, &base_addr);
1570 base64_addr = base_addr & 0xfffffff0;
1571
1572 pci_bus_read_config_dword(pci_dev->bus, devfn, SBREG_BAR + 0x4, &base_addr);
1573 base64_addr |= (u64)base_addr << 32;
1574
1575
1576 if (hidden)
1577 pci_bus_write_config_byte(pci_dev->bus, devfn, 0xe1, hidden);
1578 spin_unlock(&p2sb_spinlock);
1579
1580 res = &tco_res[ICH_RES_MEM_OFF];
1581 if (pci_dev->device == PCI_DEVICE_ID_INTEL_DNV_SMBUS)
1582 res->start = (resource_size_t)base64_addr + SBREG_SMBCTRL_DNV;
1583 else
1584 res->start = (resource_size_t)base64_addr + SBREG_SMBCTRL;
1585
1586 res->end = res->start + 3;
1587 res->flags = IORESOURCE_MEM;
1588
1589 pdev = platform_device_register_resndata(&pci_dev->dev, "iTCO_wdt", -1,
1590 tco_res, 3, &tco_platform_data,
1591 sizeof(tco_platform_data));
1592 if (IS_ERR(pdev)) {
1593 dev_warn(&pci_dev->dev, "failed to create iTCO device\n");
1594 return;
1595 }
1596
1597 priv->tco_pdev = pdev;
1598}
1599
1600#ifdef CONFIG_ACPI
1601static bool i801_acpi_is_smbus_ioport(const struct i801_priv *priv,
1602 acpi_physical_address address)
1603{
1604 return address >= priv->smba &&
1605 address <= pci_resource_end(priv->pci_dev, SMBBAR);
1606}
1607
1608static acpi_status
1609i801_acpi_io_handler(u32 function, acpi_physical_address address, u32 bits,
1610 u64 *value, void *handler_context, void *region_context)
1611{
1612 struct i801_priv *priv = handler_context;
1613 struct pci_dev *pdev = priv->pci_dev;
1614 acpi_status status;
1615
1616
1617
1618
1619
1620
1621 mutex_lock(&priv->acpi_lock);
1622
1623 if (!priv->acpi_reserved && i801_acpi_is_smbus_ioport(priv, address)) {
1624 priv->acpi_reserved = true;
1625
1626 dev_warn(&pdev->dev, "BIOS is accessing SMBus registers\n");
1627 dev_warn(&pdev->dev, "Driver SMBus register access inhibited\n");
1628
1629
1630
1631
1632
1633 pm_runtime_get_sync(&pdev->dev);
1634 }
1635
1636 if ((function & ACPI_IO_MASK) == ACPI_READ)
1637 status = acpi_os_read_port(address, (u32 *)value, bits);
1638 else
1639 status = acpi_os_write_port(address, (u32)*value, bits);
1640
1641 mutex_unlock(&priv->acpi_lock);
1642
1643 return status;
1644}
1645
1646static int i801_acpi_probe(struct i801_priv *priv)
1647{
1648 struct acpi_device *adev;
1649 acpi_status status;
1650
1651 adev = ACPI_COMPANION(&priv->pci_dev->dev);
1652 if (adev) {
1653 status = acpi_install_address_space_handler(adev->handle,
1654 ACPI_ADR_SPACE_SYSTEM_IO, i801_acpi_io_handler,
1655 NULL, priv);
1656 if (ACPI_SUCCESS(status))
1657 return 0;
1658 }
1659
1660 return acpi_check_resource_conflict(&priv->pci_dev->resource[SMBBAR]);
1661}
1662
1663static void i801_acpi_remove(struct i801_priv *priv)
1664{
1665 struct acpi_device *adev;
1666
1667 adev = ACPI_COMPANION(&priv->pci_dev->dev);
1668 if (!adev)
1669 return;
1670
1671 acpi_remove_address_space_handler(adev->handle,
1672 ACPI_ADR_SPACE_SYSTEM_IO, i801_acpi_io_handler);
1673
1674 mutex_lock(&priv->acpi_lock);
1675 if (priv->acpi_reserved)
1676 pm_runtime_put(&priv->pci_dev->dev);
1677 mutex_unlock(&priv->acpi_lock);
1678}
1679#else
1680static inline int i801_acpi_probe(struct i801_priv *priv) { return 0; }
1681static inline void i801_acpi_remove(struct i801_priv *priv) { }
1682#endif
1683
1684static int i801_probe(struct pci_dev *dev, const struct pci_device_id *id)
1685{
1686 unsigned char temp;
1687 int err, i;
1688 struct i801_priv *priv;
1689
1690 priv = devm_kzalloc(&dev->dev, sizeof(*priv), GFP_KERNEL);
1691 if (!priv)
1692 return -ENOMEM;
1693
1694 i2c_set_adapdata(&priv->adapter, priv);
1695 priv->adapter.owner = THIS_MODULE;
1696 priv->adapter.class = i801_get_adapter_class(priv);
1697 priv->adapter.algo = &smbus_algorithm;
1698 priv->adapter.dev.parent = &dev->dev;
1699 ACPI_COMPANION_SET(&priv->adapter.dev, ACPI_COMPANION(&dev->dev));
1700 priv->adapter.retries = 3;
1701 mutex_init(&priv->acpi_lock);
1702
1703 priv->pci_dev = dev;
1704 switch (dev->device) {
1705 case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_SMBUS:
1706 case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_SMBUS:
1707 case PCI_DEVICE_ID_INTEL_CANNONLAKE_H_SMBUS:
1708 case PCI_DEVICE_ID_INTEL_CANNONLAKE_LP_SMBUS:
1709 case PCI_DEVICE_ID_INTEL_LEWISBURG_SMBUS:
1710 case PCI_DEVICE_ID_INTEL_LEWISBURG_SSKU_SMBUS:
1711 case PCI_DEVICE_ID_INTEL_CDF_SMBUS:
1712 case PCI_DEVICE_ID_INTEL_DNV_SMBUS:
1713 case PCI_DEVICE_ID_INTEL_KABYLAKE_PCH_H_SMBUS:
1714 case PCI_DEVICE_ID_INTEL_ICELAKE_LP_SMBUS:
1715 case PCI_DEVICE_ID_INTEL_COMETLAKE_SMBUS:
1716 case PCI_DEVICE_ID_INTEL_ELKHART_LAKE_SMBUS:
1717 case PCI_DEVICE_ID_INTEL_TIGERLAKE_LP_SMBUS:
1718 priv->features |= FEATURE_BLOCK_PROC;
1719 priv->features |= FEATURE_I2C_BLOCK_READ;
1720 priv->features |= FEATURE_IRQ;
1721 priv->features |= FEATURE_SMBUS_PEC;
1722 priv->features |= FEATURE_BLOCK_BUFFER;
1723
1724 if (!acpi_has_watchdog())
1725 priv->features |= FEATURE_TCO;
1726 priv->features |= FEATURE_HOST_NOTIFY;
1727 break;
1728
1729 case PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF0:
1730 case PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF1:
1731 case PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS_IDF2:
1732 case PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS0:
1733 case PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS1:
1734 case PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS2:
1735 priv->features |= FEATURE_IDF;
1736
1737 default:
1738 priv->features |= FEATURE_BLOCK_PROC;
1739 priv->features |= FEATURE_I2C_BLOCK_READ;
1740 priv->features |= FEATURE_IRQ;
1741
1742 case PCI_DEVICE_ID_INTEL_82801DB_3:
1743 priv->features |= FEATURE_SMBUS_PEC;
1744 priv->features |= FEATURE_BLOCK_BUFFER;
1745
1746 case PCI_DEVICE_ID_INTEL_82801CA_3:
1747 priv->features |= FEATURE_HOST_NOTIFY;
1748
1749 case PCI_DEVICE_ID_INTEL_82801BA_2:
1750 case PCI_DEVICE_ID_INTEL_82801AB_3:
1751 case PCI_DEVICE_ID_INTEL_82801AA_3:
1752 break;
1753 }
1754
1755
1756 for (i = 0; i < ARRAY_SIZE(i801_feature_names); i++) {
1757 if (priv->features & disable_features & (1 << i))
1758 dev_notice(&dev->dev, "%s disabled by user\n",
1759 i801_feature_names[i]);
1760 }
1761 priv->features &= ~disable_features;
1762
1763 err = pcim_enable_device(dev);
1764 if (err) {
1765 dev_err(&dev->dev, "Failed to enable SMBus PCI device (%d)\n",
1766 err);
1767 return err;
1768 }
1769 pcim_pin_device(dev);
1770
1771
1772 priv->smba = pci_resource_start(dev, SMBBAR);
1773 if (!priv->smba) {
1774 dev_err(&dev->dev,
1775 "SMBus base address uninitialized, upgrade BIOS\n");
1776 return -ENODEV;
1777 }
1778
1779 if (i801_acpi_probe(priv))
1780 return -ENODEV;
1781
1782 err = pcim_iomap_regions(dev, 1 << SMBBAR,
1783 dev_driver_string(&dev->dev));
1784 if (err) {
1785 dev_err(&dev->dev,
1786 "Failed to request SMBus region 0x%lx-0x%Lx\n",
1787 priv->smba,
1788 (unsigned long long)pci_resource_end(dev, SMBBAR));
1789 i801_acpi_remove(priv);
1790 return err;
1791 }
1792
1793 pci_read_config_byte(priv->pci_dev, SMBHSTCFG, &temp);
1794 priv->original_hstcfg = temp;
1795 temp &= ~SMBHSTCFG_I2C_EN;
1796 if (!(temp & SMBHSTCFG_HST_EN)) {
1797 dev_info(&dev->dev, "Enabling SMBus device\n");
1798 temp |= SMBHSTCFG_HST_EN;
1799 }
1800 pci_write_config_byte(priv->pci_dev, SMBHSTCFG, temp);
1801
1802 if (temp & SMBHSTCFG_SMB_SMI_EN) {
1803 dev_dbg(&dev->dev, "SMBus using interrupt SMI#\n");
1804
1805 priv->features &= ~FEATURE_IRQ;
1806 }
1807 if (temp & SMBHSTCFG_SPD_WD)
1808 dev_info(&dev->dev, "SPD Write Disable is set\n");
1809
1810
1811 if (priv->features & (FEATURE_SMBUS_PEC | FEATURE_BLOCK_BUFFER))
1812 outb_p(inb_p(SMBAUXCTL(priv)) &
1813 ~(SMBAUXCTL_CRC | SMBAUXCTL_E32B), SMBAUXCTL(priv));
1814
1815
1816 if (priv->features & FEATURE_HOST_NOTIFY)
1817 priv->original_slvcmd = inb_p(SMBSLVCMD(priv));
1818
1819
1820 priv->adapter.timeout = HZ / 5;
1821
1822 if (dev->irq == IRQ_NOTCONNECTED)
1823 priv->features &= ~FEATURE_IRQ;
1824
1825 if (priv->features & FEATURE_IRQ) {
1826 u16 pcictl, pcists;
1827
1828
1829 pci_read_config_word(priv->pci_dev, SMBPCISTS, &pcists);
1830 if (pcists & SMBPCISTS_INTS)
1831 dev_warn(&dev->dev, "An interrupt is pending!\n");
1832
1833
1834 pci_read_config_word(priv->pci_dev, SMBPCICTL, &pcictl);
1835 if (pcictl & SMBPCICTL_INTDIS) {
1836 dev_info(&dev->dev, "Interrupts are disabled\n");
1837 priv->features &= ~FEATURE_IRQ;
1838 }
1839 }
1840
1841 if (priv->features & FEATURE_IRQ) {
1842 init_waitqueue_head(&priv->waitq);
1843
1844 err = devm_request_irq(&dev->dev, dev->irq, i801_isr,
1845 IRQF_SHARED,
1846 dev_driver_string(&dev->dev), priv);
1847 if (err) {
1848 dev_err(&dev->dev, "Failed to allocate irq %d: %d\n",
1849 dev->irq, err);
1850 priv->features &= ~FEATURE_IRQ;
1851 }
1852 }
1853 dev_info(&dev->dev, "SMBus using %s\n",
1854 priv->features & FEATURE_IRQ ? "PCI interrupt" : "polling");
1855
1856 i801_add_tco(priv);
1857
1858 snprintf(priv->adapter.name, sizeof(priv->adapter.name),
1859 "SMBus I801 adapter at %04lx", priv->smba);
1860 err = i2c_add_adapter(&priv->adapter);
1861 if (err) {
1862 i801_acpi_remove(priv);
1863 return err;
1864 }
1865
1866 i801_enable_host_notify(&priv->adapter);
1867
1868 i801_probe_optional_slaves(priv);
1869
1870 i801_add_mux(priv);
1871
1872 pci_set_drvdata(dev, priv);
1873
1874 pm_runtime_set_autosuspend_delay(&dev->dev, 1000);
1875 pm_runtime_use_autosuspend(&dev->dev);
1876 pm_runtime_put_autosuspend(&dev->dev);
1877 pm_runtime_allow(&dev->dev);
1878
1879 return 0;
1880}
1881
1882static void i801_remove(struct pci_dev *dev)
1883{
1884 struct i801_priv *priv = pci_get_drvdata(dev);
1885
1886 pm_runtime_forbid(&dev->dev);
1887 pm_runtime_get_noresume(&dev->dev);
1888
1889 i801_disable_host_notify(priv);
1890 i801_del_mux(priv);
1891 i2c_del_adapter(&priv->adapter);
1892 i801_acpi_remove(priv);
1893 pci_write_config_byte(dev, SMBHSTCFG, priv->original_hstcfg);
1894
1895 platform_device_unregister(priv->tco_pdev);
1896
1897
1898
1899
1900
1901}
1902
1903static void i801_shutdown(struct pci_dev *dev)
1904{
1905 struct i801_priv *priv = pci_get_drvdata(dev);
1906
1907
1908 i801_disable_host_notify(priv);
1909 pci_write_config_byte(dev, SMBHSTCFG, priv->original_hstcfg);
1910}
1911
1912#ifdef CONFIG_PM_SLEEP
1913static int i801_suspend(struct device *dev)
1914{
1915 struct pci_dev *pci_dev = to_pci_dev(dev);
1916 struct i801_priv *priv = pci_get_drvdata(pci_dev);
1917
1918 pci_write_config_byte(pci_dev, SMBHSTCFG, priv->original_hstcfg);
1919 return 0;
1920}
1921
1922static int i801_resume(struct device *dev)
1923{
1924 struct pci_dev *pci_dev = to_pci_dev(dev);
1925 struct i801_priv *priv = pci_get_drvdata(pci_dev);
1926
1927 i801_enable_host_notify(&priv->adapter);
1928
1929 return 0;
1930}
1931#endif
1932
1933static SIMPLE_DEV_PM_OPS(i801_pm_ops, i801_suspend, i801_resume);
1934
1935static struct pci_driver i801_driver = {
1936 .name = "i801_smbus",
1937 .id_table = i801_ids,
1938 .probe = i801_probe,
1939 .remove = i801_remove,
1940 .shutdown = i801_shutdown,
1941 .driver = {
1942 .pm = &i801_pm_ops,
1943 },
1944};
1945
1946static int __init i2c_i801_init(void)
1947{
1948 if (dmi_name_in_vendors("FUJITSU"))
1949 input_apanel_init();
1950 return pci_register_driver(&i801_driver);
1951}
1952
1953static void __exit i2c_i801_exit(void)
1954{
1955 pci_unregister_driver(&i801_driver);
1956}
1957
1958MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>, Jean Delvare <jdelvare@suse.de>");
1959MODULE_DESCRIPTION("I801 SMBus driver");
1960MODULE_LICENSE("GPL");
1961
1962module_init(i2c_i801_init);
1963module_exit(i2c_i801_exit);
1964