Subversion Repositories HelenOS

Rev

Rev 349 | Rev 422 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (C) 2005 Jakub Jermar
  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.  *
  9.  * - Redistributions of source code must retain the above copyright
  10.  *   notice, this list of conditions and the following disclaimer.
  11.  * - Redistributions in binary form must reproduce the above copyright
  12.  *   notice, this list of conditions and the following disclaimer in the
  13.  *   documentation and/or other materials provided with the distribution.
  14.  * - The name of the author may not be used to endorse or promote products
  15.  *   derived from this software without specific prior written permission.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  */
  28.  
  29. #include <arch/types.h>
  30. #include <typedefs.h>
  31. #include <arch/acpi/acpi.h>
  32. #include <arch/acpi/madt.h>
  33. #include <arch/smp/apic.h>
  34. #include <arch/smp/smp.h>
  35. #include <panic.h>
  36. #include <debug.h>
  37. #include <config.h>
  38. #include <print.h>
  39. #include <mm/heap.h>
  40. #include <memstr.h>
  41. #include <sort.h>
  42.  
  43. struct acpi_madt *acpi_madt = NULL;
  44.  
  45. #ifdef __SMP__
  46.  
  47. static void madt_l_apic_entry(struct madt_l_apic *la, __u32 index);
  48. static void madt_io_apic_entry(struct madt_io_apic *ioa, __u32 index);
  49. static int madt_cmp(void * a, void * b);
  50.  
  51. struct madt_l_apic *madt_l_apic_entries = NULL;
  52. struct madt_io_apic *madt_io_apic_entries = NULL;
  53.  
  54. index_t madt_l_apic_entry_index = 0;
  55. index_t madt_io_apic_entry_index = 0;
  56. count_t madt_l_apic_entry_cnt = 0;
  57. count_t madt_io_apic_entry_cnt = 0;
  58. count_t cpu_count = 0;
  59.  
  60. struct madt_apic_header * * madt_entries_index = NULL;
  61. int madt_entries_index_cnt = 0;
  62.  
  63. char *entry[] = {
  64.     "L_APIC",
  65.     "IO_APIC",
  66.     "INTR_SRC_OVRD",
  67.     "NMI_SRC",
  68.     "L_APIC_NMI",
  69.     "L_APIC_ADDR_OVRD",
  70.     "IO_SAPIC",
  71.     "L_SAPIC",
  72.     "PLATFORM_INTR_SRC"
  73. };
  74.  
  75. /*
  76.  * ACPI MADT Implementation of SMP configuration interface.
  77.  */
  78. static count_t madt_cpu_count(void);
  79. static bool madt_cpu_enabled(index_t i);
  80. static bool madt_cpu_bootstrap(index_t i);
  81. static __u8 madt_cpu_apic_id(index_t i);
  82.  
  83. struct smp_config_operations madt_config_operations = {
  84.     .cpu_count = madt_cpu_count,
  85.     .cpu_enabled = madt_cpu_enabled,
  86.     .cpu_bootstrap = madt_cpu_bootstrap,
  87.     .cpu_apic_id = madt_cpu_apic_id
  88. };
  89.  
  90. static count_t madt_cpu_count(void)
  91. {
  92.     return madt_l_apic_entry_cnt;
  93. }
  94.  
  95. static bool madt_cpu_enabled(index_t i)
  96. {
  97.     ASSERT(i < madt_l_apic_entry_cnt);
  98.     return ((struct madt_l_apic *) madt_entries_index[madt_l_apic_entry_index + i])->flags & 0x1;
  99.  
  100. }
  101.  
  102. static bool madt_cpu_bootstrap(index_t i)
  103. {
  104.     ASSERT(i < madt_l_apic_entry_cnt);
  105.     return ((struct madt_l_apic *) madt_entries_index[madt_l_apic_entry_index + i])->apic_id == l_apic_id();
  106. }
  107.  
  108. static __u8 madt_cpu_apic_id(index_t i)
  109. {
  110.     ASSERT(i < madt_l_apic_entry_cnt);
  111.     return ((struct madt_l_apic *) madt_entries_index[madt_l_apic_entry_index + i])->apic_id;
  112. }
  113.  
  114. int madt_cmp(void * a, void * b)
  115. {
  116.     return
  117.         (((struct madt_apic_header *) a)->type > ((struct madt_apic_header *) b)->type) ?
  118.         1 :
  119.         ((((struct madt_apic_header *) a)->type < ((struct madt_apic_header *) b)->type) ? -1 : 0);
  120. }
  121.    
  122. void acpi_madt_parse(void)
  123. {
  124.     struct madt_apic_header *end = (struct madt_apic_header *) (((__u8 *) acpi_madt) + acpi_madt->header.length);
  125.     struct madt_apic_header *h;
  126.    
  127.         l_apic = (__u32 *) (__native) acpi_madt->l_apic_address;
  128.  
  129.     /* calculate madt entries */
  130.     for (h = &acpi_madt->apic_header[0]; h < end; h = (struct madt_apic_header *) (((__u8 *) h) + h->length)) {
  131.         madt_entries_index_cnt++;
  132.     }
  133.  
  134.     /* create madt apic entries index array */
  135.     madt_entries_index = (struct madt_apic_header * *) malloc(madt_entries_index_cnt * sizeof(struct madt_apic_header * *));
  136.  
  137.     __u32 index = 0;
  138.  
  139.     for (h = &acpi_madt->apic_header[0]; h < end; h = (struct madt_apic_header *) (((__u8 *) h) + h->length)) {
  140.         madt_entries_index[index++] = h;
  141.     }
  142.  
  143.     /* Quicksort MADT index structure */
  144.     qsort(madt_entries_index, madt_entries_index_cnt, sizeof(__address), &madt_cmp);
  145.  
  146.     /* Parse MADT entries */   
  147.     for (index = 0; index < madt_entries_index_cnt - 1; index++) {
  148.         h = madt_entries_index[index];
  149.         switch (h->type) {
  150.             case MADT_L_APIC:
  151.                 madt_l_apic_entry((struct madt_l_apic *) h, index);
  152.                 break;
  153.             case MADT_IO_APIC:
  154.                 madt_io_apic_entry((struct madt_io_apic *) h, index);
  155.                 break;
  156.             case MADT_INTR_SRC_OVRD:
  157.             case MADT_NMI_SRC:
  158.             case MADT_L_APIC_NMI:
  159.             case MADT_L_APIC_ADDR_OVRD:
  160.             case MADT_IO_SAPIC:
  161.             case MADT_L_SAPIC:
  162.             case MADT_PLATFORM_INTR_SRC:
  163.                 printf("MADT: skipping %s entry (type=%d)\n", entry[h->type], h->type);
  164.                 break;
  165.  
  166.             default:
  167.                 if (h->type >= MADT_RESERVED_SKIP_BEGIN && h->type <= MADT_RESERVED_SKIP_END) {
  168.                     printf("MADT: skipping reserved entry (type=%d)\n", h->type);
  169.                 }
  170.                 if (h->type >= MADT_RESERVED_OEM_BEGIN) {
  171.                     printf("MADT: skipping OEM entry (type=%d)\n", h->type);
  172.                 }
  173.                 break;
  174.         }
  175.    
  176.    
  177.     }
  178.    
  179.  
  180.     if (cpu_count)
  181.         config.cpu_count = cpu_count;
  182. }
  183.  
  184.  
  185. void madt_l_apic_entry(struct madt_l_apic *la, __u32 index)
  186. {
  187.     if (!madt_l_apic_entry_cnt++) {
  188.         madt_l_apic_entry_index = index;
  189.     }
  190.        
  191.     if (!(la->flags & 0x1)) {
  192.         /* Processor is unusable, skip it. */
  193.         return;
  194.     }
  195.    
  196.     cpu_count++;   
  197.     apic_id_mask |= 1<<la->apic_id;
  198. }
  199.  
  200. void madt_io_apic_entry(struct madt_io_apic *ioa, __u32 index)
  201. {
  202.     if (!madt_io_apic_entry_cnt++) {
  203.         /* remember index of the first io apic entry */
  204.         madt_io_apic_entry_index = index;
  205.         io_apic = (__u32 *) (__native) ioa->io_apic_address;
  206.     } else {
  207.         /* currently not supported */
  208.         return;
  209.     }
  210. }
  211.  
  212.  
  213. #endif /* __SMP__ */
  214.