usr/src/uts/i86pc/os/mp_implfuncs.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 #define PSMI_1_7
  26
  27 #include <sys/vmem.h>
  28 #include <vm/hat.h>
  29 #include <sys/modctl.h>
  30 #include <vm/seg_kmem.h>
  31 #include <sys/psm.h>
  32 #include <sys/psm_modctl.h>
  33 #include <sys/smp_impldefs.h>
  34 #include <sys/reboot.h>
  35 #if defined(__xpv)
  36 #include <sys/hypervisor.h>
  37 #include <vm/kboot_mmu.h>
  38 #include <vm/hat_pte.h>
  39 #endif
  40
  41 /*
  42  *      External reference functions
  43  */
  44 extern void *get_next_mach(void *, char *);
  45 extern void close_mach_list(void);
  46 extern void open_mach_list(void);
  47
  48 /*
  49  * from startup.c - kernel VA range allocator for device mappings
  50  */
  51 extern void *device_arena_alloc(size_t size, int vm_flag);
  52 extern void device_arena_free(void * vaddr, size_t size);
  53
  54 void psm_modloadonly(void);
  55 void psm_install(void);
  56
  57 /*
  58  * Local Function Prototypes
  59  */
  60 static struct modlinkage *psm_modlinkage_alloc(struct psm_info *infop);
  61 static void psm_modlinkage_free(struct modlinkage *mlinkp);
  62
  63 static char *psm_get_impl_module(int first);
  64
  65 static int mod_installpsm(struct modlpsm *modl, struct modlinkage *modlp);
  66 static int mod_removepsm(struct modlpsm *modl, struct modlinkage *modlp);
  67 static int mod_infopsm(struct modlpsm *modl, struct modlinkage *modlp, int *p0);
  68 struct mod_ops mod_psmops = {
  69         mod_installpsm, mod_removepsm, mod_infopsm
  70 };
  71
  72 static struct psm_sw psm_swtab = {
  73         &psm_swtab, &psm_swtab, NULL, NULL
  74 };
  75
  76 kmutex_t psmsw_lock;                    /* lock accesses to psmsw       */
  77 struct psm_sw *psmsw = &psm_swtab;      /* start of all psm_sw          */
  78
  79 static struct modlinkage *
  80 psm_modlinkage_alloc(struct psm_info *infop)
  81 {
  82         int     memsz;
  83         struct modlinkage *mlinkp;
  84         struct modlpsm *mlpsmp;
  85         struct psm_sw *swp;
  86
  87         memsz = sizeof (struct modlinkage) + sizeof (struct modlpsm) +
  88             sizeof (struct psm_sw);
  89         mlinkp = (struct modlinkage *)kmem_zalloc(memsz, KM_NOSLEEP);
  90         if (!mlinkp) {
  91                 cmn_err(CE_WARN, "!psm_mod_init: Cannot install %s",
  92                     infop->p_mach_idstring);
  93                 return (NULL);
  94         }
  95         mlpsmp = (struct modlpsm *)(mlinkp + 1);
  96         swp = (struct psm_sw *)(mlpsmp + 1);
  97
  98         mlinkp->ml_rev = MODREV_1;
  99         mlinkp->ml_linkage[0] = (void *)mlpsmp;
 100         mlinkp->ml_linkage[1] = (void *)NULL;
 101
 102         mlpsmp->psm_modops = &mod_psmops;
 103         mlpsmp->psm_linkinfo = infop->p_mach_desc;
 104         mlpsmp->psm_swp = swp;
 105
 106         swp->psw_infop = infop;
 107
 108         return (mlinkp);
 109 }
 110
 111 static void
 112 psm_modlinkage_free(struct modlinkage *mlinkp)
 113 {
 114         if (!mlinkp)
 115                 return;
 116
 117         (void) kmem_free(mlinkp, (sizeof (struct modlinkage) +
 118             sizeof (struct modlpsm) + sizeof (struct psm_sw)));
 119 }
 120
 121 int
 122 psm_mod_init(void **handlepp, struct psm_info *infop)
 123 {
 124         struct modlinkage **modlpp = (struct modlinkage **)handlepp;
 125         int     status;
 126         struct modlinkage *mlinkp;
 127
 128         if (!*modlpp) {
 129                 mlinkp = psm_modlinkage_alloc(infop);
 130                 if (!mlinkp)
 131                         return (ENOSPC);
 132         } else
 133                 mlinkp = *modlpp;
 134
 135         status = mod_install(mlinkp);
 136         if (status) {
 137                 psm_modlinkage_free(mlinkp);
 138                 *modlpp = NULL;
 139         } else
 140                 *modlpp = mlinkp;
 141
 142         return (status);
 143 }
 144
 145 /*ARGSUSED1*/
 146 int
 147 psm_mod_fini(void **handlepp, struct psm_info *infop)
 148 {
 149         struct modlinkage **modlpp = (struct modlinkage **)handlepp;
 150         int     status;
 151
 152         status = mod_remove(*modlpp);
 153         if (status == 0) {
 154                 psm_modlinkage_free(*modlpp);
 155                 *modlpp = NULL;
 156         }
 157         return (status);
 158 }
 159
 160 int
 161 psm_mod_info(void **handlepp, struct psm_info *infop, struct modinfo *modinfop)
 162 {
 163         struct modlinkage **modlpp = (struct modlinkage **)handlepp;
 164         int status;
 165         struct modlinkage *mlinkp;
 166
 167         if (!*modlpp) {
 168                 mlinkp = psm_modlinkage_alloc(infop);
 169                 if (!mlinkp)
 170                         return ((int)NULL);
 171         } else
 172                 mlinkp = *modlpp;
 173
 174         status =  mod_info(mlinkp, modinfop);
 175
 176         if (!status) {
 177                 psm_modlinkage_free(mlinkp);
 178                 *modlpp = NULL;
 179         } else
 180                 *modlpp = mlinkp;
 181
 182         return (status);
 183 }
 184
 185 int
 186 psm_add_intr(int lvl, avfunc xxintr, char *name, int vect, caddr_t arg)
 187 {
 188         return (add_avintr((void *)NULL, lvl, xxintr, name, vect,
 189             arg, NULL, NULL, NULL));
 190 }
 191
 192 int
 193 psm_add_nmintr(int lvl, avfunc xxintr, char *name, caddr_t arg)
 194 {
 195         return (add_nmintr(lvl, xxintr, name, arg));
 196 }
 197
 198 processorid_t
 199 psm_get_cpu_id(void)
 200 {
 201         return (CPU->cpu_id);
 202 }
 203
 204 caddr_t
 205 psm_map_phys_new(paddr_t addr, size_t len, int prot)
 206 {
 207         uint_t pgoffset;
 208         paddr_t base;
 209         pgcnt_t npages;
 210         caddr_t cvaddr;
 211
 212         if (len == 0)
 213                 return (0);
 214
 215         pgoffset = addr & MMU_PAGEOFFSET;
 216 #ifdef __xpv
 217         /*
 218          * If we're dom0, we're starting from a MA. translate that to a PA
 219          * XXPV - what about driver domains???
 220          */
 221         if (DOMAIN_IS_INITDOMAIN(xen_info)) {
 222                 base = pfn_to_pa(xen_assign_pfn(mmu_btop(addr))) |
 223                     (addr & MMU_PAGEOFFSET);
 224         } else {
 225                 base = addr;
 226         }
 227 #else
 228         base = addr;
 229 #endif
 230         npages = mmu_btopr(len + pgoffset);
 231         cvaddr = device_arena_alloc(ptob(npages), VM_NOSLEEP);
 232         if (cvaddr == NULL)
 233                 return (0);
 234         hat_devload(kas.a_hat, cvaddr, mmu_ptob(npages), mmu_btop(base),
 235             prot, HAT_LOAD_LOCK);
 236         return (cvaddr + pgoffset);
 237 }
 238
 239 void
 240 psm_unmap_phys(caddr_t addr, size_t len)
 241 {
 242         uint_t pgoffset;
 243         caddr_t base;
 244         pgcnt_t npages;
 245
 246         if (len == 0)
 247                 return;
 248
 249         pgoffset = (uintptr_t)addr & MMU_PAGEOFFSET;
 250         base = addr - pgoffset;
 251         npages = mmu_btopr(len + pgoffset);
 252         hat_unload(kas.a_hat, base, ptob(npages), HAT_UNLOAD_UNLOCK);
 253         device_arena_free(base, ptob(npages));
 254 }
 255
 256 caddr_t
 257 psm_map_new(paddr_t addr, size_t len, int prot)
 258 {
 259         int phys_prot = PROT_READ;
 260
 261         ASSERT(prot == (prot & (PSM_PROT_WRITE | PSM_PROT_READ)));
 262         if (prot & PSM_PROT_WRITE)
 263                 phys_prot |= PROT_WRITE;
 264
 265         return (psm_map_phys(addr, len, phys_prot));
 266 }
 267
 268 #undef psm_map_phys
 269 #undef psm_map
 270
 271 caddr_t
 272 psm_map_phys(uint32_t addr, size_t len, int prot)
 273 {
 274         return (psm_map_phys_new((paddr_t)(addr & 0xffffffff), len, prot));
 275 }
 276
 277 caddr_t
 278 psm_map(uint32_t addr, size_t len, int prot)
 279 {
 280         return (psm_map_new((paddr_t)(addr & 0xffffffff), len, prot));
 281 }
 282
 283 void
 284 psm_unmap(caddr_t addr, size_t len)
 285 {
 286         uint_t pgoffset;
 287         caddr_t base;
 288         pgcnt_t npages;
 289
 290         if (len == 0)
 291                 return;
 292
 293         pgoffset = (uintptr_t)addr & MMU_PAGEOFFSET;
 294         base = addr - pgoffset;
 295         npages = mmu_btopr(len + pgoffset);
 296         hat_unload(kas.a_hat, base, ptob(npages), HAT_UNLOAD_UNLOCK);
 297         device_arena_free(base, ptob(npages));
 298 }
 299
 300 /*ARGSUSED1*/
 301 static int
 302 mod_installpsm(struct modlpsm *modl, struct modlinkage *modlp)
 303 {
 304         struct psm_sw *swp;
 305
 306         swp = modl->psm_swp;
 307         mutex_enter(&psmsw_lock);
 308         psmsw->psw_back->psw_forw = swp;
 309         swp->psw_back = psmsw->psw_back;
 310         swp->psw_forw = psmsw;
 311         psmsw->psw_back = swp;
 312         swp->psw_flag |= PSM_MOD_INSTALL;
 313         mutex_exit(&psmsw_lock);
 314         return (0);
 315 }
 316
 317 /*ARGSUSED1*/
 318 static int
 319 mod_removepsm(struct modlpsm *modl, struct modlinkage *modlp)
 320 {
 321         struct psm_sw *swp;
 322
 323         swp = modl->psm_swp;
 324         mutex_enter(&psmsw_lock);
 325         if (swp->psw_flag & PSM_MOD_IDENTIFY) {
 326                 mutex_exit(&psmsw_lock);
 327                 return (EBUSY);
 328         }
 329         if (!(swp->psw_flag & PSM_MOD_INSTALL)) {
 330                 mutex_exit(&psmsw_lock);
 331                 return (0);
 332         }
 333
 334         swp->psw_back->psw_forw = swp->psw_forw;
 335         swp->psw_forw->psw_back = swp->psw_back;
 336         mutex_exit(&psmsw_lock);
 337         return (0);
 338 }
 339
 340 /*ARGSUSED1*/
 341 static int
 342 mod_infopsm(struct modlpsm *modl, struct modlinkage *modlp, int *p0)
 343 {
 344         *p0 = (int)modl->psm_swp->psw_infop->p_owner;
 345         return (0);
 346 }
 347
 348 #if defined(__xpv)
 349 #define DEFAULT_PSM_MODULE      "xpv_uppc"
 350 #else
 351 #define DEFAULT_PSM_MODULE      "uppc"
 352 #endif
 353
 354 static char *
 355 psm_get_impl_module(int first)
 356 {
 357         static char **pnamep;
 358         static char *psm_impl_module_list[] = {
 359                 DEFAULT_PSM_MODULE,
 360                 (char *)0
 361         };
 362         static void *mhdl = NULL;
 363         static char machname[MAXNAMELEN];
 364
 365         if (first)
 366                 pnamep = psm_impl_module_list;
 367
 368         if (*pnamep != (char *)0)
 369                 return (*pnamep++);
 370
 371         mhdl = get_next_mach(mhdl, machname);
 372         if (mhdl)
 373                 return (machname);
 374         return ((char *)0);
 375 }
 376
 377 void
 378 psm_modload(void)
 379 {
 380         char *this;
 381
 382         mutex_init(&psmsw_lock, NULL, MUTEX_DEFAULT, NULL);
 383         open_mach_list();
 384
 385         for (this = psm_get_impl_module(1); this != (char *)NULL;
 386             this = psm_get_impl_module(0)) {
 387                 if (modload("mach", this) == -1)
 388                         cmn_err(CE_CONT, "!Skipping psm: %s\n", this);
 389         }
 390         close_mach_list();
 391 }
 392
 393 #if defined(__xpv)
 394 #define NOTSUP_MSG "This version of Solaris xVM does not support this hardware"
 395 #else
 396 #define NOTSUP_MSG "This version of Solaris does not support this hardware"
 397 #endif  /* __xpv */
 398
 399 void
 400 psm_install(void)
 401 {
 402         struct psm_sw *swp, *cswp;
 403         struct psm_ops *opsp;
 404         char machstring[15];
 405         int err, psmcnt = 0;
 406
 407         mutex_enter(&psmsw_lock);
 408         for (swp = psmsw->psw_forw; swp != psmsw; ) {
 409                 opsp = swp->psw_infop->p_ops;
 410                 if (opsp->psm_probe) {
 411                         if ((*opsp->psm_probe)() == PSM_SUCCESS) {
 412                                 psmcnt++;
 413                                 swp->psw_flag |= PSM_MOD_IDENTIFY;
 414                                 swp = swp->psw_forw;
 415                                 continue;
 416                         }
 417                 }
 418                 /* remove the unsuccessful psm modules */
 419                 cswp = swp;
 420                 swp = swp->psw_forw;
 421
 422                 mutex_exit(&psmsw_lock);
 423                 (void) strcpy(&machstring[0], cswp->psw_infop->p_mach_idstring);
 424                 err = mod_remove_by_name(cswp->psw_infop->p_mach_idstring);
 425                 if (err)
 426                         cmn_err(CE_WARN, "!%s: mod_remove_by_name failed %d",
 427                             &machstring[0], err);
 428                 mutex_enter(&psmsw_lock);
 429         }
 430         mutex_exit(&psmsw_lock);
 431         if (psmcnt == 0)
 432                 halt(NOTSUP_MSG);
 433         (*psminitf)();
 434 }
 435
 436 /*
 437  * Return 1 if kernel debugger is present, and 0 if not.
 438  */
 439 int
 440 psm_debugger(void)
 441 {
 442         return ((boothowto & RB_DEBUG) != 0);
 443 }