aw_wdog.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) 2013 Oleksandr Tymoshenko <gonzo@freebsd.org>
    3  * Copyright (c) 2016 Emmanuel Vadot <manu@freebsd.org>
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   25  * SUCH DAMAGE.
   26  */
   27 #include <sys/cdefs.h>
   28 __FBSDID("$FreeBSD$");
   29 
   30 #include <sys/param.h>
   31 #include <sys/eventhandler.h>
   32 #include <sys/systm.h>
   33 #include <sys/watchdog.h>
   34 #include <sys/reboot.h>
   35 #include <sys/bus.h>
   36 #include <sys/kernel.h>
   37 #include <sys/lock.h>
   38 #include <sys/module.h>
   39 #include <sys/mutex.h>
   40 #include <sys/rman.h>
   41 
   42 #include <dev/ofw/openfirm.h>
   43 #include <dev/ofw/ofw_bus.h>
   44 #include <dev/ofw/ofw_bus_subr.h>
   45 
   46 #include <machine/bus.h>
   47 #include <machine/machdep.h>
   48 
   49 #include <arm/allwinner/aw_wdog.h>
   50 
   51 #define READ(_sc, _r) bus_read_4((_sc)->res, (_r))
   52 #define WRITE(_sc, _r, _v) bus_write_4((_sc)->res, (_r), (_v))
   53 
   54 #define A10_WDOG_CTRL           0x00
   55 #define A31_WDOG_CTRL           0x10
   56 #define  WDOG_CTRL_RESTART      (1 << 0)
   57 #define  A31_WDOG_CTRL_KEY      (0xa57 << 1)
   58 #define A10_WDOG_MODE           0x04
   59 #define A31_WDOG_MODE           0x18
   60 #define  A10_WDOG_MODE_INTVL_SHIFT      3
   61 #define  A31_WDOG_MODE_INTVL_SHIFT      4
   62 #define  A10_WDOG_MODE_RST_EN   (1 << 1)
   63 #define  WDOG_MODE_EN           (1 << 0)
   64 #define A31_WDOG_CONFIG         0x14
   65 #define  A31_WDOG_CONFIG_RST_EN_SYSTEM  (1 << 0)
   66 #define  A31_WDOG_CONFIG_RST_EN_INT     (2 << 0)
   67 
   68 struct aw_wdog_interval {
   69         uint64_t        milliseconds;
   70         unsigned int    value;
   71 };
   72 
   73 struct aw_wdog_interval wd_intervals[] = {
   74         {   500,         0 },
   75         {  1000,         1 },
   76         {  2000,         2 },
   77         {  3000,         3 },
   78         {  4000,         4 },
   79         {  5000,         5 },
   80         {  6000,         6 },
   81         {  8000,         7 },
   82         { 10000,         8 },
   83         { 12000,         9 },
   84         { 14000,        10 },
   85         { 16000,        11 },
   86         { 0,             0 } /* sentinel */
   87 };
   88 
   89 static struct aw_wdog_softc *aw_wdog_sc = NULL;
   90 
   91 struct aw_wdog_softc {
   92         device_t                dev;
   93         struct resource *       res;
   94         struct mtx              mtx;
   95         uint8_t                 wdog_ctrl;
   96         uint32_t                wdog_ctrl_key;
   97         uint8_t                 wdog_mode;
   98         uint8_t                 wdog_mode_intvl_shift;
   99         uint8_t                 wdog_mode_en;
  100         uint8_t                 wdog_config;
  101         uint8_t                 wdog_config_value;
  102 };
  103 
  104 #define A10_WATCHDOG    1
  105 #define A31_WATCHDOG    2
  106 
  107 static struct ofw_compat_data compat_data[] = {
  108         {"allwinner,sun4i-a10-wdt", A10_WATCHDOG},
  109         {"allwinner,sun6i-a31-wdt", A31_WATCHDOG},
  110         {NULL,             0}
  111 };
  112 
  113 static void aw_wdog_watchdog_fn(void *, u_int, int *);
  114 static void aw_wdog_shutdown_fn(void *, int);
  115 
  116 static int
  117 aw_wdog_probe(device_t dev)
  118 {
  119 
  120         if (!ofw_bus_status_okay(dev))
  121                 return (ENXIO);
  122         switch (ofw_bus_search_compatible(dev, compat_data)->ocd_data) {
  123         case A10_WATCHDOG:
  124                 device_set_desc(dev, "Allwinner A10 Watchdog");
  125                 return (BUS_PROBE_DEFAULT);
  126         case A31_WATCHDOG:
  127                 device_set_desc(dev, "Allwinner A31 Watchdog");
  128                 return (BUS_PROBE_DEFAULT);
  129         }
  130         return (ENXIO);
  131 }
  132 
  133 static int
  134 aw_wdog_attach(device_t dev)
  135 {
  136         struct aw_wdog_softc *sc;
  137         int rid;
  138 
  139         if (aw_wdog_sc != NULL)
  140                 return (ENXIO);
  141 
  142         sc = device_get_softc(dev);
  143         sc->dev = dev;
  144 
  145         rid = 0;
  146         sc->res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, RF_ACTIVE);
  147         if (sc->res == NULL) {
  148                 device_printf(dev, "could not allocate memory resource\n");
  149                 return (ENXIO);
  150         }
  151 
  152         aw_wdog_sc = sc;
  153 
  154         switch (ofw_bus_search_compatible(dev, compat_data)->ocd_data) {
  155         case A10_WATCHDOG:
  156                 sc->wdog_ctrl = A10_WDOG_CTRL;
  157                 sc->wdog_mode = A10_WDOG_MODE;
  158                 sc->wdog_mode_intvl_shift = A10_WDOG_MODE_INTVL_SHIFT;
  159                 sc->wdog_mode_en = A10_WDOG_MODE_RST_EN | WDOG_MODE_EN;
  160                 break;
  161         case A31_WATCHDOG:
  162                 sc->wdog_ctrl = A31_WDOG_CTRL;
  163                 sc->wdog_ctrl_key = A31_WDOG_CTRL_KEY;
  164                 sc->wdog_mode = A31_WDOG_MODE;
  165                 sc->wdog_mode_intvl_shift = A31_WDOG_MODE_INTVL_SHIFT;
  166                 sc->wdog_mode_en = WDOG_MODE_EN;
  167                 sc->wdog_config = A31_WDOG_CONFIG;
  168                 sc->wdog_config_value = A31_WDOG_CONFIG_RST_EN_SYSTEM;
  169                 break;
  170         default:
  171                 bus_release_resource(dev, SYS_RES_MEMORY, rid, sc->res);
  172                 return (ENXIO);
  173         }
  174 
  175         mtx_init(&sc->mtx, "AW Watchdog", "aw_wdog", MTX_DEF);
  176         EVENTHANDLER_REGISTER(watchdog_list, aw_wdog_watchdog_fn, sc, 0);
  177         EVENTHANDLER_REGISTER(shutdown_final, aw_wdog_shutdown_fn, sc,
  178             SHUTDOWN_PRI_LAST - 1);
  179 
  180         return (0);
  181 }
  182 
  183 static void
  184 aw_wdog_watchdog_fn(void *private, u_int cmd, int *error)
  185 {
  186         struct aw_wdog_softc *sc;
  187         uint64_t ms;
  188         int i;
  189 
  190         sc = private;
  191         mtx_lock(&sc->mtx);
  192 
  193         cmd &= WD_INTERVAL;
  194 
  195         if (cmd > 0) {
  196                 ms = ((uint64_t)1 << (cmd & WD_INTERVAL)) / 1000000;
  197                 i = 0;
  198                 while (wd_intervals[i].milliseconds &&
  199                     (ms > wd_intervals[i].milliseconds))
  200                         i++;
  201                 if (wd_intervals[i].milliseconds) {
  202                         WRITE(sc, sc->wdog_mode,
  203                           (wd_intervals[i].value << sc->wdog_mode_intvl_shift) |
  204                             sc->wdog_mode_en);
  205                         WRITE(sc, sc->wdog_ctrl,
  206                             WDOG_CTRL_RESTART | sc->wdog_ctrl_key);
  207                         if (sc->wdog_config)
  208                                 WRITE(sc, sc->wdog_config,
  209                                     sc->wdog_config_value);
  210                         *error = 0;
  211                 }
  212                 else {
  213                         /*
  214                          * Can't arm
  215                          * disable watchdog as watchdog(9) requires
  216                          */
  217                         device_printf(sc->dev,
  218                             "Can't arm, timeout is more than 16 sec\n");
  219                         mtx_unlock(&sc->mtx);
  220                         WRITE(sc, sc->wdog_mode, 0);
  221                         return;
  222                 }
  223         }
  224         else
  225                 WRITE(sc, sc->wdog_mode, 0);
  226 
  227         mtx_unlock(&sc->mtx);
  228 }
  229 
  230 static void
  231 aw_wdog_shutdown_fn(void *private, int howto)
  232 {
  233         if ((howto & (RB_POWEROFF|RB_HALT)) == 0)
  234                 aw_wdog_watchdog_reset();
  235 }
  236 
  237 void
  238 aw_wdog_watchdog_reset(void)
  239 {
  240 
  241         if (aw_wdog_sc == NULL) {
  242                 printf("Reset: watchdog device has not been initialized\n");
  243                 return;
  244         }
  245 
  246         WRITE(aw_wdog_sc, aw_wdog_sc->wdog_mode,
  247             (wd_intervals[0].value << aw_wdog_sc->wdog_mode_intvl_shift) |
  248             aw_wdog_sc->wdog_mode_en);
  249         if (aw_wdog_sc->wdog_config)
  250                 WRITE(aw_wdog_sc, aw_wdog_sc->wdog_config,
  251                       aw_wdog_sc->wdog_config_value);
  252         WRITE(aw_wdog_sc, aw_wdog_sc->wdog_ctrl,
  253             WDOG_CTRL_RESTART | aw_wdog_sc->wdog_ctrl_key);
  254         while(1)
  255                 ;
  256 
  257 }
  258 
  259 static device_method_t aw_wdog_methods[] = {
  260         DEVMETHOD(device_probe, aw_wdog_probe),
  261         DEVMETHOD(device_attach, aw_wdog_attach),
  262 
  263         DEVMETHOD_END
  264 };
  265 
  266 static driver_t aw_wdog_driver = {
  267         "aw_wdog",
  268         aw_wdog_methods,
  269         sizeof(struct aw_wdog_softc),
  270 };
  271 static devclass_t aw_wdog_devclass;
  272 
  273 DRIVER_MODULE(aw_wdog, simplebus, aw_wdog_driver, aw_wdog_devclass, 0, 0);

Cache object: 2fde67d97b9dd20cdf50bbf8e28f57f4

[ 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/arm/allwinner/aw_wdog.c

FreeBSD/Linux Kernel Cross Reference
sys/arm/allwinner/aw_wdog.c