51 #include <sys/sysmacros.h>
  52 #include <sys/systeminfo.h>
  53 #include <sys/utsname.h>
  54 #include <sys/atomic.h>
  55 #include <sys/spl.h>
  56 #include <sys/archsystm.h>
  57 #include <vm/seg_kmem.h>
  58 #include <sys/ontrap.h>
  59 #include <sys/fm/protocol.h>
  60 #include <sys/ramdisk.h>
  61 #include <sys/sunndi.h>
  62 #include <sys/vmem.h>
  63 #include <sys/pci_impl.h>
  64 #if defined(__xpv)
  65 #include <sys/hypervisor.h>
  66 #endif
  67 #include <sys/mach_intr.h>
  68 #include <vm/hat_i86.h>
  69 #include <sys/x86_archext.h>
  70 #include <sys/avl.h>

  71 
  72 /*
  73  * DDI Boot Configuration
  74  */
  75 
  76 /*
  77  * Platform drivers on this platform
  78  */
  79 char *platform_module_list[] = {
  80         "acpippm",
  81         "ppm",
  82         (char *)0
  83 };
  84 
  85 /* pci bus resource maps */
  86 struct pci_bus_resource *pci_bus_res;
  87 
  88 size_t dma_max_copybuf_size = 0x101000;         /* 1M + 4K */
  89 
  90 uint64_t ramdisk_start, ramdisk_end;

