xref: /freebsd/stand/i386/libi386/biosdisk.c (revision e17f5b1d)
1 /*-
2  * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
3  * Copyright (c) 2012 Andrey V. Elsukov <ae@FreeBSD.org>
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
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.
14  *
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
25  * SUCH DAMAGE.
26  */
27 
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
30 
31 /*
32  * BIOS disk device handling.
33  *
34  * Ideas and algorithms from:
35  *
36  * - NetBSD libi386/biosdisk.c
37  * - FreeBSD biosboot/disk.c
38  *
39  */
40 
41 #include <sys/disk.h>
42 #include <sys/limits.h>
43 #include <sys/queue.h>
44 #include <stand.h>
45 #include <machine/bootinfo.h>
46 #include <stdarg.h>
47 #include <stdbool.h>
48 
49 #include <bootstrap.h>
50 #include <btxv86.h>
51 #include <edd.h>
52 #include "disk.h"
53 #include "libi386.h"
54 
55 #define	BIOS_NUMDRIVES		0x475
56 #define	BIOSDISK_SECSIZE	512
57 #define	BUFSIZE			(1 * BIOSDISK_SECSIZE)
58 
59 #define	DT_ATAPI	0x10	/* disk type for ATAPI floppies */
60 #define	WDMAJOR		0	/* major numbers for devices we frontend for */
61 #define	WFDMAJOR	1
62 #define	FDMAJOR		2
63 #define	DAMAJOR		4
64 #define	ACDMAJOR	117
65 #define	CDMAJOR		15
66 
67 /*
68  * INT13 commands
69  */
70 #define	CMD_RESET	0x0000
71 #define	CMD_READ_CHS	0x0200
72 #define	CMD_WRITE_CHS	0x0300
73 #define	CMD_READ_PARAM	0x0800
74 #define	CMD_DRIVE_TYPE	0x1500
75 #define	CMD_CHECK_EDD	0x4100
76 #define	CMD_READ_LBA	0x4200
77 #define	CMD_WRITE_LBA	0x4300
78 #define	CMD_EXT_PARAM	0x4800
79 #define	CMD_CD_GET_STATUS 0x4b01
80 
81 #define	DISK_BIOS	0x13
82 
83 #ifdef DISK_DEBUG
84 #define	DPRINTF(fmt, args...)	printf("%s: " fmt "\n", __func__, ## args)
85 #else
86 #define	DPRINTF(fmt, args...)	((void)0)
87 #endif
88 
89 struct specification_packet {
90 	uint8_t		sp_size;
91 	uint8_t		sp_bootmedia;
92 	uint8_t		sp_drive;
93 	uint8_t		sp_controller;
94 	uint32_t	sp_lba;
95 	uint16_t	sp_devicespec;
96 	uint16_t	sp_buffersegment;
97 	uint16_t	sp_loadsegment;
98 	uint16_t	sp_sectorcount;
99 	uint16_t	sp_cylsec;
100 	uint8_t		sp_head;
101 	uint8_t		sp_dummy[16];	/* Avoid memory corruption */
102 };
103 
104 /*
105  * List of BIOS devices, translation from disk unit number to
106  * BIOS unit number.
107  */
108 typedef struct bdinfo
109 {
110 	STAILQ_ENTRY(bdinfo)	bd_link;	/* link in device list */
111 	int		bd_unit;	/* BIOS unit number */
112 	int		bd_cyl;		/* BIOS geometry */
113 	int		bd_hds;
114 	int		bd_sec;
115 	int		bd_flags;
116 #define	BD_MODEINT13	0x0000
117 #define	BD_MODEEDD1	0x0001
118 #define	BD_MODEEDD3	0x0002
119 #define	BD_MODEEDD	(BD_MODEEDD1 | BD_MODEEDD3)
120 #define	BD_MODEMASK	0x0003
121 #define	BD_FLOPPY	0x0004
122 #define	BD_CDROM	0x0008
123 #define	BD_NO_MEDIA	0x0010
124 	int		bd_type;	/* BIOS 'drive type' (floppy only) */
125 	uint16_t	bd_sectorsize;	/* Sector size */
126 	uint64_t	bd_sectors;	/* Disk size */
127 	int		bd_open;	/* reference counter */
128 	void		*bd_bcache;	/* buffer cache data */
129 } bdinfo_t;
130 
131 #define	BD_RD		0
132 #define	BD_WR		1
133 
134 typedef STAILQ_HEAD(bdinfo_list, bdinfo) bdinfo_list_t;
135 static bdinfo_list_t fdinfo = STAILQ_HEAD_INITIALIZER(fdinfo);
136 static bdinfo_list_t cdinfo = STAILQ_HEAD_INITIALIZER(cdinfo);
137 static bdinfo_list_t hdinfo = STAILQ_HEAD_INITIALIZER(hdinfo);
138 
139 static void bd_io_workaround(bdinfo_t *);
140 static int bd_io(struct disk_devdesc *, bdinfo_t *, daddr_t, int, caddr_t, int);
141 static bool bd_int13probe(bdinfo_t *);
142 
143 static int bd_init(void);
144 static int cd_init(void);
145 static int fd_init(void);
146 static int bd_strategy(void *devdata, int flag, daddr_t dblk, size_t size,
147     char *buf, size_t *rsize);
148 static int bd_realstrategy(void *devdata, int flag, daddr_t dblk, size_t size,
149     char *buf, size_t *rsize);
150 static int bd_open(struct open_file *f, ...);
151 static int bd_close(struct open_file *f);
152 static int bd_ioctl(struct open_file *f, u_long cmd, void *data);
153 static int bd_print(int verbose);
154 static int cd_print(int verbose);
155 static int fd_print(int verbose);
156 static void bd_reset_disk(int);
157 static int bd_get_diskinfo_std(struct bdinfo *);
158 
159 struct devsw biosfd = {
160 	.dv_name = "fd",
161 	.dv_type = DEVT_FD,
162 	.dv_init = fd_init,
163 	.dv_strategy = bd_strategy,
164 	.dv_open = bd_open,
165 	.dv_close = bd_close,
166 	.dv_ioctl = bd_ioctl,
167 	.dv_print = fd_print,
168 	.dv_cleanup = NULL
169 };
170 
171 struct devsw bioscd = {
172 	.dv_name = "cd",
173 	.dv_type = DEVT_CD,
174 	.dv_init = cd_init,
175 	.dv_strategy = bd_strategy,
176 	.dv_open = bd_open,
177 	.dv_close = bd_close,
178 	.dv_ioctl = bd_ioctl,
179 	.dv_print = cd_print,
180 	.dv_cleanup = NULL
181 };
182 
183 struct devsw bioshd = {
184 	.dv_name = "disk",
185 	.dv_type = DEVT_DISK,
186 	.dv_init = bd_init,
187 	.dv_strategy = bd_strategy,
188 	.dv_open = bd_open,
189 	.dv_close = bd_close,
190 	.dv_ioctl = bd_ioctl,
191 	.dv_print = bd_print,
192 	.dv_cleanup = NULL
193 };
194 
195 static bdinfo_list_t *
196 bd_get_bdinfo_list(struct devsw *dev)
197 {
198 	if (dev->dv_type == DEVT_DISK)
199 		return (&hdinfo);
200 	if (dev->dv_type == DEVT_CD)
201 		return (&cdinfo);
202 	if (dev->dv_type == DEVT_FD)
203 		return (&fdinfo);
204 	return (NULL);
205 }
206 
207 /* XXX this gets called way way too often, investigate */
208 static bdinfo_t *
209 bd_get_bdinfo(struct devdesc *dev)
210 {
211 	bdinfo_list_t *bdi;
212 	bdinfo_t *bd = NULL;
213 	int unit;
214 
215 	bdi = bd_get_bdinfo_list(dev->d_dev);
216 	if (bdi == NULL)
217 		return (bd);
218 
219 	unit = 0;
220 	STAILQ_FOREACH(bd, bdi, bd_link) {
221 		if (unit == dev->d_unit)
222 			return (bd);
223 		unit++;
224 	}
225 	return (bd);
226 }
227 
228 /*
229  * Translate between BIOS device numbers and our private unit numbers.
230  */
231 int
232 bd_bios2unit(int biosdev)
233 {
234 	bdinfo_list_t *bdi[] = { &fdinfo, &cdinfo, &hdinfo, NULL };
235 	bdinfo_t *bd;
236 	int i, unit;
237 
238 	DPRINTF("looking for bios device 0x%x", biosdev);
239 	for (i = 0; bdi[i] != NULL; i++) {
240 		unit = 0;
241 		STAILQ_FOREACH(bd, bdi[i], bd_link) {
242 			if (bd->bd_unit == biosdev) {
243 				DPRINTF("bd unit %d is BIOS device 0x%x", unit,
244 				    bd->bd_unit);
245 				return (unit);
246 			}
247 			unit++;
248 		}
249 	}
250 	return (-1);
251 }
252 
253 int
254 bd_unit2bios(struct i386_devdesc *dev)
255 {
256 	bdinfo_list_t *bdi;
257 	bdinfo_t *bd;
258 	int unit;
259 
260 	bdi = bd_get_bdinfo_list(dev->dd.d_dev);
261 	if (bdi == NULL)
262 		return (-1);
263 
264 	unit = 0;
265 	STAILQ_FOREACH(bd, bdi, bd_link) {
266 		if (unit == dev->dd.d_unit)
267 			return (bd->bd_unit);
268 		unit++;
269 	}
270 	return (-1);
271 }
272 
273 /*
274  * Use INT13 AH=15 - Read Drive Type.
275  */
276 static int
277 fd_count(void)
278 {
279 	int drive;
280 
281 	for (drive = 0; drive < MAXBDDEV; drive++) {
282 		bd_reset_disk(drive);
283 
284 		v86.ctl = V86_FLAGS;
285 		v86.addr = DISK_BIOS;
286 		v86.eax = CMD_DRIVE_TYPE;
287 		v86.edx = drive;
288 		v86int();
289 
290 		if (V86_CY(v86.efl))
291 			break;
292 
293 		if ((v86.eax & 0x300) == 0)
294 			break;
295 	}
296 
297 	return (drive);
298 }
299 
300 /*
301  * Quiz the BIOS for disk devices, save a little info about them.
302  */
303 static int
304 fd_init(void)
305 {
306 	int unit, numfd;
307 	bdinfo_t *bd;
308 
309 	numfd = fd_count();
310 	for (unit = 0; unit < numfd; unit++) {
311 		if ((bd = calloc(1, sizeof(*bd))) == NULL)
312 			break;
313 
314 		bd->bd_sectorsize = BIOSDISK_SECSIZE;
315 		bd->bd_flags = BD_FLOPPY;
316 		bd->bd_unit = unit;
317 
318 		/* Use std diskinfo for floppy drive */
319 		if (bd_get_diskinfo_std(bd) != 0) {
320 			free(bd);
321 			break;
322 		}
323 		if (bd->bd_sectors == 0)
324 			bd->bd_flags |= BD_NO_MEDIA;
325 
326 		printf("BIOS drive %c: is %s%d\n", ('A' + unit),
327 		    biosfd.dv_name, unit);
328 
329 		STAILQ_INSERT_TAIL(&fdinfo, bd, bd_link);
330 	}
331 
332 	bcache_add_dev(unit);
333 	return (0);
334 }
335 
336 static int
337 bd_init(void)
338 {
339 	int base, unit;
340 	bdinfo_t *bd;
341 
342 	base = 0x80;
343 	for (unit = 0; unit < *(unsigned char *)PTOV(BIOS_NUMDRIVES); unit++) {
344 		/*
345 		 * Check the BIOS equipment list for number of fixed disks.
346 		 */
347 		if ((bd = calloc(1, sizeof(*bd))) == NULL)
348 			break;
349 		bd->bd_unit = base + unit;
350 		if (!bd_int13probe(bd)) {
351 			free(bd);
352 			break;
353 		}
354 
355 		printf("BIOS drive %c: is %s%d\n", ('C' + unit),
356 		    bioshd.dv_name, unit);
357 
358 		STAILQ_INSERT_TAIL(&hdinfo, bd, bd_link);
359 	}
360 	bcache_add_dev(unit);
361 	return (0);
362 }
363 
364 /*
365  * We can't quiz, we have to be told what device to use, so this function
366  * doesn't do anything.  Instead, the loader calls bc_add() with the BIOS
367  * device number to add.
368  */
369 static int
370 cd_init(void)
371 {
372 
373 	return (0);
374 }
375 
376 /*
377  * Information from bootable CD-ROM.
378  */
379 static int
380 bd_get_diskinfo_cd(struct bdinfo *bd)
381 {
382 	struct specification_packet bc_sp;
383 	int ret = -1;
384 
385 	(void) memset(&bc_sp, 0, sizeof (bc_sp));
386 	/* Set sp_size as per specification. */
387 	bc_sp.sp_size = sizeof (bc_sp) - sizeof (bc_sp.sp_dummy);
388 
389         v86.ctl = V86_FLAGS;
390         v86.addr = DISK_BIOS;
391         v86.eax = CMD_CD_GET_STATUS;
392         v86.edx = bd->bd_unit;
393         v86.ds = VTOPSEG(&bc_sp);
394         v86.esi = VTOPOFF(&bc_sp);
395         v86int();
396 
397 	if ((v86.eax & 0xff00) == 0 &&
398 	    bc_sp.sp_drive == bd->bd_unit) {
399 		bd->bd_cyl = ((bc_sp.sp_cylsec & 0xc0) << 2) +
400 		    ((bc_sp.sp_cylsec & 0xff00) >> 8) + 1;
401 		bd->bd_sec = bc_sp.sp_cylsec & 0x3f;
402 		bd->bd_hds = bc_sp.sp_head + 1;
403 		bd->bd_sectors = (uint64_t)bd->bd_cyl * bd->bd_hds * bd->bd_sec;
404 
405 		if (bc_sp.sp_bootmedia & 0x0F) {
406 			/* Floppy or hard-disk emulation */
407 			bd->bd_sectorsize = BIOSDISK_SECSIZE;
408 			return (-1);
409 		} else {
410 			bd->bd_sectorsize = 2048;
411 			bd->bd_flags = BD_MODEEDD | BD_CDROM;
412 			ret = 0;
413 		}
414 	}
415 
416 	/*
417 	 * If this is the boot_drive, default to non-emulation bootable CD-ROM.
418 	 */
419 	if (ret != 0 && bd->bd_unit >= 0x88) {
420 		bd->bd_cyl = 0;
421 		bd->bd_hds = 1;
422 		bd->bd_sec = 15;
423 		bd->bd_sectorsize = 2048;
424 		bd->bd_flags = BD_MODEEDD | BD_CDROM;
425 		bd->bd_sectors = 0;
426 		ret = 0;
427 	}
428 
429 	/*
430 	 * Note we can not use bd_get_diskinfo_ext() nor bd_get_diskinfo_std()
431 	 * here - some systems do get hung with those.
432 	 */
433 	/*
434 	 * Still no size? use 7.961GB. The size does not really matter
435 	 * as long as it is reasonably large to make our reads to pass
436 	 * the sector count check.
437 	 */
438 	if (bd->bd_sectors == 0)
439 		bd->bd_sectors = 4173824;
440 
441 	return (ret);
442 }
443 
444 int
445 bc_add(int biosdev)
446 {
447 	bdinfo_t *bd;
448 	int nbcinfo = 0;
449 
450 	if (!STAILQ_EMPTY(&cdinfo))
451                 return (-1);
452 
453 	if ((bd = calloc(1, sizeof(*bd))) == NULL)
454 		return (-1);
455 
456 	bd->bd_unit = biosdev;
457 	if (bd_get_diskinfo_cd(bd) < 0) {
458 		free(bd);
459 		return (-1);
460 	}
461 
462 	STAILQ_INSERT_TAIL(&cdinfo, bd, bd_link);
463         printf("BIOS CD is cd%d\n", nbcinfo);
464         nbcinfo++;
465         bcache_add_dev(nbcinfo);        /* register cd device in bcache */
466         return(0);
467 }
468 
469 /*
470  * Return EDD version or 0 if EDD is not supported on this drive.
471  */
472 static int
473 bd_check_extensions(int unit)
474 {
475 	/* do not use ext calls for floppy devices */
476 	if (unit < 0x80)
477 		return (0);
478 
479 	/* Determine if we can use EDD with this device. */
480 	v86.ctl = V86_FLAGS;
481 	v86.addr = DISK_BIOS;
482 	v86.eax = CMD_CHECK_EDD;
483 	v86.edx = unit;
484 	v86.ebx = EDD_QUERY_MAGIC;
485 	v86int();
486 
487 	if (V86_CY(v86.efl) ||			/* carry set */
488 	    (v86.ebx & 0xffff) != EDD_INSTALLED) /* signature */
489 		return (0);
490 
491 	/* extended disk access functions (AH=42h-44h,47h,48h) supported */
492 	if ((v86.ecx & EDD_INTERFACE_FIXED_DISK) == 0)
493 		return (0);
494 
495 	return ((v86.eax >> 8) & 0xff);
496 }
497 
498 static void
499 bd_reset_disk(int unit)
500 {
501 	/* reset disk */
502 	v86.ctl = V86_FLAGS;
503 	v86.addr = DISK_BIOS;
504 	v86.eax = CMD_RESET;
505 	v86.edx = unit;
506 	v86int();
507 }
508 
509 /*
510  * Read CHS info. Return 0 on success, error otherwise.
511  */
512 static int
513 bd_get_diskinfo_std(struct bdinfo *bd)
514 {
515 	bzero(&v86, sizeof(v86));
516 	v86.ctl = V86_FLAGS;
517 	v86.addr = DISK_BIOS;
518 	v86.eax = CMD_READ_PARAM;
519 	v86.edx = bd->bd_unit;
520 	v86int();
521 
522 	if (V86_CY(v86.efl) && ((v86.eax & 0xff00) != 0))
523 		return ((v86.eax & 0xff00) >> 8);
524 
525 	/* return custom error on absurd sector number */
526 	if ((v86.ecx & 0x3f) == 0)
527 		return (0x60);
528 
529 	bd->bd_cyl = ((v86.ecx & 0xc0) << 2) + ((v86.ecx & 0xff00) >> 8) + 1;
530 	/* Convert max head # -> # of heads */
531 	bd->bd_hds = ((v86.edx & 0xff00) >> 8) + 1;
532 	bd->bd_sec = v86.ecx & 0x3f;
533 	bd->bd_type = v86.ebx;
534 	bd->bd_sectors = (uint64_t)bd->bd_cyl * bd->bd_hds * bd->bd_sec;
535 
536 	return (0);
537 }
538 
539 /*
540  * Read EDD info. Return 0 on success, error otherwise.
541  *
542  * Avoid stack corruption on some systems by adding extra bytes to
543  * params block.
544  */
545 static int
546 bd_get_diskinfo_ext(struct bdinfo *bd)
547 {
548 	struct disk_params {
549 		struct edd_params head;
550 		struct edd_device_path_v3 device_path;
551 		uint8_t dummy[16];
552 	} __packed dparams;
553 	struct edd_params *params;
554 	uint64_t total;
555 
556 	params = &dparams.head;
557 
558 	/* Get disk params */
559 	bzero(&dparams, sizeof(dparams));
560 	params->len = sizeof(struct edd_params_v3);
561 	v86.ctl = V86_FLAGS;
562 	v86.addr = DISK_BIOS;
563 	v86.eax = CMD_EXT_PARAM;
564 	v86.edx = bd->bd_unit;
565 	v86.ds = VTOPSEG(&dparams);
566 	v86.esi = VTOPOFF(&dparams);
567 	v86int();
568 
569 	if (V86_CY(v86.efl) && ((v86.eax & 0xff00) != 0))
570 		return ((v86.eax & 0xff00) >> 8);
571 
572 	/*
573 	 * Sector size must be a multiple of 512 bytes.
574 	 * An alternate test would be to check power of 2,
575 	 * powerof2(params.sector_size).
576 	 * 16K is largest read buffer we can use at this time.
577 	 */
578 	if (params->sector_size >= 512 &&
579 	    params->sector_size <= 16384 &&
580 	    (params->sector_size % BIOSDISK_SECSIZE) == 0)
581 		bd->bd_sectorsize = params->sector_size;
582 
583 	bd->bd_cyl = params->cylinders;
584 	bd->bd_hds = params->heads;
585 	bd->bd_sec = params->sectors_per_track;
586 
587 	if (params->sectors != 0) {
588 		total = params->sectors;
589 	} else {
590 		total = (uint64_t)params->cylinders *
591 		    params->heads * params->sectors_per_track;
592 	}
593 	bd->bd_sectors = total;
594 
595 	return (0);
596 }
597 
598 /*
599  * Try to detect a device supported by the legacy int13 BIOS
600  */
601 static bool
602 bd_int13probe(bdinfo_t *bd)
603 {
604 	int edd, ret;
605 
606 	bd->bd_flags &= ~BD_NO_MEDIA;
607 
608 	if ((bd->bd_flags & BD_CDROM) != 0) {
609 		return (bd_get_diskinfo_cd(bd) == 0);
610 	}
611 
612 	edd = bd_check_extensions(bd->bd_unit);
613 	if (edd == 0)
614 		bd->bd_flags |= BD_MODEINT13;
615 	else if (edd < 0x30)
616 		bd->bd_flags |= BD_MODEEDD1;
617 	else
618 		bd->bd_flags |= BD_MODEEDD3;
619 
620 	/* Default sector size */
621 	if (bd->bd_sectorsize == 0)
622 		bd->bd_sectorsize = BIOSDISK_SECSIZE;
623 
624 	/*
625 	 * Test if the floppy device is present, so we can avoid receiving
626 	 * bogus information from bd_get_diskinfo_std().
627 	 */
628 	if (bd->bd_unit < 0x80) {
629 		/* reset disk */
630 		bd_reset_disk(bd->bd_unit);
631 
632 		/* Get disk type */
633 		v86.ctl = V86_FLAGS;
634 		v86.addr = DISK_BIOS;
635 		v86.eax = CMD_DRIVE_TYPE;
636 		v86.edx = bd->bd_unit;
637 		v86int();
638 		if (V86_CY(v86.efl) || (v86.eax & 0x300) == 0)
639 			return (false);
640 	}
641 
642 	ret = 1;
643 	if (edd != 0)
644 		ret = bd_get_diskinfo_ext(bd);
645 	if (ret != 0 || bd->bd_sectors == 0)
646 		ret = bd_get_diskinfo_std(bd);
647 
648 	if (ret != 0 && bd->bd_unit < 0x80) {
649 		/* Set defaults for 1.44 floppy */
650 		bd->bd_cyl = 80;
651 		bd->bd_hds = 2;
652 		bd->bd_sec = 18;
653 		bd->bd_sectors = 2880;
654 		/* Since we are there, there most likely is no media */
655 		bd->bd_flags |= BD_NO_MEDIA;
656 		ret = 0;
657 	}
658 
659 	if (ret != 0) {
660 		if (bd->bd_sectors != 0 && edd != 0) {
661 			bd->bd_sec = 63;
662 			bd->bd_hds = 255;
663 			bd->bd_cyl =
664 			    (bd->bd_sectors + bd->bd_sec * bd->bd_hds - 1) /
665 			    bd->bd_sec * bd->bd_hds;
666 		} else {
667 			const char *dv_name;
668 
669 			if ((bd->bd_flags & BD_FLOPPY) != 0)
670 				dv_name = biosfd.dv_name;
671 			else
672 				dv_name = bioshd.dv_name;
673 
674 			printf("Can not get information about %s unit %#x\n",
675 			    dv_name, bd->bd_unit);
676 			return (false);
677 		}
678 	}
679 
680 	if (bd->bd_sec == 0)
681 		bd->bd_sec = 63;
682 	if (bd->bd_hds == 0)
683 		bd->bd_hds = 255;
684 
685 	if (bd->bd_sectors == 0)
686 		bd->bd_sectors = (uint64_t)bd->bd_cyl * bd->bd_hds * bd->bd_sec;
687 
688 	DPRINTF("unit 0x%x geometry %d/%d/%d\n", bd->bd_unit, bd->bd_cyl,
689 	    bd->bd_hds, bd->bd_sec);
690 
691 	return (true);
692 }
693 
694 static int
695 bd_count(bdinfo_list_t *bdi)
696 {
697 	bdinfo_t *bd;
698 	int i;
699 
700 	i = 0;
701 	STAILQ_FOREACH(bd, bdi, bd_link)
702 		i++;
703 	return (i);
704 }
705 
706 /*
707  * Print information about disks
708  */
709 static int
710 bd_print_common(struct devsw *dev, bdinfo_list_t *bdi, int verbose)
711 {
712 	char line[80];
713 	struct disk_devdesc devd;
714 	bdinfo_t *bd;
715 	int i, ret = 0;
716 	char drive;
717 
718 	if (STAILQ_EMPTY(bdi))
719 		return (0);
720 
721 	printf("%s devices:", dev->dv_name);
722 	if ((ret = pager_output("\n")) != 0)
723 		return (ret);
724 
725 	i = -1;
726 	STAILQ_FOREACH(bd, bdi, bd_link) {
727 		i++;
728 
729 		switch (dev->dv_type) {
730 		case DEVT_FD:
731 			drive = 'A';
732 			break;
733 		case DEVT_CD:
734 			drive = 'C' + bd_count(&hdinfo);
735 			break;
736 		default:
737 			drive = 'C';
738 			break;
739 		}
740 
741 		snprintf(line, sizeof(line),
742 		    "    %s%d:   BIOS drive %c (%s%ju X %u):\n",
743 		    dev->dv_name, i, drive + i,
744 		    (bd->bd_flags & BD_NO_MEDIA) == BD_NO_MEDIA ?
745 		    "no media, " : "",
746 		    (uintmax_t)bd->bd_sectors,
747 		    bd->bd_sectorsize);
748 		if ((ret = pager_output(line)) != 0)
749 			break;
750 
751 		if ((bd->bd_flags & BD_NO_MEDIA) == BD_NO_MEDIA)
752 			continue;
753 
754 		if (dev->dv_type != DEVT_DISK)
755 			continue;
756 
757 		devd.dd.d_dev = dev;
758 		devd.dd.d_unit = i;
759 		devd.d_slice = D_SLICENONE;
760 		devd.d_partition = D_PARTNONE;
761 		if (disk_open(&devd,
762 		    bd->bd_sectorsize * bd->bd_sectors,
763 		    bd->bd_sectorsize) == 0) {
764 			snprintf(line, sizeof(line), "    %s%d",
765 			    dev->dv_name, i);
766 			ret = disk_print(&devd, line, verbose);
767 			disk_close(&devd);
768 			if (ret != 0)
769 				break;
770 		}
771 	}
772 	return (ret);
773 }
774 
775 static int
776 fd_print(int verbose)
777 {
778 	return (bd_print_common(&biosfd, &fdinfo, verbose));
779 }
780 
781 static int
782 bd_print(int verbose)
783 {
784 	return (bd_print_common(&bioshd, &hdinfo, verbose));
785 }
786 
787 static int
788 cd_print(int verbose)
789 {
790 	return (bd_print_common(&bioscd, &cdinfo, verbose));
791 }
792 
793 /*
794  * Read disk size from partition.
795  * This is needed to work around buggy BIOS systems returning
796  * wrong (truncated) disk media size.
797  * During bd_probe() we tested if the multiplication of bd_sectors
798  * would overflow so it should be safe to perform here.
799  */
800 static uint64_t
801 bd_disk_get_sectors(struct disk_devdesc *dev)
802 {
803 	bdinfo_t *bd;
804 	struct disk_devdesc disk;
805 	uint64_t size;
806 
807 	bd = bd_get_bdinfo(&dev->dd);
808 	if (bd == NULL)
809 		return (0);
810 
811 	disk.dd.d_dev = dev->dd.d_dev;
812 	disk.dd.d_unit = dev->dd.d_unit;
813 	disk.d_slice = D_SLICENONE;
814 	disk.d_partition = D_PARTNONE;
815 	disk.d_offset = 0;
816 
817 	size = bd->bd_sectors * bd->bd_sectorsize;
818 	if (disk_open(&disk, size, bd->bd_sectorsize) == 0) {
819 		(void) disk_ioctl(&disk, DIOCGMEDIASIZE, &size);
820 		disk_close(&disk);
821 	}
822 	return (size / bd->bd_sectorsize);
823 }
824 
825 /*
826  * Attempt to open the disk described by (dev) for use by (f).
827  *
828  * Note that the philosophy here is "give them exactly what
829  * they ask for".  This is necessary because being too "smart"
830  * about what the user might want leads to complications.
831  * (eg. given no slice or partition value, with a disk that is
832  *  sliced - are they after the first BSD slice, or the DOS
833  *  slice before it?)
834  */
835 static int
836 bd_open(struct open_file *f, ...)
837 {
838 	bdinfo_t *bd;
839 	struct disk_devdesc *dev;
840 	va_list ap;
841 	int rc;
842 
843 	va_start(ap, f);
844 	dev = va_arg(ap, struct disk_devdesc *);
845 	va_end(ap);
846 
847 	bd = bd_get_bdinfo(&dev->dd);
848 	if (bd == NULL)
849 		return (EIO);
850 
851 	if ((bd->bd_flags & BD_NO_MEDIA) == BD_NO_MEDIA) {
852 		if (!bd_int13probe(bd))
853 			return (EIO);
854 		if ((bd->bd_flags & BD_NO_MEDIA) == BD_NO_MEDIA)
855 			return (EIO);
856 	}
857 	if (bd->bd_bcache == NULL)
858 	    bd->bd_bcache = bcache_allocate();
859 
860 	if (bd->bd_open == 0)
861 		bd->bd_sectors = bd_disk_get_sectors(dev);
862 	bd->bd_open++;
863 
864 	rc = 0;
865 	if (dev->dd.d_dev->dv_type == DEVT_DISK) {
866 		rc = disk_open(dev, bd->bd_sectors * bd->bd_sectorsize,
867 		    bd->bd_sectorsize);
868 		if (rc != 0) {
869 			bd->bd_open--;
870 			if (bd->bd_open == 0) {
871 				bcache_free(bd->bd_bcache);
872 				bd->bd_bcache = NULL;
873 			}
874 		}
875 	}
876 	return (rc);
877 }
878 
879 static int
880 bd_close(struct open_file *f)
881 {
882 	struct disk_devdesc *dev;
883 	bdinfo_t *bd;
884 	int rc = 0;
885 
886 	dev = (struct disk_devdesc *)f->f_devdata;
887 	bd = bd_get_bdinfo(&dev->dd);
888 	if (bd == NULL)
889 		return (EIO);
890 
891 	bd->bd_open--;
892 	if (bd->bd_open == 0) {
893 	    bcache_free(bd->bd_bcache);
894 	    bd->bd_bcache = NULL;
895 	}
896 	if (dev->dd.d_dev->dv_type == DEVT_DISK)
897 		rc = disk_close(dev);
898 	return (rc);
899 }
900 
901 static int
902 bd_ioctl(struct open_file *f, u_long cmd, void *data)
903 {
904 	bdinfo_t *bd;
905 	struct disk_devdesc *dev;
906 	int rc;
907 
908 	dev = (struct disk_devdesc *)f->f_devdata;
909 	bd = bd_get_bdinfo(&dev->dd);
910 	if (bd == NULL)
911 		return (EIO);
912 
913 	if (dev->dd.d_dev->dv_type == DEVT_DISK) {
914 		rc = disk_ioctl(dev, cmd, data);
915 		if (rc != ENOTTY)
916 			return (rc);
917 	}
918 
919 	switch (cmd) {
920 	case DIOCGSECTORSIZE:
921 		*(uint32_t *)data = bd->bd_sectorsize;
922 		break;
923 	case DIOCGMEDIASIZE:
924 		*(uint64_t *)data = bd->bd_sectors * bd->bd_sectorsize;
925 		break;
926 	default:
927 		return (ENOTTY);
928 	}
929 	return (0);
930 }
931 
932 static int
933 bd_strategy(void *devdata, int rw, daddr_t dblk, size_t size,
934     char *buf, size_t *rsize)
935 {
936 	bdinfo_t *bd;
937 	struct bcache_devdata bcd;
938 	struct disk_devdesc *dev;
939 	daddr_t offset;
940 
941 	dev = (struct disk_devdesc *)devdata;
942 	bd = bd_get_bdinfo(&dev->dd);
943 	if (bd == NULL)
944 		return (EINVAL);
945 
946 	bcd.dv_strategy = bd_realstrategy;
947 	bcd.dv_devdata = devdata;
948 	bcd.dv_cache = bd->bd_bcache;
949 
950 	offset = 0;
951 	if (dev->dd.d_dev->dv_type == DEVT_DISK) {
952 
953 		offset = dev->d_offset * bd->bd_sectorsize;
954 		offset /= BIOSDISK_SECSIZE;
955 	}
956 	return (bcache_strategy(&bcd, rw, dblk + offset, size,
957 	    buf, rsize));
958 }
959 
960 static int
961 bd_realstrategy(void *devdata, int rw, daddr_t dblk, size_t size,
962     char *buf, size_t *rsize)
963 {
964 	struct disk_devdesc *dev = (struct disk_devdesc *)devdata;
965 	bdinfo_t *bd;
966 	uint64_t disk_blocks, offset, d_offset;
967 	size_t blks, blkoff, bsize, bio_size, rest;
968 	caddr_t bbuf = NULL;
969 	int rc;
970 
971 	bd = bd_get_bdinfo(&dev->dd);
972 	if (bd == NULL || (bd->bd_flags & BD_NO_MEDIA) == BD_NO_MEDIA)
973 		return (EIO);
974 
975 	/*
976 	 * First make sure the IO size is a multiple of 512 bytes. While we do
977 	 * process partial reads below, the strategy mechanism is built
978 	 * assuming IO is a multiple of 512B blocks. If the request is not
979 	 * a multiple of 512B blocks, it has to be some sort of bug.
980 	 */
981 	if (size == 0 || (size % BIOSDISK_SECSIZE) != 0) {
982 		printf("bd_strategy: %d bytes I/O not multiple of %d\n",
983 		    size, BIOSDISK_SECSIZE);
984 		return (EIO);
985 	}
986 
987 	DPRINTF("open_disk %p", dev);
988 
989 	offset = dblk * BIOSDISK_SECSIZE;
990 	dblk = offset / bd->bd_sectorsize;
991 	blkoff = offset % bd->bd_sectorsize;
992 
993 	/*
994 	 * Check the value of the size argument. We do have quite small
995 	 * heap (64MB), but we do not know good upper limit, so we check against
996 	 * INT_MAX here. This will also protect us against possible overflows
997 	 * while translating block count to bytes.
998 	 */
999 	if (size > INT_MAX) {
1000 		DPRINTF("too large I/O: %zu bytes", size);
1001 		return (EIO);
1002 	}
1003 
1004 	blks = size / bd->bd_sectorsize;
1005 	if (blks == 0 || (size % bd->bd_sectorsize) != 0)
1006 		blks++;
1007 
1008 	if (dblk > dblk + blks)
1009 		return (EIO);
1010 
1011 	if (rsize)
1012 		*rsize = 0;
1013 
1014 	/*
1015 	 * Get disk blocks, this value is either for whole disk or for
1016 	 * partition.
1017 	 */
1018 	d_offset = 0;
1019 	disk_blocks = 0;
1020 	if (dev->dd.d_dev->dv_type == DEVT_DISK) {
1021 		if (disk_ioctl(dev, DIOCGMEDIASIZE, &disk_blocks) == 0) {
1022 			/* DIOCGMEDIASIZE does return bytes. */
1023 			disk_blocks /= bd->bd_sectorsize;
1024 		}
1025 		d_offset = dev->d_offset;
1026 	}
1027 	if (disk_blocks == 0)
1028 		disk_blocks = bd->bd_sectors - d_offset;
1029 
1030 	/* Validate source block address. */
1031 	if (dblk < d_offset || dblk >= d_offset + disk_blocks)
1032 		return (EIO);
1033 
1034 	/*
1035 	 * Truncate if we are crossing disk or partition end.
1036 	 */
1037 	if (dblk + blks >= d_offset + disk_blocks) {
1038 		blks = d_offset + disk_blocks - dblk;
1039 		size = blks * bd->bd_sectorsize;
1040 		DPRINTF("short I/O %d", blks);
1041 	}
1042 
1043 	bio_size = min(BIO_BUFFER_SIZE, size);
1044 	while (bio_size > bd->bd_sectorsize) {
1045 		bbuf = bio_alloc(bio_size);
1046 		if (bbuf != NULL)
1047 			break;
1048 		bio_size -= bd->bd_sectorsize;
1049 	}
1050 	if (bbuf == NULL) {
1051 		bio_size = V86_IO_BUFFER_SIZE;
1052 		if (bio_size / bd->bd_sectorsize == 0)
1053 			panic("BUG: Real mode buffer is too small");
1054 
1055 		/* Use alternate 4k buffer */
1056 		bbuf = PTOV(V86_IO_BUFFER);
1057 	}
1058 	rest = size;
1059 	rc = 0;
1060 	while (blks > 0) {
1061 		int x = min(blks, bio_size / bd->bd_sectorsize);
1062 
1063 		switch (rw & F_MASK) {
1064 		case F_READ:
1065 			DPRINTF("read %d from %lld to %p", x, dblk, buf);
1066 			bsize = bd->bd_sectorsize * x - blkoff;
1067 			if (rest < bsize)
1068 				bsize = rest;
1069 
1070 			if ((rc = bd_io(dev, bd, dblk, x, bbuf, BD_RD)) != 0) {
1071 				rc = EIO;
1072 				goto error;
1073 			}
1074 
1075 			bcopy(bbuf + blkoff, buf, bsize);
1076 			break;
1077 		case F_WRITE :
1078 			DPRINTF("write %d from %lld to %p", x, dblk, buf);
1079 			if (blkoff != 0) {
1080 				/*
1081 				 * We got offset to sector, read 1 sector to
1082 				 * bbuf.
1083 				 */
1084 				x = 1;
1085 				bsize = bd->bd_sectorsize - blkoff;
1086 				bsize = min(bsize, rest);
1087 				rc = bd_io(dev, bd, dblk, x, bbuf, BD_RD);
1088 			} else if (rest < bd->bd_sectorsize) {
1089 				/*
1090 				 * The remaining block is not full
1091 				 * sector. Read 1 sector to bbuf.
1092 				 */
1093 				x = 1;
1094 				bsize = rest;
1095 				rc = bd_io(dev, bd, dblk, x, bbuf, BD_RD);
1096 			} else {
1097 				/* We can write full sector(s). */
1098 				bsize = bd->bd_sectorsize * x;
1099 			}
1100 			/*
1101 			 * Put your Data In, Put your Data out,
1102 			 * Put your Data In, and shake it all about
1103 			 */
1104 			bcopy(buf, bbuf + blkoff, bsize);
1105 			if ((rc = bd_io(dev, bd, dblk, x, bbuf, BD_WR)) != 0) {
1106 				rc = EIO;
1107 				goto error;
1108 			}
1109 
1110 			break;
1111 		default:
1112 			/* DO NOTHING */
1113 			rc = EROFS;
1114 			goto error;
1115 		}
1116 
1117 		blkoff = 0;
1118 		buf += bsize;
1119 		rest -= bsize;
1120 		blks -= x;
1121 		dblk += x;
1122 	}
1123 
1124 	if (rsize != NULL)
1125 		*rsize = size;
1126 error:
1127 	if (bbuf != PTOV(V86_IO_BUFFER))
1128 		bio_free(bbuf, bio_size);
1129 	return (rc);
1130 }
1131 
1132 static int
1133 bd_edd_io(bdinfo_t *bd, daddr_t dblk, int blks, caddr_t dest,
1134     int dowrite)
1135 {
1136 	static struct edd_packet packet;
1137 
1138 	packet.len = sizeof(struct edd_packet);
1139 	packet.count = blks;
1140 	packet.off = VTOPOFF(dest);
1141 	packet.seg = VTOPSEG(dest);
1142 	packet.lba = dblk;
1143 	v86.ctl = V86_FLAGS;
1144 	v86.addr = DISK_BIOS;
1145 	if (dowrite == BD_WR)
1146 		v86.eax = CMD_WRITE_LBA; /* maybe Write with verify 0x4302? */
1147 	else
1148 		v86.eax = CMD_READ_LBA;
1149 	v86.edx = bd->bd_unit;
1150 	v86.ds = VTOPSEG(&packet);
1151 	v86.esi = VTOPOFF(&packet);
1152 	v86int();
1153 	if (V86_CY(v86.efl))
1154 		return (v86.eax >> 8);
1155 	return (0);
1156 }
1157 
1158 static int
1159 bd_chs_io(bdinfo_t *bd, daddr_t dblk, int blks, caddr_t dest,
1160     int dowrite)
1161 {
1162 	uint32_t x, bpc, cyl, hd, sec;
1163 
1164 	bpc = bd->bd_sec * bd->bd_hds;	/* blocks per cylinder */
1165 	x = dblk;
1166 	cyl = x / bpc;			/* block # / blocks per cylinder */
1167 	x %= bpc;				/* block offset into cylinder */
1168 	hd = x / bd->bd_sec;		/* offset / blocks per track */
1169 	sec = x % bd->bd_sec;		/* offset into track */
1170 
1171 	/* correct sector number for 1-based BIOS numbering */
1172 	sec++;
1173 
1174 	if (cyl > 1023) {
1175 		/* CHS doesn't support cylinders > 1023. */
1176 		return (1);
1177 	}
1178 
1179 	v86.ctl = V86_FLAGS;
1180 	v86.addr = DISK_BIOS;
1181 	if (dowrite == BD_WR)
1182 		v86.eax = CMD_WRITE_CHS | blks;
1183 	else
1184 		v86.eax = CMD_READ_CHS | blks;
1185 	v86.ecx = ((cyl & 0xff) << 8) | ((cyl & 0x300) >> 2) | sec;
1186 	v86.edx = (hd << 8) | bd->bd_unit;
1187 	v86.es = VTOPSEG(dest);
1188 	v86.ebx = VTOPOFF(dest);
1189 	v86int();
1190 	if (V86_CY(v86.efl))
1191 		return (v86.eax >> 8);
1192 	return (0);
1193 }
1194 
1195 static void
1196 bd_io_workaround(bdinfo_t *bd)
1197 {
1198 	uint8_t buf[8 * 1024];
1199 
1200 	bd_edd_io(bd, 0xffffffff, 1, (caddr_t)buf, BD_RD);
1201 }
1202 
1203 static int
1204 bd_io(struct disk_devdesc *dev, bdinfo_t *bd, daddr_t dblk, int blks,
1205     caddr_t dest, int dowrite)
1206 {
1207 	int result, retry;
1208 
1209 	/* Just in case some idiot actually tries to read/write -1 blocks... */
1210 	if (blks < 0)
1211 		return (-1);
1212 
1213 	/*
1214 	 * Workaround for a problem with some HP ProLiant BIOS failing to work
1215 	 * out the boot disk after installation. hrs and kuriyama discovered
1216 	 * this problem with an HP ProLiant DL320e Gen 8 with a 3TB HDD, and
1217 	 * discovered that an int13h call seems to cause a buffer overrun in
1218 	 * the bios. The problem is alleviated by doing an extra read before
1219 	 * the buggy read. It is not immediately known whether other models
1220 	 * are similarly affected.
1221 	 * Loop retrying the operation a couple of times.  The BIOS
1222 	 * may also retry.
1223 	 */
1224 	if (dowrite == BD_RD && dblk >= 0x100000000)
1225 		bd_io_workaround(bd);
1226 	for (retry = 0; retry < 3; retry++) {
1227 		if (bd->bd_flags & BD_MODEEDD)
1228 			result = bd_edd_io(bd, dblk, blks, dest, dowrite);
1229 		else
1230 			result = bd_chs_io(bd, dblk, blks, dest, dowrite);
1231 
1232 		if (result == 0) {
1233 			if (bd->bd_flags & BD_NO_MEDIA)
1234 				bd->bd_flags &= ~BD_NO_MEDIA;
1235 			break;
1236 		}
1237 
1238 		bd_reset_disk(bd->bd_unit);
1239 
1240 		/*
1241 		 * Error codes:
1242 		 * 20h	controller failure
1243 		 * 31h	no media in drive (IBM/MS INT 13 extensions)
1244 		 * 80h	no media in drive, VMWare (Fusion)
1245 		 * There is no reason to repeat the IO with errors above.
1246 		 */
1247 		if (result == 0x20 || result == 0x31 || result == 0x80) {
1248 			bd->bd_flags |= BD_NO_MEDIA;
1249 			break;
1250 		}
1251 	}
1252 
1253 	if (result != 0 && (bd->bd_flags & BD_NO_MEDIA) == 0) {
1254 		if (dowrite == BD_WR) {
1255 			printf("%s%d: Write %d sector(s) from %p (0x%x) "
1256 			    "to %lld: 0x%x\n", dev->dd.d_dev->dv_name,
1257 			    dev->dd.d_unit, blks, dest, VTOP(dest), dblk,
1258 			    result);
1259 		} else {
1260 			printf("%s%d: Read %d sector(s) from %lld to %p "
1261 			    "(0x%x): 0x%x\n", dev->dd.d_dev->dv_name,
1262 			    dev->dd.d_unit, blks, dblk, dest, VTOP(dest),
1263 			    result);
1264 		}
1265 	}
1266 
1267 	return (result);
1268 }
1269 
1270 /*
1271  * Return the BIOS geometry of a given "fixed drive" in a format
1272  * suitable for the legacy bootinfo structure.  Since the kernel is
1273  * expecting raw int 0x13/0x8 values for N_BIOS_GEOM drives, we
1274  * prefer to get the information directly, rather than rely on being
1275  * able to put it together from information already maintained for
1276  * different purposes and for a probably different number of drives.
1277  *
1278  * For valid drives, the geometry is expected in the format (31..0)
1279  * "000000cc cccccccc hhhhhhhh 00ssssss"; and invalid drives are
1280  * indicated by returning the geometry of a "1.2M" PC-format floppy
1281  * disk.  And, incidentally, what is returned is not the geometry as
1282  * such but the highest valid cylinder, head, and sector numbers.
1283  */
1284 uint32_t
1285 bd_getbigeom(int bunit)
1286 {
1287 
1288 	v86.ctl = V86_FLAGS;
1289 	v86.addr = DISK_BIOS;
1290 	v86.eax = CMD_READ_PARAM;
1291 	v86.edx = 0x80 + bunit;
1292 	v86int();
1293 	if (V86_CY(v86.efl))
1294 		return (0x4f010f);
1295 	return (((v86.ecx & 0xc0) << 18) | ((v86.ecx & 0xff00) << 8) |
1296 	    (v86.edx & 0xff00) | (v86.ecx & 0x3f));
1297 }
1298 
1299 /*
1300  * Return a suitable dev_t value for (dev).
1301  *
1302  * In the case where it looks like (dev) is a SCSI disk, we allow the number of
1303  * IDE disks to be specified in $num_ide_disks.  There should be a Better Way.
1304  */
1305 int
1306 bd_getdev(struct i386_devdesc *d)
1307 {
1308 	struct disk_devdesc *dev;
1309 	bdinfo_t *bd;
1310 	int	biosdev;
1311 	int	major;
1312 	int	rootdev;
1313 	char	*nip, *cp;
1314 	int	i, unit, slice, partition;
1315 
1316 	/* XXX: Assume partition 'a'. */
1317 	slice = 0;
1318 	partition = 0;
1319 
1320 	dev = (struct disk_devdesc *)d;
1321 	bd = bd_get_bdinfo(&dev->dd);
1322 	if (bd == NULL)
1323 		return (-1);
1324 
1325 	biosdev = bd_unit2bios(d);
1326 	DPRINTF("unit %d BIOS device %d", dev->dd.d_unit, biosdev);
1327 	if (biosdev == -1)			/* not a BIOS device */
1328 		return (-1);
1329 
1330 	if (dev->dd.d_dev->dv_type == DEVT_DISK) {
1331 		if (disk_open(dev, bd->bd_sectors * bd->bd_sectorsize,
1332 		    bd->bd_sectorsize) != 0)	/* oops, not a viable device */
1333 			return (-1);
1334 		else
1335 			disk_close(dev);
1336 		slice = dev->d_slice + 1;
1337 		partition = dev->d_partition;
1338 	}
1339 
1340 	if (biosdev < 0x80) {
1341 		/* floppy (or emulated floppy) or ATAPI device */
1342 		if (bd->bd_type == DT_ATAPI) {
1343 			/* is an ATAPI disk */
1344 			major = WFDMAJOR;
1345 		} else {
1346 			/* is a floppy disk */
1347 			major = FDMAJOR;
1348 		}
1349 	} else {
1350 		/* assume an IDE disk */
1351 		major = WDMAJOR;
1352 	}
1353 	/* default root disk unit number */
1354 	unit = biosdev & 0x7f;
1355 
1356 	if (dev->dd.d_dev->dv_type == DEVT_CD) {
1357 		/*
1358 		 * XXX: Need to examine device spec here to figure out if
1359 		 * SCSI or ATAPI.  No idea on how to figure out device number.
1360 		 * All we can really pass to the kernel is what bus and device
1361 		 * on which bus we were booted from, which dev_t isn't well
1362 		 * suited to since those number don't match to unit numbers
1363 		 * very well.  We may just need to engage in a hack where
1364 		 * we pass -C to the boot args if we are the boot device.
1365 		 */
1366 		major = ACDMAJOR;
1367 		unit = 0;       /* XXX */
1368 	}
1369 
1370 	/* XXX a better kludge to set the root disk unit number */
1371 	if ((nip = getenv("root_disk_unit")) != NULL) {
1372 		i = strtol(nip, &cp, 0);
1373 		/* check for parse error */
1374 		if ((cp != nip) && (*cp == 0))
1375 			unit = i;
1376 	}
1377 
1378 	rootdev = MAKEBOOTDEV(major, slice, unit, partition);
1379 	DPRINTF("dev is 0x%x\n", rootdev);
1380 	return (rootdev);
1381 }
1382