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