treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / i2c / busses / i2c-sis630.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3     Copyright (c) 2002,2003 Alexander Malysh <amalysh@web.de>
4
5 */
6
7 /*
8    Status: beta
9
10    Supports:
11         SIS 630
12         SIS 730
13         SIS 964
14
15    Notable differences between chips:
16         +------------------------+--------------------+-------------------+
17         |                        |     SIS630/730     |      SIS964       |
18         +------------------------+--------------------+-------------------+
19         | Clock                  | 14kHz/56kHz        | 55.56kHz/27.78kHz |
20         | SMBus registers offset | 0x80               | 0xE0              |
21         | SMB_CNT                | Bit 1 = Slave Busy | Bit 1 = Bus probe |
22         |         (not used yet) | Bit 3 is reserved  | Bit 3 = Last byte |
23         | SMB_PCOUNT             | Offset + 0x06      | Offset + 0x14     |
24         | SMB_COUNT              | 4:0 bits           | 5:0 bits          |
25         +------------------------+--------------------+-------------------+
26         (Other differences don't affect the functions provided by the driver)
27
28    Note: we assume there can only be one device, with one SMBus interface.
29 */
30
31 #include <linux/kernel.h>
32 #include <linux/module.h>
33 #include <linux/delay.h>
34 #include <linux/pci.h>
35 #include <linux/ioport.h>
36 #include <linux/i2c.h>
37 #include <linux/acpi.h>
38 #include <linux/io.h>
39
40 /* SIS964 id is defined here as we are the only file using it */
41 #define PCI_DEVICE_ID_SI_964    0x0964
42
43 /* SIS630/730/964 SMBus registers */
44 #define SMB_STS                 0x00    /* status */
45 #define SMB_CNT                 0x02    /* control */
46 #define SMBHOST_CNT             0x03    /* host control */
47 #define SMB_ADDR                0x04    /* address */
48 #define SMB_CMD                 0x05    /* command */
49 #define SMB_COUNT               0x07    /* byte count */
50 #define SMB_BYTE                0x08    /* ~0x8F data byte field */
51
52 /* SMB_STS register */
53 #define BYTE_DONE_STS           0x10    /* Byte Done Status / Block Array */
54 #define SMBCOL_STS              0x04    /* Collision */
55 #define SMBERR_STS              0x02    /* Device error */
56
57 /* SMB_CNT register */
58 #define MSTO_EN                 0x40    /* Host Master Timeout Enable */
59 #define SMBCLK_SEL              0x20    /* Host master clock selection */
60 #define SMB_PROBE               0x02    /* Bus Probe/Slave busy */
61 #define SMB_HOSTBUSY            0x01    /* Host Busy */
62
63 /* SMBHOST_CNT register */
64 #define SMB_KILL                0x20    /* Kill */
65 #define SMB_START               0x10    /* Start */
66
67 /* register count for request_region
68  * As we don't use SMB_PCOUNT, 20 is ok for SiS630 and SiS964
69  */
70 #define SIS630_SMB_IOREGION     20
71
72 /* PCI address constants */
73 /* acpi base address register  */
74 #define SIS630_ACPI_BASE_REG    0x74
75 /* bios control register */
76 #define SIS630_BIOS_CTL_REG     0x40
77
78 /* Other settings */
79 #define MAX_TIMEOUT             500
80
81 /* SIS630 constants */
82 #define SIS630_QUICK            0x00
83 #define SIS630_BYTE             0x01
84 #define SIS630_BYTE_DATA        0x02
85 #define SIS630_WORD_DATA        0x03
86 #define SIS630_PCALL            0x04
87 #define SIS630_BLOCK_DATA       0x05
88
89 static struct pci_driver sis630_driver;
90
91 /* insmod parameters */
92 static bool high_clock;
93 static bool force;
94 module_param(high_clock, bool, 0);
95 MODULE_PARM_DESC(high_clock,
96         "Set Host Master Clock to 56KHz (default 14KHz) (SIS630/730 only).");
97 module_param(force, bool, 0);
98 MODULE_PARM_DESC(force, "Forcibly enable the SIS630. DANGEROUS!");
99
100 /* SMBus base adress */
101 static unsigned short smbus_base;
102
103 /* supported chips */
104 static int supported[] = {
105         PCI_DEVICE_ID_SI_630,
106         PCI_DEVICE_ID_SI_730,
107         PCI_DEVICE_ID_SI_760,
108         0 /* terminates the list */
109 };
110
111 static inline u8 sis630_read(u8 reg)
112 {
113         return inb(smbus_base + reg);
114 }
115
116 static inline void sis630_write(u8 reg, u8 data)
117 {
118         outb(data, smbus_base + reg);
119 }
120
121 static int sis630_transaction_start(struct i2c_adapter *adap, int size,
122                                     u8 *oldclock)
123 {
124         int temp;
125
126         /* Make sure the SMBus host is ready to start transmitting. */
127         temp = sis630_read(SMB_CNT);
128         if ((temp & (SMB_PROBE | SMB_HOSTBUSY)) != 0x00) {
129                 dev_dbg(&adap->dev, "SMBus busy (%02x). Resetting...\n", temp);
130                 /* kill smbus transaction */
131                 sis630_write(SMBHOST_CNT, SMB_KILL);
132
133                 temp = sis630_read(SMB_CNT);
134                 if (temp & (SMB_PROBE | SMB_HOSTBUSY)) {
135                         dev_dbg(&adap->dev, "Failed! (%02x)\n", temp);
136                         return -EBUSY;
137                 } else {
138                         dev_dbg(&adap->dev, "Successful!\n");
139                 }
140         }
141
142         /* save old clock, so we can prevent machine for hung */
143         *oldclock = sis630_read(SMB_CNT);
144
145         dev_dbg(&adap->dev, "saved clock 0x%02x\n", *oldclock);
146
147         /* disable timeout interrupt,
148          * set Host Master Clock to 56KHz if requested */
149         if (high_clock)
150                 sis630_write(SMB_CNT, SMBCLK_SEL);
151         else
152                 sis630_write(SMB_CNT, (*oldclock & ~MSTO_EN));
153
154         /* clear all sticky bits */
155         temp = sis630_read(SMB_STS);
156         sis630_write(SMB_STS, temp & 0x1e);
157
158         /* start the transaction by setting bit 4 and size */
159         sis630_write(SMBHOST_CNT, SMB_START | (size & 0x07));
160
161         return 0;
162 }
163
164 static int sis630_transaction_wait(struct i2c_adapter *adap, int size)
165 {
166         int temp, result = 0, timeout = 0;
167
168         /* We will always wait for a fraction of a second! */
169         do {
170                 msleep(1);
171                 temp = sis630_read(SMB_STS);
172                 /* check if block transmitted */
173                 if (size == SIS630_BLOCK_DATA && (temp & BYTE_DONE_STS))
174                         break;
175         } while (!(temp & 0x0e) && (timeout++ < MAX_TIMEOUT));
176
177         /* If the SMBus is still busy, we give up */
178         if (timeout > MAX_TIMEOUT) {
179                 dev_dbg(&adap->dev, "SMBus Timeout!\n");
180                 result = -ETIMEDOUT;
181         }
182
183         if (temp & SMBERR_STS) {
184                 dev_dbg(&adap->dev, "Error: Failed bus transaction\n");
185                 result = -ENXIO;
186         }
187
188         if (temp & SMBCOL_STS) {
189                 dev_err(&adap->dev, "Bus collision!\n");
190                 result = -EAGAIN;
191         }
192
193         return result;
194 }
195
196 static void sis630_transaction_end(struct i2c_adapter *adap, u8 oldclock)
197 {
198         /* clear all status "sticky" bits */
199         sis630_write(SMB_STS, 0xFF);
200
201         dev_dbg(&adap->dev,
202                 "SMB_CNT before clock restore 0x%02x\n", sis630_read(SMB_CNT));
203
204         /*
205          * restore old Host Master Clock if high_clock is set
206          * and oldclock was not 56KHz
207          */
208         if (high_clock && !(oldclock & SMBCLK_SEL))
209                 sis630_write(SMB_CNT, sis630_read(SMB_CNT) & ~SMBCLK_SEL);
210
211         dev_dbg(&adap->dev,
212                 "SMB_CNT after clock restore 0x%02x\n", sis630_read(SMB_CNT));
213 }
214
215 static int sis630_transaction(struct i2c_adapter *adap, int size)
216 {
217         int result = 0;
218         u8 oldclock = 0;
219
220         result = sis630_transaction_start(adap, size, &oldclock);
221         if (!result) {
222                 result = sis630_transaction_wait(adap, size);
223                 sis630_transaction_end(adap, oldclock);
224         }
225
226         return result;
227 }
228
229 static int sis630_block_data(struct i2c_adapter *adap,
230                              union i2c_smbus_data *data, int read_write)
231 {
232         int i, len = 0, rc = 0;
233         u8 oldclock = 0;
234
235         if (read_write == I2C_SMBUS_WRITE) {
236                 len = data->block[0];
237                 if (len < 0)
238                         len = 0;
239                 else if (len > 32)
240                         len = 32;
241                 sis630_write(SMB_COUNT, len);
242                 for (i = 1; i <= len; i++) {
243                         dev_dbg(&adap->dev,
244                                 "set data 0x%02x\n", data->block[i]);
245                         /* set data */
246                         sis630_write(SMB_BYTE + (i - 1) % 8, data->block[i]);
247                         if (i == 8 || (len < 8 && i == len)) {
248                                 dev_dbg(&adap->dev,
249                                         "start trans len=%d i=%d\n", len, i);
250                                 /* first transaction */
251                                 rc = sis630_transaction_start(adap,
252                                                 SIS630_BLOCK_DATA, &oldclock);
253                                 if (rc)
254                                         return rc;
255                         } else if ((i - 1) % 8 == 7 || i == len) {
256                                 dev_dbg(&adap->dev,
257                                         "trans_wait len=%d i=%d\n", len, i);
258                                 if (i > 8) {
259                                         dev_dbg(&adap->dev,
260                                                 "clear smbary_sts"
261                                                 " len=%d i=%d\n", len, i);
262                                         /*
263                                            If this is not first transaction,
264                                            we must clear sticky bit.
265                                            clear SMBARY_STS
266                                         */
267                                         sis630_write(SMB_STS, BYTE_DONE_STS);
268                                 }
269                                 rc = sis630_transaction_wait(adap,
270                                                 SIS630_BLOCK_DATA);
271                                 if (rc) {
272                                         dev_dbg(&adap->dev,
273                                                 "trans_wait failed\n");
274                                         break;
275                                 }
276                         }
277                 }
278         } else {
279                 /* read request */
280                 data->block[0] = len = 0;
281                 rc = sis630_transaction_start(adap,
282                                 SIS630_BLOCK_DATA, &oldclock);
283                 if (rc)
284                         return rc;
285                 do {
286                         rc = sis630_transaction_wait(adap, SIS630_BLOCK_DATA);
287                         if (rc) {
288                                 dev_dbg(&adap->dev, "trans_wait failed\n");
289                                 break;
290                         }
291                         /* if this first transaction then read byte count */
292                         if (len == 0)
293                                 data->block[0] = sis630_read(SMB_COUNT);
294
295                         /* just to be sure */
296                         if (data->block[0] > 32)
297                                 data->block[0] = 32;
298
299                         dev_dbg(&adap->dev,
300                                 "block data read len=0x%x\n", data->block[0]);
301
302                         for (i = 0; i < 8 && len < data->block[0]; i++, len++) {
303                                 dev_dbg(&adap->dev,
304                                         "read i=%d len=%d\n", i, len);
305                                 data->block[len + 1] = sis630_read(SMB_BYTE +
306                                                                    i);
307                         }
308
309                         dev_dbg(&adap->dev,
310                                 "clear smbary_sts len=%d i=%d\n", len, i);
311
312                         /* clear SMBARY_STS */
313                         sis630_write(SMB_STS, BYTE_DONE_STS);
314                 } while (len < data->block[0]);
315         }
316
317         sis630_transaction_end(adap, oldclock);
318
319         return rc;
320 }
321
322 /* Return negative errno on error. */
323 static s32 sis630_access(struct i2c_adapter *adap, u16 addr,
324                          unsigned short flags, char read_write,
325                          u8 command, int size, union i2c_smbus_data *data)
326 {
327         int status;
328
329         switch (size) {
330         case I2C_SMBUS_QUICK:
331                 sis630_write(SMB_ADDR,
332                              ((addr & 0x7f) << 1) | (read_write & 0x01));
333                 size = SIS630_QUICK;
334                 break;
335         case I2C_SMBUS_BYTE:
336                 sis630_write(SMB_ADDR,
337                              ((addr & 0x7f) << 1) | (read_write & 0x01));
338                 if (read_write == I2C_SMBUS_WRITE)
339                         sis630_write(SMB_CMD, command);
340                 size = SIS630_BYTE;
341                 break;
342         case I2C_SMBUS_BYTE_DATA:
343                 sis630_write(SMB_ADDR,
344                              ((addr & 0x7f) << 1) | (read_write & 0x01));
345                 sis630_write(SMB_CMD, command);
346                 if (read_write == I2C_SMBUS_WRITE)
347                         sis630_write(SMB_BYTE, data->byte);
348                 size = SIS630_BYTE_DATA;
349                 break;
350         case I2C_SMBUS_PROC_CALL:
351         case I2C_SMBUS_WORD_DATA:
352                 sis630_write(SMB_ADDR,
353                              ((addr & 0x7f) << 1) | (read_write & 0x01));
354                 sis630_write(SMB_CMD, command);
355                 if (read_write == I2C_SMBUS_WRITE) {
356                         sis630_write(SMB_BYTE, data->word & 0xff);
357                         sis630_write(SMB_BYTE + 1, (data->word & 0xff00) >> 8);
358                 }
359                 size = (size == I2C_SMBUS_PROC_CALL ?
360                         SIS630_PCALL : SIS630_WORD_DATA);
361                 break;
362         case I2C_SMBUS_BLOCK_DATA:
363                 sis630_write(SMB_ADDR,
364                              ((addr & 0x7f) << 1) | (read_write & 0x01));
365                 sis630_write(SMB_CMD, command);
366                 size = SIS630_BLOCK_DATA;
367                 return sis630_block_data(adap, data, read_write);
368         default:
369                 dev_warn(&adap->dev, "Unsupported transaction %d\n", size);
370                 return -EOPNOTSUPP;
371         }
372
373         status = sis630_transaction(adap, size);
374         if (status)
375                 return status;
376
377         if ((size != SIS630_PCALL) &&
378                 ((read_write == I2C_SMBUS_WRITE) || (size == SIS630_QUICK))) {
379                 return 0;
380         }
381
382         switch (size) {
383         case SIS630_BYTE:
384         case SIS630_BYTE_DATA:
385                 data->byte = sis630_read(SMB_BYTE);
386                 break;
387         case SIS630_PCALL:
388         case SIS630_WORD_DATA:
389                 data->word = sis630_read(SMB_BYTE) +
390                              (sis630_read(SMB_BYTE + 1) << 8);
391                 break;
392         }
393
394         return 0;
395 }
396
397 static u32 sis630_func(struct i2c_adapter *adapter)
398 {
399         return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
400                 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
401                 I2C_FUNC_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_BLOCK_DATA;
402 }
403
404 static int sis630_setup(struct pci_dev *sis630_dev)
405 {
406         unsigned char b;
407         struct pci_dev *dummy = NULL;
408         int retval, i;
409         /* acpi base address */
410         unsigned short acpi_base;
411
412         /* check for supported SiS devices */
413         for (i = 0; supported[i] > 0; i++) {
414                 dummy = pci_get_device(PCI_VENDOR_ID_SI, supported[i], dummy);
415                 if (dummy)
416                         break; /* found */
417         }
418
419         if (dummy) {
420                 pci_dev_put(dummy);
421         } else if (force) {
422                 dev_err(&sis630_dev->dev,
423                         "WARNING: Can't detect SIS630 compatible device, but "
424                         "loading because of force option enabled\n");
425         } else {
426                 return -ENODEV;
427         }
428
429         /*
430            Enable ACPI first , so we can accsess reg 74-75
431            in acpi io space and read acpi base addr
432         */
433         if (pci_read_config_byte(sis630_dev, SIS630_BIOS_CTL_REG, &b)) {
434                 dev_err(&sis630_dev->dev, "Error: Can't read bios ctl reg\n");
435                 retval = -ENODEV;
436                 goto exit;
437         }
438         /* if ACPI already enabled , do nothing */
439         if (!(b & 0x80) &&
440             pci_write_config_byte(sis630_dev, SIS630_BIOS_CTL_REG, b | 0x80)) {
441                 dev_err(&sis630_dev->dev, "Error: Can't enable ACPI\n");
442                 retval = -ENODEV;
443                 goto exit;
444         }
445
446         /* Determine the ACPI base address */
447         if (pci_read_config_word(sis630_dev,
448                                  SIS630_ACPI_BASE_REG, &acpi_base)) {
449                 dev_err(&sis630_dev->dev,
450                         "Error: Can't determine ACPI base address\n");
451                 retval = -ENODEV;
452                 goto exit;
453         }
454
455         dev_dbg(&sis630_dev->dev, "ACPI base at 0x%04hx\n", acpi_base);
456
457         if (supported[i] == PCI_DEVICE_ID_SI_760)
458                 smbus_base = acpi_base + 0xE0;
459         else
460                 smbus_base = acpi_base + 0x80;
461
462         dev_dbg(&sis630_dev->dev, "SMBus base at 0x%04hx\n", smbus_base);
463
464         retval = acpi_check_region(smbus_base + SMB_STS, SIS630_SMB_IOREGION,
465                                    sis630_driver.name);
466         if (retval)
467                 goto exit;
468
469         /* Everything is happy, let's grab the memory and set things up. */
470         if (!request_region(smbus_base + SMB_STS, SIS630_SMB_IOREGION,
471                             sis630_driver.name)) {
472                 dev_err(&sis630_dev->dev,
473                         "I/O Region 0x%04x-0x%04x for SMBus already in use.\n",
474                         smbus_base + SMB_STS,
475                         smbus_base + SMB_STS + SIS630_SMB_IOREGION - 1);
476                 retval = -EBUSY;
477                 goto exit;
478         }
479
480         retval = 0;
481
482 exit:
483         if (retval)
484                 smbus_base = 0;
485         return retval;
486 }
487
488
489 static const struct i2c_algorithm smbus_algorithm = {
490         .smbus_xfer     = sis630_access,
491         .functionality  = sis630_func,
492 };
493
494 static struct i2c_adapter sis630_adapter = {
495         .owner          = THIS_MODULE,
496         .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
497         .algo           = &smbus_algorithm,
498         .retries        = 3
499 };
500
501 static const struct pci_device_id sis630_ids[] = {
502         { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
503         { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_LPC) },
504         { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_964) },
505         { 0, }
506 };
507
508 MODULE_DEVICE_TABLE(pci, sis630_ids);
509
510 static int sis630_probe(struct pci_dev *dev, const struct pci_device_id *id)
511 {
512         if (sis630_setup(dev)) {
513                 dev_err(&dev->dev,
514                         "SIS630 compatible bus not detected, "
515                         "module not inserted.\n");
516                 return -ENODEV;
517         }
518
519         /* set up the sysfs linkage to our parent device */
520         sis630_adapter.dev.parent = &dev->dev;
521
522         snprintf(sis630_adapter.name, sizeof(sis630_adapter.name),
523                  "SMBus SIS630 adapter at %04x", smbus_base + SMB_STS);
524
525         return i2c_add_adapter(&sis630_adapter);
526 }
527
528 static void sis630_remove(struct pci_dev *dev)
529 {
530         if (smbus_base) {
531                 i2c_del_adapter(&sis630_adapter);
532                 release_region(smbus_base + SMB_STS, SIS630_SMB_IOREGION);
533                 smbus_base = 0;
534         }
535 }
536
537
538 static struct pci_driver sis630_driver = {
539         .name           = "sis630_smbus",
540         .id_table       = sis630_ids,
541         .probe          = sis630_probe,
542         .remove         = sis630_remove,
543 };
544
545 module_pci_driver(sis630_driver);
546
547 MODULE_LICENSE("GPL");
548 MODULE_AUTHOR("Alexander Malysh <amalysh@web.de>");
549 MODULE_DESCRIPTION("SIS630 SMBus driver");