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 #include "i2c-parport.h"
  29
  30 /* ----- Device list ------------------------------------------------------ */
  31
  32 struct i2c_par {
  33         struct pardevice *pdev;
  34         struct i2c_adapter adapter;
  35         struct i2c_algo_bit_data algo_data;
  36         struct i2c_smbus_alert_setup alert_data;
  37         struct i2c_client *ara;
  38         struct list_head node;
  39 };
  40
  41 static LIST_HEAD(adapter_list);
  42 static DEFINE_MUTEX(adapter_list_lock);
  43 #define MAX_DEVICE 4
  44 static int parport[MAX_DEVICE] = {0, -1, -1, -1};
  45
  46
  47 /* ----- Low-level parallel port access ----------------------------------- */
  48
  49 static void port_write_data(struct parport *p, unsigned char d)
  50 {
  51         parport_write_data(p, d);
  52 }
  53
  54 static void port_write_control(struct parport *p, unsigned char d)
  55 {
  56         parport_write_control(p, d);
  57 }
  58
  59 static unsigned char port_read_data(struct parport *p)
  60 {
  61         return parport_read_data(p);
  62 }
  63
  64 static unsigned char port_read_status(struct parport *p)
  65 {
  66         return parport_read_status(p);
  67 }
  68
  69 static unsigned char port_read_control(struct parport *p)
  70 {
  71         return parport_read_control(p);
  72 }
  73
  74 static void (* const port_write[])(struct parport *, unsigned char) = {
  75         port_write_data,
  76         NULL,
  77         port_write_control,
  78 };
  79
  80 static unsigned char (* const port_read[])(struct parport *) = {
  81         port_read_data,
  82         port_read_status,
  83         port_read_control,
  84 };
  85
  86 /* ----- Unified line operation functions --------------------------------- */
  87
  88 static inline void line_set(struct parport *data, int state,
  89         const struct lineop *op)
  90 {
  91         u8 oldval = port_read[op->port](data);
  92
  93         /* Touch only the bit(s) needed */
  94         if ((op->inverted && !state) || (!op->inverted && state))
  95                 port_write[op->port](data, oldval | op->val);
  96         else
  97                 port_write[op->port](data, oldval & ~op->val);
  98 }
  99
 100 static inline int line_get(struct parport *data,
 101         const struct lineop *op)
 102 {
 103         u8 oldval = port_read[op->port](data);
 104
 105         return ((op->inverted && (oldval & op->val) != op->val)
 106             || (!op->inverted && (oldval & op->val) == op->val));
 107 }
 108
 109 /* ----- I2C algorithm call-back functions and structures ----------------- */
 110
 111 static void parport_setscl(void *data, int state)
 112 {
 113         line_set((struct parport *) data, state, &adapter_parm[type].setscl);
 114 }
 115
 116 static void parport_setsda(void *data, int state)
 117 {
 118         line_set((struct parport *) data, state, &adapter_parm[type].setsda);
 119 }
 120
 121 static int parport_getscl(void *data)
 122 {
 123         return line_get((struct parport *) data, &adapter_parm[type].getscl);
 124 }
 125
 126 static int parport_getsda(void *data)
 127 {
 128         return line_get((struct parport *) data, &adapter_parm[type].getsda);
 129 }
 130
 131 /* Encapsulate the functions above in the correct structure.
 132    Note that this is only a template, from which the real structures are
 133    copied. The attaching code will set getscl to NULL for adapters that
 134    cannot read SCL back, and will also make the data field point to
 135    the parallel port structure. */
 136 static const struct i2c_algo_bit_data parport_algo_data = {
 137         .setsda         = parport_setsda,
 138         .setscl         = parport_setscl,
 139         .getsda         = parport_getsda,
 140         .getscl         = parport_getscl,
 141         .udelay         = 10, /* ~50 kbps */
 142         .timeout        = HZ,
 143 };
 144
 145 /* ----- I2c and parallel port call-back functions and structures --------- */
 146
 147 static void i2c_parport_irq(void *data)
 148 {
 149         struct i2c_par *adapter = data;
 150         struct i2c_client *ara = adapter->ara;
 151
 152         if (ara) {
 153                 dev_dbg(&ara->dev, "SMBus alert received\n");
 154                 i2c_handle_smbus_alert(ara);
 155         } else
 156                 dev_dbg(&adapter->adapter.dev,
 157                         "SMBus alert received but no ARA client!\n");
 158 }
 159
 160 static void i2c_parport_attach(struct parport *port)
 161 {
 162         struct i2c_par *adapter;
 163         int i;
 164         struct pardev_cb i2c_parport_cb;
 165
 166         for (i = 0; i < MAX_DEVICE; i++) {
 167                 if (parport[i] == -1)
 168                         continue;
 169                 if (port->number == parport[i])
 170                         break;
 171         }
 172         if (i == MAX_DEVICE) {
 173                 pr_debug("Not using parport%d.\n", port->number);
 174                 return;
 175         }
 176
 177         adapter = kzalloc(sizeof(struct i2c_par), GFP_KERNEL);
 178         if (!adapter)
 179                 return;
 180         memset(&i2c_parport_cb, 0, sizeof(i2c_parport_cb));
 181         i2c_parport_cb.flags = PARPORT_FLAG_EXCL;
 182         i2c_parport_cb.irq_func = i2c_parport_irq;
 183         i2c_parport_cb.private = adapter;
 184
 185         pr_debug("attaching to %s\n", port->name);
 186         parport_disable_irq(port);
 187         adapter->pdev = parport_register_dev_model(port, "i2c-parport",
 188                                                    &i2c_parport_cb, i);
 189         if (!adapter->pdev) {
 190                 pr_err("Unable to register with parport\n");
 191                 goto err_free;
 192         }
 193
 194         /* Fill the rest of the structure */
 195         adapter->adapter.owner = THIS_MODULE;
 196         adapter->adapter.class = I2C_CLASS_HWMON;
 197         strlcpy(adapter->adapter.name, "Parallel port adapter",
 198                 sizeof(adapter->adapter.name));
 199         adapter->algo_data = parport_algo_data;
 200         /* Slow down if we can't sense SCL */
 201         if (!adapter_parm[type].getscl.val) {
 202                 adapter->algo_data.getscl = NULL;
 203                 adapter->algo_data.udelay = 50; /* ~10 kbps */
 204         }
 205         adapter->algo_data.data = port;
 206         adapter->adapter.algo_data = &adapter->algo_data;
 207         adapter->adapter.dev.parent = port->physport->dev;
 208
 209         if (parport_claim_or_block(adapter->pdev) < 0) {
 210                 dev_err(&adapter->pdev->dev,
 211                         "Could not claim parallel port\n");
 212                 goto err_unregister;
 213         }
 214
 215         /* Reset hardware to a sane state (SCL and SDA high) */
 216         parport_setsda(port, 1);
 217         parport_setscl(port, 1);
 218         /* Other init if needed (power on...) */
 219         if (adapter_parm[type].init.val) {
 220                 line_set(port, 1, &adapter_parm[type].init);
 221                 /* Give powered devices some time to settle */
 222                 msleep(100);
 223         }
 224
 225         if (i2c_bit_add_bus(&adapter->adapter) < 0) {
 226                 dev_err(&adapter->pdev->dev, "Unable to register with I2C\n");
 227                 goto err_unregister;
 228         }
 229
 230         /* Setup SMBus alert if supported */
 231         if (adapter_parm[type].smbus_alert) {
 232                 adapter->ara = i2c_setup_smbus_alert(&adapter->adapter,
 233                                                      &adapter->alert_data);
 234                 if (adapter->ara)
 235                         parport_enable_irq(port);
 236                 else
 237                         dev_warn(&adapter->pdev->dev,
 238                                  "Failed to register ARA client\n");
 239         }
 240
 241         /* Add the new adapter to the list */
 242         mutex_lock(&adapter_list_lock);
 243         list_add_tail(&adapter->node, &adapter_list);
 244         mutex_unlock(&adapter_list_lock);
 245         return;
 246
 247  err_unregister:
 248         parport_release(adapter->pdev);
 249         parport_unregister_device(adapter->pdev);
 250  err_free:
 251         kfree(adapter);
 252 }
 253
 254 static void i2c_parport_detach(struct parport *port)
 255 {
 256         struct i2c_par *adapter, *_n;
 257
 258         /* Walk the list */
 259         mutex_lock(&adapter_list_lock);
 260         list_for_each_entry_safe(adapter, _n, &adapter_list, node) {
 261                 if (adapter->pdev->port == port) {
 262                         if (adapter->ara) {
 263                                 parport_disable_irq(port);
 264                                 i2c_unregister_device(adapter->ara);
 265                         }
 266                         i2c_del_adapter(&adapter->adapter);
 267
 268                         /* Un-init if needed (power off...) */
 269                         if (adapter_parm[type].init.val)
 270                                 line_set(port, 0, &adapter_parm[type].init);
 271
 272                         parport_release(adapter->pdev);
 273                         parport_unregister_device(adapter->pdev);
 274                         list_del(&adapter->node);
 275                         kfree(adapter);
 276                 }
 277         }
 278         mutex_unlock(&adapter_list_lock);
 279 }
 280
 281 static struct parport_driver i2c_parport_driver = {
 282         .name = "i2c-parport",
 283         .match_port = i2c_parport_attach,
 284         .detach = i2c_parport_detach,
 285         .devmodel = true,
 286 };
 287
 288 /* ----- Module loading, unloading and information ------------------------ */
 289
 290 static int __init i2c_parport_init(void)
 291 {
 292         if (type < 0) {
 293                 pr_warn("adapter type unspecified\n");
 294                 return -ENODEV;
 295         }
 296
 297         if (type >= ARRAY_SIZE(adapter_parm)) {
 298                 pr_warn("invalid type (%d)\n", type);
 299                 return -ENODEV;
 300         }
 301
 302         return parport_register_driver(&i2c_parport_driver);
 303 }
 304
 305 static void __exit i2c_parport_exit(void)
 306 {
 307         parport_unregister_driver(&i2c_parport_driver);
 308 }
 309
 310 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
 311 MODULE_DESCRIPTION("I2C bus over parallel port");
 312 MODULE_LICENSE("GPL");
 313
 314 module_param_array(parport, int, NULL, 0);
 315 MODULE_PARM_DESC(parport,
 316                  "List of parallel ports to bind to, by index.\n"
 317                  " Atmost " __stringify(MAX_DEVICE) " devices are supported.\n"
 318                  " Default is one device connected to parport0.\n"
 319 );
 320
 321 module_init(i2c_parport_init);
 322 module_exit(i2c_parport_exit);