sys/dev/powermac_nvram/powermac_nvram.c

   1 /*
   2  * Copyright (c) 2006 Maxim Sobolev <sobomax@FreeBSD.org>
   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 ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  18  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  20  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  22  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  23  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  24  * POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #include <sys/param.h>
  30 #include <sys/systm.h>
  31 #include <sys/module.h>
  32 #include <sys/bus.h>
  33 #include <sys/conf.h>
  34 #include <sys/kernel.h>
  35 #include <sys/uio.h>
  36
  37 #include <dev/ofw/openfirm.h>
  38 #include <dev/ofw/ofw_pci.h>
  39
  40 #include <machine/bus.h>
  41 #include <machine/md_var.h>
  42 #include <machine/nexusvar.h>
  43 #include <machine/pio.h>
  44 #include <machine/resource.h>
  45
  46 #include <sys/rman.h>
  47
  48 #include <powerpc/ofw/ofw_pci.h>
  49 #include <dev/powermac_nvram/powermac_nvramvar.h>
  50
  51 #include <vm/vm.h>
  52 #include <vm/pmap.h>
  53
  54 /*
  55  * Device interface.
  56  */
  57 static int              powermac_nvram_probe(device_t);
  58 static int              powermac_nvram_attach(device_t);
  59 static int              powermac_nvram_detach(device_t);
  60
  61 /* Helper functions */
  62 static int              powermac_nvram_check(void *data);
  63 static int              chrp_checksum(int sum, uint8_t *, uint8_t *);
  64 static uint32_t         adler_checksum(uint8_t *, int);
  65 static int              erase_bank(device_t, uint8_t *);
  66 static int              write_bank(device_t, uint8_t *, uint8_t *);
  67
  68 /*
  69  * Driver methods.
  70  */
  71 static device_method_t  powermac_nvram_methods[] = {
  72         /* Device interface */
  73         DEVMETHOD(device_probe,         powermac_nvram_probe),
  74         DEVMETHOD(device_attach,        powermac_nvram_attach),
  75         DEVMETHOD(device_detach,        powermac_nvram_detach),
  76
  77         { 0, 0 }
  78 };
  79
  80 static driver_t powermac_nvram_driver = {
  81         "powermac_nvram",
  82         powermac_nvram_methods,
  83         sizeof(struct powermac_nvram_softc)
  84 };
  85
  86 static devclass_t powermac_nvram_devclass;
  87
  88 DRIVER_MODULE(powermac_nvram, nexus, powermac_nvram_driver, powermac_nvram_devclass, 0, 0);
  89
  90 /*
  91  * Cdev methods.
  92  */
  93
  94 #define NVRAM_UNIT(dev)         dev2unit(dev)
  95 #define NVRAM_SOFTC(unit)       ((struct powermac_nvram_softc *) \
  96      devclass_get_softc(powermac_nvram_devclass, unit))
  97
  98 static  d_open_t        powermac_nvram_open;
  99 static  d_close_t       powermac_nvram_close;
 100 static  d_read_t        powermac_nvram_read;
 101 static  d_write_t       powermac_nvram_write;
 102
 103 static struct cdevsw powermac_nvram_cdevsw = {
 104         .d_version =    D_VERSION,
 105         .d_flags =      D_NEEDGIANT,
 106         .d_open =       powermac_nvram_open,
 107         .d_close =      powermac_nvram_close,
 108         .d_read =       powermac_nvram_read,
 109         .d_write =      powermac_nvram_write,
 110         .d_name =       "powermac_nvram",
 111 };
 112
 113 static int
 114 powermac_nvram_probe(device_t dev)
 115 {
 116         char    *type, *compatible;
 117
 118         type = nexus_get_device_type(dev);
 119         compatible = nexus_get_compatible(dev);
 120
 121         if (type == NULL || compatible == NULL)
 122                 return ENXIO;
 123
 124         if (strcmp(type, "nvram") != 0 || strcmp(compatible, "amd-0137") != 0)
 125                 return ENXIO;
 126
 127         device_set_desc(dev, "Apple NVRAM");
 128         return 0;
 129 }
 130
 131 static int
 132 powermac_nvram_attach(device_t dev)
 133 {
 134         struct powermac_nvram_softc *sc;
 135         phandle_t node;
 136         u_int32_t reg[2];
 137         int gen0, gen1;
 138
 139         node = nexus_get_node(dev);
 140         sc = device_get_softc(dev);
 141
 142         if (OF_getprop(node, "reg", reg, sizeof(reg)) < 8)
 143                 return ENXIO;
 144
 145         sc->sc_dev = dev;
 146         sc->sc_node = node;
 147
 148         sc->sc_bank0 = (vm_offset_t)pmap_mapdev(reg[0], NVRAM_SIZE * 2);
 149         sc->sc_bank1 = sc->sc_bank0 + NVRAM_SIZE;
 150
 151         gen0 = powermac_nvram_check((void *)sc->sc_bank0);
 152         gen1 = powermac_nvram_check((void *)sc->sc_bank1);
 153
 154         if (gen0 == -1 && gen1 == -1) {
 155                 if ((void *)sc->sc_bank0 != NULL)
 156                         pmap_unmapdev(sc->sc_bank0, NVRAM_SIZE * 2);
 157                 device_printf(dev, "both banks appear to be corrupt\n");
 158                 return ENXIO;
 159         }
 160         device_printf(dev, "bank0 generation %d, bank1 generation %d\n",
 161             gen0, gen1);
 162
 163         sc->sc_bank = (gen0 > gen1) ? sc->sc_bank0 : sc->sc_bank1;
 164         bcopy((void *)sc->sc_bank, (void *)sc->sc_data, NVRAM_SIZE);
 165
 166         sc->sc_cdev = make_dev(&powermac_nvram_cdevsw, 0, 0, 0, 0600,
 167             "powermac_nvram");
 168
 169         return 0;
 170 }
 171
 172 static int
 173 powermac_nvram_detach(device_t dev)
 174 {
 175         struct powermac_nvram_softc *sc;
 176
 177         sc = device_get_softc(dev);
 178
 179         if ((void *)sc->sc_bank0 != NULL)
 180                 pmap_unmapdev(sc->sc_bank0, NVRAM_SIZE * 2);
 181
 182         if (sc->sc_cdev != NULL)
 183                 destroy_dev(sc->sc_cdev);
 184
 185         return 0;
 186 }
 187
 188 static int
 189 powermac_nvram_open(struct cdev *dev, int flags, int fmt, struct thread *td)
 190 {
 191         struct powermac_nvram_softc *sc;
 192
 193         sc = NVRAM_SOFTC(NVRAM_UNIT(dev));
 194         if (sc->sc_isopen)
 195                 return EBUSY;
 196         sc->sc_isopen = 1;
 197         sc->sc_rpos = sc->sc_wpos = 0;
 198         return 0;
 199 }
 200
 201 static int
 202 powermac_nvram_close(struct cdev *dev, int fflag, int devtype, struct thread *td)
 203 {
 204         struct powermac_nvram_softc *sc;
 205         struct core99_header *header;
 206         vm_offset_t bank;
 207
 208         sc = NVRAM_SOFTC(NVRAM_UNIT(dev));
 209
 210         if (sc->sc_wpos != sizeof(sc->sc_data)) {
 211                 /* Short write, restore in-memory copy */
 212                 bcopy((void *)sc->sc_bank, (void *)sc->sc_data, NVRAM_SIZE);
 213                 sc->sc_isopen = 0;
 214                 return 0;
 215         }
 216
 217         header = (struct core99_header *)sc->sc_data;
 218
 219         header->generation = ((struct core99_header *)sc->sc_bank)->generation;
 220         header->generation++;
 221         header->chrp_header.signature = CORE99_SIGNATURE;
 222
 223         header->adler_checksum =
 224             adler_checksum((uint8_t *)&(header->generation),
 225             NVRAM_SIZE - offsetof(struct core99_header, generation));
 226         header->chrp_header.chrp_checksum = chrp_checksum(header->chrp_header.signature,
 227             (uint8_t *)&(header->chrp_header.length),
 228             (uint8_t *)&(header->adler_checksum));
 229
 230         bank = (sc->sc_bank == sc->sc_bank0) ? sc->sc_bank1 : sc->sc_bank0;
 231         if (erase_bank(sc->sc_dev, (uint8_t *)bank) != 0 ||
 232             write_bank(sc->sc_dev, (uint8_t *)bank, sc->sc_data) != 0) {
 233                 sc->sc_isopen = 0;
 234                 return ENOSPC;
 235         }
 236         sc->sc_bank = bank;
 237         sc->sc_isopen = 0;
 238         return 0;
 239 }
 240
 241 static int
 242 powermac_nvram_read(struct cdev *dev, struct uio *uio, int ioflag)
 243 {
 244         int rv, amnt, data_available;
 245         struct powermac_nvram_softc *sc;
 246
 247         sc = NVRAM_SOFTC(NVRAM_UNIT(dev));
 248
 249         rv = 0;
 250         while (uio->uio_resid > 0) {
 251                 data_available = sizeof(sc->sc_data) - sc->sc_rpos;
 252                 if (data_available > 0) {
 253                         amnt = MIN(uio->uio_resid, data_available);
 254                         rv = uiomove((void *)(sc->sc_data + sc->sc_rpos),
 255                             amnt, uio);
 256                         if (rv != 0)
 257                                 break;
 258                         sc->sc_rpos += amnt;
 259                 } else {
 260                         break;
 261                 }
 262         }
 263         return rv;
 264 }
 265
 266 static int
 267 powermac_nvram_write(struct cdev *dev, struct uio *uio, int ioflag)
 268 {
 269         int rv, amnt, data_available;
 270         struct powermac_nvram_softc *sc;
 271
 272         sc = NVRAM_SOFTC(NVRAM_UNIT(dev));
 273
 274         if (sc->sc_wpos >= sizeof(sc->sc_data))
 275                 return EINVAL;
 276
 277         rv = 0;
 278         while (uio->uio_resid > 0) {
 279                 data_available = sizeof(sc->sc_data) - sc->sc_wpos;
 280                 if (data_available > 0) {
 281                         amnt = MIN(uio->uio_resid, data_available);
 282                         rv = uiomove((void *)(sc->sc_data + sc->sc_wpos),
 283                             amnt, uio);
 284                         if (rv != 0)
 285                                 break;
 286                         sc->sc_wpos += amnt;
 287                 } else {
 288                         break;
 289                 }
 290         }
 291         return rv;
 292 }
 293
 294 static int
 295 powermac_nvram_check(void *data)
 296 {
 297         struct core99_header *header;
 298
 299         header = (struct core99_header *)data;
 300
 301         if (header->chrp_header.signature != CORE99_SIGNATURE)
 302                 return -1;
 303         if (header->chrp_header.chrp_checksum !=
 304             chrp_checksum(header->chrp_header.signature,
 305             (uint8_t *)&(header->chrp_header.length),
 306             (uint8_t *)&(header->adler_checksum)))
 307                 return -1;
 308         if (header->adler_checksum !=
 309             adler_checksum((uint8_t *)&(header->generation),
 310             NVRAM_SIZE - offsetof(struct core99_header, generation)))
 311                 return -1;
 312         return header->generation;
 313 }
 314
 315 static int
 316 chrp_checksum(int sum, uint8_t *data, uint8_t *end)
 317 {
 318
 319         for (; data < end; data++)
 320                 sum += data[0];
 321         while (sum > 0xff)
 322                 sum = (sum & 0xff) + (sum >> 8);
 323         return sum;
 324 }
 325
 326 static uint32_t
 327 adler_checksum(uint8_t *data, int len)
 328 {
 329         uint32_t low, high;
 330         int i;
 331
 332         low = 1;
 333         high = 0;
 334         for (i = 0; i < len; i++) {
 335                 if ((i % 5000) == 0) {
 336                         high %= 65521UL;
 337                         high %= 65521UL;
 338                 }
 339                 low += data[i];
 340                 high += low;
 341         }
 342         low %= 65521UL;
 343         high %= 65521UL;
 344
 345         return (high << 16) | low;
 346 }
 347
 348 #define OUTB_DELAY(a, v)        outb(a, v); DELAY(1);
 349
 350 static int
 351 wait_operation_complete(uint8_t *bank)
 352 {
 353         int i;
 354
 355         for (i = 1000000; i != 0; i--)
 356                 if ((inb(bank) ^ inb(bank)) == 0)
 357                         return 0;
 358         return -1;
 359 }
 360
 361 static int
 362 erase_bank(device_t dev, uint8_t *bank)
 363 {
 364         unsigned int i;
 365
 366         /* Unlock 1 */
 367         OUTB_DELAY(bank + 0x555, 0xaa);
 368         /* Unlock 2 */
 369         OUTB_DELAY(bank + 0x2aa, 0x55);
 370
 371         /* Sector-Erase */
 372         OUTB_DELAY(bank + 0x555, 0x80);
 373         OUTB_DELAY(bank + 0x555, 0xaa);
 374         OUTB_DELAY(bank + 0x2aa, 0x55);
 375         OUTB_DELAY(bank, 0x30);
 376
 377         if (wait_operation_complete(bank) != 0) {
 378                 device_printf(dev, "flash erase timeout\n");
 379                 return -1;
 380         }
 381
 382         /* Reset */
 383         OUTB_DELAY(bank, 0xf0);
 384
 385         for (i = 0; i < NVRAM_SIZE; i++) {
 386                 if (bank[i] != 0xff) {
 387                         device_printf(dev, "flash erase has failed\n");
 388                         return -1;
 389                 }
 390         }
 391         return 0;
 392 }
 393
 394 static int
 395 write_bank(device_t dev, uint8_t *bank, uint8_t *data)
 396 {
 397         unsigned int i;
 398
 399         for (i = 0; i < NVRAM_SIZE; i++) {
 400                 /* Unlock 1 */
 401                 OUTB_DELAY(bank + 0x555, 0xaa);
 402                 /* Unlock 2 */
 403                 OUTB_DELAY(bank + 0x2aa, 0x55);
 404
 405                 /* Write single word */
 406                 OUTB_DELAY(bank + 0x555, 0xa0);
 407                 OUTB_DELAY(bank + i, data[i]);
 408                 if (wait_operation_complete(bank) != 0) {
 409                         device_printf(dev, "flash write timeout\n");
 410                         return -1;
 411                 }
 412         }
 413
 414         /* Reset */
 415         OUTB_DELAY(bank, 0xf0);
 416
 417         for (i = 0; i < NVRAM_SIZE; i++) {
 418                 if (bank[i] != data[i]) {
 419                         device_printf(dev, "flash write has failed\n");
 420                         return -1;
 421                 }
 422         }
 423         return 0;
 424 }