drivers/i2c/busses/i2c-parport.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* ------------------------------------------------------------------------ *
   3  * i2c-parport.c I2C bus over parallel port                                 *
   4  * ------------------------------------------------------------------------ *
   5    Copyright (C) 2003-2011 Jean Delvare <jdelvare@suse.de>
   6
   7    Based on older i2c-philips-par.c driver
   8    Copyright (C) 1995-2000 Simon G. Vogl
   9    With some changes from:
  10    Frodo Looijaard <frodol@dds.nl>
  11    Kyösti Mälkki <kmalkki@cc.hut.fi>
  12
  13  * ------------------------------------------------------------------------ */
  14
  15 #define pr_fmt(fmt) "i2c-parport: " fmt
  16
  17 #include <linux/kernel.h>
  18 #include <linux/module.h>
  19 #include <linux/init.h>
  20 #include <linux/delay.h>
  21 #include <linux/parport.h>
  22 #include <linux/i2c.h>
  23 #include <linux/i2c-algo-bit.h>
  24 #include <linux/i2c-smbus.h>
  25 #include <linux/slab.h>
  26 #include <linux/list.h>
  27 #include <linux/mutex.h>
  28
  29 #define PORT_DATA       0
  30 #define PORT_STAT       1
  31 #define PORT_CTRL       2
  32
  33 struct lineop {
  34         u8 val;
  35         u8 port;
  36         u8 inverted;
  37 };
  38
  39 struct adapter_parm {
  40         struct lineop setsda;
  41         struct lineop setscl;
  42         struct lineop getsda;
  43         struct lineop getscl;
  44         struct lineop init;
  45         unsigned int smbus_alert:1;
  46 };
  47
  48 static const struct adapter_parm adapter_parm[] = {
  49         /* type 0: Philips adapter */
  50         {
  51                 .setsda = { 0x80, PORT_DATA, 1 },
  52                 .setscl = { 0x08, PORT_CTRL, 0 },
  53                 .getsda = { 0x80, PORT_STAT, 0 },
  54                 .getscl = { 0x08, PORT_STAT, 0 },
  55         },
  56         /* type 1: home brew teletext adapter */
  57         {
  58                 .setsda = { 0x02, PORT_DATA, 0 },
  59                 .setscl = { 0x01, PORT_DATA, 0 },
  60                 .getsda = { 0x80, PORT_STAT, 1 },
  61         },
  62         /* type 2: Velleman K8000 adapter */
  63         {
  64                 .setsda = { 0x02, PORT_CTRL, 1 },
  65                 .setscl = { 0x08, PORT_CTRL, 1 },
  66                 .getsda = { 0x10, PORT_STAT, 0 },
  67         },
  68         /* type 3: ELV adapter */
  69         {
  70                 .setsda = { 0x02, PORT_DATA, 1 },
  71                 .setscl = { 0x01, PORT_DATA, 1 },
  72                 .getsda = { 0x40, PORT_STAT, 1 },
  73                 .getscl = { 0x08, PORT_STAT, 1 },
  74         },
  75         /* type 4: ADM1032 evaluation board */
  76         {
  77                 .setsda = { 0x02, PORT_DATA, 1 },
  78                 .setscl = { 0x01, PORT_DATA, 1 },
  79                 .getsda = { 0x10, PORT_STAT, 1 },
  80                 .init   = { 0xf0, PORT_DATA, 0 },
  81                 .smbus_alert = 1,
  82         },
  83         /* type 5: ADM1025, ADM1030 and ADM1031 evaluation boards */
  84         {
  85                 .setsda = { 0x02, PORT_DATA, 1 },
  86                 .setscl = { 0x01, PORT_DATA, 1 },
  87                 .getsda = { 0x10, PORT_STAT, 1 },
  88         },
  89         /* type 6: Barco LPT->DVI (K5800236) adapter */
  90         {
  91                 .setsda = { 0x02, PORT_DATA, 1 },
  92                 .setscl = { 0x01, PORT_DATA, 1 },
  93                 .getsda = { 0x20, PORT_STAT, 0 },
  94                 .getscl = { 0x40, PORT_STAT, 0 },
  95                 .init   = { 0xfc, PORT_DATA, 0 },
  96         },
  97         /* type 7: One For All JP1 parallel port adapter */
  98         {
  99                 .setsda = { 0x01, PORT_DATA, 0 },
 100                 .setscl = { 0x02, PORT_DATA, 0 },
 101                 .getsda = { 0x80, PORT_STAT, 1 },
 102                 .init   = { 0x04, PORT_DATA, 1 },
 103         },
 104         /* type 8: VCT-jig */
 105         {
 106                 .setsda = { 0x04, PORT_DATA, 1 },
 107                 .setscl = { 0x01, PORT_DATA, 1 },
 108                 .getsda = { 0x40, PORT_STAT, 0 },
 109                 .getscl = { 0x80, PORT_STAT, 1 },
 110         },
 111 };
 112
 113 /* ----- Device list ------------------------------------------------------ */
 114
 115 struct i2c_par {
 116         struct pardevice *pdev;
 117         struct i2c_adapter adapter;
 118         struct i2c_algo_bit_data algo_data;
 119         struct i2c_smbus_alert_setup alert_data;
 120         struct i2c_client *ara;
 121         struct list_head node;
 122 };
 123
 124 static LIST_HEAD(adapter_list);
 125 static DEFINE_MUTEX(adapter_list_lock);
 126
 127 #define MAX_DEVICE 4
 128 static int parport[MAX_DEVICE] = {0, -1, -1, -1};
 129 module_param_array(parport, int, NULL, 0);
 130 MODULE_PARM_DESC(parport,
 131                  "List of parallel ports to bind to, by index.\n"
 132                  " At most " __stringify(MAX_DEVICE) " devices are supported.\n"
 133                  " Default is one device connected to parport0.\n"
 134 );
 135
 136 static int type = -1;
 137 module_param(type, int, 0);
 138 MODULE_PARM_DESC(type,
 139         "Type of adapter:\n"
 140         " 0 = Philips adapter\n"
 141         " 1 = home brew teletext adapter\n"
 142         " 2 = Velleman K8000 adapter\n"
 143         " 3 = ELV adapter\n"
 144         " 4 = ADM1032 evaluation board\n"
 145         " 5 = ADM1025, ADM1030 and ADM1031 evaluation boards\n"
 146         " 6 = Barco LPT->DVI (K5800236) adapter\n"
 147         " 7 = One For All JP1 parallel port adapter\n"
 148         " 8 = VCT-jig\n"
 149 );
 150
 151 /* ----- Low-level parallel port access ----------------------------------- */
 152
 153 static void port_write_data(struct parport *p, unsigned char d)
 154 {
 155         parport_write_data(p, d);
 156 }
 157
 158 static void port_write_control(struct parport *p, unsigned char d)
 159 {
 160         parport_write_control(p, d);
 161 }
 162
 163 static unsigned char port_read_data(struct parport *p)
 164 {
 165         return parport_read_data(p);
 166 }
 167
 168 static unsigned char port_read_status(struct parport *p)
 169 {
 170         return parport_read_status(p);
 171 }
 172
 173 static unsigned char port_read_control(struct parport *p)
 174 {
 175         return parport_read_control(p);
 176 }
 177
 178 static void (* const port_write[])(struct parport *, unsigned char) = {
 179         port_write_data,
 180         NULL,
 181         port_write_control,
 182 };
 183
 184 static unsigned char (* const port_read[])(struct parport *) = {
 185         port_read_data,
 186         port_read_status,
 187         port_read_control,
 188 };
 189
 190 /* ----- Unified line operation functions --------------------------------- */
 191
 192 static inline void line_set(struct parport *data, int state,
 193         const struct lineop *op)
 194 {
 195         u8 oldval = port_read[op->port](data);
 196
 197         /* Touch only the bit(s) needed */
 198         if ((op->inverted && !state) || (!op->inverted && state))
 199                 port_write[op->port](data, oldval | op->val);
 200         else
 201                 port_write[op->port](data, oldval & ~op->val);
 202 }
 203
 204 static inline int line_get(struct parport *data,
 205         const struct lineop *op)
 206 {
 207         u8 oldval = port_read[op->port](data);
 208
 209         return ((op->inverted && (oldval & op->val) != op->val)
 210             || (!op->inverted && (oldval & op->val) == op->val));
 211 }
 212
 213 /* ----- I2C algorithm call-back functions and structures ----------------- */
 214
 215 static void parport_setscl(void *data, int state)
 216 {
 217         line_set((struct parport *) data, state, &adapter_parm[type].setscl);
 218 }
 219
 220 static void parport_setsda(void *data, int state)
 221 {
 222         line_set((struct parport *) data, state, &adapter_parm[type].setsda);
 223 }
 224
 225 static int parport_getscl(void *data)
 226 {
 227         return line_get((struct parport *) data, &adapter_parm[type].getscl);
 228 }
 229
 230 static int parport_getsda(void *data)
 231 {
 232         return line_get((struct parport *) data, &adapter_parm[type].getsda);
 233 }
 234
 235 /* Encapsulate the functions above in the correct structure.
 236    Note that this is only a template, from which the real structures are
 237    copied. The attaching code will set getscl to NULL for adapters that
 238    cannot read SCL back, and will also make the data field point to
 239    the parallel port structure. */
 240 static const struct i2c_algo_bit_data parport_algo_data = {
 241         .setsda         = parport_setsda,
 242         .setscl         = parport_setscl,
 243         .getsda         = parport_getsda,
 244         .getscl         = parport_getscl,
 245         .udelay         = 10, /* ~50 kbps */
 246         .timeout        = HZ,
 247 };
 248
 249 /* ----- I2c and parallel port call-back functions and structures --------- */
 250
 251 static void i2c_parport_irq(void *data)
 252 {
 253         struct i2c_par *adapter = data;
 254         struct i2c_client *ara = adapter->ara;
 255
 256         if (ara) {
 257                 dev_dbg(&ara->dev, "SMBus alert received\n");
 258                 i2c_handle_smbus_alert(ara);
 259         } else
 260                 dev_dbg(&adapter->adapter.dev,
 261                         "SMBus alert received but no ARA client!\n");
 262 }
 263
 264 static void i2c_parport_attach(struct parport *port)
 265 {
 266         struct i2c_par *adapter;
 267         int i;
 268         struct pardev_cb i2c_parport_cb;
 269
 270         for (i = 0; i < MAX_DEVICE; i++) {
 271                 if (parport[i] == -1)
 272                         continue;
 273                 if (port->number == parport[i])
 274                         break;
 275         }
 276         if (i == MAX_DEVICE) {
 277                 pr_debug("Not using parport%d.\n", port->number);
 278                 return;
 279         }
 280
 281         adapter = kzalloc(sizeof(struct i2c_par), GFP_KERNEL);
 282         if (!adapter)
 283                 return;
 284         memset(&i2c_parport_cb, 0, sizeof(i2c_parport_cb));
 285         i2c_parport_cb.flags = PARPORT_FLAG_EXCL;
 286         i2c_parport_cb.irq_func = i2c_parport_irq;
 287         i2c_parport_cb.private = adapter;
 288
 289         pr_debug("attaching to %s\n", port->name);
 290         parport_disable_irq(port);
 291         adapter->pdev = parport_register_dev_model(port, "i2c-parport",
 292                                                    &i2c_parport_cb, i);
 293         if (!adapter->pdev) {
 294                 pr_err("Unable to register with parport\n");
 295                 goto err_free;
 296         }
 297
 298         /* Fill the rest of the structure */
 299         adapter->adapter.owner = THIS_MODULE;
 300         adapter->adapter.class = I2C_CLASS_HWMON;
 301         strlcpy(adapter->adapter.name, "Parallel port adapter",
 302                 sizeof(adapter->adapter.name));
 303         adapter->algo_data = parport_algo_data;
 304         /* Slow down if we can't sense SCL */
 305         if (!adapter_parm[type].getscl.val) {
 306                 adapter->algo_data.getscl = NULL;
 307                 adapter->algo_data.udelay = 50; /* ~10 kbps */
 308         }
 309         adapter->algo_data.data = port;
 310         adapter->adapter.algo_data = &adapter->algo_data;
 311         adapter->adapter.dev.parent = port->physport->dev;
 312
 313         if (parport_claim_or_block(adapter->pdev) < 0) {
 314                 dev_err(&adapter->pdev->dev,
 315                         "Could not claim parallel port\n");
 316                 goto err_unregister;
 317         }
 318
 319         /* Reset hardware to a sane state (SCL and SDA high) */
 320         parport_setsda(port, 1);
 321         parport_setscl(port, 1);
 322         /* Other init if needed (power on...) */
 323         if (adapter_parm[type].init.val) {
 324                 line_set(port, 1, &adapter_parm[type].init);
 325                 /* Give powered devices some time to settle */
 326                 msleep(100);
 327         }
 328
 329         if (i2c_bit_add_bus(&adapter->adapter) < 0) {
 330                 dev_err(&adapter->pdev->dev, "Unable to register with I2C\n");
 331                 goto err_unregister;
 332         }
 333
 334         /* Setup SMBus alert if supported */
 335         if (adapter_parm[type].smbus_alert) {
 336                 struct i2c_client *ara;
 337
 338                 ara = i2c_new_smbus_alert_device(&adapter->adapter,
 339                                                  &adapter->alert_data);
 340                 if (!IS_ERR(ara)) {
 341                         adapter->ara = ara;
 342                         parport_enable_irq(port);
 343                 } else {
 344                         dev_warn(&adapter->pdev->dev,
 345                                  "Failed to register ARA client\n");
 346                 }
 347         }
 348
 349         /* Add the new adapter to the list */
 350         mutex_lock(&adapter_list_lock);
 351         list_add_tail(&adapter->node, &adapter_list);
 352         mutex_unlock(&adapter_list_lock);
 353         return;
 354
 355  err_unregister:
 356         parport_release(adapter->pdev);
 357         parport_unregister_device(adapter->pdev);
 358  err_free:
 359         kfree(adapter);
 360 }
 361
 362 static void i2c_parport_detach(struct parport *port)
 363 {
 364         struct i2c_par *adapter, *_n;
 365
 366         /* Walk the list */
 367         mutex_lock(&adapter_list_lock);
 368         list_for_each_entry_safe(adapter, _n, &adapter_list, node) {
 369                 if (adapter->pdev->port == port) {
 370                         if (adapter->ara) {
 371                                 parport_disable_irq(port);
 372                                 i2c_unregister_device(adapter->ara);
 373                         }
 374                         i2c_del_adapter(&adapter->adapter);
 375
 376                         /* Un-init if needed (power off...) */
 377                         if (adapter_parm[type].init.val)
 378                                 line_set(port, 0, &adapter_parm[type].init);
 379
 380                         parport_release(adapter->pdev);
 381                         parport_unregister_device(adapter->pdev);
 382                         list_del(&adapter->node);
 383                         kfree(adapter);
 384                 }
 385         }
 386         mutex_unlock(&adapter_list_lock);
 387 }
 388
 389 static struct parport_driver i2c_parport_driver = {
 390         .name = "i2c-parport",
 391         .match_port = i2c_parport_attach,
 392         .detach = i2c_parport_detach,
 393         .devmodel = true,
 394 };
 395
 396 /* ----- Module loading, unloading and information ------------------------ */
 397
 398 static int __init i2c_parport_init(void)
 399 {
 400         if (type < 0) {
 401                 pr_warn("adapter type unspecified\n");
 402                 return -ENODEV;
 403         }
 404
 405         if (type >= ARRAY_SIZE(adapter_parm)) {
 406                 pr_warn("invalid type (%d)\n", type);
 407                 return -ENODEV;
 408         }
 409
 410         return parport_register_driver(&i2c_parport_driver);
 411 }
 412
 413 static void __exit i2c_parport_exit(void)
 414 {
 415         parport_unregister_driver(&i2c_parport_driver);
 416 }
 417
 418 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
 419 MODULE_DESCRIPTION("I2C bus over parallel port");
 420 MODULE_LICENSE("GPL");
 421
 422 module_init(i2c_parport_init);
 423 module_exit(i2c_parport_exit);