2 * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
3 * Copyright (c) 2012 Andrey V. Elsukov <ae@FreeBSD.org>
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 #include <sys/cdefs.h>
31 * BIOS disk device handling.
33 * Ideas and algorithms from:
35 * - NetBSD libi386/biosdisk.c
36 * - FreeBSD biosboot/disk.c
41 #include <sys/limits.h>
43 #include <machine/bootinfo.h>
46 #include <bootstrap.h>
52 CTASSERT(sizeof(struct i386_devdesc
) >= sizeof(struct disk_devdesc
));
54 #define BIOS_NUMDRIVES 0x475
55 #define BIOSDISK_SECSIZE 512
56 #define BUFSIZE (1 * BIOSDISK_SECSIZE)
58 #define DT_ATAPI 0x10 /* disk type for ATAPI floppies */
59 #define WDMAJOR 0 /* major numbers for devices we frontend for */
65 # define DEBUG(fmt, args...) printf("%s: " fmt "\n" , __func__ , ## args)
67 # define DEBUG(fmt, args...)
71 * List of BIOS devices, translation from disk unit number to
76 int bd_unit
; /* BIOS unit number */
77 int bd_cyl
; /* BIOS geometry */
81 #define BD_MODEINT13 0x0000
82 #define BD_MODEEDD1 0x0001
83 #define BD_MODEEDD3 0x0002
84 #define BD_MODEMASK 0x0003
85 #define BD_FLOPPY 0x0004
86 int bd_type
; /* BIOS 'drive type' (floppy only) */
87 uint16_t bd_sectorsize
; /* Sector size */
88 uint64_t bd_sectors
; /* Disk size */
89 int bd_open
; /* reference counter */
90 void *bd_bcache
; /* buffer cache data */
92 static int nbdinfo
= 0;
94 #define BD(dev) (bdinfo[(dev)->dd.d_unit])
96 static int bd_io(struct disk_devdesc
*, daddr_t
, int, caddr_t
, int);
97 static int bd_int13probe(struct bdinfo
*bd
);
99 static int bd_init(void);
100 static int bd_strategy(void *devdata
, int flag
, daddr_t dblk
, size_t size
,
101 char *buf
, size_t *rsize
);
102 static int bd_realstrategy(void *devdata
, int flag
, daddr_t dblk
, size_t size
,
103 char *buf
, size_t *rsize
);
104 static int bd_open(struct open_file
*f
, ...);
105 static int bd_close(struct open_file
*f
);
106 static int bd_ioctl(struct open_file
*f
, u_long cmd
, void *data
);
107 static int bd_print(int verbose
);
109 struct devsw biosdisk
= {
122 * Translate between BIOS device numbers and our private unit numbers.
125 bd_bios2unit(int biosdev
)
129 DEBUG("looking for bios device 0x%x", biosdev
);
130 for (i
= 0; i
< nbdinfo
; i
++) {
131 DEBUG("bd unit %d is BIOS device 0x%x", i
, bdinfo
[i
].bd_unit
);
132 if (bdinfo
[i
].bd_unit
== biosdev
)
139 bd_unit2bios(int unit
)
142 if ((unit
>= 0) && (unit
< nbdinfo
))
143 return (bdinfo
[unit
].bd_unit
);
148 * Quiz the BIOS for disk devices, save a little info about them.
153 int base
, unit
, nfd
= 0;
155 /* sequence 0, 0x80 */
156 for (base
= 0; base
<= 0x80; base
+= 0x80) {
157 for (unit
= base
; (nbdinfo
< MAXBDDEV
); unit
++) {
160 * Check the BIOS equipment list for number
164 (nfd
>= *(unsigned char *)PTOV(BIOS_NUMDRIVES
)))
167 bdinfo
[nbdinfo
].bd_open
= 0;
168 bdinfo
[nbdinfo
].bd_bcache
= NULL
;
169 bdinfo
[nbdinfo
].bd_unit
= unit
;
170 bdinfo
[nbdinfo
].bd_flags
= unit
< 0x80 ? BD_FLOPPY
: 0;
171 if (!bd_int13probe(&bdinfo
[nbdinfo
]))
175 /* XXX we need "disk aliases" to make this simpler */
176 printf("BIOS drive %c: is disk%d\n", (unit
< 0x80) ?
177 ('A' + unit
): ('C' + unit
- 0x80), nbdinfo
);
184 bcache_add_dev(nbdinfo
);
189 * Try to detect a device supported by the legacy int13 BIOS
192 bd_int13probe(struct bdinfo
*bd
)
194 struct edd_params params
;
195 int ret
= 1; /* assume success */
200 v86
.edx
= bd
->bd_unit
;
203 /* Don't error out if we get bad sector number, try EDD as well */
204 if (V86_CY(v86
.efl
) || /* carry set */
205 (v86
.edx
& 0xff) <= (unsigned)(bd
->bd_unit
& 0x7f)) /* unit # bad */
206 return (0); /* skip device */
208 if ((v86
.ecx
& 0x3f) == 0) /* absurd sector number */
209 ret
= 0; /* set error */
211 /* Convert max cyl # -> # of cylinders */
212 bd
->bd_cyl
= ((v86
.ecx
& 0xc0) << 2) + ((v86
.ecx
& 0xff00) >> 8) + 1;
213 /* Convert max head # -> # of heads */
214 bd
->bd_hds
= ((v86
.edx
& 0xff00) >> 8) + 1;
215 bd
->bd_sec
= v86
.ecx
& 0x3f;
216 bd
->bd_type
= v86
.ebx
& 0xff;
217 bd
->bd_flags
|= BD_MODEINT13
;
219 /* Calculate sectors count from the geometry */
220 bd
->bd_sectors
= bd
->bd_cyl
* bd
->bd_hds
* bd
->bd_sec
;
221 bd
->bd_sectorsize
= BIOSDISK_SECSIZE
;
222 DEBUG("unit 0x%x geometry %d/%d/%d", bd
->bd_unit
, bd
->bd_cyl
,
223 bd
->bd_hds
, bd
->bd_sec
);
225 /* Determine if we can use EDD with this device. */
229 v86
.edx
= bd
->bd_unit
;
232 if (V86_CY(v86
.efl
) || /* carry set */
233 (v86
.ebx
& 0xffff) != 0xaa55 || /* signature */
234 (v86
.ecx
& EDD_INTERFACE_FIXED_DISK
) == 0)
235 return (ret
); /* return code from int13 AH=08 */
238 bd
->bd_flags
|= BD_MODEEDD1
;
239 if ((v86
.eax
& 0xff00) >= 0x3000)
240 bd
->bd_flags
|= BD_MODEEDD3
;
241 /* Get disk params */
242 params
.len
= sizeof(struct edd_params
);
246 v86
.edx
= bd
->bd_unit
;
247 v86
.ds
= VTOPSEG(¶ms
);
248 v86
.esi
= VTOPOFF(¶ms
);
250 if (!V86_CY(v86
.efl
)) {
254 * Sector size must be a multiple of 512 bytes.
255 * An alternate test would be to check power of 2,
256 * powerof2(params.sector_size).
258 if (params
.sector_size
% BIOSDISK_SECSIZE
)
259 bd
->bd_sectorsize
= BIOSDISK_SECSIZE
;
261 bd
->bd_sectorsize
= params
.sector_size
;
263 total
= bd
->bd_sectorsize
* params
.sectors
;
264 if (params
.sectors
!= 0) {
265 /* Only update if we did not overflow. */
266 if (total
> params
.sectors
)
267 bd
->bd_sectors
= params
.sectors
;
270 total
= (uint64_t)params
.cylinders
*
271 params
.heads
* params
.sectors_per_track
;
272 if (bd
->bd_sectors
< total
)
273 bd
->bd_sectors
= total
;
277 DEBUG("unit 0x%x flags %x, sectors %llu, sectorsize %u",
278 bd
->bd_unit
, bd
->bd_flags
, bd
->bd_sectors
, bd
->bd_sectorsize
);
283 * Print information about disks
286 bd_print(int verbose
)
288 static char line
[80];
289 struct disk_devdesc dev
;
295 printf("%s devices:", biosdisk
.dv_name
);
296 if ((ret
= pager_output("\n")) != 0)
299 for (i
= 0; i
< nbdinfo
; i
++) {
300 snprintf(line
, sizeof (line
),
301 " disk%d: BIOS drive %c (%ju X %u):\n", i
,
302 (bdinfo
[i
].bd_unit
< 0x80) ? ('A' + bdinfo
[i
].bd_unit
):
303 ('C' + bdinfo
[i
].bd_unit
- 0x80),
304 (uintmax_t)bdinfo
[i
].bd_sectors
,
305 bdinfo
[i
].bd_sectorsize
);
306 ret
= pager_output(line
);
310 dev
.dd
.d_dev
= &biosdisk
;
313 dev
.d_partition
= -1;
315 bdinfo
[i
].bd_sectorsize
* bdinfo
[i
].bd_sectors
,
316 bdinfo
[i
].bd_sectorsize
) == 0) {
317 sprintf(line
, " disk%d", i
);
318 ret
= disk_print(&dev
, line
, verbose
);
328 * Attempt to open the disk described by (dev) for use by (f).
330 * Note that the philosophy here is "give them exactly what
331 * they ask for". This is necessary because being too "smart"
332 * about what the user might want leads to complications.
333 * (eg. given no slice or partition value, with a disk that is
334 * sliced - are they after the first BSD slice, or the DOS
338 bd_open(struct open_file
*f
, ...)
340 struct disk_devdesc
*dev
;
341 struct disk_devdesc disk
;
347 dev
= va_arg(ap
, struct disk_devdesc
*);
350 if (dev
->dd
.d_unit
< 0 || dev
->dd
.d_unit
>= nbdinfo
)
353 if (BD(dev
).bd_bcache
== NULL
)
354 BD(dev
).bd_bcache
= bcache_allocate();
357 * Read disk size from partition.
358 * This is needed to work around buggy BIOS systems returning
359 * wrong (truncated) disk media size.
360 * During bd_probe() we tested if the mulitplication of bd_sectors
361 * would overflow so it should be safe to perform here.
363 disk
.dd
.d_dev
= dev
->dd
.d_dev
;
364 disk
.dd
.d_unit
= dev
->dd
.d_unit
;
366 disk
.d_partition
= -1;
369 if (disk_open(&disk
, BD(dev
).bd_sectors
* BD(dev
).bd_sectorsize
,
370 BD(dev
).bd_sectorsize
) == 0) {
372 if (disk_ioctl(&disk
, DIOCGMEDIASIZE
, &size
) == 0) {
373 size
/= BD(dev
).bd_sectorsize
;
374 if (size
> BD(dev
).bd_sectors
)
375 BD(dev
).bd_sectors
= size
;
380 rc
= disk_open(dev
, BD(dev
).bd_sectors
* BD(dev
).bd_sectorsize
,
381 BD(dev
).bd_sectorsize
);
384 if (BD(dev
).bd_open
== 0) {
385 bcache_free(BD(dev
).bd_bcache
);
386 BD(dev
).bd_bcache
= NULL
;
393 bd_close(struct open_file
*f
)
395 struct disk_devdesc
*dev
;
397 dev
= (struct disk_devdesc
*)f
->f_devdata
;
399 if (BD(dev
).bd_open
== 0) {
400 bcache_free(BD(dev
).bd_bcache
);
401 BD(dev
).bd_bcache
= NULL
;
403 return (disk_close(dev
));
407 bd_ioctl(struct open_file
*f
, u_long cmd
, void *data
)
409 struct disk_devdesc
*dev
;
412 dev
= (struct disk_devdesc
*)f
->f_devdata
;
414 rc
= disk_ioctl(dev
, cmd
, data
);
419 case DIOCGSECTORSIZE
:
420 *(u_int
*)data
= BD(dev
).bd_sectorsize
;
423 *(uint64_t *)data
= BD(dev
).bd_sectors
* BD(dev
).bd_sectorsize
;
432 bd_strategy(void *devdata
, int rw
, daddr_t dblk
, size_t size
,
433 char *buf
, size_t *rsize
)
435 struct bcache_devdata bcd
;
436 struct disk_devdesc
*dev
;
438 dev
= (struct disk_devdesc
*)devdata
;
439 bcd
.dv_strategy
= bd_realstrategy
;
440 bcd
.dv_devdata
= devdata
;
441 bcd
.dv_cache
= BD(dev
).bd_bcache
;
443 return (bcache_strategy(&bcd
, rw
, dblk
+ dev
->d_offset
, size
,
448 bd_realstrategy(void *devdata
, int rw
, daddr_t dblk
, size_t size
,
449 char *buf
, size_t *rsize
)
451 struct disk_devdesc
*dev
= (struct disk_devdesc
*)devdata
;
452 uint64_t disk_blocks
, offset
;
453 size_t blks
, blkoff
, bsize
, rest
;
458 * First make sure the IO size is a multiple of 512 bytes. While we do
459 * process partial reads below, the strategy mechanism is built
460 * assuming IO is a multiple of 512B blocks. If the request is not
461 * a multiple of 512B blocks, it has to be some sort of bug.
463 if (size
== 0 || (size
% BIOSDISK_SECSIZE
) != 0) {
464 printf("bd_strategy: %d bytes I/O not multiple of %d\n",
465 size
, BIOSDISK_SECSIZE
);
469 DEBUG("open_disk %p", dev
);
471 offset
= dblk
* BIOSDISK_SECSIZE
;
472 dblk
= offset
/ BD(dev
).bd_sectorsize
;
473 blkoff
= offset
% BD(dev
).bd_sectorsize
;
476 * Check the value of the size argument. We do have quite small
477 * heap (64MB), but we do not know good upper limit, so we check against
478 * INT_MAX here. This will also protect us against possible overflows
479 * while translating block count to bytes.
481 if (size
> INT_MAX
) {
482 DEBUG("requested read: %zu too large", size
);
486 blks
= size
/ BD(dev
).bd_sectorsize
;
487 if (blks
== 0 || (size
% BD(dev
).bd_sectorsize
) != 0)
490 if (dblk
> dblk
+ blks
)
497 * Get disk blocks, this value is either for whole disk or for
500 if (disk_ioctl(dev
, DIOCGMEDIASIZE
, &disk_blocks
) == 0) {
501 /* DIOCGMEDIASIZE does return bytes. */
502 disk_blocks
/= BD(dev
).bd_sectorsize
;
504 /* We should not get here. Just try to survive. */
505 disk_blocks
= BD(dev
).bd_sectors
- dev
->d_offset
;
508 /* Validate source block address. */
509 if (dblk
< dev
->d_offset
|| dblk
>= dev
->d_offset
+ disk_blocks
)
513 * Truncate if we are crossing disk or partition end.
515 if (dblk
+ blks
>= dev
->d_offset
+ disk_blocks
) {
516 blks
= dev
->d_offset
+ disk_blocks
- dblk
;
517 size
= blks
* BD(dev
).bd_sectorsize
;
518 DEBUG("short read %d", blks
);
521 if (V86_IO_BUFFER_SIZE
/ BD(dev
).bd_sectorsize
== 0)
522 panic("BUG: Real mode buffer is too small\n");
524 bbuf
= PTOV(V86_IO_BUFFER
);
528 int x
= min(blks
, V86_IO_BUFFER_SIZE
/ BD(dev
).bd_sectorsize
);
530 switch (rw
& F_MASK
) {
532 DEBUG("read %d from %lld to %p", x
, dblk
, buf
);
533 bsize
= BD(dev
).bd_sectorsize
* x
- blkoff
;
537 if ((rc
= bd_io(dev
, dblk
, x
, bbuf
, 0)) != 0)
540 bcopy(bbuf
+ blkoff
, buf
, bsize
);
543 DEBUG("write %d from %lld to %p", x
, dblk
, buf
);
546 * We got offset to sector, read 1 sector to
550 bsize
= BD(dev
).bd_sectorsize
- blkoff
;
551 bsize
= min(bsize
, rest
);
552 rc
= bd_io(dev
, dblk
, x
, bbuf
, 0);
553 } else if (rest
< BD(dev
).bd_sectorsize
) {
555 * The remaining block is not full
556 * sector. Read 1 sector to bbuf.
560 rc
= bd_io(dev
, dblk
, x
, bbuf
, 0);
562 /* We can write full sector(s). */
563 bsize
= BD(dev
).bd_sectorsize
* x
;
566 * Put your Data In, Put your Data out,
567 * Put your Data In, and shake it all about
569 bcopy(buf
, bbuf
+ blkoff
, bsize
);
570 if ((rc
= bd_io(dev
, dblk
, x
, bbuf
, 1)) != 0)
592 bd_edd_io(struct disk_devdesc
*dev
, daddr_t dblk
, int blks
, caddr_t dest
,
595 static struct edd_packet packet
;
597 packet
.len
= sizeof(struct edd_packet
);
599 packet
.off
= VTOPOFF(dest
);
600 packet
.seg
= VTOPSEG(dest
);
605 /* Should we Write with verify ?? 0x4302 ? */
609 v86
.edx
= BD(dev
).bd_unit
;
610 v86
.ds
= VTOPSEG(&packet
);
611 v86
.esi
= VTOPOFF(&packet
);
614 return (v86
.eax
>> 8);
619 bd_chs_io(struct disk_devdesc
*dev
, daddr_t dblk
, int blks
, caddr_t dest
,
622 u_int x
, bpc
, cyl
, hd
, sec
;
624 bpc
= BD(dev
).bd_sec
* BD(dev
).bd_hds
; /* blocks per cylinder */
626 cyl
= x
/ bpc
; /* block # / blocks per cylinder */
627 x
%= bpc
; /* block offset into cylinder */
628 hd
= x
/ BD(dev
).bd_sec
; /* offset / blocks per track */
629 sec
= x
% BD(dev
).bd_sec
; /* offset into track */
631 /* correct sector number for 1-based BIOS numbering */
635 /* CHS doesn't support cylinders > 1023. */
641 v86
.eax
= 0x300 | blks
;
643 v86
.eax
= 0x200 | blks
;
644 v86
.ecx
= ((cyl
& 0xff) << 8) | ((cyl
& 0x300) >> 2) | sec
;
645 v86
.edx
= (hd
<< 8) | BD(dev
).bd_unit
;
646 v86
.es
= VTOPSEG(dest
);
647 v86
.ebx
= VTOPOFF(dest
);
650 return (v86
.eax
>> 8);
655 bd_io(struct disk_devdesc
*dev
, daddr_t dblk
, int blks
, caddr_t dest
,
660 /* Just in case some idiot actually tries to read/write -1 blocks... */
665 * Loop retrying the operation a couple of times. The BIOS
668 for (retry
= 0; retry
< 3; retry
++) {
669 /* if retrying, reset the drive */
674 v86
.edx
= BD(dev
).bd_unit
;
678 if (BD(dev
).bd_flags
& BD_MODEEDD1
)
679 result
= bd_edd_io(dev
, dblk
, blks
, dest
, dowrite
);
681 result
= bd_chs_io(dev
, dblk
, blks
, dest
, dowrite
);
688 * 0x20 - Controller failure. This is common error when the
689 * media is not present.
691 if (result
!= 0 && result
!= 0x20) {
693 printf("%s%d: Write %d sector(s) from %p (0x%x) "
694 "to %lld: 0x%x", dev
->dd
.d_dev
->dv_name
,
695 dev
->dd
.d_unit
, blks
, dest
, VTOP(dest
), dblk
,
698 printf("%s%d: Read %d sector(s) from %lld to %p "
699 "(0x%x): 0x%x", dev
->dd
.d_dev
->dv_name
,
700 dev
->dd
.d_unit
, blks
, dblk
, dest
, VTOP(dest
),
712 * Return the BIOS geometry of a given "fixed drive" in a format
713 * suitable for the legacy bootinfo structure. Since the kernel is
714 * expecting raw int 0x13/0x8 values for N_BIOS_GEOM drives, we
715 * prefer to get the information directly, rather than rely on being
716 * able to put it together from information already maintained for
717 * different purposes and for a probably different number of drives.
719 * For valid drives, the geometry is expected in the format (31..0)
720 * "000000cc cccccccc hhhhhhhh 00ssssss"; and invalid drives are
721 * indicated by returning the geometry of a "1.2M" PC-format floppy
722 * disk. And, incidentally, what is returned is not the geometry as
723 * such but the highest valid cylinder, head, and sector numbers.
726 bd_getbigeom(int bunit
)
732 v86
.edx
= 0x80 + bunit
;
736 return ((v86
.ecx
& 0xc0) << 18) | ((v86
.ecx
& 0xff00) << 8) |
737 (v86
.edx
& 0xff00) | (v86
.ecx
& 0x3f);
741 * Return a suitable dev_t value for (dev).
743 * In the case where it looks like (dev) is a SCSI disk, we allow the number of
744 * IDE disks to be specified in $num_ide_disks. There should be a Better Way.
747 bd_getdev(struct i386_devdesc
*d
)
749 struct disk_devdesc
*dev
;
756 dev
= (struct disk_devdesc
*)d
;
757 biosdev
= bd_unit2bios(dev
->dd
.d_unit
);
758 DEBUG("unit %d BIOS device %d", dev
->dd
.d_unit
, biosdev
);
759 if (biosdev
== -1) /* not a BIOS device */
761 if (disk_open(dev
, BD(dev
).bd_sectors
* BD(dev
).bd_sectorsize
,
762 BD(dev
).bd_sectorsize
) != 0) /* oops, not a viable device */
767 if (biosdev
< 0x80) {
768 /* floppy (or emulated floppy) or ATAPI device */
769 if (bdinfo
[dev
->dd
.d_unit
].bd_type
== DT_ATAPI
) {
770 /* is an ATAPI disk */
773 /* is a floppy disk */
777 /* assume an IDE disk */
780 /* default root disk unit number */
781 unit
= biosdev
& 0x7f;
783 /* XXX a better kludge to set the root disk unit number */
784 if ((nip
= getenv("root_disk_unit")) != NULL
) {
785 i
= strtol(nip
, &cp
, 0);
786 /* check for parse error */
787 if ((cp
!= nip
) && (*cp
== 0))
791 rootdev
= MAKEBOOTDEV(major
, dev
->d_slice
+ 1, unit
, dev
->d_partition
);
792 DEBUG("dev is 0x%x\n", rootdev
);