root/arch/i386/stand/libsa/biosdev.c

DEFINITIONS

1. biosdreset
2. bios_getdiskinfo
3. CHS_rw
4. EDD_rw
5. biosd_io
6. bios_getdisklabel
7. biosopen
8. biosdisk_err
9. biosdisk_errno
10. biosstrategy
11. biosclose
12. biosioctl

    1 /*      $OpenBSD: biosdev.c,v 1.72 2007/05/27 00:57:17 tom Exp $        */
    3 /*
    4  * Copyright (c) 1996 Michael Shalayeff
    5  * Copyright (c) 2003 Tobias Weingartner
    6  * All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   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
   19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  *
   29  */
   31 #include <sys/param.h>
   32 #include <sys/reboot.h>
   33 #include <sys/disklabel.h>
   34 #include <machine/tss.h>
   35 #include <machine/biosvar.h>
   36 #include <lib/libsa/saerrno.h>
   37 #include <isofs/cd9660/iso.h>
   38 #include "disk.h"
   39 #include "debug.h"
   40 #include "libsa.h"
   41 #include "biosdev.h"
   43 static const char *biosdisk_err(u_int);
   44 static int biosdisk_errno(u_int);
   46 static int CHS_rw (int, int, int, int, int, int, void *);
   47 static int EDD_rw (int, int, u_int64_t, u_int32_t, void *);
   49 extern int debug;
   50 int bios_bootdev;
   51 int bios_cddev = -1;            /* Set by srt0 if coming from CD */
   53 #if 0
   54 struct biosdisk {
bios_diskinfo_t *bios_info;
dev_t   bsddev;
   57         struct disklabel disklabel;
   58 };
   59 #endif
   61 struct EDD_CB {
u_int8_t  edd_len;      /* size of packet */
u_int8_t  edd_res1;     /* reserved */
u_int8_t  edd_nblk;     /* # of blocks to transfer */
u_int8_t  edd_res2;     /* reserved */
u_int16_t edd_off;      /* address of buffer (offset) */
u_int16_t edd_seg;      /* address of buffer (segment) */
u_int64_t edd_daddr;    /* starting block */
   69 };
   71 /*
   72  * reset disk system
   73  */
   74 static int
biosdreset(int dev)
   76 {
   77         int rv;
   79         __asm __volatile (DOINT(0x13) "; setc %b0" : "=a" (rv)
   80             : "0" (0), "d" (dev) : "%ecx", "cc");
   82         return ((rv & 0xff)? rv >> 8 : 0);
   83 }
   85 /*
   86  * Fill out a bios_diskinfo_t for this device.
   87  * Return 0 if all ok.
   88  * Return 1 if not ok.
   89  */
   90 int