1824 {
1825         int i = 0;
1826 
1827         while (i < len - 1 && boot_str[i] != '\0') {
1828                 kern_str[i] = boot_str[i];
1829                 i++;
1830         }
1831 
1832         kern_str[i] = 0;        /* null terminate */
1833         if (boot_str[i] != '\0')
1834                 cmn_err(CE_WARN,
1835                     "boot property string is truncated to %s", kern_str);
1836 }
1837 
1838 static void
1839 get_boot_properties(void)
1840 {
1841         extern char hw_provider[];
1842         dev_info_t *devi;
1843         char *name;
1844         int length;
1845         char property_name[50], property_val[50];
1846         void *bop_staging_area;
1847 
1848         bop_staging_area = kmem_zalloc(MMU_PAGESIZE, KM_NOSLEEP);
1849 
1850         /*
1851          * Import "root" properties from the boot.
1852          *
1853          * We do this by invoking BOP_NEXTPROP until the list
1854          * is completely copied in.
1855          */
1856 
1857         devi = ddi_root_node();
1858         for (name = BOP_NEXTPROP(bootops, "");          /* get first */
1859             name;                                       /* NULL => DONE */
1860             name = BOP_NEXTPROP(bootops, name)) {       /* get next */
1861 
1862                 /* copy string to memory above kernelbase */
1863                 copy_boot_str(name, property_name, 50);
1864 
1865                 /*
1866                  * Skip vga properties. They will be picked up later
1867                  * by get_vga_properties.
1868                  */
1869                 if (strcmp(property_name, "display-edif-block") == 0 ||
1870                     strcmp(property_name, "display-edif-id") == 0) {
1871                         continue;
1872                 }
1873 
1874                 length = BOP_GETPROPLEN(bootops, property_name);
1875                 if (length == 0)
1876                         continue;
1877                 if (length > MMU_PAGESIZE) {
1878                         cmn_err(CE_NOTE,
1879                             "boot property %s longer than 0x%x, ignored\n",
1880                             property_name, MMU_PAGESIZE);
1881                         continue;
1882                 }
1883                 BOP_GETPROP(bootops, property_name, bop_staging_area);

1884 
1885                 /*
1886                  * special properties:
1887                  * si-machine, si-hw-provider
1888                  *      goes to kernel data structures.
1889                  * bios-boot-device and stdout
1890                  *      goes to hardware property list so it may show up
1891                  *      in the prtconf -vp output. This is needed by
1892                  *      Install/Upgrade. Once we fix install upgrade,
1893                  *      this can be taken out.
1894                  */
1895                 if (strcmp(name, "si-machine") == 0) {
1896                         (void) strncpy(utsname.machine, bop_staging_area,
1897                             SYS_NMLN);
1898                         utsname.machine[SYS_NMLN - 1] = (char)NULL;
1899                 } else if (strcmp(name, "si-hw-provider") == 0) {


1900                         (void) strncpy(hw_provider, bop_staging_area, SYS_NMLN);
1901                         hw_provider[SYS_NMLN - 1] = (char)NULL;
1902                 } else if (strcmp(name, "bios-boot-device") == 0) {


1903                         copy_boot_str(bop_staging_area, property_val, 50);
1904                         (void) ndi_prop_update_string(DDI_DEV_T_NONE, devi,
1905                             property_name, property_val);
1906                 } else if (strcmp(name, "acpi-root-tab") == 0) {
1907                         (void) ndi_prop_update_int64(DDI_DEV_T_NONE, devi,
1908                             property_name, *((int64_t *)bop_staging_area));
1909                 } else if (strcmp(name, "smbios-address") == 0) {
1910                         (void) ndi_prop_update_int64(DDI_DEV_T_NONE, devi,
1911                             property_name, *((int64_t *)bop_staging_area));
1912                 } else if (strcmp(name, "efi-systab") == 0) {
1913                         (void) ndi_prop_update_int64(DDI_DEV_T_NONE, devi,
1914                             property_name, *((int64_t *)bop_staging_area));
1915                 } else if (strcmp(name, "efi-systype") == 0) {
1916                         copy_boot_str(bop_staging_area, property_val, 50);
1917                         (void) ndi_prop_update_string(DDI_DEV_T_NONE, devi,
1918                             property_name, property_val);
1919                 } else if (strcmp(name, "stdout") == 0) {
1920                         (void) ndi_prop_update_int(DDI_DEV_T_NONE, devi,
1921                             property_name, *((int *)bop_staging_area));
1922                 } else if (strcmp(name, "boot-args") == 0) {
1923                         copy_boot_str(bop_staging_area, property_val, 50);






















1924                         (void) e_ddi_prop_update_string(DDI_DEV_T_NONE, devi,
1925                             property_name, property_val);
1926                 } else if (strcmp(name, "bootargs") == 0) {
1927                         copy_boot_str(bop_staging_area, property_val, 50);
1928                         (void) e_ddi_prop_update_string(DDI_DEV_T_NONE, devi,
1929                             property_name, property_val);
1930                 } else if (strcmp(name, "bootp-response") == 0) {
1931                         (void) e_ddi_prop_update_byte_array(DDI_DEV_T_NONE,
1932                             devi, property_name, bop_staging_area, length);
1933                 } else if (strcmp(name, "ramdisk_start") == 0) {
1934                         (void) e_ddi_prop_update_int64(DDI_DEV_T_NONE, devi,
1935                             property_name, *((int64_t *)bop_staging_area));
1936                 } else if (strcmp(name, "ramdisk_end") == 0) {
1937                         (void) e_ddi_prop_update_int64(DDI_DEV_T_NONE, devi,
1938                             property_name, *((int64_t *)bop_staging_area));
1939                 } else if (strncmp(name, "module-addr-", 12) == 0) {
1940                         (void) e_ddi_prop_update_int64(DDI_DEV_T_NONE, devi,
1941                             property_name, *((int64_t *)bop_staging_area));
1942                 } else if (strncmp(name, "module-size-", 12) == 0) {
1943                         (void) e_ddi_prop_update_int64(DDI_DEV_T_NONE, devi,
1944                             property_name, *((int64_t *)bop_staging_area));
1945                 } else {







1946                         /* Property type unknown, use old prop interface */
1947                         (void) e_ddi_prop_create(DDI_DEV_T_NONE, devi,
1948                             DDI_PROP_CANSLEEP, property_name, bop_staging_area,
1949                             length);
1950                 }
1951         }
1952 
1953         kmem_free(bop_staging_area, MMU_PAGESIZE);
1954 }
1955 
1956 static void
1957 get_vga_properties(void)
1958 {
1959         dev_info_t *devi;
1960         major_t major;
1961         char *name;
1962         int length;
1963         char property_val[50];
1964         void *bop_staging_area;
1965 

2001          * And you can set monitor type manually in kdmconfig
2002          * if you are really an old junky.
2003          */
2004         (void) ndi_prop_update_string(DDI_DEV_T_NONE,
2005             devi, "display-type", "color");
2006         (void) ndi_prop_update_string(DDI_DEV_T_NONE,
2007             devi, "video-adapter-type", "svga");
2008 
2009         name = "display-edif-id";
2010         length = BOP_GETPROPLEN(bootops, name);
2011         if (length > 0 && length < MMU_PAGESIZE) {
2012                 BOP_GETPROP(bootops, name, bop_staging_area);
2013                 copy_boot_str(bop_staging_area, property_val, length);
2014                 (void) ndi_prop_update_string(DDI_DEV_T_NONE,
2015                     devi, name, property_val);
2016         }
2017 
2018         kmem_free(bop_staging_area, MMU_PAGESIZE);
2019 }
2020 














