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