sys/dev/acpi_support/acpi_rapidstart.c

   1 /*-
   2  * Copyright (c) 2013 Takanori Watanabe
   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 "opt_acpi.h"
  31 #include <sys/param.h>
  32 #include <sys/kernel.h>
  33 #include <sys/bus.h>
  34
  35 #include <contrib/dev/acpica/include/acpi.h>
  36
  37 #include "acpi_if.h"
  38 #include <sys/module.h>
  39 #include <dev/acpica/acpivar.h>
  40 #include <sys/sysctl.h>
  41 static int sysctl_acpi_rapidstart_gen_handler(SYSCTL_HANDLER_ARGS);
  42
  43 static struct acpi_rapidstart_name_list
  44 {
  45         char *nodename;
  46         char *getmethod;
  47         char *setmethod;
  48         char *comment;
  49 } acpi_rapidstart_oids[] ={
  50         {"ffs","GFFS","SFFS","Flash Fast Store Flag"},
  51         {"ftv","GFTV","SFTV","Time value"},
  52         {NULL, NULL, NULL, NULL}
  53 };
  54
  55 struct acpi_rapidstart_softc {
  56         struct sysctl_ctx_list  *sysctl_ctx;
  57         struct sysctl_oid       *sysctl_tree;
  58
  59 };
  60 static char    *rapidstart_ids[] = {"INT3392", NULL};
  61 static int
  62 acpi_rapidstart_probe(device_t dev)
  63 {
  64         int rv;
  65
  66         if (acpi_disabled("rapidstart") ||
  67             device_get_unit(dev) != 0)
  68                 return (ENXIO);
  69         rv = ACPI_ID_PROBE(device_get_parent(dev), dev, rapidstart_ids, NULL);
  70         if (rv <= 0)
  71                 device_set_desc(dev, "Intel Rapid Start ACPI device");
  72
  73         return (rv);
  74
  75 }
  76
  77 static int
  78 acpi_rapidstart_attach(device_t dev)
  79 {
  80         struct acpi_rapidstart_softc *sc;
  81         int i;
  82
  83         sc = device_get_softc(dev);
  84
  85         sc->sysctl_ctx = device_get_sysctl_ctx(dev);
  86         sc->sysctl_tree = device_get_sysctl_tree(dev);
  87         for (i = 0 ; acpi_rapidstart_oids[i].nodename != NULL; i++){
  88                 if (acpi_rapidstart_oids[i].setmethod != NULL) {
  89                         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
  90                             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
  91                             i, acpi_rapidstart_oids[i].nodename,
  92                             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
  93                             dev, i, sysctl_acpi_rapidstart_gen_handler, "I",
  94                             acpi_rapidstart_oids[i].comment);
  95                 } else {
  96                         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
  97                             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
  98                             i, acpi_rapidstart_oids[i].nodename,
  99                             CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
 100                             dev, i, sysctl_acpi_rapidstart_gen_handler, "I",
 101                             acpi_rapidstart_oids[i].comment);
 102                 }
 103         }
 104         return (0);
 105 }
 106
 107 static int
 108 sysctl_acpi_rapidstart_gen_handler(SYSCTL_HANDLER_ARGS)
 109 {
 110         device_t        dev = arg1;
 111         int     function = oidp->oid_arg2;
 112         int             error = 0, val;
 113
 114         acpi_GetInteger(acpi_get_handle(dev),
 115             acpi_rapidstart_oids[function].getmethod, &val);
 116         error = sysctl_handle_int(oidp, &val, 0, req);
 117         if (error || !req->newptr || !acpi_rapidstart_oids[function].setmethod)
 118                 return (error);
 119         acpi_SetInteger(acpi_get_handle(dev),
 120             acpi_rapidstart_oids[function].setmethod, val);
 121         return (0);
 122 }
 123
 124 static device_method_t acpi_rapidstart_methods[] = {
 125         /* Device interface */
 126         DEVMETHOD(device_probe, acpi_rapidstart_probe),
 127         DEVMETHOD(device_attach, acpi_rapidstart_attach),
 128
 129         DEVMETHOD_END
 130 };
 131
 132 static driver_t acpi_rapidstart_driver = {
 133         "acpi_rapidstart",
 134         acpi_rapidstart_methods,
 135         sizeof(struct acpi_rapidstart_softc),
 136 };
 137
 138 static devclass_t acpi_rapidstart_devclass;
 139
 140 DRIVER_MODULE(acpi_rapidstart, acpi, acpi_rapidstart_driver, acpi_rapidstart_devclass,
 141               0, 0);
 142 MODULE_DEPEND(acpi_rapidstart, acpi, 1, 1, 1);