drivers/i2c/busses/i2c-parport.c

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