drivers/pps/clients/pps_parport.c

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