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