2021 



































2022 /*
2023  * This is temporary, but absolutely necessary.  If we are being
2024  * booted with a device tree created by the DevConf project's bootconf
2025  * program, then we have device information nodes that reflect
2026  * reality.  At this point in time in the Solaris release schedule, the
2027  * kernel drivers aren't prepared for reality.  They still depend on their
2028  * own ad-hoc interpretations of the properties created when their .conf
2029  * files were interpreted. These drivers use an "ignore-hardware-nodes"
2030  * property to prevent them from using the nodes passed up from the bootconf
2031  * device tree.
2032  *
2033  * Trying to assemble root file system drivers as we are booting from
2034  * devconf will fail if the kernel driver is basing its name_addr's on the
2035  * psuedo-node device info while the bootpath passed up from bootconf is using
2036  * reality-based name_addrs.  We help the boot along in this case by
2037  * looking at the pre-bootconf bootpath and determining if we would have
2038  * successfully matched if that had been the bootpath we had chosen.
2039  *
2040  * Note that we only even perform this extra check if we've booted
2041  * using bootconf's 1275 compliant bootpath, this is the boot device, and

2553 
2554         /* isa node */
2555         if (pseudo_isa) {
2556                 ndi_devi_alloc_sleep(ddi_root_node(), "isa",
2557                     (pnode_t)DEVI_SID_NODEID, &isa_dip);
2558                 (void) ndi_prop_update_string(DDI_DEV_T_NONE, isa_dip,
2559                     "device_type", "isa");
2560                 (void) ndi_prop_update_string(DDI_DEV_T_NONE, isa_dip,
2561                     "bus-type", "isa");
2562                 (void) ndi_devi_bind_driver(isa_dip, 0);
2563         }
2564 
2565         /*
2566          * Read in the properties from the boot.
2567          */
2568         get_boot_properties();
2569 
2570         /* not framebuffer should be enumerated, if present */
2571         get_vga_properties();
2572 



