Merge from vendor branch GDB:
[dragonfly.git] / sys / boot / pc32 / libi386 / bioscd.c
1 /*-
2  * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
3  * Copyright (c) 2001 John H. Baldwin <jhb@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  * $FreeBSD: src/sys/boot/i386/libi386/bioscd.c,v 1.5 2003/08/25 23:28:31 obrien Exp $
28  * $DragonFly: src/sys/boot/pc32/libi386/bioscd.c,v 1.5 2004/09/09 03:47:08 joerg Exp $
29  */
30 /*
31  * BIOS CD device handling for CD's that have been booted off of via no
32  * emulation booting as defined in the El Torito standard.
33  * 
34  * Ideas and algorithms from:
35  *
36  * - FreeBSD libi386/biosdisk.c
37  *
38  */
39
40 #include <stand.h>
41
42 #include <sys/param.h>
43 #include <machine/bootinfo.h>
44 #include <machine/psl.h>
45
46 #include <stdarg.h>
47
48 #include <bootstrap.h>
49 #include <btxv86.h>
50 #include "libi386.h"
51
52 #define BIOSCD_SECSIZE          2048
53 #define BUFSIZE                 (1 * BIOSCD_SECSIZE)
54 #define MAXBCDEV                1
55
56 /* Major numbers for devices we frontend for. */
57 #define ACDMAJOR                117
58 #define CDMAJOR                 15
59
60 #ifdef DISK_DEBUG
61 # define DEBUG(fmt, args...)    printf("%s: " fmt "\n" , __func__ , ## args)
62 #else
63 # define DEBUG(fmt, args...)
64 #endif
65
66 struct specification_packet {
67         u_char  sp_size;
68         u_char  sp_bootmedia;
69         u_char  sp_drive;
70         u_char  sp_controller;
71         u_int   sp_lba;
72         u_short sp_devicespec;
73         u_short sp_buffersegment;
74         u_short sp_loadsegment;
75         u_short sp_sectorcount;
76         u_short sp_cylsec;
77         u_char  sp_head;
78 };
79
80 /*
81  * List of BIOS devices, translation from disk unit number to
82  * BIOS unit number.
83  */
84 static struct bcinfo {
85         int     bc_unit;                /* BIOS unit number */
86         struct specification_packet bc_sp;
87 } bcinfo [MAXBCDEV];
88 static int nbcinfo = 0;
89
90 static int      bc_read(int unit, daddr_t dblk, int blks, caddr_t dest);
91 static int      bc_init(void);
92 static int      bc_strategy(void *devdata, int flag, daddr_t dblk,
93                     size_t size, char *buf, size_t *rsize);
94 static int      bc_open(struct open_file *f, ...);
95 static int      bc_close(struct open_file *f);
96 static void     bc_print(int verbose);
97
98 struct devsw bioscd = {
99         "cd", 
100         DEVT_CD, 
101         bc_init,
102         bc_strategy, 
103         bc_open, 
104         bc_close, 
105         noioctl,
106         bc_print,
107         NULL
108 };
109
110 /*
111  * Translate between BIOS device numbers and our private unit numbers.
112  */
113 int
114 bc_bios2unit(int biosdev)
115 {
116         int i;
117     
118         DEBUG("looking for bios device 0x%x", biosdev);
119         for (i = 0; i < nbcinfo; i++) {
120                 DEBUG("bc unit %d is BIOS device 0x%x", i, bcinfo[i].bc_unit);
121                 if (bcinfo[i].bc_unit == biosdev)
122                         return(i);
123         }
124         return(-1);
125 }
126
127 int
128 bc_unit2bios(int unit)
129 {
130         if ((unit >= 0) && (unit < nbcinfo))
131                 return(bcinfo[unit].bc_unit);
132         return(-1);
133 }
134
135 /*    
136  * We can't quiz, we have to be told what device to use, so this functoin
137  * doesn't do anything.  Instead, the loader calls bc_add() with the BIOS
138  * device number to add.
139  */
140 static int
141 bc_init(void) 
142 {
143
144         return (0);
145 }
146
147 int
148 bc_add(int biosdev)
149 {
150
151         if (nbcinfo >= MAXBCDEV)
152                 return (-1);
153         bcinfo[nbcinfo].bc_unit = biosdev;
154         v86.ctl = V86_FLAGS;
155         v86.addr = 0x13;
156         v86.eax = 0x4b01;
157         v86.edx = biosdev;
158         v86.ds = VTOPSEG(&bcinfo[nbcinfo].bc_sp);
159         v86.esi = VTOPOFF(&bcinfo[nbcinfo].bc_sp);
160         v86int();
161         if ((v86.eax & 0xff00) != 0)
162                 return (-1);
163
164         printf("BIOS CD is cd%d\n", nbcinfo);
165         nbcinfo++;
166         return(0);
167 }
168
169 /*
170  * Print information about disks
171  */
172 static void
173 bc_print(int verbose)
174 {
175         int i;
176         char line[80];
177     
178         for (i = 0; i < nbcinfo; i++) {
179                 sprintf(line, "    cd%d: Device 0x%x\n", i,
180                     bcinfo[i].bc_sp.sp_devicespec);
181                 pager_output(line);
182         }
183 }
184
185 /*
186  * Attempt to open the disk described by (dev) for use by (f).
187  */
188 static int 
189 bc_open(struct open_file *f, ...)
190 {
191         va_list ap;
192         struct i386_devdesc *dev;
193         int error;
194
195         va_start(ap, f);
196         dev = va_arg(ap, struct i386_devdesc *);
197         va_end(ap);
198         if (dev->d_kind.bioscd.unit >= nbcinfo) {
199                 DEBUG("attempt to open nonexistent disk");
200                 return(ENXIO);
201         }
202
203         return(0);
204 }
205  
206 static int 
207 bc_close(struct open_file *f)
208 {
209
210         return(0);
211 }
212
213 static int 
214 bc_strategy(void *devdata, int rw, daddr_t dblk, size_t size, char *buf,
215     size_t *rsize)
216 {
217         struct i386_devdesc *dev;
218         int unit;
219         int blks;
220 #ifdef BD_SUPPORT_FRAGS
221         char fragbuf[BIOSCD_SECSIZE];
222         size_t fragsize;
223
224         fragsize = size % BIOSCD_SECSIZE;
225 #else
226         if (size % BIOSCD_SECSIZE)
227                 return (EINVAL);
228 #endif
229
230         if (rw != F_READ)
231                 return(EROFS);
232         dev = (struct i386_devdesc *)devdata;
233         unit = dev->d_kind.bioscd.unit;
234         blks = size / BIOSCD_SECSIZE;
235         if (dblk % (BIOSCD_SECSIZE / DEV_BSIZE) != 0)
236                 return (EINVAL);
237         dblk /= (BIOSCD_SECSIZE / DEV_BSIZE);
238         DEBUG("read %d from %d to %p", blks, dblk, buf);
239
240         if (rsize)
241                 *rsize = 0;
242         if (blks && bc_read(unit, dblk, blks, buf)) {
243                 DEBUG("read error");
244                 return (EIO);
245         }
246 #ifdef BD_SUPPORT_FRAGS
247         DEBUG("bc_strategy: frag read %d from %d+%d to %p", 
248             fragsize, dblk, blks, buf + (blks * BIOSCD_SECSIZE));
249         if (fragsize && bc_read(unit, dblk + blks, 1, fragsize)) {
250                 DEBUG("frag read error");
251                 return(EIO);
252         }
253         bcopy(fragbuf, buf + (blks * BIOSCD_SECSIZE), fragsize);
254 #endif  
255         if (rsize)
256                 *rsize = size;
257         return (0);
258 }
259
260 static int
261 bc_read(int unit, daddr_t dblk, int blks, caddr_t dest)
262 {
263         u_int result, resid, retry;
264         static unsigned short packet[8];
265         int biosdev;
266 #ifdef DISK_DEBUG
267         int error;
268 #endif
269     
270         /* Just in case some idiot actually tries to read -1 blocks... */
271         if (blks < 0)
272                 return (-1);
273
274         /* If nothing to do, just return succcess. */
275         if (blks == 0)
276                 return (0);
277
278         biosdev = bc_unit2bios(unit);
279         /*
280          * Loop retrying the operation a couple of times.  The BIOS
281          * may also retry.
282          */
283         for (retry = 0; retry < 3; retry++) {
284                 /* If retrying, reset the drive */
285                 if (retry > 0) {
286                         v86.ctl = V86_FLAGS;
287                         v86.addr = 0x13;
288                         v86.eax = 0;
289                         v86.edx = biosdev;
290                         v86int();
291                 }
292             
293                 packet[0] = 0x10;
294                 packet[1] = blks;
295                 packet[2] = VTOPOFF(dest);
296                 packet[3] = VTOPSEG(dest);
297                 packet[4] = dblk & 0xffff;
298                 packet[5] = dblk >> 16;
299                 packet[6] = 0;
300                 packet[7] = 0;
301                 v86.ctl = V86_FLAGS;
302                 v86.addr = 0x13;
303                 v86.eax = 0x4200;
304                 v86.edx = biosdev;
305                 v86.ds = VTOPSEG(packet);
306                 v86.esi = VTOPOFF(packet);
307                 v86int();
308                 result = (v86.efl & PSL_C);
309                 if (result == 0)
310                         break;
311         }
312         
313 #ifdef DISK_DEBUG
314         error = (v86.eax >> 8) & 0xff;
315 #endif
316         DEBUG("%d sectors from %ld to %p (0x%x) %s", blks, dblk, dest,
317             VTOP(dest), result ? "failed" : "ok");
318         DEBUG("unit %d  status 0x%x",  unit, error);
319         
320 /*      hexdump(dest, (blks * BIOSCD_SECSIZE)); */
321         return(0);
322 }
323
324 /*
325  * Return a suitable dev_t value for (dev).
326  */
327 int
328 bc_getdev(struct i386_devdesc *dev)
329 {
330     int biosdev, unit;
331     int major;
332     int rootdev;
333
334     unit = dev->d_kind.bioscd.unit;
335     biosdev = bc_unit2bios(unit);
336     DEBUG("unit %d BIOS device %d", unit, biosdev);
337     if (biosdev == -1)                          /* not a BIOS device */
338         return(-1);
339
340     /*
341      * XXX: Need to examine device spec here to figure out if SCSI or
342      * ATAPI.  No idea on how to figure out device number.  All we can
343      * really pass to the kernel is what bus and device on which bus we
344      * were booted from, which dev_t isn't well suited to since those
345      * number don't match to unit numbers very well.  We may just need
346      * to engage in a hack where we pass -C to the boot args if we are
347      * the boot device.
348      */
349     major = ACDMAJOR;
350     unit = 0;   /* XXX */
351
352     /* XXX: Assume partition 'a'. */
353     rootdev = MAKEBOOTDEV(major, 0, 0, unit, 0);
354     DEBUG("dev is 0x%x\n", rootdev);
355     return(rootdev);
356 }