Subversion Repositories HelenOS-historic

Rev

Rev 822 | Go to most recent revision | Blame | 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 <genarch/acpi/acpi.h>
  32. #include <genarch/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/slab.h>
  40. #include <memstr.h>
  41. #include <sort.h>
  42.  
  43. struct acpi_madt *acpi_madt = NULL;
  44.  
  45. #ifdef CONFIG_SMP
  46.  
  47. /** Standard ISA IRQ map; can be overriden by Interrupt Source Override entries of MADT. */
  48. int isa_irq_map[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
  49.  
  50. static void madt_l_apic_entry(struct madt_l_apic *la, __u32 index);
  51. static void madt_io_apic_entry(struct madt_io_apic *ioa, __u32 index);
  52. static void madt_intr_src_ovrd_entry(struct madt_intr_src_ovrd *override, __u32 index);
  53. static int madt_cmp(void * a, void * b);
  54.  
  55. struct madt_l_apic *madt_l_apic_entries = NULL;
  56. struct madt_io_apic *madt_io_apic_entries = NULL;
  57.  
  58. index_t madt_l_apic_entry_index = 0;
  59. index_t madt_io_apic_entry_index = 0;
  60. count_t madt_l_apic_entry_cnt = 0;
  61. count_t madt_io_apic_entry_cnt = 0;
  62. count_t cpu_count = 0;
  63.  
  64. struct madt_apic_header * * madt_entries_index = NULL;
  65. int madt_entries_index_cnt = 0;
  66.  
  67. char *entry[] = {
  68.     "L_APIC",
  69.     "IO_APIC",
  70.     "INTR_SRC_OVRD",
  71.     "NMI_SRC",
  72.     "L_APIC_NMI",
  73.     "L_APIC_ADDR_OVRD",
  74.     "IO_SAPIC",
  75.     "L_SAPIC",
  76.     "PLATFORM_INTR_SRC"
  77. };
  78.  
  79. /*
  80.  * ACPI MADT Implementation of SMP configuration interface.
  81.  */
  82. static count_t madt_cpu_count(void);
  83. static bool madt_cpu_enabled(index_t i);
  84. static bool madt_cpu_bootstrap(index_t i);
  85. static __u8 madt_cpu_apic_id(index_t i);
  86. static int madt_irq_to_pin(int irq);
  87.  
  88. struct smp_config_operations madt_config_operations = {
  89.     .cpu_count = madt_cpu_count,
  90.     .cpu_enabled = madt_cpu_enabled,
  91.     .cpu_bootstrap = madt_cpu_bootstrap,
  92.     .cpu_apic_id = madt_cpu_apic_id,
  93.     .irq_to_pin = madt_irq_to_pin
  94. };
  95.  
  96. count_t madt_cpu_count(void)
  97. {
  98.     return madt_l_apic_entry_cnt;
  99. }
  100.  
  101. bool madt_cpu_enabled(index_t i)
  102. {
  103.     ASSERT(i < madt_l_apic_entry_cnt);
  104.     return ((struct madt_l_apic *) madt_entries_index[madt_l_apic_entry_index + i])->flags & 0x1;
  105.  
  106. }
  107.  
  108. bool madt_cpu_bootstrap(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 == l_apic_id();
  112. }
  113.  
  114. __u8 madt_cpu_apic_id(index_t i)
  115. {
  116.     ASSERT(i < madt_l_apic_entry_cnt);
  117.     return ((struct madt_l_apic *) madt_entries_index[madt_l_apic_entry_index + i])->apic_id;
  118. }
  119.  
  120. int madt_irq_to_pin(int irq)
  121. {
  122.     ASSERT(irq < sizeof(isa_irq_map)/sizeof(int));
  123.         return isa_irq_map[irq];
  124. }
  125.  
  126. int madt_cmp(void * a, void * b)
  127. {
  128.     return
  129.         (((struct madt_apic_header *) a)->type > ((struct madt_apic_header *) b)->type) ?
  130.         1 :
  131.         ((((struct madt_apic_header *) a)->type < ((struct madt_apic_header *) b)->type) ? -1 : 0);
  132. }
  133.    
  134. void acpi_madt_parse(void)
  135. {
  136.     struct madt_apic_header *end = (struct madt_apic_header *) (((__u8 *) acpi_madt) + acpi_madt->header.length);
  137.     struct madt_apic_header *h;
  138.    
  139.         l_apic = (__u32 *) (__native) acpi_madt->l_apic_address;
  140.  
  141.     /* calculate madt entries */
  142.     for (h = &acpi_madt->apic_header[0]; h < end; h = (struct madt_apic_header *) (((__u8 *) h) + h->length)) {
  143.         madt_entries_index_cnt++;
  144.     }
  145.  
  146.     /* create madt apic entries index array */
  147.     madt_entries_index = (struct madt_apic_header * *) malloc(madt_entries_index_cnt * sizeof(struct madt_apic_header * *), FRAME_ATOMIC);
  148.     if (!madt_entries_index)
  149.         panic("Memory allocation error.");
  150.  
  151.     __u32 index = 0;
  152.  
  153.     for (h = &acpi_madt->apic_header[0]; h < end; h = (struct madt_apic_header *) (((__u8 *) h) + h->length)) {
  154.         madt_entries_index[index++] = h;
  155.     }
  156.  
  157.     /* Quicksort MADT index structure */
  158.     qsort(madt_entries_index, madt_entries_index_cnt, sizeof(__address), &madt_cmp);
  159.  
  160.     /* Parse MADT entries */   
  161.     for (index = 0; index < madt_entries_index_cnt - 1; index++) {
  162.         h = madt_entries_index[index];
  163.         switch (h->type) {
  164.             case MADT_L_APIC:
  165.                 madt_l_apic_entry((struct madt_l_apic *) h, index);
  166.                 break;
  167.             case MADT_IO_APIC:
  168.                 madt_io_apic_entry((struct madt_io_apic *) h, index);
  169.                 break;
  170.             case MADT_INTR_SRC_OVRD:
  171.                 madt_intr_src_ovrd_entry((struct madt_intr_src_ovrd *) h, index);
  172.                 break;
  173.             case MADT_NMI_SRC:
  174.             case MADT_L_APIC_NMI:
  175.             case MADT_L_APIC_ADDR_OVRD:
  176.             case MADT_IO_SAPIC:
  177.             case MADT_L_SAPIC:
  178.             case MADT_PLATFORM_INTR_SRC:
  179.                 printf("MADT: skipping %s entry (type=%zd)\n", entry[h->type], h->type);
  180.                 break;
  181.  
  182.             default:
  183.                 if (h->type >= MADT_RESERVED_SKIP_BEGIN && h->type <= MADT_RESERVED_SKIP_END) {
  184.                     printf("MADT: skipping reserved entry (type=%zd)\n", h->type);
  185.                 }
  186.                 if (h->type >= MADT_RESERVED_OEM_BEGIN) {
  187.                     printf("MADT: skipping OEM entry (type=%zd)\n", h->type);
  188.                 }
  189.                 break;
  190.         }
  191.    
  192.    
  193.     }
  194.    
  195.  
  196.     if (cpu_count)
  197.         config.cpu_count = cpu_count;
  198. }
  199.  
  200.  
  201. void madt_l_apic_entry(struct madt_l_apic *la, __u32 index)
  202. {
  203.     if (!madt_l_apic_entry_cnt++) {
  204.         madt_l_apic_entry_index = index;
  205.     }
  206.        
  207.     if (!(la->flags & 0x1)) {
  208.         /* Processor is unusable, skip it. */
  209.         return;
  210.     }
  211.    
  212.     cpu_count++;   
  213.     apic_id_mask |= 1<<la->apic_id;
  214. }
  215.  
  216. void madt_io_apic_entry(struct madt_io_apic *ioa, __u32 index)
  217. {
  218.     if (!madt_io_apic_entry_cnt++) {
  219.         /* remember index of the first io apic entry */
  220.         madt_io_apic_entry_index = index;
  221.         io_apic = (__u32 *) (__native) ioa->io_apic_address;
  222.     } else {
  223.         /* currently not supported */
  224.         return;
  225.     }
  226. }
  227.  
  228. void madt_intr_src_ovrd_entry(struct madt_intr_src_ovrd *override, __u32 index)
  229. {
  230.     ASSERT(override->source < sizeof(isa_irq_map)/sizeof(int));
  231.     printf("MADT: ignoring %s entry: bus=%zd, source=%zd, global_int=%zd, flags=%#hX\n",
  232.         entry[override->header.type], override->bus, override->source,
  233.         override->global_int, override->flags);
  234. }
  235.  
  236. #endif /* CONFIG_SMP */
  237.