arch/x86/kernel/platform/i86pc/os/biosdisk.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
  26 #include <sys/types.h>
  27 #include <sys/param.h>
  28 #include <sys/controlregs.h>
  29 #include <sys/bootconf.h>
  30 #include <sys/bootvfs.h>
  31 #include <sys/bootregs.h>
  32 #include <sys/bootconf.h>
  33 #include <sys/conf.h>
  34 #include <sys/promif.h>
  35 #include <sys/ddi.h>
  36 #include <sys/sunddi.h>
  37 #include <sys/sunndi.h>
  38 #include <sys/biosdisk.h>
  39 #include <sys/psw.h>
  40
  41 extern int prom_debug;
  42
  43 /* hard code realmode memory address for now */
  44 #define BIOS_RES_BUFFER_ADDR            0x7000
  45
  46 #define BIOSDEV_NUM     8
  47 #define STARTING_DRVNUM 0x80
  48 #define FP_OFF(fp) (((uintptr_t)(fp)) & 0xFFFF)
  49 #define FP_SEG(fp) ((((uintptr_t)(fp)) >> 16) & 0xFFFF)
  50
  51 #ifdef DEBUG
  52 int biosdebug = 0;
  53 #define dprintf(fmt) \
  54         if (biosdebug) \
  55                 prom_printf fmt
  56 #else
  57 #define dprintf(fmt)
  58 #endif
  59
  60 biosdev_data_t biosdev_info[BIOSDEV_NUM]; /* from 0x80 to 0x87 */
  61
  62
  63 static int bios_check_extension_present(uchar_t);
  64 static int get_dev_params(uchar_t);
  65 static int read_firstblock(uchar_t drivenum);
  66 static int drive_present(uchar_t drivenum);
  67 static void reset_disk(uchar_t drivenum);
  68 static int is_eltorito(uchar_t drivenum);
  69
  70 void
  71 startup_bios_disk()
  72 {
  73         uchar_t drivenum;
  74         int got_devparams = 0;
  75         int got_first_block = 0;
  76         uchar_t name[20];
  77         dev_info_t      *devi;
  78         int extensions;
  79
  80         for (drivenum = 0x80; drivenum < (0x80 + BIOSDEV_NUM); drivenum++) {
  81
  82                 if (!drive_present(drivenum))
  83                         continue;
  84
  85                 extensions = bios_check_extension_present(drivenum);
  86
  87                 /*
  88                  * If we're booting from an Eltorito CD/DVD image, there's
  89                  * no need to get the device parameters or read the first block
  90                  * because we'll never install onto this device.
  91                  */
  92                 if (extensions && is_eltorito(drivenum))
  93                         continue;
  94
  95                 if (extensions && get_dev_params(drivenum))
  96                         got_devparams = 1;
  97                 else
  98                         got_devparams = 0;
  99
 100                 if ((got_first_block = read_firstblock(drivenum)) == 0) {
 101                         /* retry */
 102                         got_first_block = read_firstblock(drivenum);
 103                 }
 104
 105                 if (got_devparams || got_first_block) {
 106                         (void) sprintf((char *)name, "biosdev-0x%x", drivenum);
 107                         devi = ddi_root_node();
 108                         (void) e_ddi_prop_update_byte_array(DDI_DEV_T_NONE,
 109                             devi, (char *)name,
 110                             (uchar_t *)&biosdev_info[drivenum - 0x80],
 111                             sizeof (biosdev_data_t));
 112                 }
 113         }
 114 }
 115
 116 static int
 117 bios_check_extension_present(uchar_t drivenum)
 118 {
 119         struct bop_regs rp = {0};
 120         extern struct bootops           *bootops;
 121
 122         rp.eax.word.ax = 0x4100;
 123         rp.ebx.word.bx = 0x55AA;
 124         rp.edx.word.dx = drivenum;
 125
 126         /* make sure we have extension support */
 127         BOP_DOINT(bootops, 0x13, &rp);
 128
 129         if (((rp.eflags & PS_C) != 0) || (rp.ebx.word.bx != 0xAA55)) {
 130                 dprintf(("bios_check_extension_present int13 fn 41 "
 131                     "failed %d bx = %x\n", rp.eflags, rp.ebx.word.bx));
 132                 return (0);
 133         }
 134
 135         if ((rp.ecx.word.cx & 0x7) == 0) {
 136                 dprintf(("bios_check_extension_present get device parameters "
 137                     "not supported cx = %x\n", rp.ecx.word.cx));
 138                 return (0);
 139         }
 140
 141         return (1);
 142 }
 143
 144 static int
 145 get_dev_params(uchar_t drivenum)
 146 {
 147         struct bop_regs rp = {0};
 148         fn48_t   *bufp;
 149         extern struct bootops           *bootops;
 150         int i;
 151         int index;
 152         uchar_t *tmp;
 153
 154         dprintf(("In get_dev_params\n"));
 155
 156         bufp = (fn48_t *)BIOS_RES_BUFFER_ADDR;
 157
 158         /*
 159          * We cannot use bzero here as we're initializing data
 160          * at an address below kernel base.
 161          */
 162         for (i = 0; i < sizeof (*bufp); i++)
 163                 ((uchar_t *)bufp)[i] = 0;
 164
 165         bufp->buflen = sizeof (*bufp);
 166         rp.eax.word.ax = 0x4800;
 167         rp.edx.byte.dl = drivenum;
 168
 169         rp.esi.word.si = (uint16_t)FP_OFF((uint_t)(uintptr_t)bufp);
 170         rp.ds = FP_SEG((uint_t)(uintptr_t)bufp);
 171
 172         BOP_DOINT(bootops, 0x13, &rp);
 173
 174         if ((rp.eflags & PS_C) != 0) {
 175                 dprintf(("EDD FAILED on drive eflag = %x ah= %x\n",
 176                     rp.eflags, rp.eax.byte.ah));
 177                 return (0);
 178         }
 179
 180         index = drivenum - 0x80;
 181         biosdev_info[index].edd_valid = 1;
 182
 183         /*
 184          * Some compilers turn a structure copy into a call
 185          * to memcpy.  Since we are copying data below kernel
 186          * base intentionally, and memcpy asserts that's not
 187          * the case, we do the copy manually here.
 188          */
 189         tmp = (uchar_t *)&biosdev_info[index].fn48_dev_params;
 190         for (i = 0; i < sizeof (*bufp); i++)
 191                 tmp[i] = ((uchar_t *)bufp)[i];
 192
 193         return (1);
 194 }
 195
 196 static int
 197 drive_present(uchar_t drivenum)
 198 {
 199         struct bop_regs rp = {0};
 200
 201         rp.eax.byte.ah = 0x8;   /* get params */
 202         rp.edx.byte.dl = drivenum;
 203
 204         BOP_DOINT(bootops, 0x13, &rp);
 205
 206         if (((rp.eflags & PS_C) != 0) || rp.eax.byte.ah != 0) {
 207                 dprintf(("drive not present drivenum %x eflag %x ah %x\n",
 208                     drivenum, rp.eflags, rp.eax.byte.ah));
 209                 return (0);
 210         }
 211
 212         dprintf(("drive-present %x\n", drivenum));
 213         return (1);
 214 }
 215
 216 static void
 217 reset_disk(uchar_t drivenum)
 218 {
 219         struct bop_regs rp = {0};
 220         int status;
 221
 222         rp.eax.byte.ah = 0x0;   /* reset disk */
 223         rp.edx.byte.dl = drivenum;
 224
 225         BOP_DOINT(bootops, 0x13, &rp);
 226
 227         status = rp.eax.byte.ah;
 228
 229         if (((rp.eflags & PS_C) != 0) || status != 0)
 230                 dprintf(("Bad disk reset driv %x, status %x\n", drivenum,
 231                     status));
 232 }
 233
 234 /* Get first block */
 235 static int
 236 read_firstblock(uchar_t drivenum)
 237 {
 238
 239         struct bop_regs rp = {0};
 240         caddr_t  bufp;
 241         uchar_t status;
 242         int i, index;
 243
 244
 245         reset_disk(drivenum);
 246         bufp = (caddr_t)BIOS_RES_BUFFER_ADDR;
 247
 248
 249         rp.eax.byte.ah = 0x2;   /* Read disk */
 250         rp.eax.byte.al = 1;     /* nsect */
 251         rp.ecx.byte.ch = 0;     /* cyl & 0xff */
 252         rp.ecx.byte.cl = 1;     /* cyl >> 2 & 0xc0 (sector number) */
 253         rp.edx.byte.dh = 0;     /* head */
 254         rp.edx.byte.dl = drivenum;      /* drivenum */
 255
 256         /* es:bx is buf address */
 257         rp.ebx.word.bx = (uint16_t)FP_OFF((uint_t)(uintptr_t)bufp);
 258         rp.es = FP_SEG((uint_t)(uintptr_t)bufp);
 259
 260         BOP_DOINT(bootops, 0x13, &rp);
 261
 262         status = rp.eax.byte.ah;
 263         if (((rp.eflags & PS_C) != 0) || status != 0) {
 264                 dprintf(("read_firstblock AH not clear %x \n", status));
 265                 return (0);
 266         }
 267
 268         dprintf(("drivenum %x uid at 0x1b8 is %x\n", drivenum,
 269             *(uint32_t *)(bufp +0x1b8)));
 270
 271         index = drivenum - 0x80;
 272
 273         biosdev_info[index].first_block_valid = 1;
 274         for (i = 0; i < 512; i++)
 275                 biosdev_info[index].first_block[i] = *((uchar_t *)bufp + i);
 276
 277         return (1);
 278 }
 279
 280 static int
 281 is_eltorito(uchar_t drivenum)
 282 {
 283         struct bop_regs rp = {0};
 284         fn4b_t   *bufp;
 285         extern struct bootops           *bootops;
 286         int i;
 287
 288         dprintf(("In is_eltorito\n"));
 289
 290         bufp = (fn4b_t *)BIOS_RES_BUFFER_ADDR;
 291
 292         /*
 293          * We cannot use bzero here as we're initializing data
 294          * at an address below kernel base.
 295          */
 296         for (i = 0; i < sizeof (*bufp); i++)
 297                 ((uchar_t *)bufp)[i] = 0;
 298
 299         bufp->pkt_size = sizeof (*bufp);
 300         rp.eax.word.ax = 0x4b01;
 301         rp.edx.byte.dl = drivenum;
 302
 303         rp.esi.word.si = (uint16_t)FP_OFF((uint_t)(uintptr_t)bufp);
 304         rp.ds = FP_SEG((uint_t)(uintptr_t)bufp);
 305
 306         BOP_DOINT(bootops, 0x13, &rp);
 307
 308         if ((rp.eflags & PS_C) != 0 || bufp->drivenum != drivenum) {
 309                 dprintf(("fn 0x4b01 FAILED on drive "
 310                     "eflags=%x ah=%x drivenum=%x\n",
 311                     rp.eflags, rp.eax.byte.ah, bufp->drivenum));
 312                 return (0);
 313         }
 314
 315         if (prom_debug)
 316                 prom_printf("INT13 FN4B01 mtype => %x", bufp->boot_mtype);
 317
 318         return (1);
 319 }