drivers/i2c/busses/i2c-pca-isa.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  i2c-pca-isa.c driver for PCA9564 on ISA boards
   4  *    Copyright (C) 2004 Arcom Control Systems
   5  *    Copyright (C) 2008 Pengutronix
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/ioport.h>
  10 #include <linux/module.h>
  11 #include <linux/moduleparam.h>
  12 #include <linux/delay.h>
  13 #include <linux/jiffies.h>
  14 #include <linux/init.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/wait.h>
  17 #include <linux/isa.h>
  18 #include <linux/i2c.h>
  19 #include <linux/i2c-algo-pca.h>
  20 #include <linux/io.h>
  21
  22 #include <asm/irq.h>
  23
  24 #define DRIVER "i2c-pca-isa"
  25 #define IO_SIZE 4
  26
  27 static unsigned long base;
  28 static int irq = -1;
  29
  30 /* Data sheet recommends 59kHz for 100kHz operation due to variation
  31  * in the actual clock rate */
  32 static int clock  = 59000;
  33
  34 static struct i2c_adapter pca_isa_ops;
  35 static wait_queue_head_t pca_wait;
  36
  37 static void pca_isa_writebyte(void *pd, int reg, int val)
  38 {
  39 #ifdef DEBUG_IO
  40         static char *names[] = { "T/O", "DAT", "ADR", "CON" };
  41         printk(KERN_DEBUG "*** write %s at %#lx <= %#04x\n", names[reg],
  42                base+reg, val);
  43 #endif
  44         outb(val, base+reg);
  45 }
  46
  47 static int pca_isa_readbyte(void *pd, int reg)
  48 {
  49         int res = inb(base+reg);
  50 #ifdef DEBUG_IO
  51         {
  52                 static char *names[] = { "STA", "DAT", "ADR", "CON" };
  53                 printk(KERN_DEBUG "*** read  %s => %#04x\n", names[reg], res);
  54         }
  55 #endif
  56         return res;
  57 }
  58
  59 static int pca_isa_waitforcompletion(void *pd)
  60 {
  61         unsigned long timeout;
  62         long ret;
  63
  64         if (irq > -1) {
  65                 ret = wait_event_timeout(pca_wait,
  66                                 pca_isa_readbyte(pd, I2C_PCA_CON)
  67                                 & I2C_PCA_CON_SI, pca_isa_ops.timeout);
  68         } else {
  69                 /* Do polling */
  70                 timeout = jiffies + pca_isa_ops.timeout;
  71                 do {
  72                         ret = time_before(jiffies, timeout);
  73                         if (pca_isa_readbyte(pd, I2C_PCA_CON)
  74                                         & I2C_PCA_CON_SI)
  75                                 break;
  76                         udelay(100);
  77                 } while (ret);
  78         }
  79
  80         return ret > 0;
  81 }
  82
  83 static void pca_isa_resetchip(void *pd)
  84 {
  85         /* apparently only an external reset will do it. not a lot can be done */
  86         printk(KERN_WARNING DRIVER ": Haven't figured out how to do a reset yet\n");
  87 }
  88
  89 static irqreturn_t pca_handler(int this_irq, void *dev_id) {
  90         wake_up(&pca_wait);
  91         return IRQ_HANDLED;
  92 }
  93
  94 static struct i2c_algo_pca_data pca_isa_data = {
  95         /* .data intentionally left NULL, not needed with ISA */
  96         .write_byte             = pca_isa_writebyte,
  97         .read_byte              = pca_isa_readbyte,
  98         .wait_for_completion    = pca_isa_waitforcompletion,
  99         .reset_chip             = pca_isa_resetchip,
 100 };
 101
 102 static struct i2c_adapter pca_isa_ops = {
 103         .owner          = THIS_MODULE,
 104         .algo_data      = &pca_isa_data,
 105         .name           = "PCA9564/PCA9665 ISA Adapter",
 106         .timeout        = HZ,
 107 };
 108
 109 static int pca_isa_match(struct device *dev, unsigned int id)
 110 {
 111         int match = base != 0;
 112
 113         if (match) {
 114                 if (irq <= -1)
 115                         dev_warn(dev, "Using polling mode (specify irq)\n");
 116         } else
 117                 dev_err(dev, "Please specify I/O base\n");
 118
 119         return match;
 120 }
 121
 122 static int pca_isa_probe(struct device *dev, unsigned int id)
 123 {
 124         init_waitqueue_head(&pca_wait);
 125
 126         dev_info(dev, "i/o base %#08lx. irq %d\n", base, irq);
 127
 128 #ifdef CONFIG_PPC
 129         if (check_legacy_ioport(base)) {
 130                 dev_err(dev, "I/O address %#08lx is not available\n", base);
 131                 goto out;
 132         }
 133 #endif
 134
 135         if (!request_region(base, IO_SIZE, "i2c-pca-isa")) {
 136                 dev_err(dev, "I/O address %#08lx is in use\n", base);
 137                 goto out;
 138         }
 139
 140         if (irq > -1) {
 141                 if (request_irq(irq, pca_handler, 0, "i2c-pca-isa", &pca_isa_ops) < 0) {
 142                         dev_err(dev, "Request irq%d failed\n", irq);
 143                         goto out_region;
 144                 }
 145         }
 146
 147         pca_isa_data.i2c_clock = clock;
 148         if (i2c_pca_add_bus(&pca_isa_ops) < 0) {
 149                 dev_err(dev, "Failed to add i2c bus\n");
 150                 goto out_irq;
 151         }
 152
 153         return 0;
 154
 155  out_irq:
 156         if (irq > -1)
 157                 free_irq(irq, &pca_isa_ops);
 158  out_region:
 159         release_region(base, IO_SIZE);
 160  out:
 161         return -ENODEV;
 162 }
 163
 164 static int pca_isa_remove(struct device *dev, unsigned int id)
 165 {
 166         i2c_del_adapter(&pca_isa_ops);
 167
 168         if (irq > -1) {
 169                 disable_irq(irq);
 170                 free_irq(irq, &pca_isa_ops);
 171         }
 172         release_region(base, IO_SIZE);
 173
 174         return 0;
 175 }
 176
 177 static struct isa_driver pca_isa_driver = {
 178         .match          = pca_isa_match,
 179         .probe          = pca_isa_probe,
 180         .remove         = pca_isa_remove,
 181         .driver = {
 182                 .owner  = THIS_MODULE,
 183                 .name   = DRIVER,
 184         }
 185 };
 186
 187 MODULE_AUTHOR("Ian Campbell <icampbell@arcom.com>");
 188 MODULE_DESCRIPTION("ISA base PCA9564/PCA9665 driver");
 189 MODULE_LICENSE("GPL");
 190
 191 module_param_hw(base, ulong, ioport, 0);
 192 MODULE_PARM_DESC(base, "I/O base address");
 193 module_param_hw(irq, int, irq, 0);
 194 MODULE_PARM_DESC(irq, "IRQ");
 195 module_param(clock, int, 0);
 196 MODULE_PARM_DESC(clock, "Clock rate in hertz.\n\t\t"
 197                 "For PCA9564: 330000,288000,217000,146000,"
 198                 "88000,59000,44000,36000\n"
 199                 "\t\tFor PCA9665:\tStandard: 60300 - 100099\n"
 200                 "\t\t\t\tFast: 100100 - 400099\n"
 201                 "\t\t\t\tFast+: 400100 - 10000099\n"
 202                 "\t\t\t\tTurbo: Up to 1265800");
 203 module_isa_driver(pca_isa_driver, 1);