1 /* 2 * pps_parport.c -- kernel parallel port PPS client 3 * 4 * 5 * Copyright (C) 2009 Alexander Gordeev <lasaine@lvk.cs.msu.su> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 23 /* 24 * TODO: 25 * implement echo over SEL pin 26 */ 27 28 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 29 30 #include <linux/kernel.h> 31 #include <linux/module.h> 32 #include <linux/init.h> 33 #include <linux/irqnr.h> 34 #include <linux/time.h> 35 #include <linux/slab.h> 36 #include <linux/parport.h> 37 #include <linux/pps_kernel.h> 38 39 #define DRVDESC "parallel port PPS client" 40 41 /* module parameters */ 42 43 #define CLEAR_WAIT_MAX 100 44 #define CLEAR_WAIT_MAX_ERRORS 5 45 46 static unsigned int clear_wait = 100; 47 MODULE_PARM_DESC(clear_wait, 48 "Maximum number of port reads when polling for signal clear," 49 " zero turns clear edge capture off entirely"); 50 module_param(clear_wait, uint, 0); 51 52 static DEFINE_IDA(pps_client_index); 53 54 /* internal per port structure */ 55 struct pps_client_pp { 56 struct pardevice *pardev; /* parport device */ 57 struct pps_device *pps; /* PPS device */ 58 unsigned int cw; /* port clear timeout */ 59 unsigned int cw_err; /* number of timeouts */ 60 int index; /* device number */ 61 }; 62 63 static inline int signal_is_set(struct parport *port) 64 { 65 return (port->ops->read_status(port) & PARPORT_STATUS_ACK) != 0; 66 } 67 68 /* parport interrupt handler */ 69 static void parport_irq(void *handle) 70 { 71 struct pps_event_time ts_assert, ts_clear; 72 struct pps_client_pp *dev = handle; 73 struct parport *port = dev->pardev->port; 74 unsigned int i; 75 unsigned long flags; 76 77 /* first of all we get the time stamp... */ 78 pps_get_ts(&ts_assert); 79 80 if (dev->cw == 0) 81 /* clear edge capture disabled */ 82 goto out_assert; 83 84 /* try capture the clear edge */ 85 86 /* We have to disable interrupts here. The idea is to prevent 87 * other interrupts on the same processor to introduce random 88 * lags while polling the port. Reading from IO port is known 89 * to take approximately 1us while other interrupt handlers can 90 * take much more potentially. 91 * 92 * Interrupts won't be disabled for a long time because the 93 * number of polls is limited by clear_wait parameter which is 94 * kept rather low. So it should never be an issue. 95 */ 96 local_irq_save(flags); 97 /* check the signal (no signal means the pulse is lost this time) */ 98 if (!signal_is_set(port)) { 99 local_irq_restore(flags); 100 dev_err(dev->pps->dev, "lost the signal\n"); 101 goto out_assert; 102 } 103 104 /* poll the port until the signal is unset */ 105 for (i = dev->cw; i; i--) 106 if (!signal_is_set(port)) { 107 pps_get_ts(&ts_clear); 108 local_irq_restore(flags); 109 dev->cw_err = 0; 110 goto out_both; 111 } 112 local_irq_restore(flags); 113 114 /* timeout */ 115 dev->cw_err++; 116 if (dev->cw_err >= CLEAR_WAIT_MAX_ERRORS) { 117 dev_err(dev->pps->dev, "disabled clear edge capture after %d" 118 " timeouts\n", dev->cw_err); 119 dev->cw = 0; 120 dev->cw_err = 0; 121 } 122 123 out_assert: 124 /* fire assert event */ 125 pps_event(dev->pps, &ts_assert, 126 PPS_CAPTUREASSERT, NULL); 127 return; 128 129 out_both: 130 /* fire assert event */ 131 pps_event(dev->pps, &ts_assert, 132 PPS_CAPTUREASSERT, NULL); 133 /* fire clear event */ 134 pps_event(dev->pps, &ts_clear, 135 PPS_CAPTURECLEAR, NULL); 136 return; 137 } 138 139 static void parport_attach(struct parport *port) 140 { 141 struct pardev_cb pps_client_cb; 142 int index; 143 struct pps_client_pp *device; 144 struct pps_source_info info = { 145 .name = KBUILD_MODNAME, 146 .path = "", 147 .mode = PPS_CAPTUREBOTH | \ 148 PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \ 149 PPS_ECHOASSERT | PPS_ECHOCLEAR | \ 150 PPS_CANWAIT | PPS_TSFMT_TSPEC, 151 .owner = THIS_MODULE, 152 .dev = NULL 153 }; 154 155 device = kzalloc(sizeof(struct pps_client_pp), GFP_KERNEL); 156 if (!device) { 157 pr_err("memory allocation failed, not attaching\n"); 158 return; 159 } 160 161 index = ida_simple_get(&pps_client_index, 0, 0, GFP_KERNEL); 162 memset(&pps_client_cb, 0, sizeof(pps_client_cb)); 163 pps_client_cb.private = device; 164 pps_client_cb.irq_func = parport_irq; 165 pps_client_cb.flags = PARPORT_FLAG_EXCL; 166 device->pardev = parport_register_dev_model(port, 167 KBUILD_MODNAME, 168 &pps_client_cb, 169 index); 170 if (!device->pardev) { 171 pr_err("couldn't register with %s\n", port->name); 172 goto err_free; 173 } 174 175 if (parport_claim_or_block(device->pardev) < 0) { 176 pr_err("couldn't claim %s\n", port->name); 177 goto err_unregister_dev; 178 } 179 180 device->pps = pps_register_source(&info, 181 PPS_CAPTUREBOTH | PPS_OFFSETASSERT | PPS_OFFSETCLEAR); 182 if (IS_ERR(device->pps)) { 183 pr_err("couldn't register PPS source\n"); 184 goto err_release_dev; 185 } 186 187 device->cw = clear_wait; 188 189 port->ops->enable_irq(port); 190 device->index = index; 191 192 pr_info("attached to %s\n", port->name); 193 194 return; 195 196 err_release_dev: 197 parport_release(device->pardev); 198 err_unregister_dev: 199 parport_unregister_device(device->pardev); 200 err_free: 201 ida_simple_remove(&pps_client_index, index); 202 kfree(device); 203 } 204 205 static void parport_detach(struct parport *port) 206 { 207 struct pardevice *pardev = port->cad; 208 struct pps_client_pp *device; 209 210 /* FIXME: oooh, this is ugly! */ 211 if (!pardev || strcmp(pardev->name, KBUILD_MODNAME)) 212 /* not our port */ 213 return; 214 215 device = pardev->private; 216 217 port->ops->disable_irq(port); 218 pps_unregister_source(device->pps); 219 parport_release(pardev); 220 parport_unregister_device(pardev); 221 ida_simple_remove(&pps_client_index, device->index); 222 kfree(device); 223 } 224 225 static struct parport_driver pps_parport_driver = { 226 .name = KBUILD_MODNAME, 227 .match_port = parport_attach, 228 .detach = parport_detach, 229 .devmodel = true, 230 }; 231 232 /* module staff */ 233 234 static int __init pps_parport_init(void) 235 { 236 int ret; 237 238 pr_info(DRVDESC "\n"); 239 240 if (clear_wait > CLEAR_WAIT_MAX) { 241 pr_err("clear_wait value should be not greater" 242 " then %d\n", CLEAR_WAIT_MAX); 243 return -EINVAL; 244 } 245 246 ret = parport_register_driver(&pps_parport_driver); 247 if (ret) { 248 pr_err("unable to register with parport\n"); 249 return ret; 250 } 251 252 return 0; 253 } 254 255 static void __exit pps_parport_exit(void) 256 { 257 parport_unregister_driver(&pps_parport_driver); 258 } 259 260 module_init(pps_parport_init); 261 module_exit(pps_parport_exit); 262 263 MODULE_AUTHOR("Alexander Gordeev <lasaine@lvk.cs.msu.su>"); 264 MODULE_DESCRIPTION(DRVDESC); 265 MODULE_LICENSE("GPL"); 266