eltorito.c@ 42057

Last change on this file since 42057 was 41653, checked in by vboxsync, 13 years ago
BIOS: Remove signed 32-bit multiply/divide routines (unnecessary).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 32.5 KB

Line
1	/*
2	* Copyright (C) 2006-2011 Oracle Corporation
3	*
4	* This file is part of VirtualBox Open Source Edition (OSE), as
5	* available from http://www.virtualbox.org. This file is free software;
6	* you can redistribute it and/or modify it under the terms of the GNU
7	* General Public License (GPL) as published by the Free Software
8	* Foundation, in version 2 as it comes in the "COPYING" file of the
9	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
10	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
11	* --------------------------------------------------------------------
12	*
13	* This code is based on:
14	*
15	* ROM BIOS for use with Bochs/Plex86/QEMU emulation environment
16	*
17	* Copyright (C) 2002 MandrakeSoft S.A.
18	*
19	* MandrakeSoft S.A.
20	* 43, rue d'Aboukir
21	* 75002 Paris - France
22	* http://www.linux-mandrake.com/
23	* http://www.mandrakesoft.com/
24	*
25	* This library is free software; you can redistribute it and/or
26	* modify it under the terms of the GNU Lesser General Public
27	* License as published by the Free Software Foundation; either
28	* version 2 of the License, or (at your option) any later version.
29	*
30	* This library is distributed in the hope that it will be useful,
31	* but WITHOUT ANY WARRANTY; without even the implied warranty of
32	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
33	* Lesser General Public License for more details.
34	*
35	* You should have received a copy of the GNU Lesser General Public
36	* License along with this library; if not, write to the Free Software
37	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
38	*
39	*/
40
41
42	#include <stdint.h>
43	#include <string.h>
44	#include "inlines.h"
45	#include "biosint.h"
46	#include "ebda.h"
47	#include "ata.h"
48
49	#if DEBUG_ELTORITO
50	# define BX_DEBUG_INT13_ET(...) BX_DEBUG(__VA_ARGS__)
51	#else
52	# define BX_DEBUG_INT13_ET(...)
53	#endif
54
55	#if DEBUG_INT13_CD
56	# define BX_DEBUG_INT13_CD(...) BX_DEBUG(__VA_ARGS__)
57	#else
58	# define BX_DEBUG_INT13_CD(...)
59	#endif
60
61	#if DEBUG_CD_BOOT
62	# define BX_DEBUG_ELTORITO(...) BX_DEBUG(__VA_ARGS__)
63	#else
64	# define BX_DEBUG_ELTORITO(...)
65	#endif
66
67
68	//@todo: put in a header
69	#define AX r.gr.u.r16.ax
70	#define BX r.gr.u.r16.bx
71	#define CX r.gr.u.r16.cx
72	#define DX r.gr.u.r16.dx
73	#define SI r.gr.u.r16.si
74	#define DI r.gr.u.r16.di
75	#define BP r.gr.u.r16.bp
76	#define ELDX r.gr.u.r16.sp
77	#define DS r.ds
78	#define ES r.es
79	#define FLAGS r.ra.flags.u.r16.flags
80
81	#pragma pack(1)
82
83	/* READ_10/WRITE_10 CDB padded to 12 bytes for ATAPI. */
84	typedef struct {
85	uint16_t command; /* Command. */
86	uint32_t lba; /* LBA, MSB first! */
87	uint8_t pad1; /* Unused. */
88	uint16_t nsect; /* Sector count, MSB first! */
89	uint8_t pad2[3]; /* Unused. */
90	} cdb_atapi;
91
92	#pragma pack()
93
94	ct_assert(sizeof(cdb_atapi) == 12);
95
96	// ---------------------------------------------------------------------------
97	// Start of El-Torito boot functions
98	// ---------------------------------------------------------------------------
99
100	// !! TODO !! convert EBDA accesses to far pointers
101
102	extern int diskette_param_table;
103
104
105	void BIOSCALL cdemu_init(void)
106	{
107	// @TODO: a macro or a function for getting the EBDA segment
108	uint16_t ebda_seg = read_word(0x0040,0x000E);
109
110	// the only important data is this one for now
111	write_byte(ebda_seg,(uint16_t)&EbdaData->cdemu.active, 0x00);
112	}
113
114	uint8_t BIOSCALL cdemu_isactive(void)
115	{
116	// @TODO: a macro or a function for getting the EBDA segment
117	uint16_t ebda_seg = read_word(0x0040,0x000E);
118
119	return read_byte(ebda_seg,(uint16_t)&EbdaData->cdemu.active);
120	}
121
122	uint8_t BIOSCALL cdemu_emulated_drive(void)
123	{
124	// @TODO: a macro or a function for getting the EBDA segment
125	uint16_t ebda_seg = read_word(0x0040,0x000E);
126
127	return read_byte(ebda_seg,(uint16_t)&EbdaData->cdemu.emulated_drive);
128	}
129
130	// ---------------------------------------------------------------------------
131	// Start of int13 for eltorito functions
132	// ---------------------------------------------------------------------------
133
134	void BIOSCALL int13_eltorito(disk_regs_t r)
135	{
136	// @TODO: a macro or a function for getting the EBDA segment
137	uint16_t ebda_seg=read_word(0x0040,0x000E);
138	cdemu_t __far *cdemu;
139
140	cdemu = ebda_seg :> &EbdaData->cdemu;
141
142
143	BX_DEBUG_INT13_ET("%s: AX=%04x BX=%04x CX=%04x DX=%04x ES=%04x\n", __func__, AX, BX, CX, DX, ES);
144	// BX_DEBUG_INT13_ET("%s: SS=%04x DS=%04x ES=%04x DI=%04x SI=%04x\n", __func__, get_SS(), DS, ES, DI, SI);
145
146	switch (GET_AH()) {
147
148	// FIXME ElTorito Various. Should be implemented
149	case 0x4a: // ElTorito - Initiate disk emu
150	case 0x4c: // ElTorito - Initiate disk emu and boot
151	case 0x4d: // ElTorito - Return Boot catalog
152	BX_PANIC("%s: call with AX=%04x. Please report\n", __func__, AX);
153	goto int13_fail;
154	break;
155
156	case 0x4b: // ElTorito - Terminate disk emu
157	// FIXME ElTorito Hardcoded
158	//@todo: maybe our cdemu struct should match El Torito to allow memcpy()?
159	write_byte(DS,SI+0x00,0x13);
160	write_byte(DS,SI+0x01,cdemu->media);
161	write_byte(DS,SI+0x02,cdemu->emulated_drive);
162	write_byte(DS,SI+0x03,cdemu->controller_index);
163	write_dword(DS,SI+0x04,cdemu->ilba);
164	write_word(DS,SI+0x08,cdemu->device_spec);
165	write_word(DS,SI+0x0a,cdemu->buffer_segment);
166	write_word(DS,SI+0x0c,cdemu->load_segment);
167	write_word(DS,SI+0x0e,cdemu->sector_count);
168	write_byte(DS,SI+0x10,cdemu->vdevice.cylinders);
169	write_byte(DS,SI+0x11,cdemu->vdevice.spt);
170	write_byte(DS,SI+0x12,cdemu->vdevice.heads);
171
172	// If we have to terminate emulation
173	if(GET_AL() == 0x00) {
174	// FIXME ElTorito Various. Should be handled accordingly to spec
175	cdemu->active = 0; // bye bye
176	}
177
178	goto int13_success;
179	break;
180
181	default:
182	BX_INFO("%s: unsupported AH=%02x\n", __func__, GET_AH());
183	goto int13_fail;
184	break;
185	}
186
187	int13_fail:
188	SET_AH(0x01); // defaults to invalid function in AH or invalid parameter
189	SET_DISK_RET_STATUS(GET_AH());
190	SET_CF(); // error occurred
191	return;
192
193	int13_success:
194	SET_AH(0x00); // no error
195	SET_DISK_RET_STATUS(0x00);
196	CLEAR_CF(); // no error
197	return;
198	}
199
200	// ---------------------------------------------------------------------------
201	// End of int13 for eltorito functions
202	// ---------------------------------------------------------------------------
203
204	/* Utility routine to check if a device is a CD-ROM. */
205	//@todo: this function is kinda useless as the ATAPI type check is obsolete.
206	static uint16_t device_is_cdrom(uint8_t device)
207	{
208	bio_dsk_t __far *bios_dsk;
209
210	bios_dsk = read_word(0x0040, 0x000E) :> &EbdaData->bdisk;
211
212	if (device >= BX_MAX_STORAGE_DEVICES)
213	return 0;
214
215	// if (bios_dsk->devices[device].type != DSK_TYPE_ATAPI)
216	// return 0;
217
218	if (bios_dsk->devices[device].device != DSK_DEVICE_CDROM)
219	return 0;
220
221	return 1;
222	}
223
224	// ---------------------------------------------------------------------------
225	// End of ATA/ATAPI generic functions
226	// ---------------------------------------------------------------------------
227	static const char isotag[]="CD001";
228	static const char eltorito[]="EL TORITO SPECIFICATION";
229	//
230	// Returns ah: emulated drive, al: error code
231	//
232	uint16_t cdrom_boot(void)
233	{
234	// @TODO: a macro or a function for getting the EBDA segment
235	uint16_t ebda_seg=read_word(0x0040,0x000E);
236	uint8_t buffer[2048];
237	cdb_atapi atapicmd;
238	uint32_t lba;
239	uint16_t boot_segment, nbsectors, i, error;
240	uint8_t device;
241	uint8_t read_try;
242	cdemu_t __far *cdemu;
243	bio_dsk_t __far *bios_dsk;
244
245	cdemu = ebda_seg :> &EbdaData->cdemu;
246	bios_dsk = ebda_seg :> &EbdaData->bdisk;
247
248	/* Find the first CD-ROM. */
249	for (device = 0; device < BX_MAX_STORAGE_DEVICES; ++device) {
250	if (device_is_cdrom(device))
251	break;
252	}
253
254	/* Fail if not found. */
255	if (device >= BX_MAX_STORAGE_DEVICES)
256	return 2;
257
258	/* Read the Boot Record Volume Descriptor (BRVD). */
259	_fmemset(&atapicmd, 0, sizeof(atapicmd));
260	atapicmd.command = 0x28; // READ 10 command
261	atapicmd.lba = swap_32(0x11);
262	atapicmd.nsect = swap_16(1);
263
264	bios_dsk->drqp.nsect = 1;
265	bios_dsk->drqp.sect_sz = 2048;
266
267	for (read_try = 0; read_try <= 4; ++read_try)
268	{
269	//@todo: Use indirect calls instead?
270	if (device > BX_MAX_ATA_DEVICES)
271	error = ahci_cmd_packet(device, 12, (char __far *)&atapicmd, 0, 2048L, ATA_DATA_IN, &buffer);
272	else
273	error = ata_cmd_packet(device, 12, (char __far *)&atapicmd, 0, 2048L, ATA_DATA_IN, &buffer);
274	if (!error)
275	break;
276	}
277	if (error)
278	return 3;
279
280	/* Check for a valid BRVD. */
281	if (buffer[0] != 0)
282	return 4;
283	//@todo: what's wrong with memcmp()?
284	for (i = 0; i < 5; ++i) {
285	if (buffer[1+i] != isotag[i])
286	return 5;
287	}
288	for (i = 0; i < 23; ++i)
289	if (buffer[7+i] != eltorito[i])
290	return 6;
291
292	// ok, now we calculate the Boot catalog address
293	lba = ((uint32_t )&buffer[0x47]);
294	BX_DEBUG_ELTORITO("BRVD at LBA %lx\n", lba);
295
296	/* Now we read the Boot Catalog. */
297	atapicmd.command = 0x28; // READ 10 command
298	atapicmd.lba = swap_32(lba);
299	atapicmd.nsect = swap_16(1);
300
301	#if 0 // Not necessary as long as previous values are reused
302	bios_dsk->drqp.nsect = 1;
303	bios_dsk->drqp.sect_sz = 512;
304	#endif
305
306	if (device > BX_MAX_ATA_DEVICES)
307	error = ahci_cmd_packet(device, 12, (char __far *)&atapicmd, 0, 2048L, ATA_DATA_IN, &buffer);
308	else
309	error = ata_cmd_packet(device, 12, (char __far *)&atapicmd, 0, 2048L, ATA_DATA_IN, &buffer);
310
311	if (error != 0)
312	return 7;
313
314	//@todo: Define a struct for the Boot Catalog, the hardcoded offsets are so dumb...
315
316	/* Check if the Boot Catalog looks valid. */
317	if (buffer[0x00] != 0x01)
318	return 8; // Header
319	if (buffer[0x01] != 0x00)
320	return 9; // Platform
321	if (buffer[0x1E] != 0x55)
322	return 10; // key 1
323	if (buffer[0x1F] != 0xAA)
324	return 10; // key 2
325
326	// Initial/Default Entry
327	if (buffer[0x20] != 0x88)
328	return 11; // Bootable
329
330	cdemu->media = buffer[0x21];
331	if (buffer[0x21] == 0) {
332	// FIXME ElTorito Hardcoded. cdrom is hardcoded as device 0xE0.
333	// Win2000 cd boot needs to know it booted from cd
334	cdemu->emulated_drive = 0xE0;
335	}
336	else if (buffer[0x21] < 4)
337	cdemu->emulated_drive = 0x00;
338	else
339	cdemu->emulated_drive = 0x80;
340
341	cdemu->controller_index = device / 2;
342	cdemu->device_spec = device % 2;
343
344	boot_segment = ((uint16_t )&buffer[0x22]);
345	if (boot_segment == 0)
346	boot_segment = 0x07C0;
347
348	cdemu->load_segment = boot_segment;
349	cdemu->buffer_segment = 0x0000;
350
351	nbsectors = ((uint16_t *)buffer)[0x26 / 2];
352	cdemu->sector_count = nbsectors;
353
354	lba = ((uint32_t )&buffer[0x28]);
355	cdemu->ilba = lba;
356
357	BX_DEBUG_ELTORITO("Emulate drive %02x, type %02x, LBA %lu\n",
358	cdemu->emulated_drive, cdemu->media, cdemu->ilba);
359
360	/* Read the disk image's boot sector into memory. */
361	atapicmd.command = 0x28; // READ 10 command
362	atapicmd.lba = swap_32(lba);
363	atapicmd.nsect = swap_16(1 + (nbsectors - 1) / 4);
364
365	bios_dsk->drqp.nsect = 1 + (nbsectors - 1) / 4;
366	bios_dsk->drqp.sect_sz = 512;
367
368	bios_dsk->drqp.skip_a = 2048 - nbsectors * 512UL % 2048;
369
370	if (device > BX_MAX_ATA_DEVICES)
371	error = ahci_cmd_packet(device, 12, (char __far )&atapicmd, 0, nbsectors512L, ATA_DATA_IN, MK_FP(boot_segment,0));
372	else
373	error = ata_cmd_packet(device, 12, (char __far )&atapicmd, 0, nbsectors512L, ATA_DATA_IN, MK_FP(boot_segment,0));
374
375	bios_dsk->drqp.skip_a = 0;
376
377	if (error != 0)
378	return 12;
379
380	BX_DEBUG_ELTORITO("Emulate drive %02x, type %02x, LBA %lu\n",
381	cdemu->emulated_drive, cdemu->media, cdemu->ilba);
382	/* Set up emulated drive geometry based on the media type. */
383	switch (cdemu->media) {
384	case 0x01: /* 1.2M floppy */
385	cdemu->vdevice.spt = 15;
386	cdemu->vdevice.cylinders = 80;
387	cdemu->vdevice.heads = 2;
388	break;
389	case 0x02: /* 1.44M floppy */
390	cdemu->vdevice.spt = 18;
391	cdemu->vdevice.cylinders = 80;
392	cdemu->vdevice.heads = 2;
393	break;
394	case 0x03: /* 2.88M floppy */
395	cdemu->vdevice.spt = 36;
396	cdemu->vdevice.cylinders = 80;
397	cdemu->vdevice.heads = 2;
398	break;
399	case 0x04: /* Hard disk */
400	cdemu->vdevice.spt = read_byte(boot_segment,446+6)&0x3f;
401	cdemu->vdevice.cylinders = (read_byte(boot_segment,446+6)<<2) + read_byte(boot_segment,446+7) + 1;
402	cdemu->vdevice.heads = read_byte(boot_segment,446+5) + 1;
403	break;
404	}
405	BX_DEBUG_ELTORITO("VCHS=%u/%u/%u\n", cdemu->vdevice.cylinders,
406	cdemu->vdevice.heads, cdemu->vdevice.spt);
407
408	if (cdemu->media != 0) {
409	/* Increase BIOS installed number of drives (floppy or fixed). */
410	if (cdemu->emulated_drive == 0x00)
411	write_byte(0x40,0x10,read_byte(0x40,0x10)\|0x41);
412	else
413	write_byte(ebda_seg,(uint16_t)&EbdaData->bdisk.hdcount, read_byte(ebda_seg, (uint16_t)&EbdaData->bdisk.hdcount) + 1);
414	}
415
416	// everything is ok, so from now on, the emulation is active
417	if (cdemu->media != 0)
418	cdemu->active = 0x01;
419
420	// return the boot drive + no error
421	return (cdemu->emulated_drive*0x100)+0;
422	}
423
424	// ---------------------------------------------------------------------------
425	// End of El-Torito boot functions
426	// ---------------------------------------------------------------------------
427
428	// ---------------------------------------------------------------------------
429	// Start of int13 when emulating a device from the cd
430	// ---------------------------------------------------------------------------
431
432	void BIOSCALL int13_cdemu(disk_regs_t r)
433	{
434	// @TODO: a macro or a function for getting the EBDA segment
435	uint16_t ebda_seg=read_word(0x0040,0x000E);
436	uint8_t device, status;
437	uint16_t vheads, vspt, vcylinders;
438	uint16_t head, sector, cylinder, nbsectors;
439	uint32_t vlba, ilba, slba, elba;
440	uint16_t before, segment, offset;
441	cdb_atapi atapicmd;
442	cdemu_t __far *cdemu;
443	bio_dsk_t __far *bios_dsk;
444
445	cdemu = ebda_seg :> &EbdaData->cdemu;
446	bios_dsk = ebda_seg :> &EbdaData->bdisk;
447
448	BX_DEBUG_INT13_ET("%s: AX=%04x BX=%04x CX=%04x DX=%04x ES=%04x\n", __func__, AX, BX, CX, DX, ES);
449
450	/* at this point, we are emulating a floppy/harddisk */
451
452	// Recompute the device number
453	device = cdemu->controller_index * 2;
454	device += cdemu->device_spec;
455
456	SET_DISK_RET_STATUS(0x00);
457
458	/* basic checks : emulation should be active, dl should equal the emulated drive */
459	if (!cdemu->active \|\| (cdemu->emulated_drive != GET_DL())) {
460	BX_INFO("%s: function %02x, emulation not active for DL= %02x\n", __func__, GET_AH(), GET_DL());
461	goto int13_fail;
462	}
463
464	switch (GET_AH()) {
465
466	// all those functions return SUCCESS
467	case 0x00: /* disk controller reset */
468	case 0x09: /* initialize drive parameters */
469	case 0x0c: /* seek to specified cylinder */
470	case 0x0d: /* alternate disk reset */ // FIXME ElTorito Various. should really reset ?
471	case 0x10: /* check drive ready */ // FIXME ElTorito Various. should check if ready ?
472	case 0x11: /* recalibrate */
473	case 0x14: /* controller internal diagnostic */
474	case 0x16: /* detect disk change */
475	goto int13_success;
476	break;
477
478	// all those functions return disk write-protected
479	case 0x03: /* write disk sectors */
480	case 0x05: /* format disk track */
481	SET_AH(0x03);
482	goto int13_fail_noah;
483	break;
484
485	case 0x01: /* read disk status */
486	status=read_byte(0x0040, 0x0074);
487	SET_AH(status);
488	SET_DISK_RET_STATUS(0);
489
490	/* set CF if error status read */
491	if (status)
492	goto int13_fail_nostatus;
493	else
494	goto int13_success_noah;
495	break;
496
497	case 0x02: // read disk sectors
498	case 0x04: // verify disk sectors
499	vspt = cdemu->vdevice.spt;
500	vcylinders = cdemu->vdevice.cylinders;
501	vheads = cdemu->vdevice.heads;
502	ilba = cdemu->ilba;
503
504	sector = GET_CL() & 0x003f;
505	cylinder = (GET_CL() & 0x00c0) << 2 \| GET_CH();
506	head = GET_DH();
507	nbsectors = GET_AL();
508	segment = ES;
509	offset = BX;
510
511	BX_DEBUG_INT13_ET("%s: read to %04x:%04x @ VCHS %u/%u/%u (%u sectors)\n", __func__,
512	ES, BX, cylinder, head, sector, nbsectors);
513
514	// no sector to read ?
515	if(nbsectors==0)
516	goto int13_success;
517
518	// sanity checks sco openserver needs this!
519	if ((sector > vspt)
520	\|\| (cylinder >= vcylinders)
521	\|\| (head >= vheads)) {
522	goto int13_fail;
523	}
524
525	// After validating the input, verify does nothing
526	if (GET_AH() == 0x04)
527	goto int13_success;
528
529	segment = ES+(BX / 16);
530	offset = BX % 16;
531
532	// calculate the virtual lba inside the image
533	vlba=((((uint32_t)cylinder(uint32_t)vheads)+(uint32_t)head)(uint32_t)vspt)+((uint32_t)(sector-1));
534
535	// In advance so we don't lose the count
536	SET_AL(nbsectors);
537
538	// start lba on cd
539	slba = (uint32_t)vlba / 4;
540	before = (uint32_t)vlba % 4;
541
542	// end lba on cd
543	elba = (uint32_t)(vlba + nbsectors - 1) / 4;
544
545	_fmemset(&atapicmd, 0, sizeof(atapicmd));
546	atapicmd.command = 0x28; // READ 10 command
547	atapicmd.lba = swap_32(ilba + slba);
548	atapicmd.nsect = swap_16(elba - slba + 1);
549
550	bios_dsk->drqp.nsect = elba - slba + 1;
551	bios_dsk->drqp.sect_sz = 512;
552
553	bios_dsk->drqp.skip_b = before * 512;
554	bios_dsk->drqp.skip_a = 2048 - nbsectors * 512UL % 2048 - bios_dsk->drqp.skip_b;
555
556	if (device > BX_MAX_ATA_DEVICES)
557	status = ahci_cmd_packet(device, 12, (char __far )&atapicmd, before512, nbsectors*512L, ATA_DATA_IN, MK_FP(segment,offset));
558	else
559	status = ata_cmd_packet(device, 12, (char __far )&atapicmd, before512, nbsectors*512L, ATA_DATA_IN, MK_FP(segment,offset));
560
561	bios_dsk->drqp.skip_b = 0;
562	bios_dsk->drqp.skip_a = 0;
563
564	if (status != 0) {
565	BX_INFO("%s: function %02x, error %02x !\n", __func__, GET_AH(), status);
566	SET_AH(0x02);
567	SET_AL(0);
568	goto int13_fail_noah;
569	}
570
571	goto int13_success;
572	break;
573
574	case 0x08: /* read disk drive parameters */
575	vspt = cdemu->vdevice.spt;
576	vcylinders = cdemu->vdevice.cylinders - 1;
577	vheads = cdemu->vdevice.heads - 1;
578
579	SET_AL( 0x00 );
580	SET_BL( 0x00 );
581	SET_CH( vcylinders & 0xff );
582	SET_CL((( vcylinders >> 2) & 0xc0) \| ( vspt & 0x3f ));
583	SET_DH( vheads );
584	SET_DL( 0x02 ); // FIXME ElTorito Various. should send the real count of drives 1 or 2
585	// FIXME ElTorito Harddisk. should send the HD count
586
587	switch (cdemu->media) {
588	case 0x01: SET_BL( 0x02 ); break;
589	case 0x02: SET_BL( 0x04 ); break;
590	case 0x03: SET_BL( 0x06 ); break;
591	}
592
593	DI = (uint16_t)&diskette_param_table; // @todo: or really DPT2?
594	ES = 0xF000; // @todo: how to make this relocatable?
595	goto int13_success;
596	break;
597
598	case 0x15: /* read disk drive size */
599	// FIXME ElTorito Harddisk. What geometry to send ?
600	SET_AH(0x03);
601	goto int13_success_noah;
602	break;
603
604	// all those functions return unimplemented
605	case 0x0a: /* read disk sectors with ECC */
606	case 0x0b: /* write disk sectors with ECC */
607	case 0x18: /* set media type for format */
608	case 0x41: // IBM/MS installation check
609	// FIXME ElTorito Harddisk. Darwin would like to use EDD
610	case 0x42: // IBM/MS extended read
611	case 0x43: // IBM/MS extended write
612	case 0x44: // IBM/MS verify sectors
613	case 0x45: // IBM/MS lock/unlock drive
614	case 0x46: // IBM/MS eject media
615	case 0x47: // IBM/MS extended seek
616	case 0x48: // IBM/MS get drive parameters
617	case 0x49: // IBM/MS extended media change
618	case 0x4e: // ? - set hardware configuration
619	case 0x50: // ? - send packet command
620	default:
621	BX_INFO("%s: function AH=%02x unsupported, returns fail\n", __func__, GET_AH());
622	goto int13_fail;
623	break;
624	}
625
626	int13_fail:
627	SET_AH(0x01); // defaults to invalid function in AH or invalid parameter
628	int13_fail_noah:
629	SET_DISK_RET_STATUS(GET_AH());
630	int13_fail_nostatus:
631	SET_CF(); // error occurred
632	return;
633
634	int13_success:
635	SET_AH(0x00); // no error
636	int13_success_noah:
637	SET_DISK_RET_STATUS(0x00);
638	CLEAR_CF(); // no error
639	return;
640	}
641
642	// ---------------------------------------------------------------------------
643	// Start of int13 for cdrom
644	// ---------------------------------------------------------------------------
645
646	void BIOSCALL int13_cdrom(uint16_t EHBX, disk_regs_t r)
647	{
648	uint16_t ebda_seg = read_word(0x0040,0x000E);
649	uint8_t device, status, locks;
650	cdb_atapi atapicmd;
651	uint32_t lba;
652	uint16_t count, segment, offset, size;
653	bio_dsk_t __far *bios_dsk;
654	int13ext_t __far *i13x;
655	dpt_t __far *dpt;
656
657	bios_dsk = ebda_seg :> &EbdaData->bdisk;
658
659	BX_DEBUG_INT13_CD("%s: AX=%04x BX=%04x CX=%04x DX=%04x ES=%04x\n", __func__, AX, BX, CX, DX, ES);
660
661	SET_DISK_RET_STATUS(0x00);
662
663	/* basic check : device should be 0xE0+ */
664	if( (GET_ELDL() < 0xE0) \|\| (GET_ELDL() >= 0xE0 + BX_MAX_STORAGE_DEVICES) ) {
665	BX_DEBUG("%s: function %02x, ELDL out of range %02x\n", __func__, GET_AH(), GET_ELDL());
666	goto int13_fail;
667	}
668
669	// Get the ata channel
670	device = bios_dsk->cdidmap[GET_ELDL()-0xE0];
671
672	/* basic check : device has to be valid */
673	if (device >= BX_MAX_STORAGE_DEVICES) {
674	BX_DEBUG("%s: function %02x, unmapped device for ELDL=%02x\n", __func__, GET_AH(), GET_ELDL());
675	goto int13_fail;
676	}
677
678	switch (GET_AH()) {
679
680	// all those functions return SUCCESS
681	case 0x00: /* disk controller reset */
682	case 0x09: /* initialize drive parameters */
683	case 0x0c: /* seek to specified cylinder */
684	case 0x0d: /* alternate disk reset */
685	case 0x10: /* check drive ready */
686	case 0x11: /* recalibrate */
687	case 0x14: /* controller internal diagnostic */
688	case 0x16: /* detect disk change */
689	goto int13_success;
690	break;
691
692	// all those functions return disk write-protected
693	case 0x03: /* write disk sectors */
694	case 0x05: /* format disk track */
695	case 0x43: // IBM/MS extended write
696	SET_AH(0x03);
697	goto int13_fail_noah;
698	break;
699
700	case 0x01: /* read disk status */
701	status = read_byte(0x0040, 0x0074);
702	SET_AH(status);
703	SET_DISK_RET_STATUS(0);
704
705	/* set CF if error status read */
706	if (status)
707	goto int13_fail_nostatus;
708	else
709	goto int13_success_noah;
710	break;
711
712	case 0x15: /* read disk drive size */
713	SET_AH(0x02);
714	goto int13_fail_noah;
715	break;
716
717	case 0x41: // IBM/MS installation check
718	BX = 0xaa55; // install check
719	SET_AH(0x30); // EDD 2.1
720	CX = 0x0007; // ext disk access, removable and edd
721	goto int13_success_noah;
722	break;
723
724	case 0x42: // IBM/MS extended read
725	case 0x44: // IBM/MS verify sectors
726	case 0x47: // IBM/MS extended seek
727
728	/* Load the I13X struct pointer. */
729	i13x = MK_FP(DS, SI);
730
731	count = i13x->count;
732	segment = i13x->segment;
733	offset = i13x->offset;
734
735	// Can't use 64 bits lba
736	lba = i13x->lba2;
737	if (lba != 0L) {
738	BX_PANIC("%s: function %02x. Can't use 64bits lba\n", __func__, GET_AH());
739	goto int13_fail;
740	}
741
742	// Get 32 bits lba
743	lba = i13x->lba1;
744
745	// If verify or seek
746	if (( GET_AH() == 0x44 ) \|\| ( GET_AH() == 0x47 ))
747	goto int13_success;
748
749	BX_DEBUG_INT13_CD("%s: read %u sectors @ LBA %lu to %04X:%04X\n",
750	__func__, count, lba, segment, offset);
751
752	_fmemset(&atapicmd, 0, sizeof(atapicmd));
753	atapicmd.command = 0x28; // READ 10 command
754	atapicmd.lba = swap_32(lba);
755	atapicmd.nsect = swap_16(count);
756
757	bios_dsk->drqp.nsect = count;
758	bios_dsk->drqp.sect_sz = 2048;
759
760	if (device > BX_MAX_ATA_DEVICES)
761	status = ahci_cmd_packet(device, 12, (char __far )&atapicmd, 0, count2048L, ATA_DATA_IN, MK_FP(segment,offset));
762	else
763	status = ata_cmd_packet(device, 12, (char __far )&atapicmd, 0, count2048L, ATA_DATA_IN, MK_FP(segment,offset));
764
765	count = (uint16_t)(bios_dsk->drqp.trsfbytes >> 11);
766	i13x->count = count;
767
768	if (status != 0) {
769	BX_INFO("%s: function %02x, status %02x !\n", __func__, GET_AH(), status);
770	SET_AH(0x0c);
771	goto int13_fail_noah;
772	}
773
774	goto int13_success;
775	break;
776
777	case 0x45: // IBM/MS lock/unlock drive
778	if (GET_AL() > 2)
779	goto int13_fail;
780
781	locks = bios_dsk->devices[device].lock;
782
783	switch (GET_AL()) {
784	case 0 : // lock
785	if (locks == 0xff) {
786	SET_AH(0xb4);
787	SET_AL(1);
788	goto int13_fail_noah;
789	}
790	bios_dsk->devices[device].lock = ++locks;
791	SET_AL(1);
792	break;
793	case 1 : // unlock
794	if (locks == 0x00) {
795	SET_AH(0xb0);
796	SET_AL(0);
797	goto int13_fail_noah;
798	}
799	bios_dsk->devices[device].lock = --locks;
800	SET_AL(locks==0?0:1);
801	break;
802	case 2 : // status
803	SET_AL(locks==0?0:1);
804	break;
805	}
806	goto int13_success;
807	break;
808
809	case 0x46: // IBM/MS eject media
810	locks = bios_dsk->devices[device].lock;
811
812	if (locks != 0) {
813	SET_AH(0xb1); // media locked
814	goto int13_fail_noah;
815	}
816	// FIXME should handle 0x31 no media in device
817	// FIXME should handle 0xb5 valid request failed
818
819	#if 0 //@todo: implement!
820	// Call removable media eject
821	ASM_START
822	push bp
823	mov bp, sp
824
825	mov ah, #0x52
826	int #0x15
827	mov _int13_cdrom.status + 2[bp], ah
828	jnc int13_cdrom_rme_end
829	mov _int13_cdrom.status, #1
830	int13_cdrom_rme_end:
831	pop bp
832	ASM_END
833	#endif
834
835	if (status != 0) {
836	SET_AH(0xb1); // media locked
837	goto int13_fail_noah;
838	}
839
840	goto int13_success;
841	break;
842
843	//@todo: Part of this should be merged with analogous code in disk.c
844	case 0x48: // IBM/MS get drive parameters
845	dpt = DS :> (dpt_t *)SI;
846	size = dpt->size;
847
848	// Buffer is too small
849	if (size < 0x1a)
850	goto int13_fail;
851
852	// EDD 1.x
853	if (size >= 0x1a) {
854	uint16_t blksize;
855
856	blksize = bios_dsk->devices[device].blksize;
857
858	dpt->size = 0x1a;
859	dpt->infos = 0x74; /* Removable, media change, lockable, max values */
860	dpt->cylinders = 0xffffffff;
861	dpt->heads = 0xffffffff;
862	dpt->spt = 0xffffffff;
863	dpt->blksize = blksize;
864	dpt->sector_count1 = 0xffffffff; // FIXME should be Bit64
865	dpt->sector_count2 = 0xffffffff;
866	}
867
868	// EDD 2.x
869	if(size >= 0x1e) {
870	uint8_t channel, irq, mode, checksum, i;
871	uint16_t iobase1, iobase2, options;
872
873	dpt->size = 0x1e;
874	dpt->dpte_segment = ebda_seg;
875	dpt->dpte_offset = (uint16_t)&EbdaData->bdisk.dpte;
876
877	// Fill in dpte
878	channel = device / 2;
879	iobase1 = bios_dsk->channels[channel].iobase1;
880	iobase2 = bios_dsk->channels[channel].iobase2;
881	irq = bios_dsk->channels[channel].irq;
882	mode = bios_dsk->devices[device].mode;
883
884	// FIXME atapi device
885	options = (1<<4); // lba translation
886	options \|= (1<<5); // removable device
887	options \|= (1<<6); // atapi device
888	options \|= (mode==ATA_MODE_PIO32?1:0<<7);
889
890	bios_dsk->dpte.iobase1 = iobase1;
891	bios_dsk->dpte.iobase2 = iobase2;
892	bios_dsk->dpte.prefix = (0xe \| (device % 2))<<4;
893	bios_dsk->dpte.unused = 0xcb;
894	bios_dsk->dpte.irq = irq;
895	bios_dsk->dpte.blkcount = 1 ;
896	bios_dsk->dpte.dma = 0;
897	bios_dsk->dpte.pio = 0;
898	bios_dsk->dpte.options = options;
899	bios_dsk->dpte.reserved = 0;
900	bios_dsk->dpte.revision = 0x11;
901
902	checksum = 0;
903	for (i = 0; i < 15; ++i)
904	checksum += read_byte(ebda_seg, (uint16_t)&EbdaData->bdisk.dpte + i);
905	checksum = -checksum;
906	bios_dsk->dpte.checksum = checksum;
907	}
908
909	// EDD 3.x
910	if(size >= 0x42) {
911	uint8_t channel, iface, checksum, i;
912	uint16_t iobase1;
913
914	channel = device / 2;
915	iface = bios_dsk->channels[channel].iface;
916	iobase1 = bios_dsk->channels[channel].iobase1;
917
918	dpt->size = 0x42;
919	dpt->key = 0xbedd;
920	dpt->dpi_length = 0x24;
921	dpt->reserved1 = 0;
922	dpt->reserved2 = 0;
923
924	if (iface == ATA_IFACE_ISA) {
925	dpt->host_bus[0] = 'I';
926	dpt->host_bus[1] = 'S';
927	dpt->host_bus[2] = 'A';
928	dpt->host_bus[3] = ' ';
929	}
930	else {
931	// FIXME PCI
932	}
933	dpt->iface_type[0] = 'A';
934	dpt->iface_type[1] = 'T';
935	dpt->iface_type[2] = 'A';
936	dpt->iface_type[3] = ' ';
937	dpt->iface_type[4] = ' ';
938	dpt->iface_type[5] = ' ';
939	dpt->iface_type[6] = ' ';
940	dpt->iface_type[7] = ' ';
941
942	if (iface == ATA_IFACE_ISA) {
943	((uint16_t __far *)dpt->iface_path)[0] = iobase1;
944	((uint16_t __far *)dpt->iface_path)[1] = 0;
945	((uint32_t __far *)dpt->iface_path)[1] = 0;
946	}
947	else {
948	// FIXME PCI
949	}
950	((uint16_t __far *)dpt->device_path)[0] = device & 1;
951	((uint16_t __far *)dpt->device_path)[1] = 0;
952	((uint32_t __far *)dpt->device_path)[1] = 0;
953
954	checksum = 0;
955	for (i = 30; i < 64; ++i)
956	checksum += ((uint8_t __far *)dpt)[i];
957	checksum = -checksum;
958	dpt->checksum = checksum;
959	}
960
961	goto int13_success;
962	break;
963
964	case 0x49: // IBM/MS extended media change
965	// always send changed ??
966	SET_AH(06);
967	goto int13_fail_nostatus;
968	break;
969
970	case 0x4e: // // IBM/MS set hardware configuration
971	// DMA, prefetch, PIO maximum not supported
972	switch (GET_AL()) {
973	case 0x01:
974	case 0x03:
975	case 0x04:
976	case 0x06:
977	goto int13_success;
978	break;
979	default :
980	goto int13_fail;
981	}
982	break;
983
984	// all those functions return unimplemented
985	case 0x02: /* read sectors */
986	case 0x04: /* verify sectors */
987	case 0x08: /* read disk drive parameters */
988	case 0x0a: /* read disk sectors with ECC */
989	case 0x0b: /* write disk sectors with ECC */
990	case 0x18: /* set media type for format */
991	case 0x50: // ? - send packet command
992	default:
993	BX_INFO("%s: unsupported AH=%02x\n", __func__, GET_AH());
994	goto int13_fail;
995	break;
996	}
997
998	int13_fail:
999	SET_AH(0x01); // defaults to invalid function in AH or invalid parameter
1000	int13_fail_noah:
1001	SET_DISK_RET_STATUS(GET_AH());
1002	int13_fail_nostatus:
1003	SET_CF(); // error occurred
1004	return;
1005
1006	int13_success:
1007	SET_AH(0x00); // no error
1008	int13_success_noah:
1009	SET_DISK_RET_STATUS(0x00);
1010	CLEAR_CF(); // no error
1011	return;
1012	}
1013
1014	// ---------------------------------------------------------------------------
1015	// End of int13 for cdrom
1016	// ---------------------------------------------------------------------------

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/PC/BIOS/eltorito.c@ 42057

Download in other formats: