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/i386/bios/smapi.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2003 Matthew N. Dodd <winter@jurai.net>
    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/kernel.h>
   33 
   34 #include <sys/module.h>
   35 #include <sys/bus.h>
   36 #include <sys/conf.h>
   37 
   38 #include <machine/bus.h>
   39 #include <machine/resource.h>
   40 #include <sys/rman.h>
   41 
   42 /* And all this for BIOS_PADDRTOVADDR() */
   43 #include <vm/vm.h>
   44 #include <vm/vm_param.h>
   45 #include <vm/pmap.h>
   46 #include <machine/md_var.h>
   47 #include <machine/pc/bios.h>
   48 
   49 #include <machine/smapi.h>
   50 
   51 #define SMAPI_START     0xf0000
   52 #define SMAPI_STEP      0x10
   53 #define SMAPI_OFF       0
   54 #define SMAPI_LEN       4
   55 #define SMAPI_SIG       "$SMB"
   56 
   57 #define RES2HDR(res)    ((struct smapi_bios_header *)rman_get_virtual(res))
   58 #define ADDR2HDR(addr)  ((struct smapi_bios_header *)BIOS_PADDRTOVADDR(addr))
   59 
   60 struct smapi_softc {
   61         struct cdev *cdev;
   62         device_t                dev;
   63         struct resource *       res;
   64         int                     rid;
   65 
   66         u_int32_t               smapi32_entry;
   67 
   68         struct smapi_bios_header *header;
   69 };
   70 
   71 extern u_long smapi32_offset;
   72 extern u_short smapi32_segment;
   73 
   74 devclass_t smapi_devclass;
   75 
   76 static d_ioctl_t smapi_ioctl;
   77 
   78 static struct cdevsw smapi_cdevsw = {
   79         .d_version =    D_VERSION,
   80         .d_ioctl =      smapi_ioctl,
   81         .d_name =       "smapi",
   82         .d_flags =      D_MEM | D_NEEDGIANT,
   83 };
   84 
   85 static void     smapi_identify          (driver_t *, device_t);
   86 static int      smapi_probe             (device_t);
   87 static int      smapi_attach            (device_t);
   88 static int      smapi_detach            (device_t);
   89 static int      smapi_modevent          (module_t, int, void *);
   90                 
   91 static int      smapi_header_cksum      (struct smapi_bios_header *);
   92 
   93 extern int      smapi32                 (struct smapi_bios_parameter *,
   94                                          struct smapi_bios_parameter *);
   95 extern int      smapi32_new             (u_long, u_short,
   96                                          struct smapi_bios_parameter *,
   97                                          struct smapi_bios_parameter *);
   98 
   99 static int
  100 smapi_ioctl (dev, cmd, data, fflag, td)
  101         struct cdev *dev;
  102         u_long          cmd;
  103         caddr_t         data;
  104         int             fflag;
  105         d_thread_t *    td;
  106 {
  107         struct smapi_softc *sc;
  108         int error;
  109 
  110         error = 0;
  111         sc = devclass_get_softc(smapi_devclass, minor(dev)); 
  112         if (sc == NULL) {
  113                 error = ENXIO;
  114                 goto fail;
  115         }
  116 
  117         switch (cmd) {
  118         case SMAPIOGHEADER:
  119                 bcopy((caddr_t)sc->header, data,
  120                                 sizeof(struct smapi_bios_header)); 
  121                 error = 0;
  122                 break;
  123         case SMAPIOCGFUNCTION:
  124                 smapi32_offset = sc->smapi32_entry;
  125                 error = smapi32((struct smapi_bios_parameter *)data,
  126                                 (struct smapi_bios_parameter *)data);
  127                 break;
  128         default:
  129                 error = ENOTTY;
  130         }
  131 
  132 fail:
  133         return (error);
  134 }
  135 
  136 static int
  137 smapi_header_cksum (struct smapi_bios_header *header)
  138 {
  139         u_int8_t *ptr;
  140         u_int8_t cksum;
  141         int i;
  142 
  143         ptr = (u_int8_t *)header;
  144         cksum = 0;
  145         for (i = 0; i < header->length; i++) {
  146                 cksum += ptr[i];        
  147         }
  148 
  149         return (cksum);
  150 }
  151 
  152 static void
  153 smapi_identify (driver_t *driver, device_t parent)
  154 {
  155         device_t child;
  156         u_int32_t addr;
  157         int length;
  158         int rid;
  159 
  160         if (!device_is_alive(parent))
  161                 return;
  162 
  163         addr = bios_sigsearch(SMAPI_START, SMAPI_SIG, SMAPI_LEN,
  164                               SMAPI_STEP, SMAPI_OFF);
  165         if (addr != 0) {
  166                 rid = 0;
  167                 length = ADDR2HDR(addr)->length;
  168 
  169                 child = BUS_ADD_CHILD(parent, 0, "smapi", -1);
  170                 device_set_driver(child, driver);
  171                 bus_set_resource(child, SYS_RES_MEMORY, rid, addr, length);
  172                 device_set_desc(child, "SMAPI BIOS");
  173         }
  174 
  175         return;
  176 }
  177 
  178 static int
  179 smapi_probe (device_t dev)
  180 {
  181         struct resource *res;
  182         int rid;
  183         int error;
  184 
  185         error = 0;
  186         rid = 0;
  187         res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, RF_ACTIVE);
  188         if (res == NULL) {
  189                 device_printf(dev, "Unable to allocate memory resource.\n");
  190                 error = ENOMEM;
  191                 goto bad;
  192         }
  193 
  194         if (smapi_header_cksum(RES2HDR(res))) {
  195                 device_printf(dev, "SMAPI header checksum failed.\n");
  196                 error = ENXIO;
  197                 goto bad;
  198         }
  199 
  200 bad:
  201         if (res)
  202                 bus_release_resource(dev, SYS_RES_MEMORY, rid, res);
  203         return (error);
  204 }
  205 
  206 static int
  207 smapi_attach (device_t dev)
  208 {
  209         struct smapi_softc *sc;
  210         int error;
  211 
  212         sc = device_get_softc(dev);
  213         error = 0;
  214 
  215         sc->dev = dev;
  216         sc->rid = 0;
  217         sc->res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sc->rid,
  218                  RF_ACTIVE);
  219         if (sc->res == NULL) {
  220                 device_printf(dev, "Unable to allocate memory resource.\n");
  221                 error = ENOMEM;
  222                 goto bad;
  223         }
  224         sc->header = (struct smapi_bios_header *)rman_get_virtual(sc->res);
  225         sc->smapi32_entry = (u_int32_t)BIOS_PADDRTOVADDR(
  226                                         sc->header->prot32_segment +
  227                                         sc->header->prot32_offset);
  228 
  229         sc->cdev = make_dev(&smapi_cdevsw,
  230                         device_get_unit(sc->dev),
  231                         UID_ROOT, GID_WHEEL, 0600,
  232                         "%s%d",
  233                         smapi_cdevsw.d_name,
  234                         device_get_unit(sc->dev));
  235 
  236         device_printf(dev, "Version: %d.%02d, Length: %d, Checksum: 0x%02x\n",
  237                 bcd2bin(sc->header->version_major),
  238                 bcd2bin(sc->header->version_minor),
  239                 sc->header->length,
  240                 sc->header->checksum);
  241         device_printf(dev, "Information=0x%b\n",
  242                 sc->header->information,
  243                 "\020"
  244                 "\001REAL_VM86"
  245                 "\002PROTECTED_16"
  246                 "\003PROTECTED_32");
  247 
  248         if (bootverbose) {
  249                 if (sc->header->information & SMAPI_REAL_VM86)
  250                         device_printf(dev, "Real/VM86 mode: Segment 0x%04x, Offset 0x%04x\n",
  251                                 sc->header->real16_segment,
  252                                 sc->header->real16_offset);
  253                 if (sc->header->information & SMAPI_PROT_16BIT)
  254                         device_printf(dev, "16-bit Protected mode: Segment 0x%08x, Offset 0x%04x\n",
  255                                 sc->header->prot16_segment,
  256                                 sc->header->prot16_offset);
  257                 if (sc->header->information & SMAPI_PROT_32BIT)
  258                         device_printf(dev, "32-bit Protected mode: Segment 0x%08x, Offset 0x%08x\n",
  259                                 sc->header->prot32_segment,
  260                                 sc->header->prot32_offset);
  261         }
  262 
  263         return (0);
  264 bad:
  265         if (sc->res)
  266                 bus_release_resource(dev, SYS_RES_MEMORY, sc->rid, sc->res);
  267         return (error);
  268 }
  269 
  270 static int
  271 smapi_detach (device_t dev)
  272 {
  273         struct smapi_softc *sc;
  274 
  275         sc = device_get_softc(dev);
  276 
  277         destroy_dev(sc->cdev);
  278 
  279         if (sc->res)
  280                 bus_release_resource(dev, SYS_RES_MEMORY, sc->rid, sc->res);
  281 
  282         return (0);
  283 }
  284 
  285 static int
  286 smapi_modevent (mod, what, arg)
  287         module_t        mod;
  288         int             what;
  289         void *          arg;
  290 {
  291         device_t *      devs;
  292         int             count;
  293         int             i;
  294 
  295         switch (what) {
  296         case MOD_LOAD:
  297                 break;
  298         case MOD_UNLOAD:
  299                 devclass_get_devices(smapi_devclass, &devs, &count);
  300                 for (i = 0; i < count; i++) {
  301                         device_delete_child(device_get_parent(devs[i]), devs[i]);
  302                 }
  303                 break;
  304         default:
  305                 break;
  306         }
  307 
  308         return (0);
  309 }
  310 
  311 static device_method_t smapi_methods[] = {
  312         /* Device interface */
  313         DEVMETHOD(device_identify,      smapi_identify),
  314         DEVMETHOD(device_probe,         smapi_probe),
  315         DEVMETHOD(device_attach,        smapi_attach),
  316         DEVMETHOD(device_detach,        smapi_detach),
  317         { 0, 0 }
  318 };
  319 
  320 static driver_t smapi_driver = {
  321         "smapi",
  322         smapi_methods,
  323         sizeof(struct smapi_softc),
  324 };
  325 
  326 DRIVER_MODULE(smapi, nexus, smapi_driver, smapi_devclass, smapi_modevent, 0);
  327 MODULE_VERSION(smapi, 1);

Cache object: 607d7905e20e49df4066a6c6b1bff99e


[ 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.