[BACK]Return to acpi.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / dev / acpi

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/dev/acpi/acpi.c between version 1.101 and 1.101.16.27

version 1.101, 2007/02/19 22:31:05 version 1.101.16.27, 2007/12/09 19:37:43
Line 122  MALLOC_DECLARE(M_ACPI);
Line 122  MALLOC_DECLARE(M_ACPI);
 static int acpi_dbgr = 0x00;  static int acpi_dbgr = 0x00;
 #endif  #endif
   
   static ACPI_TABLE_DESC  acpi_initial_tables[128];
   
 static int      acpi_match(struct device *, struct cfdata *, void *);  static int      acpi_match(struct device *, struct cfdata *, void *);
 static void     acpi_attach(struct device *, struct device *, void *);  static void     acpi_attach(struct device *, struct device *, void *);
   
Line 191  acpi_probe(void)
Line 193  acpi_probe(void)
                 panic("acpi_probe: ACPI has already been probed");                  panic("acpi_probe: ACPI has already been probed");
         beenhere = 1;          beenhere = 1;
   
         mutex_init(&acpi_slock, MUTEX_DRIVER, IPL_NONE);          mutex_init(&acpi_slock, MUTEX_DEFAULT, IPL_NONE);
         mutex_init(&acpi_interrupt_list_mtx, MUTEX_DRIVER, IPL_NONE);          mutex_init(&acpi_interrupt_list_mtx, MUTEX_DEFAULT, IPL_NONE);
         acpi_locked = 0;          acpi_locked = 0;
   
         /*          /*
Line 203  acpi_probe(void)
Line 205  acpi_probe(void)
                 acpi_osd_debugger();                  acpi_osd_debugger();
 #endif  #endif
   
           AcpiGbl_AllMethodsSerialized = FALSE;
           AcpiGbl_EnableInterpreterSlack = TRUE;
   
         rv = AcpiInitializeSubsystem();          rv = AcpiInitializeSubsystem();
         if (ACPI_FAILURE(rv)) {          if (ACPI_FAILURE(rv)) {
                 printf("ACPI: unable to initialize ACPICA: %s\n",                  printf("ACPI: unable to initialize ACPICA: %s\n",
Line 210  acpi_probe(void)
Line 215  acpi_probe(void)
                 return 0;                  return 0;
         }          }
   
           rv = AcpiInitializeTables(acpi_initial_tables, 128, 0);
           if (ACPI_FAILURE(rv)) {
                   printf("ACPI: unable to initialize ACPI tables: %s\n",
                       AcpiFormatException(rv));
                   return 0;
           }
   
           rv = AcpiReallocateRootTable();
           if (ACPI_FAILURE(rv)) {
                   printf("ACPI: unable to reallocate root table: %s\n",
                       AcpiFormatException(rv));
                   return 0;
           }
   
 #ifdef ACPI_DEBUGGER  #ifdef ACPI_DEBUGGER
         if (acpi_dbgr & ACPI_DBGR_TABLES)          if (acpi_dbgr & ACPI_DBGR_TABLES)
                 acpi_osd_debugger();                  acpi_osd_debugger();
Line 222  acpi_probe(void)
Line 241  acpi_probe(void)
                 return 0;                  return 0;
         }          }
   
   #if notyet
         if (!acpi_force_load && (acpi_find_quirks() & ACPI_QUIRK_BROKEN)) {          if (!acpi_force_load && (acpi_find_quirks() & ACPI_QUIRK_BROKEN)) {
                 printf("ACPI: BIOS implementation in listed as broken:\n");                  printf("ACPI: BIOS implementation in listed as broken:\n");
                 printf("ACPI: X/RSDT: OemId <%6.6s,%8.8s,%08x>, "                  printf("ACPI: X/RSDT: OemId <%6.6s,%8.8s,%08x>, "
Line 235  acpi_probe(void)
Line 254  acpi_probe(void)
                 return 0;                  return 0;
         }          }
   
           /* Install the default address space handlers. */
           rv = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
               ACPI_ADR_SPACE_SYSTEM_MEMORY, ACPI_DEFAULT_HANDLER, NULL, NULL);
           if (ACPI_FAILURE(rv)) {
                   printf("ACPI: unable to initialise SystemMemory handler: %s\n",
                       AcpiFormatException(rv));
                   return 0;
           }
           rv = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
               ACPI_ADR_SPACE_SYSTEM_IO, ACPI_DEFAULT_HANDLER, NULL, NULL);
           if (ACPI_FAILURE(rv)) {
                   printf("ACPI: unable to initialise SystemIO handler: %s\n",
                        AcpiFormatException(rv));
                   return 0;
           }
           rv = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
               ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL);
           if (ACPI_FAILURE(rv)) {
                   printf("ACPI: unabled to initialise PciConfig handler: %s\n",
                       AcpiFormatException(rv));
                   return 0;
           }
   #endif
   
           rv = AcpiEnableSubsystem(~(ACPI_NO_HARDWARE_INIT|ACPI_NO_ACPI_ENABLE));
           if (ACPI_FAILURE(rv)) {
                   printf("ACPI: unable to enable: %s\n", AcpiFormatException(rv));
                   return 0;
           }
   
         /*          /*
          * Looks like we have ACPI!           * Looks like we have ACPI!
          */           */
