1/*
2 * Copyright 2008-2010, Fran��ois Revol, revol@free.fr. All rights reserved.
3 * Copyright 2003-2006, Axel D��rfler, axeld@pinc-software.de.
4 * Distributed under the terms of the MIT License.
5 */
6
7
8#include <KernelExport.h>
9#include <boot/platform.h>
10#include <boot/partitions.h>
11#include <boot/stdio.h>
12#include <boot/stage2.h>
13
14#include <string.h>
15
16#include "Handle.h"
17#include "toscalls.h"
18
19//#define TRACE_DEVICES
20#ifdef TRACE_DEVICES
21#	define TRACE(x) dprintf x
22#else
23#	define TRACE(x) ;
24#endif
25
26
27// exported from shell.S
28extern uint8 gBootedFromImage;
29extern uint8 gBootDriveAPI; // ATARI_BOOT_DRIVE_API_*
30extern uint8 gBootDriveID;
31extern uint32 gBootPartitionOffset;
32
33#define SCRATCH_SIZE (2*4096)
34static uint8 gScratchBuffer[SCRATCH_SIZE];
35
36static const uint16 kParametersSizeVersion1 = sizeof(struct tos_bpb);
37static const uint16 kParametersSizeVersion2 = 0x1e;
38static const uint16 kParametersSizeVersion3 = 0x42;
39
40static const uint16 kDevicePathSignature = 0xbedd;
41
42//XXX clean this up!
43struct drive_parameters {
44	struct tos_bpb bpb;
45	uint16		parameters_size;
46	uint16		flags;
47	uint32		cylinders;
48	uint32		heads;
49	uint32		sectors_per_track;
50	uint64		sectors;
51	uint16		bytes_per_sector;
52	/* edd 2.0 */
53	//real_addr	device_table;
54	/* edd 3.0 */
55	uint16		device_path_signature;
56	uint8		device_path_size;
57	uint8		reserved1[3];
58	char		host_bus[4];
59	char		interface_type[8];
60	union {
61		struct {
62			uint16	base_address;
63		} legacy;
64		struct {
65			uint8	bus;
66			uint8	slot;
67			uint8	function;
68		} pci;
69		uint8		reserved[8];
70	} interface;
71	union {
72		struct {
73			uint8	slave;
74		} ata;
75		struct {
76			uint8	slave;
77			uint8	logical_unit;
78		} atapi;
79		struct {
80			uint8	logical_unit;
81		} scsi;
82		struct {
83			uint8	tbd;
84		} usb;
85		struct {
86			uint64	guid;
87		} firewire;
88		struct {
89			uint64	wwd;
90		} fibre;
91	} device;
92	uint8		reserved2;
93	uint8		checksum;
94} _PACKED;
95
96struct device_table {
97	uint16	base_address;
98	uint16	control_port_address;
99	uint8	_reserved1 : 4;
100	uint8	is_slave : 1;
101	uint8	_reserved2 : 1;
102	uint8	lba_enabled : 1;
103} _PACKED;
104
105struct specification_packet {
106	uint8	size;
107	uint8	media_type;
108	uint8	drive_number;
109	uint8	controller_index;
110	uint32	start_emulation;
111	uint16	device_specification;
112	uint8	_more_[9];
113} _PACKED;
114
115class BlockHandle : public Handle {
116	public:
117		BlockHandle(int handle);
118		virtual ~BlockHandle();
119
120		virtual ssize_t ReadAt(void *cookie, off_t pos, void *buffer, size_t bufferSize);
121		virtual ssize_t WriteAt(void *cookie, off_t pos, const void *buffer, size_t bufferSize);
122
123		virtual off_t Size() const { return fSize; };
124
125		uint32 BlockSize() const { return fBlockSize; }
126
127		bool HasParameters() const { return fHasParameters; }
128		const drive_parameters &Parameters() const { return fParameters; }
129
130		virtual status_t FillIdentifier();
131
132		disk_identifier &Identifier() { return fIdentifier; }
133		uint8 DriveID() const { return fHandle; }
134		status_t InitCheck() const { return fSize > 0 ? B_OK : B_ERROR; };
135
136
137
138		virtual ssize_t ReadBlocks(void *buffer, off_t first, int32 count);
139
140	protected:
141		uint64	fSize;
142		uint32	fBlockSize;
143		bool	fHasParameters;
144		drive_parameters fParameters;
145		disk_identifier fIdentifier;
146};
147
148
149class FloppyDrive : public BlockHandle {
150	public:
151		FloppyDrive(int handle);
152		virtual ~FloppyDrive();
153
154		status_t FillIdentifier();
155
156		virtual ssize_t ReadBlocks(void *buffer, off_t first, int32 count);
157
158	protected:
159		status_t	ReadBPB(struct tos_bpb *bpb);
160};
161
162
163class BIOSDrive : public BlockHandle {
164	public:
165		BIOSDrive(int handle);
166		virtual ~BIOSDrive();
167
168		status_t FillIdentifier();
169
170		virtual ssize_t ReadBlocks(void *buffer, off_t first, int32 count);
171
172	protected:
173		status_t	ReadBPB(struct tos_bpb *bpb);
174};
175
176
177class XHDIDrive : public BlockHandle {
178	public:
179		XHDIDrive(int handle, uint16 major, uint16 minor);
180		virtual ~XHDIDrive();
181
182		status_t FillIdentifier();
183
184		virtual ssize_t ReadBlocks(void *buffer, off_t first, int32 count);
185
186	protected:
187		uint16 fMajor;
188		uint16 fMinor;
189};
190
191
192static bool sBlockDevicesAdded = false;
193
194
195static status_t
196read_bpb(uint8 drive, struct tos_bpb *bpb)
197{
198	struct tos_bpb *p;
199	p = Getbpb(drive);
200	memcpy(bpb, p, sizeof(struct tos_bpb));
201	/* Getbpb is buggy so we must force a media change */
202	//XXX: docs seems to assume we should loop until it works
203	Mediach(drive);
204	return B_OK;
205}
206
207static status_t
208get_drive_parameters(uint8 drive, drive_parameters *parameters)
209{
210	status_t err;
211	err = read_bpb(drive, &parameters->bpb);
212	TRACE(("get_drive_parameters: get_bpb: 0x%08lx\n", err));
213	TRACE(("get_drive_parameters: bpb: %04x %04x %04x %04x %04x %04x %04x %04x %04x \n",
214			parameters->bpb.recsiz, parameters->bpb.clsiz,
215			parameters->bpb.clsizb, parameters->bpb.rdlen,
216			parameters->bpb.fsiz, parameters->bpb.fatrec,
217			parameters->bpb.datrec, parameters->bpb.numcl,
218			parameters->bpb.bflags));
219
220#if 0
221	// fill drive_parameters structure with useful values
222	parameters->parameters_size = kParametersSizeVersion1;
223	parameters->flags = 0;
224	parameters->cylinders = (((regs.ecx & 0xc0) << 2) | ((regs.ecx >> 8) & 0xff)) + 1;
225	parameters->heads = ((regs.edx >> 8) & 0xff) + 1;
226		// heads and cylinders start counting from 0
227	parameters->sectors_per_track = regs.ecx & 0x3f;
228	parameters->sectors = parameters->cylinders * parameters->heads
229		* parameters->sectors_per_track;
230	parameters->bytes_per_sector = 512;
231#endif
232	return B_OK;
233}
234
235
236#if 0
237/** parse EDD 3.0 drive path information */
238
239static status_t
240fill_disk_identifier_v3(disk_identifier &disk, const drive_parameters &parameters)
241{
242	if (parameters.parameters_size < kParametersSizeVersion3
243		|| parameters.device_path_signature != kDevicePathSignature)
244		return B_BAD_TYPE;
245
246	// parse host bus
247
248	if (!strncmp(parameters.host_bus, "PCI", 3)) {
249		disk.bus_type = PCI_BUS;
250
251		disk.bus.pci.bus = parameters.interface.pci.bus;
252		disk.bus.pci.slot = parameters.interface.pci.slot;
253		disk.bus.pci.function = parameters.interface.pci.function;
254	} else if (!strncmp(parameters.host_bus, "ISA", 3)) {
255		disk.bus_type = LEGACY_BUS;
256
257		disk.bus.legacy.base_address = parameters.interface.legacy.base_address;
258		dprintf("legacy base address %x\n", disk.bus.legacy.base_address);
259	} else {
260		dprintf("unknown host bus \"%s\"\n", parameters.host_bus);
261		return B_BAD_DATA;
262	}
263
264	// parse interface
265
266	if (!strncmp(parameters.interface_type, "ATA", 3)) {
267		disk.device_type = ATA_DEVICE;
268		disk.device.ata.master = !parameters.device.ata.slave;
269		dprintf("ATA device, %s\n", disk.device.ata.master ? "master" : "slave");
270	} else if (!strncmp(parameters.interface_type, "ATAPI", 3)) {
271		disk.device_type = ATAPI_DEVICE;
272		disk.device.atapi.master = !parameters.device.ata.slave;
273		disk.device.atapi.logical_unit = parameters.device.atapi.logical_unit;
274	} else if (!strncmp(parameters.interface_type, "SCSI", 3)) {
275		disk.device_type = SCSI_DEVICE;
276		disk.device.scsi.logical_unit = parameters.device.scsi.logical_unit;
277	} else if (!strncmp(parameters.interface_type, "USB", 3)) {
278		disk.device_type = USB_DEVICE;
279		disk.device.usb.tbd = parameters.device.usb.tbd;
280	} else if (!strncmp(parameters.interface_type, "1394", 3)) {
281		disk.device_type = FIREWIRE_DEVICE;
282		disk.device.firewire.guid = parameters.device.firewire.guid;
283	} else if (!strncmp(parameters.interface_type, "FIBRE", 3)) {
284		disk.device_type = FIBRE_DEVICE;
285		disk.device.fibre.wwd = parameters.device.fibre.wwd;
286	} else {
287		dprintf("unknown interface type \"%s\"\n", parameters.interface_type);
288		return B_BAD_DATA;
289	}
290
291	return B_OK;
292}
293
294
295/** EDD 2.0 drive table information */
296
297static status_t
298fill_disk_identifier_v2(disk_identifier &disk, const drive_parameters &parameters)
299{
300	if (parameters.device_table.segment == 0xffff
301		&& parameters.device_table.offset == 0xffff)
302		return B_BAD_TYPE;
303
304	device_table *table = (device_table *)LINEAR_ADDRESS(parameters.device_table.segment,
305		parameters.device_table.offset);
306
307	disk.bus_type = LEGACY_BUS;
308	disk.bus.legacy.base_address = table->base_address;
309
310	disk.device_type = ATA_DEVICE;
311	disk.device.ata.master = !table->is_slave;
312
313	return B_OK;
314}
315#endif
316
317static off_t
318get_next_check_sum_offset(int32 index, off_t maxSize)
319{
320	// The boot block often contains the disk superblock, and should be
321	// unique enough for most cases
322	if (index < 2)
323		return index * 512;
324
325	// Try some data in the first part of the drive
326	if (index < 4)
327		return (maxSize >> 10) + index * 2048;
328
329	// Some random value might do
330	return ((system_time() + index) % (maxSize >> 9)) * 512;
331}
332
333
334/**	Computes a check sum for the specified block.
335 *	The check sum is the sum of all data in that block interpreted as an
336 *	array of uint32 values.
337 *	Note, this must use the same method as the one used in kernel/fs/vfs_boot.cpp.
338 */
339
340static uint32
341compute_check_sum(BlockHandle *drive, off_t offset)
342{
343	char buffer[512];
344	ssize_t bytesRead = drive->ReadAt(NULL, offset, buffer, sizeof(buffer));
345	if (bytesRead < B_OK)
346		return 0;
347
348	if (bytesRead < (ssize_t)sizeof(buffer))
349		memset(buffer + bytesRead, 0, sizeof(buffer) - bytesRead);
350
351	uint32 *array = (uint32 *)buffer;
352	uint32 sum = 0;
353
354	for (uint32 i = 0; i < (bytesRead + sizeof(uint32) - 1) / sizeof(uint32); i++) {
355		sum += array[i];
356	}
357
358	return sum;
359}
360
361
362static void
363find_unique_check_sums(NodeList *devices)
364{
365	NodeIterator iterator = devices->GetIterator();
366	Node *device;
367	int32 index = 0;
368	off_t minSize = 0;
369	const int32 kMaxTries = 200;
370
371	while (index < kMaxTries) {
372		bool clash = false;
373
374		iterator.Rewind();
375
376		while ((device = iterator.Next()) != NULL) {
377			BlockHandle *drive = (BlockHandle *)device;
378#if 0
379			// there is no RTTI in the boot loader...
380			BlockHandle *drive = dynamic_cast<BlockHandle *>(device);
381			if (drive == NULL)
382				continue;
383#endif
384
385			// TODO: currently, we assume that the BIOS provided us with unique
386			//	disk identifiers... hopefully this is a good idea
387			if (drive->Identifier().device_type != UNKNOWN_DEVICE)
388				continue;
389
390			if (minSize == 0 || drive->Size() < minSize)
391				minSize = drive->Size();
392
393			// check for clashes
394
395			NodeIterator compareIterator = devices->GetIterator();
396			while ((device = compareIterator.Next()) != NULL) {
397				BlockHandle *compareDrive = (BlockHandle *)device;
398
399				if (compareDrive == drive
400					|| compareDrive->Identifier().device_type != UNKNOWN_DEVICE)
401					continue;
402
403				if (!memcmp(&drive->Identifier(), &compareDrive->Identifier(),
404						sizeof(disk_identifier))) {
405					clash = true;
406					break;
407				}
408			}
409
410			if (clash)
411				break;
412		}
413
414		if (!clash) {
415			// our work here is done.
416			return;
417		}
418
419		// add a new block to the check sums
420
421		off_t offset = get_next_check_sum_offset(index, minSize);
422		int32 i = index % NUM_DISK_CHECK_SUMS;
423		iterator.Rewind();
424
425		while ((device = iterator.Next()) != NULL) {
426			BlockHandle *drive = (BlockHandle *)device;
427
428			disk_identifier& disk = drive->Identifier();
429			disk.device.unknown.check_sums[i].offset = offset;
430			disk.device.unknown.check_sums[i].sum = compute_check_sum(drive, offset);
431
432			TRACE(("disk %x, offset %Ld, sum %lu\n", drive->DriveID(), offset,
433				disk.device.unknown.check_sums[i].sum));
434		}
435
436		index++;
437	}
438
439	// If we get here, we couldn't find a way to differentiate all disks from each other.
440	// It's very likely that one disk is an exact copy of the other, so there is nothing
441	// we could do, anyway.
442
443	dprintf("Could not make BIOS drives unique! Might boot from the wrong disk...\n");
444}
445
446
447static status_t
448add_block_devices(NodeList *devicesList, bool identifierMissing)
449{
450	int32 map;
451	uint8 driveID;
452	uint8 driveCount = 0;
453
454	if (sBlockDevicesAdded)
455		return B_OK;
456
457	if (init_xhdi() >= B_OK) {
458		uint16 major;
459		uint16 minor;
460		uint32 blocksize;
461		uint32 blocksize2;
462		uint32 blocks;
463		uint32 devflags;
464		uint32 lastacc;
465		char product[33];
466		int32 err;
467
468		map = XHDrvMap();
469		dprintf("XDrvMap() 0x%08lx\n", map);
470		// sadly XDrvmap() has the same issues as XBIOS, it only lists known partitions.
471		// so we just iterate on each major and try to see if there is something.
472		for (driveID = 0; driveID < 32; driveID++) {
473			uint32 startsect;
474			err = XHInqDev(driveID, &major, &minor, &startsect, NULL);
475			if (err < 0) {
476				;//dprintf("XHInqDev(%d) error %d\n", driveID, err);
477			} else {
478				dprintf("XHInqDev(%d): (%d,%d):%d\n", driveID, major, minor, startsect);
479			}
480		}
481
482		product[32] = '\0';
483		for (major = 0; major < 256; major++) {
484			if (major == 64) // we don't want floppies
485				continue;
486			if (major > 23 && major != 64) // extensions and non-standard stuff... skip for speed.
487				break;
488
489			for (minor = 0; minor < 255; minor++) {
490				if (minor && (major < 8 || major >15))
491					break; // minor only used for the SCSI LUN AFAIK.
492				if (minor > 15) // are more used at all ?
493					break;
494
495				product[0] = '\0';
496				blocksize = 0;
497				blocksize2 = 0;
498#if 0
499				err = XHLastAccess(major, minor, &lastacc);
500				if (err < 0) {
501					;//dprintf("XHLastAccess(%d,%d) error %d\n", major, minor, err);
502				} else
503					dprintf("XHLastAccess(%d,%d): %ld\n", major, minor, lastacc);
504//continue;
505#endif
506				// we can pass NULL pointers but just to play safe we don't.
507				err = XHInqTarget(major, minor, &blocksize, &devflags, product);
508				if (err < 0) {
509					dprintf("XHInqTarget(%d,%d) error %d\n", major, minor, err);
510					continue;
511				}
512				err = XHGetCapacity(major, minor, &blocks, &blocksize2);
513				if (err < 0) {
514					//dprintf("XHGetCapacity(%d,%d) error %d\n", major, minor, err);
515					continue;
516				}
517
518				if (blocksize == 0) {
519					dprintf("XHDI: blocksize for (%d,%d) is 0!\n", major, minor);
520				}
521				//dprintf("XHDI: (%d,%d) blocksize1 %ld blocksize2 %ld\n", major, minor, blocksize, blocksize2);
522
523				dprintf("XHDI(%d,%d): blksize %d, blocks %d, flags 0x%08lx, '%s'\n", major, minor, blocksize, blocks, devflags, product);
524				driveID = (uint8)major;
525
526				//if (driveID == gBootDriveID)
527				//	continue;
528//continue;
529
530				BlockHandle *drive = new(nothrow) XHDIDrive(driveID, major, minor);
531				if (drive->InitCheck() != B_OK) {
532					dprintf("could not add drive (%d,%d)\n", major, minor);
533					delete drive;
534					continue;
535				}
536
537				devicesList->Add(drive);
538				driveCount++;
539
540				if (drive->FillIdentifier() != B_OK)
541					identifierMissing = true;
542			}
543		}
544	}
545	if (!driveCount) { // try to fallback to BIOS XXX: use MetaDOS
546		map = Drvmap();
547		dprintf("Drvmap(): 0x%08lx\n", map);
548		for (driveID = 0; driveID < 32; driveID++) {
549			bool present = map & 0x1;
550			map >>= 1;
551			if (!present)
552				continue;
553
554			if (driveID == gBootDriveID)
555				continue;
556
557			BlockHandle *drive = new(nothrow) BlockHandle(driveID);
558			if (drive->InitCheck() != B_OK) {
559				dprintf("could not add drive %u\n", driveID);
560				delete drive;
561				continue;
562			}
563
564			devicesList->Add(drive);
565			driveCount++;
566
567			if (drive->FillIdentifier() != B_OK)
568				identifierMissing = true;
569		}
570	}
571	dprintf("number of drives: %d\n", driveCount);
572
573	if (identifierMissing) {
574		// we cannot distinguish between all drives by identifier, we need
575		// compute checksums for them
576		find_unique_check_sums(devicesList);
577	}
578
579	sBlockDevicesAdded = true;
580	return B_OK;
581}
582
583
584//	#pragma mark -
585
586
587BlockHandle::BlockHandle(int handle)
588	: Handle(handle)
589	, fSize(0LL)
590	, fBlockSize(0)
591	, fHasParameters(false)
592
593{
594	TRACE(("BlockHandle::%s(): drive ID %u\n", __FUNCTION__, fHandle));
595}
596
597
598BlockHandle::~BlockHandle()
599{
600}
601
602
603ssize_t
604BlockHandle::ReadAt(void *cookie, off_t pos, void *buffer, size_t bufferSize)
605{
606	ssize_t ret;
607	uint32 offset = pos % fBlockSize;
608	pos /= fBlockSize;
609	TRACE(("BlockHandle::%s: (%d) %Ld, %d\n", __FUNCTION__, fHandle, pos, bufferSize));
610
611	uint32 blocksLeft = (bufferSize + offset + fBlockSize - 1) / fBlockSize;
612	int32 totalBytesRead = 0;
613
614	//TRACE(("BIOS reads %lu bytes from %Ld (offset = %lu)\n",
615	//	blocksLeft * fBlockSize, pos * fBlockSize, offset));
616
617	// read partial block
618	if (offset) {
619		ret = ReadBlocks(gScratchBuffer, pos, 1);
620		if (ret < 0)
621			return ret;
622		totalBytesRead += fBlockSize - offset;
623		memcpy(buffer, gScratchBuffer + offset, totalBytesRead);
624
625	}
626
627	uint32 scratchSize = SCRATCH_SIZE / fBlockSize;
628
629	while (blocksLeft > 0) {
630		uint32 blocksRead = blocksLeft;
631		if (blocksRead > scratchSize)
632			blocksRead = scratchSize;
633
634		ret = ReadBlocks(gScratchBuffer, pos, blocksRead);
635		if (ret < 0)
636			return ret;
637
638		uint32 bytesRead = fBlockSize * blocksRead - offset;
639		// copy no more than bufferSize bytes
640		if (bytesRead > bufferSize)
641			bytesRead = bufferSize;
642
643		memcpy(buffer, (void *)(gScratchBuffer + offset), bytesRead);
644		pos += blocksRead;
645		offset = 0;
646		blocksLeft -= blocksRead;
647		bufferSize -= bytesRead;
648		buffer = (void *)((addr_t)buffer + bytesRead);
649		totalBytesRead += bytesRead;
650	}
651
652	//TRACE(("BlockHandle::%s: %d bytes read\n", __FUNCTION__, totalBytesRead));
653	return totalBytesRead;
654}
655
656
657ssize_t
658BlockHandle::WriteAt(void *cookie, off_t pos, const void *buffer, size_t bufferSize)
659{
660	// we don't have to know how to write
661	return B_NOT_ALLOWED;
662}
663
664
665ssize_t
666BlockHandle::ReadBlocks(void *buffer, off_t first, int32 count)
667{
668	return B_NOT_ALLOWED;
669}
670
671
672status_t
673BlockHandle::FillIdentifier()
674{
675	return B_NOT_ALLOWED;
676}
677
678//	#pragma mark -
679
680/*
681 * BIOS based disk access.
682 * Only for fallback from missing XHDI.
683 * XXX: This is broken!
684 * XXX: check for physical drives in PUN_INFO
685 * XXX: at least try to use MetaDOS calls instead.
686 */
687
688
689FloppyDrive::FloppyDrive(int handle)
690	: BlockHandle(handle)
691{
692	TRACE(("FloppyDrive::%s(%d)\n", __FUNCTION__, fHandle));
693
694	/* first check if the drive exists */
695	/* note floppy B can be reported present anyway... */
696	uint32 map = Drvmap();
697	if (!(map & (1 << fHandle))) {
698		fSize = 0LL;
699		return;
700	}
701	//XXX: check size
702
703	if (get_drive_parameters(fHandle, &fParameters) != B_OK) {
704		dprintf("getting drive parameters for: %u failed!\n", fHandle);
705		return;
706	}
707	// XXX: probe! this is a std 1.44kB floppy
708	fBlockSize = 512;
709	fParameters.sectors = 1440 * 1024 / 512;
710	fParameters.sectors_per_track = 18;
711	fParameters.heads = 2;
712	fSize = fParameters.sectors * fBlockSize;
713	fHasParameters = false;
714/*
715	parameters->sectors_per_track = 9;
716	parameters->cylinders = (1440/2) / (9*2);
717	parameters->heads = 2;
718	parameters->sectors = parameters->cylinders * parameters->heads
719	* parameters->sectors_per_track;
720	*/
721#if 0
722	if (get_ext_drive_parameters(driveID, &fParameters) != B_OK) {
723		// old style CHS support
724
725		if (get_drive_parameters(driveID, &fParameters) != B_OK) {
726			dprintf("getting drive parameters for: %u failed!\n", fDriveID);
727			return;
728		}
729
730		TRACE(("  cylinders: %lu, heads: %lu, sectors: %lu, bytes_per_sector: %u\n",
731			fParameters.cylinders, fParameters.heads, fParameters.sectors_per_track,
732			fParameters.bytes_per_sector));
733		TRACE(("  total sectors: %Ld\n", fParameters.sectors));
734
735		fBlockSize = 512;
736		fSize = fParameters.sectors * fBlockSize;
737		fLBA = false;
738		fHasParameters = false;
739	} else {
740		TRACE(("size: %x\n", fParameters.parameters_size));
741		TRACE(("drive_path_signature: %x\n", fParameters.device_path_signature));
742		TRACE(("host bus: \"%s\", interface: \"%s\"\n", fParameters.host_bus,
743			fParameters.interface_type));
744		TRACE(("cylinders: %lu, heads: %lu, sectors: %lu, bytes_per_sector: %u\n",
745			fParameters.cylinders, fParameters.heads, fParameters.sectors_per_track,
746			fParameters.bytes_per_sector));
747		TRACE(("total sectors: %Ld\n", fParameters.sectors));
748
749		fBlockSize = fParameters.bytes_per_sector;
750		fSize = fParameters.sectors * fBlockSize;
751		fLBA = true;
752		fHasParameters = true;
753	}
754#endif
755}
756
757
758FloppyDrive::~FloppyDrive()
759{
760}
761
762
763status_t
764FloppyDrive::FillIdentifier()
765{
766	TRACE(("FloppyDrive::%s: (%d)\n", __FUNCTION__, fHandle));
767#if 0
768	if (HasParameters()) {
769		// try all drive_parameters versions, beginning from the most informative
770
771#if 0
772		if (fill_disk_identifier_v3(fIdentifier, fParameters) == B_OK)
773			return B_OK;
774
775		if (fill_disk_identifier_v2(fIdentifier, fParameters) == B_OK)
776			return B_OK;
777#else
778		// TODO: the above version is the correct one - it's currently
779		//		disabled, as the kernel boot code only supports the
780		//		UNKNOWN_BUS/UNKNOWN_DEVICE way to find the correct boot
781		//		device.
782		if (fill_disk_identifier_v3(fIdentifier, fParameters) != B_OK)
783			fill_disk_identifier_v2(fIdentifier, fParameters);
784
785#endif
786
787		// no interesting information, we have to fall back to the default
788		// unknown interface/device type identifier
789	}
790
791	fIdentifier.bus_type = UNKNOWN_BUS;
792	fIdentifier.device_type = UNKNOWN_DEVICE;
793	fIdentifier.device.unknown.size = Size();
794
795	for (int32 i = 0; i < NUM_DISK_CHECK_SUMS; i++) {
796		fIdentifier.device.unknown.check_sums[i].offset = -1;
797		fIdentifier.device.unknown.check_sums[i].sum = 0;
798	}
799#endif
800
801	return B_ERROR;
802}
803
804
805static void
806hexdump(uint8 *buf, uint32 offset)
807{
808// hexdump
809
810	for (int i = 0; i < 512; i++) {
811		if ((i % 16) == 0)
812			TRACE(("%08lx ", offset+i));
813		if ((i % 16) == 8)
814		TRACE((" "));
815		TRACE((" %02x", buf[i]));
816
817		if ((i % 16) == 15)
818			TRACE(("\n"));
819	}
820}
821
822
823ssize_t
824FloppyDrive::ReadBlocks(void *buffer, off_t first, int32 count)
825{
826	int sectorsPerBlocks = (fBlockSize / 512);
827	int sectorsPerTrack = fParameters.sectors_per_track;
828	int heads = fParameters.heads;
829	int32 ret;
830	//TRACE(("FloppyDrive::%s(%Ld,%ld) (%d)\n", __FUNCTION__, first, count, fHandle));
831	// force single sector reads to avoid crossing track boundaries
832	for (int i = 0; i < count; i++) {
833		uint8 *buf = (uint8 *)buffer;
834		buf += i * fBlockSize;
835
836		int16 track, side, sect;
837		sect = (first + i) * sectorsPerBlocks;
838		track = sect / (sectorsPerTrack * heads);
839		side = (sect / sectorsPerTrack) % heads;
840		sect %= sectorsPerTrack;
841		sect++; // 1-based
842
843
844		/*
845		  TRACE(("FloppyDrive::%s: THS: %d %d %d\n",
846		  __FUNCTION__, track, side, sect));
847		*/
848		ret = Floprd(buf, 0L, fHandle, sect, track, side, 1);
849		if (ret < 0)
850			return toserror(ret);
851		//if (first >= 1440)
852		//hexdump(buf, (uint32)(first+i)*512);
853	}
854
855	return count;
856}
857
858
859//	#pragma mark -
860
861/*
862 * BIOS based disk access.
863 * Only for fallback from missing XHDI.
864 * XXX: This is broken!
865 * XXX: check for physical drives in PUN_INFO
866 * XXX: at least try to use MetaDOS calls instead.
867 */
868
869
870BIOSDrive::BIOSDrive(int handle)
871	: BlockHandle(handle)
872{
873	TRACE(("BIOSDrive::%s(%d)\n", __FUNCTION__, fHandle));
874
875	/* first check if the drive exists */
876	/* note floppy B can be reported present anyway... */
877	uint32 map = Drvmap();
878	if (!(map & (1 << fHandle))) {
879		fSize = 0LL;
880		return;
881	}
882	//XXX: check size
883
884	if (get_drive_parameters(fHandle, &fParameters) != B_OK) {
885		dprintf("getting drive parameters for: %u failed!\n", fHandle);
886		return;
887	}
888	fBlockSize = 512;
889	fSize = fParameters.sectors * fBlockSize;
890	fHasParameters = false;
891
892#if 0
893	if (get_ext_drive_parameters(driveID, &fParameters) != B_OK) {
894		// old style CHS support
895
896		if (get_drive_parameters(driveID, &fParameters) != B_OK) {
897			dprintf("getting drive parameters for: %u failed!\n", fDriveID);
898			return;
899		}
900
901		TRACE(("  cylinders: %lu, heads: %lu, sectors: %lu, bytes_per_sector: %u\n",
902			fParameters.cylinders, fParameters.heads, fParameters.sectors_per_track,
903			fParameters.bytes_per_sector));
904		TRACE(("  total sectors: %Ld\n", fParameters.sectors));
905
906		fBlockSize = 512;
907		fSize = fParameters.sectors * fBlockSize;
908		fLBA = false;
909		fHasParameters = false;
910	} else {
911		TRACE(("size: %x\n", fParameters.parameters_size));
912		TRACE(("drive_path_signature: %x\n", fParameters.device_path_signature));
913		TRACE(("host bus: \"%s\", interface: \"%s\"\n", fParameters.host_bus,
914			fParameters.interface_type));
915		TRACE(("cylinders: %lu, heads: %lu, sectors: %lu, bytes_per_sector: %u\n",
916			fParameters.cylinders, fParameters.heads, fParameters.sectors_per_track,
917			fParameters.bytes_per_sector));
918		TRACE(("total sectors: %Ld\n", fParameters.sectors));
919
920		fBlockSize = fParameters.bytes_per_sector;
921		fSize = fParameters.sectors * fBlockSize;
922		fLBA = true;
923		fHasParameters = true;
924	}
925#endif
926}
927
928
929BIOSDrive::~BIOSDrive()
930{
931}
932
933
934status_t
935BIOSDrive::FillIdentifier()
936{
937	TRACE(("BIOSDrive::%s: (%d)\n", __FUNCTION__, fHandle));
938#if 0
939	if (HasParameters()) {
940		// try all drive_parameters versions, beginning from the most informative
941
942#if 0
943		if (fill_disk_identifier_v3(fIdentifier, fParameters) == B_OK)
944			return B_OK;
945
946		if (fill_disk_identifier_v2(fIdentifier, fParameters) == B_OK)
947			return B_OK;
948#else
949		// TODO: the above version is the correct one - it's currently
950		//		disabled, as the kernel boot code only supports the
951		//		UNKNOWN_BUS/UNKNOWN_DEVICE way to find the correct boot
952		//		device.
953		if (fill_disk_identifier_v3(fIdentifier, fParameters) != B_OK)
954			fill_disk_identifier_v2(fIdentifier, fParameters);
955
956#endif
957
958		// no interesting information, we have to fall back to the default
959		// unknown interface/device type identifier
960	}
961
962	fIdentifier.bus_type = UNKNOWN_BUS;
963	fIdentifier.device_type = UNKNOWN_DEVICE;
964	fIdentifier.device.unknown.size = Size();
965
966	for (int32 i = 0; i < NUM_DISK_CHECK_SUMS; i++) {
967		fIdentifier.device.unknown.check_sums[i].offset = -1;
968		fIdentifier.device.unknown.check_sums[i].sum = 0;
969	}
970#endif
971
972	return B_ERROR;
973}
974
975
976ssize_t
977BIOSDrive::ReadBlocks(void *buffer, off_t first, int32 count)
978{
979	int sectorsPerBlocks = (fBlockSize / 256);
980	int32 ret;
981	TRACE(("BIOSDrive::%s(%Ld,%ld) (%d)\n", __FUNCTION__, first, count, fHandle));
982	// XXX: check for AHDI 3.0 before using long recno!!!
983	ret = Rwabs(RW_READ | RW_NOTRANSLATE, buffer, sectorsPerBlocks, -1, fHandle, first * sectorsPerBlocks);
984	if (ret < 0)
985		return toserror(ret);
986	return ret;
987}
988
989
990//	#pragma mark -
991
992/*
993 * XHDI based devices
994 */
995
996
997XHDIDrive::XHDIDrive(int handle, uint16 major, uint16 minor)
998	: BlockHandle(handle)
999{
1000	/* first check if the drive exists */
1001	int32 err;
1002	uint32 devflags;
1003	uint32 blocks;
1004	uint32 blocksize;
1005	char product[33];
1006
1007	fMajor = major;
1008	fMinor = minor;
1009	TRACE(("XHDIDrive::%s(%d, %d, %d)\n", __FUNCTION__, handle, fMajor, fMinor));
1010
1011	product[32] = '\0';
1012	err = XHInqTarget(major, minor, &fBlockSize, &devflags, product);
1013	if (err < 0)
1014		return;
1015	//XXX: check size
1016	err = XHGetCapacity(major, minor, &blocks, &blocksize);
1017	if (err < 0)
1018		return;
1019
1020	if (fBlockSize == 0)
1021		fBlockSize = 512;
1022
1023	fSize = blocks * fBlockSize;
1024	fHasParameters = false;
1025#if 0
1026	if (get_drive_parameters(fHandle, &fParameters) != B_OK) {
1027		dprintf("getting drive parameters for: %u failed!\n", fHandle);
1028		return;
1029	}
1030	fBlockSize = 512;
1031	fSize = fParameters.sectors * fBlockSize;
1032	fHasParameters = false;
1033#endif
1034#if 0
1035	if (get_ext_drive_parameters(driveID, &fParameters) != B_OK) {
1036		// old style CHS support
1037
1038		if (get_drive_parameters(driveID, &fParameters) != B_OK) {
1039			dprintf("getting drive parameters for: %u failed!\n", fDriveID);
1040			return;
1041		}
1042
1043		TRACE(("  cylinders: %lu, heads: %lu, sectors: %lu, bytes_per_sector: %u\n",
1044			fParameters.cylinders, fParameters.heads, fParameters.sectors_per_track,
1045			fParameters.bytes_per_sector));
1046		TRACE(("  total sectors: %Ld\n", fParameters.sectors));
1047
1048		fBlockSize = 512;
1049		fSize = fParameters.sectors * fBlockSize;
1050		fLBA = false;
1051		fHasParameters = false;
1052	} else {
1053		TRACE(("size: %x\n", fParameters.parameters_size));
1054		TRACE(("drive_path_signature: %x\n", fParameters.device_path_signature));
1055		TRACE(("host bus: \"%s\", interface: \"%s\"\n", fParameters.host_bus,
1056			fParameters.interface_type));
1057		TRACE(("cylinders: %lu, heads: %lu, sectors: %lu, bytes_per_sector: %u\n",
1058			fParameters.cylinders, fParameters.heads, fParameters.sectors_per_track,
1059			fParameters.bytes_per_sector));
1060		TRACE(("total sectors: %Ld\n", fParameters.sectors));
1061
1062		fBlockSize = fParameters.bytes_per_sector;
1063		fSize = fParameters.sectors * fBlockSize;
1064		fLBA = true;
1065		fHasParameters = true;
1066	}
1067#endif
1068}
1069
1070
1071XHDIDrive::~XHDIDrive()
1072{
1073}
1074
1075
1076status_t
1077XHDIDrive::FillIdentifier()
1078{
1079	TRACE(("XHDIDrive::%s: (%d,%d)\n", __FUNCTION__, fMajor, fMinor));
1080
1081	fIdentifier.bus_type = UNKNOWN_BUS;
1082	fIdentifier.device_type = UNKNOWN_DEVICE;
1083	fIdentifier.device.unknown.size = Size();
1084#if 0
1085	// cf. http://toshyp.atari.org/010008.htm#XHDI-Terminologie
1086	if (fMajor >= 8 && fMajor <= 15) { // scsi
1087		fIdentifier.device_type = SCSI_DEVICE;
1088		fIdentifier.device.scsi.logical_unit = fMinor;
1089		//XXX: where am I supposed to put the ID ???
1090	}
1091#endif
1092
1093	for (int32 i = 0; i < NUM_DISK_CHECK_SUMS; i++) {
1094		fIdentifier.device.unknown.check_sums[i].offset = -1;
1095		fIdentifier.device.unknown.check_sums[i].sum = 0;
1096	}
1097
1098	return B_ERROR;
1099}
1100
1101
1102ssize_t
1103XHDIDrive::ReadBlocks(void *buffer, off_t first, int32 count)
1104{
1105	int sectorsPerBlock = (fBlockSize / 256);
1106	int32 ret;
1107	uint16 flags = RW_READ;
1108	TRACE(("XHDIDrive::%s(%Ld, %d) (%d,%d)\n", __FUNCTION__, first, count, fMajor, fMinor));
1109	ret = XHReadWrite(fMajor, fMinor, flags, (uint32)first, (uint16)count, buffer);
1110	if (ret < 0)
1111		return xhdierror(ret);
1112	//TRACE(("XHReadWrite: %ld\n", ret));
1113	/*
1114	uint8 *b = (uint8 *)buffer;
1115	int i = 0;
1116	for (i = 0; i < 512; i+=16) {
1117		TRACE(("[%8Ld+%3ld] %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
1118			first, i, b[i], b[i+1], b[i+2], b[i+3], b[i+4], b[i+5], b[i+6], b[i+7],
1119			b[i+8], b[i+9], b[i+10], b[i+11], b[i+12], b[i+13], b[i+14], b[i+15]));
1120		//break;
1121	}
1122	*/
1123	return ret;
1124}
1125
1126
1127
1128
1129//	#pragma mark -
1130
1131
1132status_t
1133platform_add_boot_device(struct stage2_args *args, NodeList *devicesList)
1134{
1135	TRACE(("boot drive ID: %x API: %d\n", gBootDriveID, gBootDriveAPI));
1136	init_xhdi();
1137
1138	//XXX: FIXME
1139	//BlockHandle *drive = new(nothrow) BlockHandle(gBootDriveID);
1140	BlockHandle *drive;
1141	switch (gBootDriveAPI) {
1142		case ATARI_BOOT_DRVAPI_FLOPPY:
1143			drive = new(nothrow) FloppyDrive(gBootDriveID);
1144			break;
1145			/*
1146		case ATARI_BOOT_DRVAPI_XBIOS:
1147			drive = new(nothrow) DMADrive(gBootDriveID);
1148			break;
1149			*/
1150		case ATARI_BOOT_DRVAPI_XHDI:
1151			drive = new(nothrow) XHDIDrive(gBootDriveID, gBootDriveID, 0);
1152			break;
1153		case ATARI_BOOT_DRVAPI_UNKNOWN:
1154		{
1155			// we don't know yet, try to ask ARAnyM via NatFeat
1156			int id = nat_feat_get_bootdrive();
1157			if (id > -1) {
1158				gBootDriveID = id;
1159				dprintf("nat_fead_get_bootdrive() = %d\n", id);
1160				// XXX: which API does it refer to ??? id = letter - 'a'
1161				drive = new(nothrow) XHDIDrive(gBootDriveID, gBootDriveID, 0);
1162				break;
1163			}
1164		}
1165		default:
1166			dprintf("unknown boot drive API %d\n", gBootDriveAPI);
1167			return B_ERROR;
1168			drive = new(nothrow) BIOSDrive(gBootDriveID);
1169	}
1170
1171	if (drive == NULL || drive->InitCheck() != B_OK) {
1172		dprintf("no boot drive!\n");
1173		return B_ERROR;
1174	}
1175
1176	devicesList->Add(drive);
1177
1178	if (drive->FillIdentifier() != B_OK) {
1179		// We need to add all block devices to give the kernel the possibility
1180		// to find the right boot volume
1181		add_block_devices(devicesList, true);
1182	}
1183
1184	TRACE(("boot drive size: %Ld bytes\n", drive->Size()));
1185	gBootVolume.SetBool(BOOT_VOLUME_BOOTED_FROM_IMAGE, gBootedFromImage);
1186
1187	return B_OK;
1188}
1189
1190
1191status_t
1192platform_get_boot_partitions(struct stage2_args *args, Node *bootDevice,
1193	NodeList *list, NodeList *partitionList)
1194{
1195	BlockHandle *drive = static_cast<BlockHandle *>(bootDevice);
1196	off_t offset = (off_t)gBootPartitionOffset * drive->BlockSize();
1197
1198	dprintf("boot partition offset: %Ld\n", offset);
1199
1200	NodeIterator iterator = list->GetIterator();
1201	boot::Partition *partition = NULL;
1202	while ((partition = (boot::Partition *)iterator.Next()) != NULL) {
1203		TRACE(("partition offset = %Ld, size = %Ld\n", partition->offset, partition->size));
1204		// search for the partition that contains the partition
1205		// offset as reported by the BFS boot block
1206		if (offset >= partition->offset
1207			&& offset < partition->offset + partition->size) {
1208			partitionList->Insert(partition);
1209			return B_OK;
1210		}
1211	}
1212
1213	return B_ENTRY_NOT_FOUND;
1214}
1215
1216
1217status_t
1218platform_add_block_devices(stage2_args *args, NodeList *devicesList)
1219{
1220	init_xhdi();
1221	return add_block_devices(devicesList, false);
1222}
1223
1224
1225status_t
1226platform_register_boot_device(Node *device)
1227{
1228	BlockHandle *drive = (BlockHandle *)device;
1229
1230#if 0
1231	check_cd_boot(drive);
1232#endif
1233
1234	gBootVolume.SetInt64("boot drive number", drive->DriveID());
1235	gBootVolume.SetData(BOOT_VOLUME_DISK_IDENTIFIER, B_RAW_TYPE,
1236		&drive->Identifier(), sizeof(disk_identifier));
1237
1238	return B_OK;
1239}
1240
1241
1242void
1243platform_cleanup_devices()
1244{
1245}
1246