SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/i2c/busses/i2c-parport.c

   1 /* ------------------------------------------------------------------------ *
   2  * i2c-parport.c I2C bus over parallel port                                 *
   3  * ------------------------------------------------------------------------ *
   4    Copyright (C) 2003-2004 Jean Delvare <khali@linux-fr.org>
   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    You should have received a copy of the GNU General Public License
  23    along with this program; if not, write to the Free Software
  24    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25  * ------------------------------------------------------------------------ */
  26
  27 #include <linux/kernel.h>
  28 #include <linux/module.h>
  29 #include <linux/init.h>
  30 #include <linux/parport.h>
  31 #include <linux/i2c.h>
  32 #include <linux/i2c-algo-bit.h>
  33 #include "i2c-parport.h"
  34
  35 /* ----- Device list ------------------------------------------------------ */
  36
  37 struct i2c_par {
  38         struct pardevice *pdev;
  39         struct i2c_adapter adapter;
  40         struct i2c_algo_bit_data algo_data;
  41         struct i2c_par *next;
  42 };
  43
  44 static struct i2c_par *adapter_list;
  45
  46 /* ----- Low-level parallel port access ----------------------------------- */
  47
  48 static void port_write_data(struct parport *p, unsigned char d)
  49 {
  50         parport_write_data(p, d);
  51 }
  52
  53 static void port_write_control(struct parport *p, unsigned char d)
  54 {
  55         parport_write_control(p, d);
  56 }
  57
  58 static unsigned char port_read_data(struct parport *p)
  59 {
  60         return parport_read_data(p);
  61 }
  62
  63 static unsigned char port_read_status(struct parport *p)
  64 {
  65         return parport_read_status(p);
  66 }
  67
  68 static unsigned char port_read_control(struct parport *p)
  69 {
  70         return parport_read_control(p);
  71 }
  72
  73 static void (*port_write[])(struct parport *, unsigned char) = {
  74         port_write_data,
  75         NULL,
  76         port_write_control,
  77 };
  78
  79 static unsigned char (*port_read[])(struct parport *) = {
  80         port_read_data,
  81         port_read_status,
  82         port_read_control,
  83 };
  84
  85 /* ----- Unified line operation functions --------------------------------- */
  86
  87 static inline void line_set(struct parport *data, int state,
  88         const struct lineop *op)
  89 {
  90         u8 oldval = port_read[op->port](data);
  91
  92         /* Touch only the bit(s) needed */
  93         if ((op->inverted && !state) || (!op->inverted && state))
  94                 port_write[op->port](data, oldval | op->val);
  95         else
  96                 port_write[op->port](data, oldval & ~op->val);
  97 }
  98
  99 static inline int line_get(struct parport *data,
 100         const struct lineop *op)
 101 {
 102         u8 oldval = port_read[op->port](data);
 103
 104         return ((op->inverted && (oldval & op->val) != op->val)
 105             || (!op->inverted && (oldval & op->val) == op->val));
 106 }
 107
 108 /* ----- I2C algorithm call-back functions and structures ----------------- */
 109
 110 static void parport_setscl(void *data, int state)
 111 {
 112         line_set((struct parport *) data, state, &adapter_parm[type].setscl);
 113 }
 114
 115 static void parport_setsda(void *data, int state)
 116 {
 117         line_set((struct parport *) data, state, &adapter_parm[type].setsda);
 118 }
 119
 120 static int parport_getscl(void *data)
 121 {
 122         return line_get((struct parport *) data, &adapter_parm[type].getscl);
 123 }
 124
 125 static int parport_getsda(void *data)
 126 {
 127         return line_get((struct parport *) data, &adapter_parm[type].getsda);
 128 }
 129
 130 /* Encapsulate the functions above in the correct structure.
 131    Note that this is only a template, from which the real structures are
 132    copied. The attaching code will set getscl to NULL for adapters that
 133    cannot read SCL back, and will also make the data field point to
 134    the parallel port structure. */
 135 static struct i2c_algo_bit_data parport_algo_data = {
 136         .setsda         = parport_setsda,
 137         .setscl         = parport_setscl,
 138         .getsda         = parport_getsda,
 139         .getscl         = parport_getscl,
 140         .udelay         = 60,
 141         .mdelay         = 60,
 142         .timeout        = HZ,
 143 };
 144
 145 /* ----- I2c and parallel port call-back functions and structures --------- */
 146
 147 static struct i2c_adapter parport_adapter = {
 148         .owner          = THIS_MODULE,
 149         .class          = I2C_CLASS_HWMON,
 150         .id             = I2C_HW_B_LP,
 151         .name           = "Parallel port adapter",
 152 };
 153
 154 static void i2c_parport_attach (struct parport *port)
 155 {
 156         struct i2c_par *adapter;
 157
 158         adapter = kmalloc(sizeof(struct i2c_par), GFP_KERNEL);
 159         if (adapter == NULL) {
 160                 printk(KERN_ERR "i2c-parport: Failed to kmalloc\n");
 161                 return;
 162         }
 163         memset(adapter, 0x00, sizeof(struct i2c_par));
 164
 165         pr_debug("i2c-parport: attaching to %s\n", port->name);
 166         adapter->pdev = parport_register_device(port, "i2c-parport",
 167                 NULL, NULL, NULL, PARPORT_FLAG_EXCL, NULL);
 168         if (!adapter->pdev) {
 169                 printk(KERN_ERR "i2c-parport: Unable to register with parport\n");
 170                 goto ERROR0;
 171         }
 172
 173         /* Fill the rest of the structure */
 174         adapter->adapter = parport_adapter;
 175         adapter->algo_data = parport_algo_data;
 176         if (!adapter_parm[type].getscl.val)
 177                 adapter->algo_data.getscl = NULL;
 178         adapter->algo_data.data = port;
 179         adapter->adapter.algo_data = &adapter->algo_data;
 180
 181         if (parport_claim_or_block(adapter->pdev) < 0) {
 182                 printk(KERN_ERR "i2c-parport: Could not claim parallel port\n");
 183                 goto ERROR1;
 184         }
 185
 186         /* Reset hardware to a sane state (SCL and SDA high) */
 187         parport_setsda(port, 1);
 188         parport_setscl(port, 1);
 189         /* Other init if needed (power on...) */
 190         if (adapter_parm[type].init.val)
 191                 line_set(port, 1, &adapter_parm[type].init);
 192
 193         parport_release(adapter->pdev);
 194
 195         if (i2c_bit_add_bus(&adapter->adapter) < 0) {
 196                 printk(KERN_ERR "i2c-parport: Unable to register with I2C\n");
 197                 goto ERROR1;
 198         }
 199
 200         /* Add the new adapter to the list */
 201         adapter->next = adapter_list;
 202         adapter_list = adapter;
 203         return;
 204
 205 ERROR1:
 206         parport_unregister_device(adapter->pdev);
 207 ERROR0:
 208         kfree(adapter);
 209 }
 210
 211 static void i2c_parport_detach (struct parport *port)
 212 {
 213         struct i2c_par *adapter, *prev;
 214
 215         /* Walk the list */
 216         for (prev = NULL, adapter = adapter_list; adapter;
 217              prev = adapter, adapter = adapter->next) {
 218                 if (adapter->pdev->port == port) {
 219                         /* Un-init if needed (power off...) */
 220                         if (adapter_parm[type].init.val)
 221                                 line_set(port, 0, &adapter_parm[type].init);
 222
 223                         i2c_bit_del_bus(&adapter->adapter);
 224                         parport_unregister_device(adapter->pdev);
 225                         if (prev)
 226                                 prev->next = adapter->next;
 227                         else
 228                                 adapter_list = adapter->next;
 229                         kfree(adapter);
 230                         return;
 231                 }
 232         }
 233 }
 234
 235 static struct parport_driver i2c_driver = {
 236         .name   = "i2c-parport",
 237         .attach = i2c_parport_attach,
 238         .detach = i2c_parport_detach,
 239 };
 240
 241 /* ----- Module loading, unloading and information ------------------------ */
 242
 243 static int __init i2c_parport_init(void)
 244 {
 245         int type_count;
 246
 247         type_count = sizeof(adapter_parm)/sizeof(struct adapter_parm);
 248         if (type < 0 || type >= type_count) {
 249                 printk(KERN_WARNING "i2c-parport: invalid type (%d)\n", type);
 250                 type = 0;
 251         }
 252
 253         return parport_register_driver(&i2c_driver);
 254 }
 255
 256 static void __exit i2c_parport_exit(void)
 257 {
 258         parport_unregister_driver(&i2c_driver);
 259 }
 260
 261 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
 262 MODULE_DESCRIPTION("I2C bus over parallel port");
 263 MODULE_LICENSE("GPL");
 264
 265 module_init(i2c_parport_init);
 266 module_exit(i2c_parport_exit);