sys/i386/i386/geode.c

   1 /*-
   2  * Copyright (c) 2003-2004 Poul-Henning Kamp
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/systm.h>
  32 #include <sys/timetc.h>
  33 #include <sys/bus.h>
  34 #include <sys/kernel.h>
  35 #include <sys/module.h>
  36 #include <sys/watchdog.h>
  37 #include <dev/pci/pcireg.h>
  38 #include <dev/pci/pcivar.h>
  39 #include <dev/led/led.h>
  40 #include <machine/pc/bios.h>
  41
  42 static struct bios_oem bios_soekris = {
  43     { 0xf0000, 0xf1000 },
  44     {
  45         { "Soekris", 0, 8 },            /* Soekris Engineering. */
  46         { "net4", 0, 8 },               /* net45xx */
  47         { "comBIOS", 0, 54 },           /* comBIOS ver. 1.26a  20040819 ... */
  48         { NULL, 0, 0 },
  49     }
  50 };
  51
  52 static struct bios_oem bios_soekris_55 = {
  53     { 0xf0000, 0xf1000 },
  54     {
  55         { "Soekris", 0, 8 },            /* Soekris Engineering. */
  56         { "net5", 0, 8 },               /* net5xxx */
  57         { "comBIOS", 0, 54 },           /* comBIOS ver. 1.26a  20040819 ... */
  58         { NULL, 0, 0 },
  59     }
  60 };
  61
  62 static struct bios_oem bios_pcengines = {
  63     { 0xf9000, 0xfa000 },
  64     {
  65         { "PC Engines WRAP", 0, 28 },   /* PC Engines WRAP.1C v1.03 */
  66         { "tinyBIOS", 0, 28 },          /* tinyBIOS V1.4a (C)1997-2003 */
  67         { NULL, 0, 0 },
  68     }
  69 };
  70
  71 static struct bios_oem bios_pcengines_55 = {
  72     { 0xf9000, 0xfa000 },
  73     {
  74         { "PC Engines ALIX", 0, 28 },   /* PC Engines ALIX */
  75         { "tinyBIOS", 0, 28 },          /* tinyBIOS V1.4a (C)1997-2005 */
  76         { NULL, 0, 0 },
  77     }
  78 };
  79
  80 static struct bios_oem bios_advantech = {
  81     { 0xfe000, 0xff000 },
  82     {
  83         { "**** PCM-582", 5, 33 },      /* PCM-5823 BIOS V1.12 ... */
  84         { "GXm-Cx5530", -11, 35 },      /* 06/07/2002-GXm-Cx5530... */
  85         { NULL, 0, 0 },
  86     }
  87 };
  88
  89 static unsigned cba;
  90 static unsigned gpio;
  91 static unsigned geode_counter;
  92
  93 static struct cdev *led1, *led2, *led3;
  94 static int      led1b, led2b, led3b;
  95
  96 static void
  97 led_func(void *ptr, int onoff)
  98 {
  99         uint32_t u;
 100         int bit;
 101
 102         bit = *(int *)ptr;
 103         if (bit < 0) {
 104                 bit = -bit;
 105                 onoff = !onoff;
 106         }
 107
 108         u = inl(gpio + 4);
 109         if (onoff)
 110                 u |= 1 << bit;
 111         else
 112                 u &= ~(1 << bit);
 113         outl(gpio, u);
 114 }
 115
 116 static void
 117 cs5536_led_func(void *ptr, int onoff)
 118 {
 119         int bit;
 120         uint16_t a;
 121
 122         bit = *(int *)ptr;
 123         if (bit < 0) {
 124                 bit = -bit;
 125                 onoff = !onoff;
 126         }
 127
 128         a = rdmsr(0x5140000c);
 129         if (bit >= 16) {
 130                 a += 0x80;
 131                 bit -= 16;
 132         }
 133
 134         if (onoff)
 135                 outl(a, 1 << bit);
 136         else
 137                 outl(a, 1 << (bit + 16));
 138 }
 139
 140
 141 static unsigned
 142 geode_get_timecount(struct timecounter *tc)
 143 {
 144         return (inl(geode_counter));
 145 }
 146
 147 static struct timecounter geode_timecounter = {
 148         geode_get_timecount,
 149         NULL,
 150         0xffffffff,
 151         27000000,
 152         "Geode",
 153         1000
 154 };
 155
 156 static uint64_t
 157 geode_cputicks(void)
 158 {
 159         unsigned c;
 160         static unsigned last;
 161         static uint64_t offset;
 162
 163         c = inl(geode_counter);
 164         if (c < last)
 165                 offset += (1LL << 32);
 166         last = c;
 167         return (offset | c);
 168 }
 169
 170 /*
 171  * The GEODE watchdog runs from a 32kHz frequency.  One period of that is
 172  * 31250 nanoseconds which we round down to 2^14 nanoseconds.  The watchdog
 173  * consists of a power-of-two prescaler and a 16 bit counter, so the math
 174  * is quite simple.  The max timeout is 14 + 16 + 13 = 2^43 nsec ~= 2h26m.
 175  */
 176 static void
 177 geode_watchdog(void *foo __unused, u_int cmd, int *error)
 178 {
 179         u_int u, p, r;
 180
 181         u = cmd & WD_INTERVAL;
 182         if (u >= 14 && u <= 43) {
 183                 u -= 14;
 184                 if (u > 16) {
 185                         p = u - 16;
 186                         u -= p;
 187                 } else {
 188                         p = 0;
 189                 }
 190                 if (u == 16)
 191                         u = (1 << u) - 1;
 192                 else
 193                         u = 1 << u;
 194                 r = inw(cba + 2) & 0xff00;
 195                 outw(cba + 2, p | 0xf0 | r);
 196                 outw(cba, u);
 197                 *error = 0;
 198         } else {
 199                 outw(cba, 0);
 200         }
 201 }
 202
 203 /*
 204  * We run MFGPT0 off the 32kHz frequency and prescale by 16384 giving a
 205  * period of half a second.
 206  * Range becomes 2^30 (= 1 sec) to 2^44 (almost 5 hours)
 207  */
 208 static void
 209 cs5536_watchdog(void *foo __unused, u_int cmd, int *error)
 210 {
 211         u_int u, p;
 212         uint16_t a;
 213         uint32_t m;
 214
 215         a = rdmsr(0x5140000d);
 216         m = rdmsr(0x51400029);
 217         m &= ~(1 << 24);
 218         wrmsr(0x51400029, m);
 219
 220         u = cmd & WD_INTERVAL;
 221         if (u >= 30 && u <= 44) {
 222                 p = 1 << (u - 29);
 223
 224                 /* Set up MFGPT0, 32khz, prescaler 16k, C2 event */
 225                 outw(a + 6, 0x030e);
 226                 /* set comparator 2 */
 227                 outw(a + 2, p);
 228                 /* reset counter */
 229                 outw(a + 4, 0);
 230                 /* Arm reset mechanism */
 231                 m |= (1 << 24);
 232                 wrmsr(0x51400029, m);
 233                 /* Start counter */
 234                 outw(a + 6, 0x8000);
 235
 236                 *error = 0;
 237         }
 238 }
 239
 240 /*
 241  * The Advantech PCM-582x watchdog expects 0x1 at I/O port 0x0443
 242  * every 1.6 secs +/- 30%. Writing 0x0 disables the watchdog
 243  * NB: reading the I/O port enables the timer as well
 244  */
 245 static void
 246 advantech_watchdog(void *foo __unused, u_int cmd, int *error)
 247 {
 248         u_int u;
 249
 250         u = cmd & WD_INTERVAL;
 251         if (u > 0 && u <= WD_TO_1SEC) {
 252                 outb(0x0443, 1);
 253                 *error = 0;
 254         } else {
 255                 outb(0x0443, 0);
 256         }
 257 }
 258
 259 static int
 260 geode_probe(device_t self)
 261 {
 262 #define BIOS_OEM_MAXLEN 80
 263         static u_char bios_oem[BIOS_OEM_MAXLEN] = "\0";
 264
 265         switch (pci_get_devid(self)) {
 266         case 0x0515100b:
 267                 if (geode_counter == 0) {
 268                         /*
 269                          * The address of the CBA is written to this register
 270                          * by the bios, see p161 in data sheet.
 271                          */
 272                         cba = pci_read_config(self, 0x64, 4);
 273                         if (bootverbose)
 274                                 printf("Geode CBA@ 0x%x\n", cba);
 275                         geode_counter = cba + 0x08;
 276                         outl(cba + 0x0d, 2);
 277                         if (bootverbose)
 278                                 printf("Geode rev: %02x %02x\n",
 279                                         inb(cba + 0x3c), inb(cba + 0x3d));
 280                         tc_init(&geode_timecounter);
 281                         EVENTHANDLER_REGISTER(watchdog_list, geode_watchdog,
 282                             NULL, 0);
 283                         set_cputicker(geode_cputicks, 27000000, 0);
 284                 }
 285                 break;
 286         case 0x0510100b:
 287                 gpio = pci_read_config(self, PCIR_BAR(0), 4);
 288                 gpio &= ~0x1f;
 289                 if (bootverbose)
 290                         printf("Geode GPIO@ = %x\n", gpio);
 291                 if (bios_oem_strings(&bios_soekris,
 292                     bios_oem, sizeof bios_oem) > 0 ) {
 293                         led1b = 20;
 294                         led1 = led_create(led_func, &led1b, "error");
 295                 } else if (bios_oem_strings(&bios_pcengines,
 296                     bios_oem, sizeof bios_oem) > 0 ) {
 297                         led1b = -2;
 298                         led2b = -3;
 299                         led3b = -18;
 300                         led1 = led_create(led_func, &led1b, "led1");
 301                         led2 = led_create(led_func, &led2b, "led2");
 302                         led3 = led_create(led_func, &led3b, "led3");
 303                         /*
 304                         * Turn on first LED so we don't make
 305                         * people think their box just died.
 306                         */
 307                         led_func(&led1b, 1);
 308                 }
 309                 if (*bios_oem)
 310                         printf("Geode %s\n", bios_oem);
 311                 break;
 312         case 0x01011078:
 313                 if (bios_oem_strings(&bios_advantech,
 314                     bios_oem, sizeof bios_oem) > 0 ) {
 315                         printf("Geode %s\n", bios_oem);
 316                         EVENTHANDLER_REGISTER(watchdog_list, advantech_watchdog,
 317                             NULL, 0);
 318                 }
 319                 break;
 320         case 0x20801022:
 321                 if (bios_oem_strings(&bios_soekris_55,
 322                     bios_oem, sizeof bios_oem) > 0 ) {
 323                         led1b = 6;
 324                         led1 = led_create(cs5536_led_func, &led1b, "error");
 325                 } else if (bios_oem_strings(&bios_pcengines_55,
 326                     bios_oem, sizeof bios_oem) > 0 ) {
 327                         led1b = -6;
 328                         led2b = -25;
 329                         led3b = -27;
 330                         led1 = led_create(cs5536_led_func, &led1b, "led1");
 331                         led2 = led_create(cs5536_led_func, &led2b, "led2");
 332                         led3 = led_create(cs5536_led_func, &led3b, "led3");
 333                         /*
 334                         * Turn on first LED so we don't make
 335                         * people think their box just died.
 336                         */
 337                         cs5536_led_func(&led1b, 1);
 338                 }
 339                 if (*bios_oem)
 340                         printf("Geode LX: %s\n", bios_oem);
 341                 if (bootverbose)
 342                         printf("MFGPT bar: %jx\n", rdmsr(0x5140000d));
 343                 EVENTHANDLER_REGISTER(watchdog_list, cs5536_watchdog, NULL, 0);
 344                 break;
 345         }
 346         return (ENXIO);
 347 }
 348
 349 static int
 350 geode_attach(device_t self)
 351 {
 352
 353         return(ENODEV);
 354 }
 355
 356 static device_method_t geode_methods[] = {
 357         /* Device interface */
 358         DEVMETHOD(device_probe,         geode_probe),
 359         DEVMETHOD(device_attach,        geode_attach),
 360         DEVMETHOD(device_suspend,       bus_generic_suspend),
 361         DEVMETHOD(device_resume,        bus_generic_resume),
 362         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
 363         {0, 0}
 364 };
 365
 366 static driver_t geode_driver = {
 367         "geode",
 368         geode_methods,
 369         0,
 370 };
 371
 372 static devclass_t geode_devclass;
 373
 374 DRIVER_MODULE(geode, pci, geode_driver, geode_devclass, 0, 0);