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