Line 257  acpi_check(device_t parent, const char *
Line 306  acpi_check(device_t parent, const char *
         return (config_search_ia(acpi_submatch, parent, ifattr, NULL) != NULL);          return (config_search_ia(acpi_submatch, parent, ifattr, NULL) != NULL);
 }  }
   
 ACPI_STATUS  ACPI_PHYSICAL_ADDRESS
 acpi_OsGetRootPointer(UINT32 Flags, ACPI_POINTER *PhysicalAddress)  acpi_OsGetRootPointer(void)
 {  {
         ACPI_STATUS rv;          ACPI_PHYSICAL_ADDRESS PhysicalAddress;
   
         /*          /*
          * IA-32: Use AcpiFindRootPointer() to locate the RSDP.           * IA-32: Use AcpiFindRootPointer() to locate the RSDP.
Line 271  acpi_OsGetRootPointer(UINT32 Flags, ACPI
Line 320  acpi_OsGetRootPointer(UINT32 Flags, ACPI
          * ways to do it.           * ways to do it.
          */           */
   
         rv = acpi_md_OsGetRootPointer(Flags, PhysicalAddress);          PhysicalAddress = acpi_md_OsGetRootPointer();
   
         if (acpi_root_pointer == 0 && ACPI_SUCCESS(rv))          if (acpi_root_pointer == 0)
                 acpi_root_pointer =                  acpi_root_pointer = PhysicalAddress;
                     (uint64_t)PhysicalAddress->Pointer.Physical;  
   
         return rv;          return PhysicalAddress;
 }  }
   
 /*  /*
Line 324  acpi_attach(struct device *parent, struc
Line 372  acpi_attach(struct device *parent, struc
         aprint_verbose("%s: using Intel ACPI CA subsystem version %08x\n",          aprint_verbose("%s: using Intel ACPI CA subsystem version %08x\n",
             sc->sc_dev.dv_xname, ACPI_CA_VERSION);              sc->sc_dev.dv_xname, ACPI_CA_VERSION);
   
   #if 0
         aprint_verbose("%s: X/RSDT: OemId <%6.6s,%8.8s,%08x>, AslId <%4.4s,%08x>\n",          aprint_verbose("%s: X/RSDT: OemId <%6.6s,%8.8s,%08x>, AslId <%4.4s,%08x>\n",
             sc->sc_dev.dv_xname,              sc->sc_dev.dv_xname,
             AcpiGbl_XSDT->OemId, AcpiGbl_XSDT->OemTableId,              AcpiGbl_XSDT->OemId, AcpiGbl_XSDT->OemTableId,
             AcpiGbl_XSDT->OemRevision,              AcpiGbl_XSDT->OemRevision,
             AcpiGbl_XSDT->AslCompilerId, AcpiGbl_XSDT->AslCompilerRevision);              AcpiGbl_XSDT->AslCompilerId, AcpiGbl_XSDT->AslCompilerRevision);
   #endif
   
         sc->sc_quirks = acpi_find_quirks();          sc->sc_quirks = acpi_find_quirks();
   
Line 341  acpi_attach(struct device *parent, struc
Line 391  acpi_attach(struct device *parent, struc
         acpi_softc = sc;          acpi_softc = sc;
   
         /*          /*
            * Register null power management handler
            */
           if (!pmf_device_register(self, NULL, NULL))
                   aprint_error_dev(self, "couldn't establish power handler\n");
   
           /*
          * Bring ACPI on-line.           * Bring ACPI on-line.
          */           */
 #ifdef ACPI_DEBUGGER  #ifdef ACPI_DEBUGGER