bios_getdiskinfo(int dev, bios_diskinfo_t *pdi)
   92 {
u_int rv;
   95         /* Just reset, don't check return code */
rv = biosdreset(dev);
   98 #ifdef BIOS_DEBUG
   99         if (debug)
printf("getinfo: try #8, 0x%x, %p\n", dev, pdi);
  101 #endif
  102         __asm __volatile (DOINT(0x13) "\n\t"
  103             "setc %b0; movzbl %h1, %1\n\t"
  104             "movzbl %%cl, %3; andb $0x3f, %b3\n\t"
  105             "xchgb %%cl, %%ch; rolb $2, %%ch"
  106             : "=a" (rv), "=d" (pdi->bios_heads),
  107               "=c" (pdi->bios_cylinders),
  108               "=b" (pdi->bios_sectors)
  109             : "0" (0x0800), "1" (dev) : "cc");
  111 #ifdef BIOS_DEBUG
  112         if (debug) {
printf("getinfo: got #8\n");
printf("disk 0x%x: %d,%d,%d\n", dev, pdi->bios_cylinders,
pdi->bios_heads, pdi->bios_sectors);
  116         }
  117 #endif
  118         if (rv & 0xff)
  119                 return 1;
  121         /* Fix up info */
pdi->bios_number = dev;
pdi->bios_heads++;
pdi->bios_cylinders &= 0x3ff;
pdi->bios_cylinders++;
  127         /* Sanity check */
  128         if (!pdi->bios_cylinders || !pdi->bios_heads || !pdi->bios_sectors)
  129                 return 1;
  131         /* CD-ROMs sometimes return heads == 1 */
  132         if (pdi->bios_heads < 2)
  133                 return 1;
  135         /* NOTE:
  136          * This currently hangs/reboots some machines
  137          * The IBM ThinkPad 750ED for one.
  138          *
  139          * Funny that an IBM/MS extension would not be
  140          * implemented by an IBM system...
  141          *
  142          * Future hangs (when reported) can be "fixed"
  143          * with getSYSCONFaddr() and an exceptions list.
  144          */
  145         if (dev & 0x80 && (dev == 0x80 || dev == 0x81 || dev == bios_bootdev)) {
  146                 int bm;
  148 #ifdef BIOS_DEBUG
  149                 if (debug)
printf("getinfo: try #41, 0x%x\n", dev);
  151 #endif
  152                 /* EDD support check */
  153                 __asm __volatile(DOINT(0x13) "; setc %b0"
  154                          : "=a" (rv), "=c" (bm)
  155                          : "0" (0x4100), "b" (0x55aa), "d" (dev) : "cc");
  156                 if (!(rv & 0xff) && (BIOS_regs.biosr_bx & 0xffff) == 0xaa55)
pdi->bios_edd = (bm & 0xffff) | ((rv & 0xff) << 16);
  158                 else
pdi->bios_edd = -1;
  161 #ifdef BIOS_DEBUG
  162                 if (debug) {
printf("getinfo: got #41\n");
printf("disk 0x%x: 0x%x\n", dev, bm);
  165                 }
  166 #endif
  167                 /*
  168                  * If extended disk access functions are not supported
  169                  * there is not much point on doing EDD.
  170                  */
  171                 if (!(pdi->bios_edd & EXT_BM_EDA))
pdi->bios_edd = -1;
  173         } else
pdi->bios_edd = -1;
  176         return 0;
  177 }
  179 /*
  180  * Read/Write a block from given place using the BIOS.
  181  */
  182 static __inline int
CHS_rw(int rw, int dev, int cyl, int head, int sect, int nsect, void *buf)
  184 {
  185         int rv;
rw = rw == F_READ ? 2 : 3;
BIOS_regs.biosr_es = (u_int32_t)buf >> 4;
  189         __asm __volatile ("movb %b7, %h1\n\t"
  190             "movb %b6, %%dh\n\t"
  191             "andl $0xf, %4\n\t"
  192             /* cylinder; the highest 2 bits of cyl is in %cl */
  193             "xchgb %%ch, %%cl\n\t"
  194             "rorb  $2, %%cl\n\t"
  195             "orb %b5, %%cl\n\t"
  196             "inc %%cx\n\t"
DOINT(0x13) "\n\t"
  198             "setc %b0"
  199             : "=a" (rv)
  200             : "0" (nsect), "d" (dev), "c" (cyl),
  201               "b" (buf), "m" (sect), "m" (head),
  202               "m" (rw)
  203             : "cc", "memory");
  205         return ((rv & 0xff)? rv >> 8 : 0);
  206 }
  208 static __inline int
EDD_rw(int rw, int dev, u_int64_t daddr, u_int32_t nblk, void *buf)
  210 {
  211         int rv;
  212         volatile static struct EDD_CB cb;
  214         /* Zero out reserved stuff */
cb.edd_res1 = 0;
cb.edd_res2 = 0;
  218         /* Fill in parameters */
cb.edd_len = sizeof(cb);
cb.edd_nblk = nblk;
cb.edd_seg = ((u_int32_t)buf >> 4) & 0xffff;
cb.edd_off = (u_int32_t)buf & 0xf;
cb.edd_daddr = daddr;
  225         /* if offset/segment are zero, punt */
  226         if (!cb.edd_seg && !cb.edd_off)
  227                 return 1;
  229         /* Call extended read/write (with disk packet) */
BIOS_regs.biosr_ds = (u_int32_t)&cb >> 4;
  231         __asm __volatile (DOINT(0x13) "; setc %b0" : "=a" (rv)
  232             : "0" ((rw == F_READ)? 0x4200: 0x4300),
  233               "d" (dev), "S" ((int) (&cb) & 0xf) : "%ecx", "cc");
  234         return ((rv & 0xff)? rv >> 8 : 0);
  235 }
  237 /*
  238  * Read given sector, handling retry/errors/etc.
  239  */
  240 int
