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); 303