Line 348  acpi_attach(struct device *parent, struc
Line 404  acpi_attach(struct device *parent, struc
                 acpi_osd_debugger();                  acpi_osd_debugger();
 #endif  #endif
   
         rv = AcpiEnableSubsystem(0);  #define ACPI_ENABLE_PHASE1 \
       (ACPI_NO_HANDLER_INIT | ACPI_NO_EVENT_INIT)
   #define ACPI_ENABLE_PHASE2 \
       (ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE | \
        ACPI_NO_ADDRESS_SPACE_INIT)
   
           rv = AcpiEnableSubsystem(ACPI_ENABLE_PHASE1);
           if (ACPI_FAILURE(rv)) {
                   aprint_error("%s: unable to enable ACPI: %s\n",
                       sc->sc_dev.dv_xname, AcpiFormatException(rv));
                   return;
           }
   
           acpi_md_callback();
   
           rv = AcpiEnableSubsystem(ACPI_ENABLE_PHASE2);
         if (ACPI_FAILURE(rv)) {          if (ACPI_FAILURE(rv)) {
                 aprint_error("%s: unable to enable ACPI: %s\n",                  aprint_error("%s: unable to enable ACPI: %s\n",
                     sc->sc_dev.dv_xname, AcpiFormatException(rv));                      sc->sc_dev.dv_xname, AcpiFormatException(rv));
Line 356  acpi_attach(struct device *parent, struc
Line 427  acpi_attach(struct device *parent, struc
         }          }
   
         /* early EC handler initialization if ECDT table is available */          /* early EC handler initialization if ECDT table is available */
 #if NACPIEC > 0          config_found_ia(&sc->sc_dev, "acpiecdtbus", NULL, NULL);
         acpiec_early_attach(&sc->sc_dev);  
 #endif  
   
         rv = AcpiInitializeObjects(0);          rv = AcpiInitializeObjects(ACPI_FULL_INITIALIZATION);
         if (ACPI_FAILURE(rv)) {          if (ACPI_FAILURE(rv)) {
                 aprint_error("%s: unable to initialize ACPI objects: %s\n",                  aprint_error("%s: unable to initialize ACPI objects: %s\n",
                     sc->sc_dev.dv_xname, AcpiFormatException(rv));                      sc->sc_dev.dv_xname, AcpiFormatException(rv));
Line 372  acpi_attach(struct device *parent, struc
Line 441  acpi_attach(struct device *parent, struc
         sc->sc_sleepstate = ACPI_STATE_S0;          sc->sc_sleepstate = ACPI_STATE_S0;
   
         /* Show SCI interrupt. */          /* Show SCI interrupt. */
         if (AcpiGbl_FADT != NULL)          aprint_verbose("%s: SCI interrupting at int %d\n",
                 aprint_verbose("%s: SCI interrupting at int %d\n",              sc->sc_dev.dv_xname, AcpiGbl_FADT.SciInterrupt);
                     sc->sc_dev.dv_xname, AcpiGbl_FADT->SciInt);  
         /*          /*
          * Check for fixed-hardware features.           * Check for fixed-hardware features.
          */           */
Line 388  acpi_attach(struct device *parent, struc
Line 457  acpi_attach(struct device *parent, struc
         if (acpi_dbgr & ACPI_DBGR_PROBE)          if (acpi_dbgr & ACPI_DBGR_PROBE)
                 acpi_osd_debugger();                  acpi_osd_debugger();
 #endif  #endif
         acpi_md_callback((struct device *)sc);  
         acpi_build_tree(sc);          acpi_build_tree(sc);
   
         if (acpi_root_pointer != 0 && acpi_node != CTL_EOL) {          if (acpi_root_pointer != 0 && acpi_node != CTL_EOL) {
Line 529  acpi_build_tree(struct acpi_softc *sc)
Line 597  acpi_build_tree(struct acpi_softc *sc)
                                     (ACPI_STA_DEV_PRESENT|ACPI_STA_DEV_ENABLED|                                      (ACPI_STA_DEV_PRESENT|ACPI_STA_DEV_ENABLED|
                                      ACPI_STA_DEV_OK))                                       ACPI_STA_DEV_OK))
                                         continue;                                          continue;
   
                                 /*  
                                  * XXX Same problem as above...  
                                  */  
                                 if ((ad->ad_devinfo->Valid & ACPI_VALID_HID)  
                                     == 0)  
                                         continue;  
                         }                          }
   
                           /*
                            * XXX Same problem as above...
                            *
                            * Do this check only for devices, as e.g.
                            * a Thermal Zone doesn't have a HID.
                            */
                           if (ad->ad_devinfo->Type == ACPI_TYPE_DEVICE &&
                               (ad->ad_devinfo->Valid & ACPI_VALID_HID) == 0)
                                   continue;
   
                         ad->ad_device = config_found_ia(&sc->sc_dev,                          ad->ad_device = config_found_ia(&sc->sc_dev,
                             "acpinodebus", &aa, acpi_print);                              "acpinodebus", &aa, acpi_print);
                 }                  }
Line 599  acpi_make_devnode(ACPI_HANDLE handle, UI
Line 670  acpi_make_devnode(ACPI_HANDLE handle, UI
         ACPI_BUFFER buf;          ACPI_BUFFER buf;
         ACPI_DEVICE_INFO *devinfo;          ACPI_DEVICE_INFO *devinfo;
         ACPI_STATUS rv;          ACPI_STATUS rv;
           ACPI_NAME_UNION *anu;
           int i, clear = 0;
   
         rv = AcpiGetType(handle, &type);          rv = AcpiGetType(handle, &type);
         if (ACPI_SUCCESS(rv)) {          if (ACPI_SUCCESS(rv)) {
Line 641  acpi_make_devnode(ACPI_HANDLE handle, UI
Line 714  acpi_make_devnode(ACPI_HANDLE handle, UI
                         ad->ad_scope = as;                          ad->ad_scope = as;
                         ad->ad_type = type;                          ad->ad_type = type;
   
                           anu = (ACPI_NAME_UNION *)&devinfo->Name;
                           ad->ad_name[4] = '\0';
                           for (i = 3, clear = 0; i >= 0; i--) {
                                   if (!clear && anu->Ascii[i] == '_')
                                           ad->ad_name[i] = '\0';
                                   else {
                                           ad->ad_name[i] = anu->Ascii[i];
                                           clear = 1;
                                   }
                           }
                           if (ad->ad_name[0] == '\0')
                                   ad->ad_name[0] = '_';
   
                         TAILQ_INSERT_TAIL(&as->as_devnodes, ad, ad_list);                          TAILQ_INSERT_TAIL(&as->as_devnodes, ad, ad_list);
   
                         if ((ad->ad_devinfo->Valid & ACPI_VALID_HID) == 0)                          if (type == ACPI_TYPE_DEVICE &&
                               (ad->ad_devinfo->Valid & ACPI_VALID_HID) == 0)
                                 goto out;                                  goto out;
   
 #ifdef ACPI_EXTRA_DEBUG  #ifdef ACPI_EXTRA_DEBUG
Line 684  acpi_print(void *aux, const char *pnp)
Line 771  acpi_print(void *aux, const char *pnp)
                             aa->aa_node->ad_devinfo->HardwareId.Value;                              aa->aa_node->ad_devinfo->HardwareId.Value;
                         char *str;                          char *str;
   
                         aprint_normal("%s ", pnpstr);                          aprint_normal("%s (%s) ", aa->aa_node->ad_name,
                               pnpstr);
                         rv = acpi_eval_string(aa->aa_node->ad_handle,                          rv = acpi_eval_string(aa->aa_node->ad_handle,
                             "_STR", &str);                              "_STR", &str);
                         if (ACPI_SUCCESS(rv)) {                          if (ACPI_SUCCESS(rv)) {
Line 706  acpi_print(void *aux, const char *pnp)
Line 794  acpi_print(void *aux, const char *pnp)
                         }                          }
   
 #endif  #endif
                 } else {                          aprint_normal("at %s", pnp);
                         aprint_normal("ACPI Object Type '%s' (0x%02x) ",                  } else if (aa->aa_node->ad_devinfo->Type != ACPI_TYPE_DEVICE) {
                            AcpiUtGetTypeName(aa->aa_node->ad_devinfo->Type),                          aprint_normal("%s (ACPI Object Type '%s' "
                            aa->aa_node->ad_devinfo->Type);                              "[0x%02x]) ", aa->aa_node->ad_name,
                 }                               AcpiUtGetTypeName(aa->aa_node->ad_devinfo->Type),
                 aprint_normal("at %s", pnp);                               aa->aa_node->ad_devinfo->Type);
                           aprint_normal("at %s", pnp);
                   } else
                           return 0;
         } else {          } else {
                   aprint_normal(" (%s", aa->aa_node->ad_name);
                 if (aa->aa_node->ad_devinfo->Valid & ACPI_VALID_HID) {                  if (aa->aa_node->ad_devinfo->Valid & ACPI_VALID_HID) {
                         aprint_normal(" (%s", aa->aa_node->ad_devinfo->HardwareId.Value);                          aprint_normal(", %s", aa->aa_node->ad_devinfo->HardwareId.Value);
                         if (aa->aa_node->ad_devinfo->Valid & ACPI_VALID_UID) {                          if (aa->aa_node->ad_devinfo->Valid & ACPI_VALID_UID) {
                                 const char *uid;                                  const char *uid;
   
Line 723  acpi_print(void *aux, const char *pnp)
Line 815  acpi_print(void *aux, const char *pnp)
                                         uid = "<null>";                                          uid = "<null>";
                                 aprint_normal("-%s", uid);                                  aprint_normal("-%s", uid);
                         }                          }
                         aprint_normal(")");  
                 }                  }
                   aprint_normal(")");
         }          }
   
         return UNCONF;          return UNCONF;
Line 755  acpi_enable_fixed_events(struct acpi_sof
Line 847  acpi_enable_fixed_events(struct acpi_sof
          * Check for fixed-hardware buttons.           * Check for fixed-hardware buttons.
          */           */
   
         if (AcpiGbl_FADT != NULL && AcpiGbl_FADT->PwrButton == 0) {          if ((AcpiGbl_FADT.Flags & ACPI_FADT_POWER_BUTTON) == 0) {
                 aprint_verbose("%s: fixed-feature power button present\n",                  aprint_verbose("%s: fixed-feature power button present\n",
                     sc->sc_dev.dv_xname);                      sc->sc_dev.dv_xname);
                 sc->sc_smpsw_power.smpsw_name = sc->sc_dev.dv_xname;                  sc->sc_smpsw_power.smpsw_name = sc->sc_dev.dv_xname;
Line 776  acpi_enable_fixed_events(struct acpi_sof
Line 868  acpi_enable_fixed_events(struct acpi_sof
                 }                  }
         }          }
   
         if (AcpiGbl_FADT != NULL && AcpiGbl_FADT->SleepButton == 0) {          if ((AcpiGbl_FADT.Flags & ACPI_FADT_SLEEP_BUTTON) == 0) {
                 aprint_verbose("%s: fixed-feature sleep button present\n",                  aprint_verbose("%s: fixed-feature sleep button present\n",
                     sc->sc_dev.dv_xname);                      sc->sc_dev.dv_xname);
                 sc->sc_smpsw_sleep.smpsw_name = sc->sc_dev.dv_xname;                  sc->sc_smpsw_sleep.smpsw_name = sc->sc_dev.dv_xname;
Line 813  acpi_fixed_button_handler(void *context)
Line 905  acpi_fixed_button_handler(void *context)
         printf("%s: fixed button handler\n", smpsw->smpsw_name);          printf("%s: fixed button handler\n", smpsw->smpsw_name);
 #endif  #endif
   
         rv = AcpiOsQueueForExecution(OSD_PRIORITY_LO,          rv = AcpiOsExecute(OSL_NOTIFY_HANDLER,
             acpi_fixed_button_pressed, smpsw);              acpi_fixed_button_pressed, smpsw);
         if (ACPI_FAILURE(rv))          if (ACPI_FAILURE(rv))
                 printf("%s: WARNING: unable to queue fixed button pressed "                  printf("%s: WARNING: unable to queue fixed button pressed "
Line 1067  is_available_state(struct acpi_softc *sc
Line 1159  is_available_state(struct acpi_softc *sc
 ACPI_STATUS  ACPI_STATUS
 acpi_enter_sleep_state(struct acpi_softc *sc, int state)  acpi_enter_sleep_state(struct acpi_softc *sc, int state)
 {  {
         int s;          int err;
         ACPI_STATUS ret = AE_OK;          ACPI_STATUS ret = AE_OK;
   
         if (state == acpi_sleepstate)          if (state == acpi_sleepstate)
Line 1087  acpi_enter_sleep_state(struct acpi_softc
Line 1179  acpi_enter_sleep_state(struct acpi_softc
                             sc->sc_dev.dv_xname, state);                              sc->sc_dev.dv_xname, state);
                         break;                          break;
                 }                  }
   
                   if (state != ACPI_STATE_S1 && !pmf_system_suspend()) {
                           aprint_error_dev(&sc->sc_dev, "aborting suspend");
                           break;
                   }
   
                 ret = AcpiEnterSleepStatePrep(state);                  ret = AcpiEnterSleepStatePrep(state);
                 if (ACPI_FAILURE(ret)) {                  if (ACPI_FAILURE(ret)) {
                         aprint_error("%s: failed preparing to sleep (%s)\n",                          aprint_error("%s: failed preparing to sleep (%s)\n",
                             sc->sc_dev.dv_xname, AcpiFormatException(ret));                              sc->sc_dev.dv_xname, AcpiFormatException(ret));
                         break;                          break;
                 }                  }
   
                 acpi_sleepstate = state;                  acpi_sleepstate = state;
                 if (state == ACPI_STATE_S1) {                  if (state == ACPI_STATE_S1) {
                         /* just enter the state */                          /* just enter the state */
                         acpi_md_OsDisableInterrupt();                          acpi_md_OsDisableInterrupt();
                         AcpiEnterSleepState((UINT8)state);                          AcpiEnterSleepState((UINT8)state);
                           AcpiLeaveSleepState((UINT8)state);
                 } else {                  } else {
                         /* XXX: powerhooks(9) framework is too poor to                          err = acpi_md_sleep(state);
                          * support ACPI sleep state...                          if (state == ACPI_STATE_S4)
                          */  
                         dopowerhooks(PWR_SOFTSUSPEND);  
                         s = splhigh();  
                         dopowerhooks(PWR_SUSPEND);  
                         acpi_md_sleep(state);  
                         dopowerhooks(PWR_RESUME);  
                         splx(s);  
                         dopowerhooks(PWR_SOFTRESUME);  
                         if (state==ACPI_STATE_S4)  
                                 AcpiEnable();                                  AcpiEnable();
                           AcpiLeaveSleepState((UINT8)state);
                           pmf_system_resume();
                 }                  }
                 AcpiLeaveSleepState((UINT8)state);  
                 break;                  break;
         case ACPI_STATE_S5:          case ACPI_STATE_S5:
                 ret = AcpiEnterSleepStatePrep(ACPI_STATE_S5);                  ret = AcpiEnterSleepStatePrep(ACPI_STATE_S5);
Line 1121  acpi_enter_sleep_state(struct acpi_softc
Line 1214  acpi_enter_sleep_state(struct acpi_softc
                                sc->sc_dev.dv_xname, AcpiFormatException(ret));                                 sc->sc_dev.dv_xname, AcpiFormatException(ret));
                         break;                          break;
                 }                  }
                   DELAY(1000000);
                 acpi_sleepstate = state;                  acpi_sleepstate = state;
                 acpi_md_OsDisableInterrupt();                  acpi_md_OsDisableInterrupt();
                 AcpiEnterSleepState(ACPI_STATE_S5);                  AcpiEnterSleepState(ACPI_STATE_S5);
Line 1129  acpi_enter_sleep_state(struct acpi_softc
Line 1223  acpi_enter_sleep_state(struct acpi_softc
                 break;                  break;
         }          }
   
         aprint_normal("%s: resuming\n", sc->sc_dev.dv_xname);  
         acpi_sleepstate = ACPI_STATE_S0;          acpi_sleepstate = ACPI_STATE_S0;
         return ret;          return ret;
 }  }
Legend:
Removed from v.1.101  
changed lines
  Added in v.1.101.16.27
CVSweb <webmaster@jp.NetBSD.org>