biosd_io(int rw, bios_diskinfo_t *bd, daddr_t off, int nsect, void *buf)
  242 {
  243         int dev = bd->bios_number;
  244         int j, error;
  245         void *bb;
  246         int bbsize = nsect * DEV_BSIZE;
  248         if (bd->flags & BDI_EL_TORITO) {        /* It's a CD device */
dev &= 0xff;                    /* Mask out this flag bit */
  251                 /*
  252                  * sys/lib/libsa/cd9600.c converts 2,048-byte CD sectors
  253                  * to DEV_BSIZE blocks before calling the device strategy
  254                  * routine.  However, the El Torito spec says that the
  255                  * BIOS will work in 2,048-byte sectors.  So shift back.
  256                  */
off >>= (ISO_DEFAULT_BLOCK_SHIFT - DEV_BSHIFT);
nsect >>= (ISO_DEFAULT_BLOCK_SHIFT - DEV_BSHIFT);
  259         }
  261         /*
  262          * Use a bounce buffer to not cross 64k DMA boundary, and to
  263          * not access 1 MB or above.
  264          */
  265         if (((((u_int32_t)buf) & ~0xffff) !=
  266             (((u_int32_t)buf + bbsize) & ~0xffff)) ||
  267             (((u_int32_t)buf) >= 0x100000)) {
  268                 /*
  269                  * XXX we believe that all the io is buffered
  270                  * by fs routines, so no big reads anyway
  271                  */
bb = alloca(bbsize);
  273                 if (rw != F_READ)
bcopy(buf, bb, bbsize);
  275         } else
bb = buf;
  278         /* Try to do operation up to 5 times */
  279         for (error = 1, j = 5; j-- && error; ) {
  280                 /* CHS or LBA access? */
  281                 if (bd->bios_edd != -1) {
error = EDD_rw(rw, dev, off, nsect, bb);
  283                 } else {
  284                         int cyl, head, sect;
size_t i, n;
  286                         char *p = bb;
  288                         /* Handle track boundaries */
  289                         for (error = i = 0; error == 0 && i < nsect;
i += n, off += n, p += n * DEV_BSIZE) {
btochs(off, cyl, head, sect, bd->bios_heads,
bd->bios_sectors);
  295                                 if ((sect + (nsect - i)) >= bd->bios_sectors)
n = bd->bios_sectors - sect;
  297                                 else
n = nsect - i;
error = CHS_rw(rw, dev, cyl, head, sect, n, p);
  302                                 /* ECC corrected */
  303                                 if (error == 0x11)
error = 0;
  305                         }
  306                 }
  307                 switch (error) {
  308                 case 0x00:      /* No errors */
  309                 case 0x11:      /* ECC corrected */
error = 0;
  311                         break;
  313                 default:        /* All other errors */
  314 #ifdef BIOS_DEBUG
  315                         if (debug)
printf("\nBIOS error 0x%x (%s)\n",
error, biosdisk_err(error));
  318 #endif
biosdreset(dev);
  320                         break;
  321                 }
  322         }
  324         if (bb != buf && rw == F_READ)
bcopy(bb, buf, bbsize);
  327 #ifdef BIOS_DEBUG
  328         if (debug) {
  329                 if (error != 0)
printf("=0x%x(%s)", error, biosdisk_err(error));
putchar('\n');
  332         }
  333 #endif
  335         return error;
  336 }
  338 /*
  339  * Try to read the bsd label on the given BIOS device
  340  */
  341 const char *
bios_getdisklabel(bios_diskinfo_t *bd, struct disklabel *label)
  343 {
daddr_t off = LABELSECTOR;
  345         char *buf;
  346         struct dos_mbr mbr;
  347         int error, i;
  349         /* Sanity check */
  350         if (bd->bios_heads == 0 || bd->bios_sectors == 0)
  351                 return "failed to read disklabel";
  353         /* MBR is a harddisk thing */
  354         if (bd->bios_number & 0x80) {
  355                 /* Read MBR */
error = biosd_io(F_READ, bd, DOSBBSECTOR, 1, &mbr);
  357                 if (error)
  358                         return (biosdisk_err(error));
  360                 /* check mbr signature */
  361                 if (mbr.dmbr_sign != DOSMBR_SIGNATURE)
  362                         return "bad MBR signature\n";
  364                 /* Search for OpenBSD partition */
  365                 for (off = 0, i = 0; off == 0 && i < NDOSPART; i++)
  366                         if (mbr.dmbr_parts[i].dp_typ == DOSPTYP_OPENBSD)
off = mbr.dmbr_parts[i].dp_start + LABELSECTOR;
  368                 if (off == 0)
  369                         return "no OpenBSD partition\n";
  370         } else
off = LABELSECTOR;
  373         /* Load BSD disklabel */
buf = alloca(DEV_BSIZE);
  375 #ifdef BIOS_DEBUG
  376         if (debug)
printf("loading disklabel @ %u\n", off);
  378 #endif
  379         /* read disklabel */
error = biosd_io(F_READ, bd, off, 1, buf);
  382         if (error)
  383                 return "failed to read disklabel";
  385         /* Fill in disklabel */
  386         return (getdisklabel(buf, label));
  387 }
  389 int
