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/acpica/acpi_machdep.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) 2001 Mitsuru IWASAKI
    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/bus.h>
   32 #include <sys/condvar.h>
   33 #include <sys/conf.h>
   34 #include <sys/fcntl.h>
   35 #include <sys/kernel.h>
   36 #include <sys/malloc.h>
   37 #include <sys/poll.h>
   38 #include <sys/sysctl.h>
   39 #include <sys/uio.h>
   40 #include <vm/vm.h>
   41 #include <vm/pmap.h>
   42 
   43 #include <contrib/dev/acpica/acpi.h>
   44 #include <dev/acpica/acpivar.h>
   45 #include <dev/acpica/acpiio.h>
   46 
   47 /*
   48  * APM driver emulation 
   49  */
   50 
   51 #include <machine/apm_bios.h>
   52 #include <machine/pc/bios.h>
   53 
   54 #include <i386/bios/apm.h>
   55 
   56 SYSCTL_DECL(_debug_acpi);
   57 
   58 uint32_t acpi_resume_beep;
   59 TUNABLE_INT("debug.acpi.resume_beep", &acpi_resume_beep);
   60 SYSCTL_UINT(_debug_acpi, OID_AUTO, resume_beep, CTLFLAG_RW, &acpi_resume_beep,
   61     0, "Beep the PC speaker when resuming");
   62 uint32_t acpi_reset_video;
   63 TUNABLE_INT("hw.acpi.reset_video", &acpi_reset_video);
   64 
   65 static int intr_model = ACPI_INTR_PIC;
   66 static int apm_active;
   67 static struct clonedevs *apm_clones;
   68 
   69 MALLOC_DEFINE(M_APMDEV, "apmdev", "APM device emulation");
   70 
   71 static d_open_t         apmopen;
   72 static d_close_t        apmclose;
   73 static d_write_t        apmwrite;
   74 static d_ioctl_t        apmioctl;
   75 static d_poll_t         apmpoll;
   76 static d_kqfilter_t     apmkqfilter;
   77 static void             apmreadfiltdetach(struct knote *kn);
   78 static int              apmreadfilt(struct knote *kn, long hint);
   79 static struct filterops apm_readfiltops =
   80         { 1, NULL, apmreadfiltdetach, apmreadfilt };
   81 
   82 static struct cdevsw apm_cdevsw = {
   83         .d_version =    D_VERSION,
   84         .d_flags =      D_TRACKCLOSE,
   85         .d_open =       apmopen,
   86         .d_close =      apmclose,
   87         .d_write =      apmwrite,
   88         .d_ioctl =      apmioctl,
   89         .d_poll =       apmpoll,
   90         .d_name =       "apm",
   91         .d_kqfilter =   apmkqfilter
   92 };
   93 
   94 static int
   95 acpi_capm_convert_battstate(struct  acpi_battinfo *battp)
   96 {
   97         int     state;
   98 
   99         state = APM_UNKNOWN;
  100 
  101         if (battp->state & ACPI_BATT_STAT_DISCHARG) {
  102                 if (battp->cap >= 50)
  103                         state = 0;      /* high */
  104                 else
  105                         state = 1;      /* low */
  106         }
  107         if (battp->state & ACPI_BATT_STAT_CRITICAL)
  108                 state = 2;              /* critical */
  109         if (battp->state & ACPI_BATT_STAT_CHARGING)
  110                 state = 3;              /* charging */
  111 
  112         /* If still unknown, determine it based on the battery capacity. */
  113         if (state == APM_UNKNOWN) {
  114                 if (battp->cap >= 50)
  115                         state = 0;      /* high */
  116                 else
  117                         state = 1;      /* low */
  118         }
  119 
  120         return (state);
  121 }
  122 
  123 static int
  124 acpi_capm_convert_battflags(struct  acpi_battinfo *battp)
  125 {
  126         int     flags;
  127 
  128         flags = 0;
  129 
  130         if (battp->cap >= 50)
  131                 flags |= APM_BATT_HIGH;
  132         else {
  133                 if (battp->state & ACPI_BATT_STAT_CRITICAL)
  134                         flags |= APM_BATT_CRITICAL;
  135                 else
  136                         flags |= APM_BATT_LOW;
  137         }
  138         if (battp->state & ACPI_BATT_STAT_CHARGING)
  139                 flags |= APM_BATT_CHARGING;
  140         if (battp->state == ACPI_BATT_STAT_NOT_PRESENT)
  141                 flags = APM_BATT_NOT_PRESENT;
  142 
  143         return (flags);
  144 }
  145 
  146 static int
  147 acpi_capm_get_info(apm_info_t aip)
  148 {
  149         int     acline;
  150         struct  acpi_battinfo batt;
  151 
  152         aip->ai_infoversion = 1;
  153         aip->ai_major       = 1;
  154         aip->ai_minor       = 2;
  155         aip->ai_status      = apm_active;
  156         aip->ai_capabilities= 0xff00;   /* unknown */
  157 
  158         if (acpi_acad_get_acline(&acline))
  159                 aip->ai_acline = APM_UNKNOWN;   /* unknown */
  160         else
  161                 aip->ai_acline = acline;        /* on/off */
  162 
  163         if (acpi_battery_get_battinfo(NULL, &batt) != 0) {
  164                 aip->ai_batt_stat = APM_UNKNOWN;
  165                 aip->ai_batt_life = APM_UNKNOWN;
  166                 aip->ai_batt_time = -1;          /* unknown */
  167                 aip->ai_batteries = ~0U;         /* unknown */
  168         } else {
  169                 aip->ai_batt_stat = acpi_capm_convert_battstate(&batt);
  170                 aip->ai_batt_life = batt.cap;
  171                 aip->ai_batt_time = (batt.min == -1) ? -1 : batt.min * 60;
  172                 aip->ai_batteries = acpi_battery_get_units();
  173         }
  174 
  175         return (0);
  176 }
  177 
  178 static int
  179 acpi_capm_get_pwstatus(apm_pwstatus_t app)
  180 {
  181         device_t dev;
  182         int     acline, unit, error;
  183         struct  acpi_battinfo batt;
  184 
  185         if (app->ap_device != PMDV_ALLDEV &&
  186             (app->ap_device < PMDV_BATT0 || app->ap_device > PMDV_BATT_ALL))
  187                 return (1);
  188 
  189         if (app->ap_device == PMDV_ALLDEV)
  190                 error = acpi_battery_get_battinfo(NULL, &batt);
  191         else {
  192                 unit = app->ap_device - PMDV_BATT0;
  193                 dev = devclass_get_device(devclass_find("battery"), unit);
  194                 if (dev != NULL)
  195                         error = acpi_battery_get_battinfo(dev, &batt);
  196                 else
  197                         error = ENXIO;
  198         }
  199         if (error)
  200                 return (1);
  201 
  202         app->ap_batt_stat = acpi_capm_convert_battstate(&batt);
  203         app->ap_batt_flag = acpi_capm_convert_battflags(&batt);
  204         app->ap_batt_life = batt.cap;
  205         app->ap_batt_time = (batt.min == -1) ? -1 : batt.min * 60;
  206 
  207         if (acpi_acad_get_acline(&acline))
  208                 app->ap_acline = APM_UNKNOWN;
  209         else
  210                 app->ap_acline = acline;        /* on/off */
  211 
  212         return (0);
  213 }
  214 
  215 /* Create single-use devices for /dev/apm and /dev/apmctl. */
  216 static void
  217 apm_clone(void *arg, struct ucred *cred, char *name, int namelen,
  218     struct cdev **dev)
  219 {
  220         int ctl_dev, unit;
  221 
  222         if (*dev != NULL)
  223                 return;
  224         if (strcmp(name, "apmctl") == 0)
  225                 ctl_dev = TRUE;
  226         else if (strcmp(name, "apm") == 0)
  227                 ctl_dev = FALSE;
  228         else
  229                 return;
  230 
  231         /* Always create a new device and unit number. */
  232         unit = -1;
  233         if (clone_create(&apm_clones, &apm_cdevsw, &unit, dev, 0)) {
  234                 if (ctl_dev) {
  235                         *dev = make_dev(&apm_cdevsw, unit2minor(unit),
  236                             UID_ROOT, GID_OPERATOR, 0660, "apmctl%d", unit);
  237                 } else {
  238                         *dev = make_dev(&apm_cdevsw, unit2minor(unit),
  239                             UID_ROOT, GID_OPERATOR, 0664, "apm%d", unit);
  240                 }
  241                 if (*dev != NULL) {
  242                         dev_ref(*dev);
  243                         (*dev)->si_flags |= SI_CHEAPCLONE;
  244                 }
  245         }
  246 }
  247 
  248 /* Create a struct for tracking per-device suspend notification. */
  249 static struct apm_clone_data *
  250 apm_create_clone(struct cdev *dev, struct acpi_softc *acpi_sc)
  251 {
  252         struct apm_clone_data *clone;
  253 
  254         clone = malloc(sizeof(*clone), M_APMDEV, M_WAITOK);
  255         clone->cdev = dev;
  256         clone->acpi_sc = acpi_sc;
  257         clone->notify_status = APM_EV_NONE;
  258         bzero(&clone->sel_read, sizeof(clone->sel_read));
  259         knlist_init(&clone->sel_read.si_note, &acpi_mutex, NULL, NULL, NULL);
  260 
  261         /*
  262          * The acpi device is always managed by devd(8) and is considered
  263          * writable (i.e., ack is required to allow suspend to proceed.)
  264          */
  265         if (strcmp("acpi", devtoname(dev)) == 0)
  266                 clone->flags = ACPI_EVF_DEVD | ACPI_EVF_WRITE;
  267         else
  268                 clone->flags = ACPI_EVF_NONE;
  269 
  270         ACPI_LOCK(acpi);
  271         STAILQ_INSERT_TAIL(&acpi_sc->apm_cdevs, clone, entries);
  272         ACPI_UNLOCK(acpi);
  273         return (clone);
  274 }
  275 
  276 static int
  277 apmopen(struct cdev *dev, int flag, int fmt, d_thread_t *td)
  278 {
  279         struct  acpi_softc *acpi_sc;
  280         struct  apm_clone_data *clone;
  281 
  282         acpi_sc = devclass_get_softc(devclass_find("acpi"), 0);
  283         clone = apm_create_clone(dev, acpi_sc);
  284         dev->si_drv1 = clone;
  285 
  286         /* If the device is opened for write, record that. */
  287         if ((flag & FWRITE) != 0)
  288                 clone->flags |= ACPI_EVF_WRITE;
  289 
  290         return (0);
  291 }
  292 
  293 static int
  294 apmclose(struct cdev *dev, int flag, int fmt, d_thread_t *td)
  295 {
  296         struct  apm_clone_data *clone;
  297         struct  acpi_softc *acpi_sc;
  298 
  299         clone = dev->si_drv1;
  300         acpi_sc = clone->acpi_sc;
  301 
  302         /* We are about to lose a reference so check if suspend should occur */
  303         if (acpi_sc->acpi_next_sstate != 0 &&
  304             clone->notify_status != APM_EV_ACKED)
  305                 acpi_AckSleepState(clone, 0);
  306 
  307         /* Remove this clone's data from the list and free it. */
  308         ACPI_LOCK(acpi);
  309         STAILQ_REMOVE(&acpi_sc->apm_cdevs, clone, apm_clone_data, entries);
  310         knlist_destroy(&clone->sel_read.si_note);
  311         ACPI_UNLOCK(acpi);
  312         free(clone, M_APMDEV);
  313         destroy_dev_sched(dev);
  314         return (0);
  315 }
  316 
  317 static int
  318 apmioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, d_thread_t *td)
  319 {
  320         int     error;
  321         struct  apm_clone_data *clone;
  322         struct  acpi_softc *acpi_sc;
  323         struct  apm_info info;
  324         struct  apm_event_info *ev_info;
  325         apm_info_old_t aiop;
  326 
  327         error = 0;
  328         clone = dev->si_drv1;
  329         acpi_sc = clone->acpi_sc;
  330 
  331         switch (cmd) {
  332         case APMIO_SUSPEND:
  333                 if ((flag & FWRITE) == 0)
  334                         return (EPERM);
  335                 if (acpi_sc->acpi_next_sstate == 0) {
  336                         if (acpi_sc->acpi_suspend_sx != ACPI_STATE_S5) {
  337                                 error = acpi_ReqSleepState(acpi_sc,
  338                                     acpi_sc->acpi_suspend_sx);
  339                         } else {
  340                                 printf(
  341                         "power off via apm suspend not supported\n");
  342                                 error = ENXIO;
  343                         }
  344                 } else
  345                         error = acpi_AckSleepState(clone, 0);
  346                 break;
  347         case APMIO_STANDBY:
  348                 if ((flag & FWRITE) == 0)
  349                         return (EPERM);
  350                 if (acpi_sc->acpi_next_sstate == 0) {
  351                         if (acpi_sc->acpi_standby_sx != ACPI_STATE_S5) {
  352                                 error = acpi_ReqSleepState(acpi_sc,
  353                                     acpi_sc->acpi_standby_sx);
  354                         } else {
  355                                 printf(
  356                         "power off via apm standby not supported\n");
  357                                 error = ENXIO;
  358                         }
  359                 } else
  360                         error = acpi_AckSleepState(clone, 0);
  361                 break;
  362         case APMIO_NEXTEVENT:
  363                 printf("apm nextevent start\n");
  364                 ACPI_LOCK(acpi);
  365                 if (acpi_sc->acpi_next_sstate != 0 && clone->notify_status ==
  366                     APM_EV_NONE) {
  367                         ev_info = (struct apm_event_info *)addr;
  368                         if (acpi_sc->acpi_next_sstate <= ACPI_STATE_S3)
  369                                 ev_info->type = PMEV_STANDBYREQ;
  370                         else
  371                                 ev_info->type = PMEV_SUSPENDREQ;
  372                         ev_info->index = 0;
  373                         clone->notify_status = APM_EV_NOTIFIED;
  374                         printf("apm event returning %d\n", ev_info->type);
  375                 } else
  376                         error = EAGAIN;
  377                 ACPI_UNLOCK(acpi);
  378                 break;
  379         case APMIO_GETINFO_OLD:
  380                 if (acpi_capm_get_info(&info))
  381                         error = ENXIO;
  382                 aiop = (apm_info_old_t)addr;
  383                 aiop->ai_major = info.ai_major;
  384                 aiop->ai_minor = info.ai_minor;
  385                 aiop->ai_acline = info.ai_acline;
  386                 aiop->ai_batt_stat = info.ai_batt_stat;
  387                 aiop->ai_batt_life = info.ai_batt_life;
  388                 aiop->ai_status = info.ai_status;
  389                 break;
  390         case APMIO_GETINFO:
  391                 if (acpi_capm_get_info((apm_info_t)addr))
  392                         error = ENXIO;
  393                 break;
  394         case APMIO_GETPWSTATUS:
  395                 if (acpi_capm_get_pwstatus((apm_pwstatus_t)addr))
  396                         error = ENXIO;
  397                 break;
  398         case APMIO_ENABLE:
  399                 if ((flag & FWRITE) == 0)
  400                         return (EPERM);
  401                 apm_active = 1;
  402                 break;
  403         case APMIO_DISABLE:
  404                 if ((flag & FWRITE) == 0)
  405                         return (EPERM);
  406                 apm_active = 0;
  407                 break;
  408         case APMIO_HALTCPU:
  409                 break;
  410         case APMIO_NOTHALTCPU:
  411                 break;
  412         case APMIO_DISPLAY:
  413                 if ((flag & FWRITE) == 0)
  414                         return (EPERM);
  415                 break;
  416         case APMIO_BIOS:
  417                 if ((flag & FWRITE) == 0)
  418                         return (EPERM);
  419                 bzero(addr, sizeof(struct apm_bios_arg));
  420                 break;
  421         default:
  422                 error = EINVAL;
  423                 break;
  424         }
  425 
  426         return (error);
  427 }
  428 
  429 static int
  430 apmwrite(struct cdev *dev, struct uio *uio, int ioflag)
  431 {
  432         return (uio->uio_resid);
  433 }
  434 
  435 static int
  436 apmpoll(struct cdev *dev, int events, d_thread_t *td)
  437 {
  438         struct  apm_clone_data *clone;
  439         int revents;
  440 
  441         revents = 0;
  442         ACPI_LOCK(acpi);
  443         clone = dev->si_drv1;
  444         if (clone->acpi_sc->acpi_next_sstate)
  445                 revents |= events & (POLLIN | POLLRDNORM);
  446         else
  447                 selrecord(td, &clone->sel_read);
  448         ACPI_UNLOCK(acpi);
  449         return (revents);
  450 }
  451 
  452 static int
  453 apmkqfilter(struct cdev *dev, struct knote *kn)
  454 {
  455         struct  apm_clone_data *clone;
  456 
  457         ACPI_LOCK(acpi);
  458         clone = dev->si_drv1;
  459         kn->kn_hook = clone;
  460         kn->kn_fop = &apm_readfiltops;
  461         knlist_add(&clone->sel_read.si_note, kn, 0);
  462         ACPI_UNLOCK(acpi);
  463         return (0);
  464 }
  465 
  466 static void
  467 apmreadfiltdetach(struct knote *kn)
  468 {
  469         struct  apm_clone_data *clone;
  470 
  471         ACPI_LOCK(acpi);
  472         clone = kn->kn_hook;
  473         knlist_remove(&clone->sel_read.si_note, kn, 0);
  474         ACPI_UNLOCK(acpi);
  475 }
  476 
  477 static int
  478 apmreadfilt(struct knote *kn, long hint)
  479 {
  480         struct  apm_clone_data *clone;
  481         int     sleeping;
  482 
  483         ACPI_LOCK(acpi);
  484         clone = kn->kn_hook;
  485         sleeping = clone->acpi_sc->acpi_next_sstate ? 1 : 0;
  486         ACPI_UNLOCK(acpi);
  487         return (sleeping);
  488 }
  489 
  490 int
  491 acpi_machdep_init(device_t dev)
  492 {
  493         struct  acpi_softc *acpi_sc;
  494 
  495         acpi_sc = devclass_get_softc(devclass_find("acpi"), 0);
  496 
  497         /* Create a clone for /dev/acpi also. */
  498         STAILQ_INIT(&acpi_sc->apm_cdevs);
  499         acpi_sc->acpi_clone = apm_create_clone(acpi_sc->acpi_dev_t, acpi_sc);
  500         clone_setup(&apm_clones);
  501         EVENTHANDLER_REGISTER(dev_clone, apm_clone, 0, 1000);
  502         acpi_install_wakeup_handler(acpi_sc);
  503 
  504         if (intr_model == ACPI_INTR_PIC)
  505                 BUS_CONFIG_INTR(dev, AcpiGbl_FADT.SciInterrupt,
  506                     INTR_TRIGGER_LEVEL, INTR_POLARITY_LOW);
  507         else
  508                 acpi_SetIntrModel(intr_model);
  509 
  510         SYSCTL_ADD_UINT(&acpi_sc->acpi_sysctl_ctx,
  511             SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO,
  512             "reset_video", CTLFLAG_RW, &acpi_reset_video, 0,
  513             "Call the VESA reset BIOS vector on the resume path");
  514 
  515         return (0);
  516 }
  517 
  518 void
  519 acpi_SetDefaultIntrModel(int model)
  520 {
  521 
  522         intr_model = model;
  523 }
  524 
  525 /* Check BIOS date.  If 1998 or older, disable ACPI. */
  526 int
  527 acpi_machdep_quirks(int *quirks)
  528 {
  529         char *va;
  530         int year;
  531 
  532         /* BIOS address 0xffff5 contains the date in the format mm/dd/yy. */
  533         va = pmap_mapbios(0xffff0, 16);
  534         sscanf(va + 11, "%2d", &year);
  535         pmap_unmapbios((vm_offset_t)va, 16);
  536 
  537         /* 
  538          * Date must be >= 1/1/1999 or we don't trust ACPI.  Note that this
  539          * check must be changed by my 114th birthday.
  540          */
  541         if (year > 90 && year < 99)
  542                 *quirks = ACPI_Q_BROKEN;
  543 
  544         return (0);
  545 }
  546 
  547 void
  548 acpi_cpu_c1()
  549 {
  550         __asm __volatile("sti; hlt");
  551 }

Cache object: 756752726effcaa553e03fb99486617b


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