sys/ia64/ia64/sal.c

   1 /*-
   2  * Copyright (c) 2001 Doug Rabson
   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/systm.h>
  32 #include <sys/kernel.h>
  33 #include <sys/malloc.h>
  34 #include <vm/vm.h>
  35 #include <vm/vm_kern.h>
  36 #include <machine/efi.h>
  37 #include <machine/md_var.h>
  38 #include <machine/sal.h>
  39 #include <machine/smp.h>
  40
  41 /*
  42  * IPIs are used more genericly than only
  43  * for inter-processor interrupts. Don't
  44  * make it a SMP specific thing...
  45  */
  46 int ipi_vector[IPI_COUNT];
  47
  48 static struct ia64_fdesc sal_fdesc;
  49 static sal_entry_t      fake_sal;
  50
  51 extern u_int64_t        ia64_pal_entry;
  52 sal_entry_t             *ia64_sal_entry = fake_sal;
  53
  54 static struct uuid sal_table = EFI_TABLE_SAL;
  55 static struct sal_system_table *sal_systbl;
  56
  57 static struct ia64_sal_result
  58 fake_sal(u_int64_t a1, u_int64_t a2, u_int64_t a3, u_int64_t a4,
  59          u_int64_t a5, u_int64_t a6, u_int64_t a7, u_int64_t a8)
  60 {
  61         struct ia64_sal_result res;
  62         res.sal_status = -3;
  63         res.sal_result[0] = 0;
  64         res.sal_result[1] = 0;
  65         res.sal_result[2] = 0;
  66         return res;
  67 }
  68
  69 static void
  70 setup_ipi_vectors(int ceil)
  71 {
  72         int ipi;
  73
  74         ipi_vector[IPI_MCA_RENDEZ] = ceil - 0x10;
  75
  76         ipi = IPI_AST;          /* First generic IPI. */
  77         ceil -= 0x20;           /* First vector in group. */
  78         while (ipi < IPI_COUNT)
  79                 ipi_vector[ipi++] = ceil++;
  80
  81         ipi_vector[IPI_HIGH_FP] = ceil - 0x30;
  82         ipi_vector[IPI_MCA_CMCV] = ceil - 0x30 + 1;
  83         ipi_vector[IPI_TEST] = ceil - 0x30 + 2;
  84 }
  85
  86 void
  87 ia64_sal_init(void)
  88 {
  89         static int sizes[6] = {
  90                 48, 32, 16, 32, 16, 16
  91         };
  92         u_int8_t *p;
  93         int i;
  94
  95         sal_systbl = efi_get_table(&sal_table);
  96         if (sal_systbl == NULL)
  97                 return;
  98
  99         if (memcmp(sal_systbl->sal_signature, SAL_SIGNATURE, 4)) {
 100                 printf("Bad signature for SAL System Table\n");
 101                 return;
 102         }
 103
 104         p = (u_int8_t *) (sal_systbl + 1);
 105         for (i = 0; i < sal_systbl->sal_entry_count; i++) {
 106                 switch (*p) {
 107                 case 0: {
 108                         struct sal_entrypoint_descriptor *dp;
 109
 110                         dp = (struct sal_entrypoint_descriptor*)p;
 111                         ia64_pal_entry = IA64_PHYS_TO_RR7(dp->sale_pal_proc);
 112                         if (bootverbose)
 113                                 printf("PAL Proc at 0x%lx\n", ia64_pal_entry);
 114                         sal_fdesc.func = IA64_PHYS_TO_RR7(dp->sale_sal_proc);
 115                         sal_fdesc.gp = IA64_PHYS_TO_RR7(dp->sale_sal_gp);
 116                         if (bootverbose)
 117                                 printf("SAL Proc at 0x%lx, GP at 0x%lx\n",
 118                                     sal_fdesc.func, sal_fdesc.gp);
 119                         ia64_sal_entry = (sal_entry_t *) &sal_fdesc;
 120                         break;
 121                 }
 122                 case 5: {
 123                         struct sal_ap_wakeup_descriptor *dp;
 124 #ifdef SMP
 125                         struct ia64_sal_result result;
 126                         struct ia64_fdesc *fd;
 127 #endif
 128
 129                         dp = (struct sal_ap_wakeup_descriptor*)p;
 130                         if (dp->sale_mechanism != 0) {
 131                                 printf("SAL: unsupported AP wake-up mechanism "
 132                                     "(%d)\n", dp->sale_mechanism);
 133                                 break;
 134                         }
 135
 136                         if (dp->sale_vector < 0x10 || dp->sale_vector > 0xff) {
 137                                 printf("SAL: invalid AP wake-up vector "
 138                                     "(0x%lx)\n", dp->sale_vector);
 139                                 break;
 140                         }
 141
 142                         /*
 143                          * SAL documents that the wake-up vector should be
 144                          * high (close to 255). The MCA rendezvous vector
 145                          * should be less than the wake-up vector, but still
 146                          * "high". We use the following priority assignment:
 147                          *      Wake-up:        priority of the sale_vector
 148                          *      Rendezvous:     priority-1
 149                          *      Generic IPIs:   priority-2
 150                          *      Special IPIs:   priority-3
 151                          * Consequently, the wake-up priority should be at
 152                          * least 4 (ie vector >= 0x40).
 153                          */
 154                         if (dp->sale_vector < 0x40) {
 155                                 printf("SAL: AP wake-up vector too low "
 156                                     "(0x%lx)\n", dp->sale_vector);
 157                                 break;
 158                         }
 159
 160                         if (bootverbose)
 161                                 printf("SAL: AP wake-up vector: 0x%lx\n",
 162                                     dp->sale_vector);
 163
 164                         ipi_vector[IPI_AP_WAKEUP] = dp->sale_vector;
 165                         setup_ipi_vectors(dp->sale_vector & 0xf0);
 166
 167 #ifdef SMP
 168                         fd = (struct ia64_fdesc *) os_boot_rendez;
 169                         result = ia64_sal_entry(SAL_SET_VECTORS,
 170                             SAL_OS_BOOT_RENDEZ, ia64_tpa(fd->func),
 171                             ia64_tpa(fd->gp), 0, 0, 0, 0);
 172 #endif
 173
 174                         break;
 175                 }
 176                 }
 177                 p += sizes[*p];
 178         }
 179
 180         if (ipi_vector[IPI_AP_WAKEUP] == 0)
 181                 setup_ipi_vectors(0xf0);
 182 }