Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/i2c/busses/i2c-sis630.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us