pcfclock.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  * Copyright (c) 2000 Sascha Schumann. All rights reserved.
    3  *
    4  * Redistribution and use in source and binary forms, with or without
    5  * modification, are permitted provided that the following conditions
    6  * are met:
    7  * 1. Redistributions of source code must retain the above copyright
    8  *    notice, this list of conditions and the following disclaimer.
    9  * 2. Redistributions in binary form must reproduce the above copyright
   10  *    notice, this list of conditions and the following disclaimer in the
   11  *    documentation and/or other materials provided with the distribution.
   12  * 
   13  * THIS SOFTWARE IS PROVIDED BY SASCHA SCHUMANN ``AS IS'' AND ANY EXPRESS OR
   14  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
   15  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
   16  * EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   17  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   18  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
   19  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   20  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   21  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
   22  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   23  *
   24  *
   25  */
   26 
   27 #include <sys/cdefs.h>
   28 __FBSDID("$FreeBSD: releng/5.4/sys/dev/ppbus/pcfclock.c 141016 2005-01-30 01:00:13Z imp $");
   29 
   30 #include "opt_pcfclock.h"
   31 
   32 #include <sys/param.h>
   33 #include <sys/systm.h>
   34 #include <sys/bus.h>
   35 #include <sys/sockio.h>
   36 #include <sys/mbuf.h>
   37 #include <sys/kernel.h>
   38 #include <sys/module.h>
   39 #include <sys/conf.h>
   40 #include <sys/fcntl.h>
   41 #include <sys/uio.h>
   42 
   43 #include <machine/bus.h>
   44 #include <machine/resource.h>
   45 
   46 #include <dev/ppbus/ppbconf.h>
   47 #include <dev/ppbus/ppb_msq.h>
   48 #include <dev/ppbus/ppbio.h>
   49 
   50 #include "ppbus_if.h"
   51 
   52 #define PCFCLOCK_NAME "pcfclock"
   53 
   54 struct pcfclock_data {
   55         int     count;
   56 };
   57 
   58 #define DEVTOSOFTC(dev) \
   59         ((struct pcfclock_data *)device_get_softc(dev))
   60 #define UNITOSOFTC(unit) \
   61         ((struct pcfclock_data *)devclass_get_softc(pcfclock_devclass, (unit)))
   62 #define UNITODEVICE(unit) \
   63         (devclass_get_device(pcfclock_devclass, (unit)))
   64 
   65 static devclass_t pcfclock_devclass;
   66 
   67 static  d_open_t                pcfclock_open;
   68 static  d_close_t               pcfclock_close;
   69 static  d_read_t                pcfclock_read;
   70 
   71 static struct cdevsw pcfclock_cdevsw = {
   72         .d_version =    D_VERSION,
   73         .d_flags =      D_NEEDGIANT,
   74         .d_open =       pcfclock_open,
   75         .d_close =      pcfclock_close,
   76         .d_read =       pcfclock_read,
   77         .d_name =       PCFCLOCK_NAME,
   78 };
   79 
   80 #ifndef PCFCLOCK_MAX_RETRIES
   81 #define PCFCLOCK_MAX_RETRIES 10
   82 #endif
   83 
   84 #define AFC_HI 0
   85 #define AFC_LO AUTOFEED
   86 
   87 /* AUTO FEED is used as clock */
   88 #define AUTOFEED_CLOCK(val) \
   89         ctr = (ctr & ~(AUTOFEED)) ^ (val); ppb_wctr(ppbus, ctr)
   90 
   91 /* SLCT is used as clock */
   92 #define CLOCK_OK \
   93         ((ppb_rstr(ppbus) & SELECT) == (i & 1 ? SELECT : 0))
   94 
   95 /* PE is used as data */
   96 #define BIT_SET (ppb_rstr(ppbus)&PERROR)
   97 
   98 /* the first byte sent as reply must be 00001001b */
   99 #define PCFCLOCK_CORRECT_SYNC(buf) (buf[0] == 9)
  100 
  101 #define NR(buf, off) (buf[off+1]*10+buf[off])
  102 
  103 /* check for correct input values */
  104 #define PCFCLOCK_CORRECT_FORMAT(buf) (\
  105         NR(buf, 14) <= 99 && \
  106         NR(buf, 12) <= 12 && \
  107         NR(buf, 10) <= 31 && \
  108         NR(buf,  6) <= 23 && \
  109         NR(buf,  4) <= 59 && \
  110         NR(buf,  2) <= 59)
  111 
  112 #define PCFCLOCK_BATTERY_STATUS_LOW(buf) (buf[8] & 4)
  113          
  114 #define PCFCLOCK_CMD_TIME 0             /* send current time */
  115 #define PCFCLOCK_CMD_COPY 7     /* copy received signal to PC */
  116 
  117 static void
  118 pcfclock_identify(driver_t *driver, device_t parent)
  119 {
  120 
  121         device_t dev;
  122 
  123         dev = device_find_child(parent, PCFCLOCK_NAME, 0);
  124         if (!dev)
  125                 BUS_ADD_CHILD(parent, 0, PCFCLOCK_NAME, -1);
  126 }
  127 
  128 static int
  129 pcfclock_probe(device_t dev)
  130 {
  131         struct pcfclock_data *sc;
  132 
  133         device_set_desc(dev, "PCF-1.0");
  134 
  135         sc = DEVTOSOFTC(dev);
  136         
  137         return (0);
  138 }
  139 
  140 static int
  141 pcfclock_attach(device_t dev)
  142 {
  143         int unit;
  144         
  145         unit = device_get_unit(dev);
  146 
  147         make_dev(&pcfclock_cdevsw, unit,
  148                         UID_ROOT, GID_WHEEL, 0400, PCFCLOCK_NAME "%d", unit);
  149 
  150         return (0);
  151 }
  152 
  153 static int 
  154 pcfclock_open(struct cdev *dev, int flag, int fms, struct thread *td)
  155 {
  156         u_int unit = minor(dev);
  157         struct pcfclock_data *sc = UNITOSOFTC(unit);
  158         device_t pcfclockdev = UNITODEVICE(unit);
  159         device_t ppbus = device_get_parent(pcfclockdev);
  160         int res;
  161         
  162         if (!sc)
  163                 return (ENXIO);
  164 
  165         if ((res = ppb_request_bus(ppbus, pcfclockdev,
  166                 (flag & O_NONBLOCK) ? PPB_DONTWAIT : PPB_WAIT)))
  167                 return (res);
  168 
  169         sc->count++;
  170         
  171         return (0);
  172 }
  173 
  174 static int
  175 pcfclock_close(struct cdev *dev, int flags, int fmt, struct thread *td)
  176 {
  177         u_int unit = minor(dev);
  178         struct pcfclock_data *sc = UNITOSOFTC(unit);
  179         device_t pcfclockdev = UNITODEVICE(unit);
  180         device_t ppbus = device_get_parent(pcfclockdev);
  181 
  182         sc->count--;
  183         if (sc->count == 0)
  184                 ppb_release_bus(ppbus, pcfclockdev);
  185 
  186         return (0);
  187 }
  188 
  189 static void
  190 pcfclock_write_cmd(struct cdev *dev, unsigned char command)
  191 {
  192         u_int unit = minor(dev);
  193         device_t ppidev = UNITODEVICE(unit);
  194         device_t ppbus = device_get_parent(ppidev);
  195         unsigned char ctr = 14;
  196         char i;
  197         
  198         for (i = 0; i <= 7; i++) {
  199                 ppb_wdtr(ppbus, i);
  200                 AUTOFEED_CLOCK(i & 1 ? AFC_HI : AFC_LO);
  201                 DELAY(3000);
  202         }
  203         ppb_wdtr(ppbus, command);
  204         AUTOFEED_CLOCK(AFC_LO);
  205         DELAY(3000);
  206         AUTOFEED_CLOCK(AFC_HI);
  207 }
  208 
  209 static void
  210 pcfclock_display_data(struct cdev *dev, char buf[18]) 
  211 {
  212         u_int unit = minor(dev);
  213 #ifdef PCFCLOCK_VERBOSE
  214         int year;
  215 
  216         year = NR(buf, 14);
  217         if (year < 70)
  218                 year += 100;
  219 
  220         printf(PCFCLOCK_NAME "%d: %02d.%02d.%4d %02d:%02d:%02d, "
  221                         "battery status: %s\n",
  222                         unit,
  223                         NR(buf, 10), NR(buf, 12), 1900 + year,
  224                         NR(buf, 6), NR(buf, 4), NR(buf, 2),
  225                         PCFCLOCK_BATTERY_STATUS_LOW(buf) ? "LOW" : "ok");
  226 #else
  227         if (PCFCLOCK_BATTERY_STATUS_LOW(buf))
  228                 printf(PCFCLOCK_NAME "%d: BATTERY STATUS LOW ON\n",
  229                                 unit);
  230 #endif
  231 }
  232 
  233 static int 
  234 pcfclock_read_data(struct cdev *dev, char *buf, ssize_t bits)
  235 {
  236         u_int unit = minor(dev);
  237         device_t ppidev = UNITODEVICE(unit);
  238         device_t ppbus = device_get_parent(ppidev);
  239         int i;
  240         char waitfor;
  241         int offset;
  242 
  243         /* one byte per four bits */
  244         bzero(buf, ((bits + 3) >> 2) + 1);
  245         
  246         waitfor = 100;
  247         for (i = 0; i <= bits; i++) {
  248                 /* wait for clock, maximum (waitfor*100) usec */
  249                 while(!CLOCK_OK && --waitfor > 0)
  250                         DELAY(100);
  251 
  252                 /* timed out? */
  253                 if (!waitfor) 
  254                         return (EIO);
  255                 
  256                 waitfor = 100; /* reload */
  257                 
  258                 /* give it some time */
  259                 DELAY(500);
  260 
  261                 /* calculate offset into buffer */
  262                 offset = i >> 2;
  263                 buf[offset] <<= 1;
  264 
  265                 if (BIT_SET)
  266                         buf[offset] |= 1;
  267         }
  268 
  269         return (0);
  270 }
  271 
  272 static int 
  273 pcfclock_read_dev(struct cdev *dev, char *buf, int maxretries) 
  274 {
  275         u_int unit = minor(dev);
  276         device_t ppidev = UNITODEVICE(unit);
  277         device_t ppbus = device_get_parent(ppidev);
  278         int error = 0;
  279 
  280         ppb_set_mode(ppbus, PPB_COMPATIBLE);
  281 
  282         while (--maxretries > 0) {
  283                 pcfclock_write_cmd(dev, PCFCLOCK_CMD_TIME);
  284                 if (pcfclock_read_data(dev, buf, 68))
  285                         continue;
  286                         
  287                 if (!PCFCLOCK_CORRECT_SYNC(buf))
  288                         continue;
  289 
  290                 if (!PCFCLOCK_CORRECT_FORMAT(buf))
  291                         continue;
  292 
  293                 break;
  294         }
  295 
  296         if (!maxretries)
  297                 error = EIO;
  298         
  299         return (error);
  300 }
  301 
  302 static int
  303 pcfclock_read(struct cdev *dev, struct uio *uio, int ioflag)
  304 {
  305         u_int unit = minor(dev);
  306         char buf[18];
  307         int error = 0;
  308 
  309         if (uio->uio_resid < 18)
  310                 return (ERANGE);
  311 
  312         error = pcfclock_read_dev(dev, buf, PCFCLOCK_MAX_RETRIES);
  313         
  314         if (error) {
  315                 printf(PCFCLOCK_NAME "%d: no PCF found\n", unit);
  316         } else {
  317                 pcfclock_display_data(dev, buf);
  318                 
  319                 uiomove(buf, 18, uio);
  320         }
  321         
  322         return (error);
  323 }
  324 
  325 static device_method_t pcfclock_methods[] = {
  326         /* device interface */
  327         DEVMETHOD(device_identify,      pcfclock_identify),
  328         DEVMETHOD(device_probe,         pcfclock_probe),
  329         DEVMETHOD(device_attach,        pcfclock_attach),
  330 
  331         { 0, 0 }
  332 };
  333 
  334 static driver_t pcfclock_driver = {
  335         PCFCLOCK_NAME,
  336         pcfclock_methods,
  337         sizeof(struct pcfclock_data),
  338 };
  339 
  340 DRIVER_MODULE(pcfclock, ppbus, pcfclock_driver, pcfclock_devclass, 0, 0);
Cache object: d3f5f978d9b59dfcf18a86c656c42d48
[ 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.
FreeBSD/Linux Kernel Cross Reference sys/dev/ppbus/pcfclock.c

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