biosopen(struct open_file *f, ...)
  391 {
va_list ap;
  393         register char   *cp, **file;
dev_t maj, unit, part;
  395         struct diskinfo *dip;
  396         int biosdev;
va_start(ap, f);
cp = *(file = va_arg(ap, char **));
va_end(ap);
  402 #ifdef BIOS_DEBUG
  403         if (debug)
printf("%s\n", cp);
  405 #endif
f->f_devdata = NULL;
  408         /* search for device specification */
cp += 2;
  410         if (cp[2] != ':') {
  411                 if (cp[3] != ':')
  412                         return ENOENT;
  413                 else
cp++;
  415         }
  417         for (maj = 0; maj < nbdevs && strncmp(*file, bdevs[maj], cp - *file); )
maj++;
  419         if (maj >= nbdevs) {
printf("Unknown device: ");
  421                 for (cp = *file; *cp != ':'; cp++)
putchar(*cp);
putchar('\n');
  424                 return EADAPT;
  425         }
  427         /* get unit */
  428         if ('0' <= *cp && *cp <= '9')
unit = *cp++ - '0';
  430         else {
printf("Bad unit number\n");
  432                 return EUNIT;
  433         }
  434         /* get partition */
  435         if ('a' <= *cp && *cp <= 'p')
part = *cp++ - 'a';
  437         else {
printf("Bad partition id\n");
  439                 return EPART;
  440         }
cp++;   /* skip ':' */
  443         if (*cp != 0)
  444                 *file = cp;
  445         else
f->f_flags |= F_RAW;
biosdev = unit;
  449         switch (maj) {
  450         case 0:  /* wd */
  451         case 4:  /* sd */
  452         case 17: /* hd */
biosdev |= 0x80;
  454                 break;
  455         case 2:  /* fd */
  456                 break;
  457         case 6:  /* cd */
biosdev = bios_bootdev & 0xff;
  459                 break;
  460         default:
  461                 return ENXIO;
  462         }
  464         /* Find device */
bootdev_dip = dip = dklookup(biosdev);
  467         /* Fix up bootdev */
  468         { dev_t bsd_dev;
bsd_dev = dip->bios_info.bsd_dev;
dip->bsddev = MAKEBOOTDEV(B_TYPE(bsd_dev), B_ADAPTOR(bsd_dev),
B_CONTROLLER(bsd_dev), unit, part);
dip->bootdev = MAKEBOOTDEV(B_TYPE(bsd_dev), B_ADAPTOR(bsd_dev),
B_CONTROLLER(bsd_dev), B_UNIT(bsd_dev), part);
  474         }
  476 #if 0
dip->bios_info.bsd_dev = dip->bootdev;
bootdev = dip->bootdev;
  479 #endif
  481 #ifdef BIOS_DEBUG
  482         if (debug) {
printf("BIOS geometry: heads=%u, s/t=%u; EDD=%d\n",
dip->bios_info.bios_heads, dip->bios_info.bios_sectors,
dip->bios_info.bios_edd);
  486         }
  487 #endif
  489         /* Try for disklabel again (might be removable media) */
  490         if (dip->bios_info.flags & BDI_BADLABEL){
  491                 const char *st = bios_getdisklabel(&dip->bios_info,
  492                     &dip->disklabel);
  493 #ifdef BIOS_DEBUG
  494                 if (debug && st)
printf("%s\n", st);
  496 #endif
  497                 if (!st) {
dip->bios_info.flags &= ~BDI_BADLABEL;
dip->bios_info.flags |= BDI_GOODLABEL;
  500                 } else
  501                         return ERDLAB;
  502         }
f->f_devdata = dip;
  506         return 0;
  507 }
  509 const u_char bidos_errs[] =
  510 /* ignored      "\x00" "successful completion\0" */
  511                 "\x01" "invalid function/parameter\0"
  512                 "\x02" "address mark not found\0"
  513                 "\x03" "write-protected\0"
  514                 "\x04" "sector not found\0"
  515                 "\x05" "reset failed\0"
  516                 "\x06" "disk changed\0"
  517                 "\x07" "drive parameter activity failed\0"
  518                 "\x08" "DMA overrun\0"
  519                 "\x09" "data boundary error\0"
  520                 "\x0A" "bad sector detected\0"
  521                 "\x0B" "bad track detected\0"
  522                 "\x0C" "invalid media\0"
  523                 "\x0E" "control data address mark detected\0"
  524                 "\x0F" "DMA arbitration level out of range\0"
  525                 "\x10" "uncorrectable CRC or ECC error on read\0"
  526 /* ignored      "\x11" "data ECC corrected\0" */
  527                 "\x20" "controller failure\0"
  528                 "\x31" "no media in drive\0"
  529                 "\x32" "incorrect drive type in CMOS\0"
  530                 "\x40" "seek failed\0"
  531                 "\x80" "operation timed out\0"
  532                 "\xAA" "drive not ready\0"
  533                 "\xB0" "volume not locked in drive\0"
  534                 "\xB1" "volume locked in drive\0"
  535                 "\xB2" "volume not removable\0"
  536                 "\xB3" "volume in use\0"
  537                 "\xB4" "lock count exceeded\0"
  538                 "\xB5" "valid eject request failed\0"
  539                 "\xBB" "undefined error\0"
  540                 "\xCC" "write fault\0"
  541                 "\xE0" "status register error\0"
  542                 "\xFF" "sense operation failed\0"
  543                 "\x00" "\0";
  545 static const char *
