The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/ppbus/pps.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * ----------------------------------------------------------------------------
    3  * "THE BEER-WARE LICENSE" (Revision 42):
    4  * <phk@FreeBSD.org> wrote this file.  As long as you retain this notice you
    5  * can do whatever you want with this stuff. If we meet some day, and you think
    6  * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
    7  * ----------------------------------------------------------------------------
    8  *
    9  *
   10  * This driver implements a draft-mogul-pps-api-02.txt PPS source.
   11  *
   12  * The input pin is pin#10 
   13  * The echo output pin is pin#14
   14  *
   15  */
   16 
   17 #include <sys/cdefs.h>
   18 __FBSDID("$FreeBSD: releng/5.4/sys/dev/ppbus/pps.c 141016 2005-01-30 01:00:13Z imp $");
   19 
   20 #include <sys/param.h>
   21 #include <sys/kernel.h>
   22 #include <sys/systm.h>
   23 #include <sys/module.h>
   24 #include <sys/bus.h>
   25 #include <sys/conf.h>
   26 #include <sys/timepps.h>
   27 #include <machine/bus.h>
   28 #include <machine/resource.h>
   29 #include <sys/rman.h>
   30 
   31 #include <dev/ppbus/ppbconf.h>
   32 #include "ppbus_if.h"
   33 #include <dev/ppbus/ppbio.h>
   34 
   35 #define PPS_NAME        "pps"           /* our official name */
   36 
   37 #define PRVERBOSE(fmt, arg...)  if (bootverbose) printf(fmt, ##arg);
   38 
   39 struct pps_data {
   40         struct  ppb_device pps_dev;     
   41         struct  pps_state pps[9];
   42         struct cdev *devs[9];
   43         device_t ppsdev;
   44         device_t ppbus;
   45         int     busy;
   46         struct callout_handle timeout;
   47         int     lastdata;
   48 
   49         struct resource *intr_resource; /* interrupt resource */
   50         void *intr_cookie;              /* interrupt registration cookie */
   51 };
   52 
   53 static void     ppsintr(void *arg);
   54 static void     ppshcpoll(void *arg);
   55 
   56 #define DEVTOSOFTC(dev) \
   57         ((struct pps_data *)device_get_softc(dev))
   58 
   59 static devclass_t pps_devclass;
   60 
   61 static  d_open_t        ppsopen;
   62 static  d_close_t       ppsclose;
   63 static  d_ioctl_t       ppsioctl;
   64 
   65 static struct cdevsw pps_cdevsw = {
   66         .d_version =    D_VERSION,
   67         .d_flags =      D_NEEDGIANT,
   68         .d_open =       ppsopen,
   69         .d_close =      ppsclose,
   70         .d_ioctl =      ppsioctl,
   71         .d_name =       PPS_NAME,
   72 };
   73 
   74 static void
   75 ppsidentify(driver_t *driver, device_t parent)
   76 {
   77 
   78         device_t dev;
   79 
   80         dev = device_find_child(parent, PPS_NAME, 0);
   81         if (!dev)
   82                 BUS_ADD_CHILD(parent, 0, PPS_NAME, -1);
   83 }
   84 
   85 static int
   86 ppstry(device_t ppbus, int send, int expect)
   87 {
   88         int i;
   89 
   90         ppb_wdtr(ppbus, send);
   91         i = ppb_rdtr(ppbus);
   92         PRVERBOSE("S: %02x E: %02x G: %02x\n", send, expect, i);
   93         return (i != expect);
   94 }
   95 
   96 static int
   97 ppsprobe(device_t ppsdev)
   98 {
   99         device_set_desc(ppsdev, "Pulse per second Timing Interface");
  100 
  101         return (0);
  102 }
  103 
  104 static int
  105 ppsattach(device_t dev)
  106 {
  107         struct pps_data *sc = DEVTOSOFTC(dev);
  108         device_t ppbus = device_get_parent(dev);
  109         struct cdev *d;
  110         intptr_t irq;
  111         int i, unit, zero = 0;
  112 
  113         /* retrieve the ppbus irq */
  114         BUS_READ_IVAR(ppbus, dev, PPBUS_IVAR_IRQ, &irq);
  115 
  116         if (irq > 0) {
  117                 /* declare our interrupt handler */
  118                 sc->intr_resource = bus_alloc_resource(dev, SYS_RES_IRQ,
  119                     &zero, irq, irq, 1, RF_SHAREABLE);
  120         }
  121         /* interrupts seem mandatory */
  122         if (sc->intr_resource == NULL)
  123                 return (ENXIO);
  124 
  125         sc->ppsdev = dev;
  126         sc->ppbus = ppbus;
  127         unit = device_get_unit(ppbus);
  128         d = make_dev(&pps_cdevsw, unit,
  129             UID_ROOT, GID_WHEEL, 0600, PPS_NAME "%d", unit);
  130         sc->devs[0] = d;
  131         sc->pps[0].ppscap = PPS_CAPTUREASSERT | PPS_ECHOASSERT;
  132         d->si_drv1 = sc;
  133         d->si_drv2 = (void*)0;
  134         pps_init(&sc->pps[0]);
  135 
  136         if (ppb_request_bus(ppbus, dev, PPB_DONTWAIT))
  137                 return (0);
  138 
  139         do {
  140                 i = ppb_set_mode(sc->ppbus, PPB_EPP);
  141                 PRVERBOSE("EPP: %d %d\n", i, PPB_IN_EPP_MODE(sc->ppbus));
  142                 if (i == -1)
  143                         break;
  144                 i = 0;
  145                 ppb_wctr(ppbus, i);
  146                 if (ppstry(ppbus, 0x00, 0x00))
  147                         break;
  148                 if (ppstry(ppbus, 0x55, 0x55))
  149                         break;
  150                 if (ppstry(ppbus, 0xaa, 0xaa))
  151                         break;
  152                 if (ppstry(ppbus, 0xff, 0xff))
  153                         break;
  154 
  155                 i = IRQENABLE | PCD | STROBE | nINIT | SELECTIN;
  156                 ppb_wctr(ppbus, i);
  157                 PRVERBOSE("CTR = %02x (%02x)\n", ppb_rctr(ppbus), i);
  158                 if (ppstry(ppbus, 0x00, 0x00))
  159                         break;
  160                 if (ppstry(ppbus, 0x55, 0x00))
  161                         break;
  162                 if (ppstry(ppbus, 0xaa, 0x00))
  163                         break;
  164                 if (ppstry(ppbus, 0xff, 0x00))
  165                         break;
  166 
  167                 i = IRQENABLE | PCD | nINIT | SELECTIN;
  168                 ppb_wctr(ppbus, i);
  169                 PRVERBOSE("CTR = %02x (%02x)\n", ppb_rctr(ppbus), i);
  170                 ppstry(ppbus, 0x00, 0xff);
  171                 ppstry(ppbus, 0x55, 0xff);
  172                 ppstry(ppbus, 0xaa, 0xff);
  173                 ppstry(ppbus, 0xff, 0xff);
  174 
  175                 for (i = 1; i < 9; i++) {
  176                         d = make_dev(&pps_cdevsw, unit + 0x10000 * i,
  177                           UID_ROOT, GID_WHEEL, 0600, PPS_NAME "%db%d", unit, i - 1);
  178                         sc->devs[i] = d;
  179                         sc->pps[i].ppscap = PPS_CAPTUREASSERT | PPS_CAPTURECLEAR;
  180                         d->si_drv1 = sc;
  181                         d->si_drv2 = (void *)(intptr_t)i;
  182                         pps_init(&sc->pps[i]);
  183                 }
  184         } while (0);
  185         i = ppb_set_mode(sc->ppbus, PPB_COMPATIBLE);
  186         ppb_release_bus(ppbus, dev);
  187 
  188         return (0);
  189 }
  190 
  191 static  int
  192 ppsopen(struct cdev *dev, int flags, int fmt, struct thread *td)
  193 {
  194         struct pps_data *sc = dev->si_drv1;
  195         int subdev = (intptr_t)dev->si_drv2;
  196         int error, i;
  197 
  198         if (!sc->busy) {
  199                 device_t ppsdev = sc->ppsdev;
  200                 device_t ppbus = sc->ppbus;
  201 
  202                 if (ppb_request_bus(ppbus, ppsdev, PPB_WAIT|PPB_INTR))
  203                         return (EINTR);
  204 
  205                 /* attach the interrupt handler */
  206                 if ((error = BUS_SETUP_INTR(ppbus, ppsdev, sc->intr_resource,
  207                                INTR_TYPE_TTY, ppsintr, ppsdev,
  208                                &sc->intr_cookie))) {
  209                         ppb_release_bus(ppbus, ppsdev);
  210                         return (error);
  211                 }
  212 
  213                 i = ppb_set_mode(sc->ppbus, PPB_PS2);
  214                 PRVERBOSE("EPP: %d %d\n", i, PPB_IN_EPP_MODE(sc->ppbus));
  215 
  216                 i = IRQENABLE | PCD | nINIT | SELECTIN;
  217                 ppb_wctr(ppbus, i);
  218         } 
  219         if (subdev > 0 && !(sc->busy & ~1)) {
  220                 sc->timeout = timeout(ppshcpoll, sc, 1);
  221                 sc->lastdata = ppb_rdtr(sc->ppbus);
  222         }
  223         sc->busy |= (1 << subdev);
  224         return(0);
  225 }
  226 
  227 static  int
  228 ppsclose(struct cdev *dev, int flags, int fmt, struct thread *td)
  229 {
  230         struct pps_data *sc = dev->si_drv1;
  231         int subdev = (intptr_t)dev->si_drv2;
  232 
  233         sc->pps[subdev].ppsparam.mode = 0;      /* PHK ??? */
  234         sc->busy &= ~(1 << subdev);
  235         if (subdev > 0 && !(sc->busy & ~1)) 
  236                 untimeout(ppshcpoll, sc, sc->timeout);
  237         if (!sc->busy) {
  238                 device_t ppsdev = sc->ppsdev;
  239                 device_t ppbus = sc->ppbus;
  240 
  241                 ppb_wdtr(ppbus, 0);
  242                 ppb_wctr(ppbus, 0);
  243 
  244                 /* Note: the interrupt handler is automatically detached */
  245                 ppb_set_mode(ppbus, PPB_COMPATIBLE);
  246                 ppb_release_bus(ppbus, ppsdev);
  247         }
  248         return(0);
  249 }
  250 
  251 static void
  252 ppshcpoll(void *arg)
  253 {
  254         struct pps_data *sc = arg;
  255         int i, j, k, l;
  256 
  257         if (!(sc->busy & ~1))
  258                 return;
  259         sc->timeout = timeout(ppshcpoll, sc, 1);
  260         i = ppb_rdtr(sc->ppbus);
  261         if (i == sc->lastdata) 
  262                 return;
  263         l = sc->lastdata ^ i;
  264         k = 1;
  265         for (j = 1; j < 9; j ++) {
  266                 if (l & k) {
  267                         pps_capture(&sc->pps[j]);
  268                         pps_event(&sc->pps[j],
  269                             i & k ? PPS_CAPTUREASSERT : PPS_CAPTURECLEAR);
  270                 }
  271                 k += k;
  272         }
  273         sc->lastdata = i;
  274 }
  275 
  276 static void
  277 ppsintr(void *arg)
  278 {
  279         device_t ppsdev = (device_t)arg;
  280         struct pps_data *sc = DEVTOSOFTC(ppsdev);
  281         device_t ppbus = sc->ppbus;
  282 
  283         pps_capture(&sc->pps[0]);
  284         if (!(ppb_rstr(ppbus) & nACK))
  285                 return;
  286         if (sc->pps[0].ppsparam.mode & PPS_ECHOASSERT) 
  287                 ppb_wctr(ppbus, IRQENABLE | AUTOFEED);
  288         pps_event(&sc->pps[0], PPS_CAPTUREASSERT);
  289         if (sc->pps[0].ppsparam.mode & PPS_ECHOASSERT) 
  290                 ppb_wctr(ppbus, IRQENABLE);
  291 }
  292 
  293 static int
  294 ppsioctl(struct cdev *dev, u_long cmd, caddr_t data, int flags, struct thread *td)
  295 {
  296         struct pps_data *sc = dev->si_drv1;
  297         int subdev = (intptr_t)dev->si_drv2;
  298 
  299         return (pps_ioctl(cmd, data, &sc->pps[subdev]));
  300 }
  301 
  302 static device_method_t pps_methods[] = {
  303         /* device interface */
  304         DEVMETHOD(device_identify,      ppsidentify),
  305         DEVMETHOD(device_probe,         ppsprobe),
  306         DEVMETHOD(device_attach,        ppsattach),
  307 
  308         { 0, 0 }
  309 };
  310 
  311 static driver_t pps_driver = {
  312         PPS_NAME,
  313         pps_methods,
  314         sizeof(struct pps_data),
  315 };
  316 DRIVER_MODULE(pps, ppbus, pps_driver, pps_devclass, 0, 0);

Cache object: aa1173e9d6a7ecbe2a48534fd5ea5a3a


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.