2573         /*
2574          * Check for administratively disabled drivers.
2575          */
2576         check_driver_disable();
2577 
2578 #if !defined(__xpv)
2579         if (!post_fastreboot && BOP_GETPROPLEN(bootops, "efi-systab") < 0)
2580                 startup_bios_disk();
2581 #endif
2582         /* do bus dependent probes. */
2583         impl_bus_initialprobe();
2584 }
2585 
2586 dev_t
2587 getrootdev(void)
2588 {
2589         /*
2590          * Usually rootfs.bo_name is initialized by the
2591          * the bootpath property from bootenv.rc, but
2592          * defaults to "/ramdisk:a" otherwise.

  51 #include <sys/sysmacros.h>
  52 #include <sys/systeminfo.h>
  53 #include <sys/utsname.h>
  54 #include <sys/atomic.h>
  55 #include <sys/spl.h>
  56 #include <sys/archsystm.h>
  57 #include <vm/seg_kmem.h>
  58 #include <sys/ontrap.h>
  59 #include <sys/fm/protocol.h>
  60 #include <sys/ramdisk.h>
  61 #include <sys/sunndi.h>
  62 #include <sys/vmem.h>
  63 #include <sys/pci_impl.h>
  64 #if defined(__xpv)
  65 #include <sys/hypervisor.h>
  66 #endif
  67 #include <sys/mach_intr.h>
  68 #include <vm/hat_i86.h>
  69 #include <sys/x86_archext.h>
  70 #include <sys/avl.h>
  71 #include <sys/font.h>
  72 
  73 /*
  74  * DDI Boot Configuration
  75  */
  76 
  77 /*
  78  * Platform drivers on this platform
  79  */
  80 char *platform_module_list[] = {
  81         "acpippm",
  82         "ppm",
  83         (char *)0
  84 };
  85 
  86 /* pci bus resource maps */
  87 struct pci_bus_resource *pci_bus_res;
  88 
  89 size_t dma_max_copybuf_size = 0x101000;         /* 1M + 4K */
  90 
  91 uint64_t ramdisk_start, ramdisk_end;

1825 {
1826         int i = 0;
1827 
1828         while (i < len - 1 && boot_str[i] != '\0') {
1829                 kern_str[i] = boot_str[i];
1830                 i++;
1831         }
1832 
1833         kern_str[i] = 0;        /* null terminate */
1834         if (boot_str[i] != '\0')
1835                 cmn_err(CE_WARN,
1836                     "boot property string is truncated to %s", kern_str);
1837 }
1838 
1839 static void
1840 get_boot_properties(void)
1841 {
1842         extern char hw_provider[];
1843         dev_info_t *devi;
1844         char *name;
1845         int length, flags;
1846         char property_name[50], property_val[50];
1847         void *bop_staging_area;
1848 
1849         bop_staging_area = kmem_zalloc(MMU_PAGESIZE, KM_NOSLEEP);
1850 
1851         /*
1852          * Import "root" properties from the boot.
1853          *
1854          * We do this by invoking BOP_NEXTPROP until the list
1855          * is completely copied in.
1856          */
1857 
1858         devi = ddi_root_node();
1859         for (name = BOP_NEXTPROP(bootops, "");          /* get first */
1860             name;                                       /* NULL => DONE */
1861             name = BOP_NEXTPROP(bootops, name)) {       /* get next */
1862 
1863                 /* copy string to memory above kernelbase */
1864                 copy_boot_str(name, property_name, 50);
1865 
1866                 /*
1867                  * Skip vga properties. They will be picked up later
1868                  * by get_vga_properties.
1869                  */
1870                 if (strcmp(property_name, "display-edif-block") == 0 ||
1871                     strcmp(property_name, "display-edif-id") == 0) {
1872                         continue;
1873                 }
1874 
1875                 length = BOP_GETPROPLEN(bootops, property_name);
1876                 if (length < 0)
1877                         continue;
1878                 if (length > MMU_PAGESIZE) {
1879                         cmn_err(CE_NOTE,
1880                             "boot property %s longer than 0x%x, ignored\n",
1881                             property_name, MMU_PAGESIZE);
1882                         continue;
1883                 }
1884                 BOP_GETPROP(bootops, property_name, bop_staging_area);
1885                 flags = do_bsys_getproptype(bootops, property_name);
1886 
1887                 /*
1888                  * special properties:
1889                  * si-machine, si-hw-provider
1890                  *      goes to kernel data structures.
1891                  * bios-boot-device and stdout
1892                  *      goes to hardware property list so it may show up
1893                  *      in the prtconf -vp output. This is needed by
1894                  *      Install/Upgrade. Once we fix install upgrade,
1895                  *      this can be taken out.
1896                  */
1897                 if (strcmp(name, "si-machine") == 0) {
1898                         (void) strncpy(utsname.machine, bop_staging_area,
1899                             SYS_NMLN);
1900                         utsname.machine[SYS_NMLN - 1] = '\0';
1901                         continue;
1902                 }
1903                 if (strcmp(name, "si-hw-provider") == 0) {
1904                         (void) strncpy(hw_provider, bop_staging_area, SYS_NMLN);
1905                         hw_provider[SYS_NMLN - 1] = '\0';
1906                         continue;
1907                 }
1908                 if (strcmp(name, "bios-boot-device") == 0) {
1909                         copy_boot_str(bop_staging_area, property_val, 50);
1910                         (void) ndi_prop_update_string(DDI_DEV_T_NONE, devi,
1911                             property_name, property_val);
1912                         continue;
1913                 }
1914                 if (strcmp(name, "stdout") == 0) {











1915                         (void) ndi_prop_update_int(DDI_DEV_T_NONE, devi,
1916                             property_name, *((int *)bop_staging_area));
1917                         continue;
1918                 }
1919 
1920                 /* Boolean property */
1921                 if (length == 0) {
1922                         (void) e_ddi_prop_create(DDI_DEV_T_NONE, devi,
1923                             DDI_PROP_CANSLEEP, property_name, NULL, 0);
1924                         continue;
1925                 }
1926 
1927                 /* Now anything else based on type. */
1928                 switch (flags) {
1929                 case DDI_PROP_TYPE_INT:
1930                         if (length == sizeof (int)) {
1931                                 (void) e_ddi_prop_update_int(DDI_DEV_T_NONE,
1932                                     devi, property_name,
1933                                     *((int *)bop_staging_area));
1934                         } else {
1935                                 (void) e_ddi_prop_update_int_array(
1936                                     DDI_DEV_T_NONE, devi, property_name,
1937                                     bop_staging_area, length / sizeof (int));
1938                         }
1939                         break;
1940                 case DDI_PROP_TYPE_STRING:
1941                         (void) e_ddi_prop_update_string(DDI_DEV_T_NONE, devi,
1942                             property_name, bop_staging_area);
1943                         break;
1944                 case DDI_PROP_TYPE_BYTE:



1945                         (void) e_ddi_prop_update_byte_array(DDI_DEV_T_NONE,
1946                             devi, property_name, bop_staging_area, length);
1947                         break;
1948                 case DDI_PROP_TYPE_INT64:
1949                         if (length == sizeof (uint64_t)) {
1950                                 (void) e_ddi_prop_update_int64(DDI_DEV_T_NONE,
1951                                     devi, property_name,
1952                                     *((uint64_t *)bop_staging_area));






1953                         } else {
1954                                 (void) e_ddi_prop_update_int64_array(
1955                                     DDI_DEV_T_NONE, devi, property_name,
1956                                     bop_staging_area,
1957                                     length / sizeof (uint64_t));
1958                         }
1959                         break;
1960                 default:
1961                         /* Property type unknown, use old prop interface */
1962                         (void) e_ddi_prop_create(DDI_DEV_T_NONE, devi,
1963                             DDI_PROP_CANSLEEP, property_name, bop_staging_area,
1964                             length);
1965                 }
1966         }
1967 
1968         kmem_free(bop_staging_area, MMU_PAGESIZE);
1969 }
1970 
1971 static void
1972 get_vga_properties(void)
1973 {
1974         dev_info_t *devi;
1975         major_t major;
1976         char *name;
1977         int length;
1978         char property_val[50];
1979         void *bop_staging_area;
1980 

2016          * And you can set monitor type manually in kdmconfig
2017          * if you are really an old junky.
2018          */
2019         (void) ndi_prop_update_string(DDI_DEV_T_NONE,
2020             devi, "display-type", "color");
2021         (void) ndi_prop_update_string(DDI_DEV_T_NONE,
2022             devi, "video-adapter-type", "svga");
2023 
2024         name = "display-edif-id";
2025         length = BOP_GETPROPLEN(bootops, name);
2026         if (length > 0 && length < MMU_PAGESIZE) {
2027                 BOP_GETPROP(bootops, name, bop_staging_area);
2028                 copy_boot_str(bop_staging_area, property_val, length);
2029                 (void) ndi_prop_update_string(DDI_DEV_T_NONE,
2030                     devi, name, property_val);
2031         }
2032 
2033         kmem_free(bop_staging_area, MMU_PAGESIZE);
2034 }
2035 
2036 /*
2037  * Copy console font to kernel memory. The temporary font setup
2038  * to use font module was done in early console setup, using low
2039  * memory and data from font module. Now we need to allocate
2040  * kernel memory and copy data over, so the low memory can be freed.
2041  * We can have at most one entry in font list from early boot.
2042  */
2043 static void
2044 get_console_font(void)
2045 {
2046         struct fontlist *fp, *fl;
2047         bitmap_data_t *bd;
2048         struct font *fd, *tmp;
2049         int i;
2050 
2051         if (STAILQ_EMPTY(&fonts))
2052                 return;
2053 
2054         fl = STAILQ_FIRST(&fonts);
2055         STAILQ_REMOVE_HEAD(&fonts, font_next);
2056         fp = kmem_zalloc(sizeof (*fp), KM_SLEEP);
2057         bd = kmem_zalloc(sizeof (*bd), KM_SLEEP);
2058         fd = kmem_zalloc(sizeof (*fd), KM_SLEEP);
2059 
2060         fp->font_name = NULL;
2061         fp->font_flags = FONT_BOOT;
2062         fp->font_data = bd;
2063 
2064         bd->width = fl->font_data->width;
2065         bd->height = fl->font_data->height;
2066         bd->uncompressed_size = fl->font_data->uncompressed_size;
2067         bd->font = fd;
2068 
2069         tmp = fl->font_data->font;
2070         fd->vf_width = tmp->vf_width;
2071         fd->vf_height = tmp->vf_height;
2072         for (i = 0; i < VFNT_MAPS; i++) {
2073                 if (tmp->vf_map_count[i] == 0)
2074                         continue;
2075                 fd->vf_map_count[i] = tmp->vf_map_count[i];
2076                 fd->vf_map[i] = kmem_alloc(fd->vf_map_count[i] *
2077                     sizeof (*fd->vf_map[i]), KM_SLEEP);
2078                 bcopy(tmp->vf_map[i], fd->vf_map[i], fd->vf_map_count[i] *
2079                     sizeof (*fd->vf_map[i]));
2080         }
2081         fd->vf_bytes = kmem_alloc(bd->uncompressed_size, KM_SLEEP);
2082         bcopy(tmp->vf_bytes, fd->vf_bytes, bd->uncompressed_size);
2083         STAILQ_INSERT_HEAD(&fonts, fp, font_next);
2084 }
2085 
2086 /*
2087  * This is temporary, but absolutely necessary.  If we are being
2088  * booted with a device tree created by the DevConf project's bootconf
2089  * program, then we have device information nodes that reflect
2090  * reality.  At this point in time in the Solaris release schedule, the
2091  * kernel drivers aren't prepared for reality.  They still depend on their
2092  * own ad-hoc interpretations of the properties created when their .conf
2093  * files were interpreted. These drivers use an "ignore-hardware-nodes"
2094  * property to prevent them from using the nodes passed up from the bootconf
2095  * device tree.
2096  *
2097  * Trying to assemble root file system drivers as we are booting from
2098  * devconf will fail if the kernel driver is basing its name_addr's on the
2099  * psuedo-node device info while the bootpath passed up from bootconf is using
2100  * reality-based name_addrs.  We help the boot along in this case by
2101  * looking at the pre-bootconf bootpath and determining if we would have
2102  * successfully matched if that had been the bootpath we had chosen.
2103  *
2104  * Note that we only even perform this extra check if we've booted
2105  * using bootconf's 1275 compliant bootpath, this is the boot device, and

2617 
2618         /* isa node */
2619         if (pseudo_isa) {
2620                 ndi_devi_alloc_sleep(ddi_root_node(), "isa",
2621                     (pnode_t)DEVI_SID_NODEID, &isa_dip);
2622                 (void) ndi_prop_update_string(DDI_DEV_T_NONE, isa_dip,
2623                     "device_type", "isa");
2624                 (void) ndi_prop_update_string(DDI_DEV_T_NONE, isa_dip,
2625                     "bus-type", "isa");
2626                 (void) ndi_devi_bind_driver(isa_dip, 0);
2627         }
2628 
2629         /*
2630          * Read in the properties from the boot.
2631          */
2632         get_boot_properties();
2633 
2634         /* not framebuffer should be enumerated, if present */
2635         get_vga_properties();
2636 
2637         /* Copy console font if provided by boot. */
2638         get_console_font();
2639 
2640         /*
2641          * Check for administratively disabled drivers.
2642          */
2643         check_driver_disable();
2644 
2645 #if !defined(__xpv)
2646         if (!post_fastreboot && BOP_GETPROPLEN(bootops, "efi-systab") < 0)
2647                 startup_bios_disk();
2648 #endif
2649         /* do bus dependent probes. */
2650         impl_bus_initialprobe();
2651 }
2652 
2653 dev_t
2654 getrootdev(void)
2655 {
2656         /*
2657          * Usually rootfs.bo_name is initialized by the
2658          * the bootpath property from bootenv.rc, but
2659          * defaults to "/ramdisk:a" otherwise.