biosdisk_err(u_int error)
  547 {
  548         register const u_char *p = bidos_errs;
  550         while (*p && *p != error)
  551                 while (*p++);
  553         return ++p;
  554 }
  556 const struct biosdisk_errors {
u_char error;
u_char errno;
  559 } tab[] = {
  560         { 0x01, EINVAL },
  561         { 0x03, EROFS },
  562         { 0x08, EINVAL },
  563         { 0x09, EINVAL },
  564         { 0x0A, EBSE },
  565         { 0x0B, EBSE },
  566         { 0x0C, ENXIO },
  567         { 0x0D, EINVAL },
  568         { 0x10, EECC },
  569         { 0x20, EHER },
  570         { 0x31, ENXIO },
  571         { 0x32, ENXIO },
  572         { 0x00, EIO }
  573 };
  575 static int
biosdisk_errno(u_int error)
  577 {
  578         register const struct biosdisk_errors *p;
  580         if (error == 0)
  581                 return 0;
  583         for (p = tab; p->error && p->error != error; p++);
  585         return p->errno;
  586 }
  588 int
biosstrategy(void *devdata, int rw, daddr_t blk, size_t size, void *buf,
size_t *rsize)
  591 {
  592         struct diskinfo *dip = (struct diskinfo *)devdata;
bios_diskinfo_t *bd = &dip->bios_info;
u_int8_t error = 0;
size_t nsect;
nsect = (size + DEV_BSIZE-1) / DEV_BSIZE;
  598         if (rsize != NULL)
blk += dip->disklabel.
d_partitions[B_PARTITION(dip->bsddev)].p_offset;
  602         /* Read all, sub-functions handle track boundaries */
error = biosd_io(rw, bd, blk, nsect, buf);
  605 #ifdef BIOS_DEBUG
  606         if (debug) {
  607                 if (error != 0)
printf("=0x%x(%s)", error, biosdisk_err(error));
putchar('\n');
  610         }
  611 #endif
  613         if (rsize != NULL)
  614                 *rsize = nsect * DEV_BSIZE;
  616         return (biosdisk_errno(error));
  617 }
  619 int
biosclose(struct open_file *f)
  621 {
f->f_devdata = NULL;
  624         return 0;
  625 }
  627 int
biosioctl(struct open_file *f, u_long cmd, void *data)
  629 {
  630         return 0;
  631 }