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