[apple/boot.git] / gen / libsaio / disk.c

/*
 * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
 * Reserved.  This file contains Original Code and/or Modifications of
 * Original Code as defined in and that are subject to the Apple Public
 * Source License Version 1.1 (the "License").  You may not use this file
 * except in compliance with the License.  Please obtain a copy of the
 * License at http://www.apple.com/publicsource and read it before using
 * this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/* 
 * Mach Operating System
 * Copyright (c) 1990 Carnegie-Mellon University
 * Copyright (c) 1989 Carnegie-Mellon University
 * All rights reserved.  The CMU software License Agreement specifies
 * the terms and conditions for use and redistribution.
 */

/*
 * 			INTEL CORPORATION PROPRIETARY INFORMATION
 *
 *	This software is supplied under the terms of a license  agreement or 
 *	nondisclosure agreement with Intel Corporation and may not be copied 
 *	nor disclosed except in accordance with the terms of that agreement.
 *
 *	Copyright 1988, 1989 Intel Corporation
 */

/*
 * Copyright 1993 NeXT Computer, Inc.
 * All rights reserved.
 */

#define DRIVER_PRIVATE

#import "sys/types.h"
#import <sys/disk.h>
#import <dev/i386/disk.h>
#import "libsaio.h"
#import "memory.h"

static Biosread(int biosdev, int secno);
static read_label(char *name, int biosdev, daddr_t *boff, int partition);
void diskActivityHook(void);
extern void spinActivityIndicator(void);

/* diskinfo unpacking */
#define	SPT(di)		((di)&0xff)
#define	HEADS(di)	((((di)>>8)&0xff)+1)
#define	SPC(di)		(SPT(di)*HEADS(di))
#define BPS		512	/* sector size of the device */
#define N_CACHE_SECS	(BIOS_LEN / BPS)

#define	DOS_BSIZE	512
#define DISKLABEL	15	/* sector num of disk label */

char *devsw[] = {
	"sd",
	"hd",
	"fd",
	NULL
};

struct diskinfo {
	int	spt;			/* sectors per track */
	int	spc;			/* sectors per cylinder */
} diskinfo;

char	*b[NBUFS];
daddr_t	blknos[NBUFS];
struct	iob iob[NFILES];
int label_secsize;
static int label_cached;

// intbuf is the whole buffer, biosbuf is the current cached sector
static char * const intbuf = (char *)ptov(BIOS_ADDR);
char *biosbuf;

void
devopen(name, io)
	char		* name;
	struct iob	* io;
{
	long	di;

	di = get_diskinfo(io->biosdev);

	/* initialize disk parameters -- spt and spc */
	io->i_error = 0;
	io->dirbuf_blkno = -1;

	diskinfo.spt = SPT(di);
	diskinfo.spc = diskinfo.spt * HEADS(di);
	if (read_label(name, io->biosdev, &io->i_boff, io->partition) < 0)
	{
		io->i_error = EIO;
	}
}

void devflush()
{
	Biosread(0,-1);
}


int devread(io)
	struct iob *io;
{
	long sector;
	int offset;
	int dev;

	io->i_flgs |= F_RDDATA;

	/* assume the best */
	io->i_error = 0;

	dev = io->i_ino.i_dev;

	sector = io->i_bn * (label_secsize/DOS_BSIZE);

	for (offset = 0; offset < io->i_cc; offset += BPS) {

		io->i_error = Biosread(io->biosdev, sector);
		if (io->i_error) {
			return(-1);
		}

		/* copy 1 sector from the internal buffer biosbuf into buf */
		bcopy(biosbuf, &io->i_ma[offset], BPS);

		sector++;
	}

	io->i_flgs &= ~F_TYPEMASK;
	return (io->i_cc);
}

/* A haque: Biosread(0,-1) means flush the sector cache.
 */
static int
Biosread(int biosdev, int secno)
{
	static int xbiosdev, xcyl=-1, xhead, xsec, xnsecs;

	int	rc;
	int	cyl, head, sec;
	int	spt, spc;
	int tries = 0;

	if (biosdev == 0 && secno == -1) {
	    xcyl = -1;
	    label_cached = 0;
	    return 0;
	}
	spt = diskinfo.spt;
	spc = diskinfo.spc;

	cyl = secno / spc;
	head = (secno % spc) / spt;
	sec = secno % spt;

	if (biosdev == xbiosdev && cyl == xcyl && head == xhead &&
		sec >= xsec && sec < (xsec + xnsecs))
	{	// this sector is in intbuf cache
		biosbuf = intbuf + (BPS * (sec-xsec));
		return 0;
	}

	xcyl = cyl;
	label_cached = 1;
	xhead = head;
	xsec = sec;
	xbiosdev = biosdev;
	xnsecs = ((sec + N_CACHE_SECS) > spt) ? (spt - sec) : N_CACHE_SECS;
	biosbuf = intbuf;

	while ((rc = biosread(biosdev,cyl,head,sec, xnsecs)) && (++tries < 5))
	{
#ifndef	SMALL
		error("    biosread error 0x%x @ %d, C:%d H:%d S:%d\n",
			rc, secno, cyl, head, sec);
#endif
		sleep(1);	// on disk errors, bleh!
	}
	diskActivityHook();
	return rc;
}

// extern char name[];

#ifndef	SMALL
static int
read_label(
	char		*name,
	int		biosdev, 
	daddr_t		*boff,
	int		partition
)
{
	struct disk_label	*dlp;
	struct fdisk_part	*fd;
	struct disk_blk0	*blk0;
	char			*cp;
	int			n, rc;
	int			part_offset = 0;
	static int		cached_boff;

	if (label_cached) {
		*boff = cached_boff;
		return 0;
	}

	// read sector 0 into the internal buffer "biosbuf"
	if ( rc = Biosread(biosdev, 0) )
		return -1;

	// Check for a valid boot block.
	blk0 = (struct disk_blk0 *)biosbuf;
	if (blk0->signature == DISK_SIGNATURE) {
	    // Check to see if the disk has been partitioned with FDISK
	    // to allow DOS and ufs filesystems to exist on the same spindle.
	    fd = (struct fdisk_part *)blk0->parts;    
	    for (	n = 0; n < FDISK_NPART; n++, fd++)
		    if (fd->systid == FDISK_NEXTNAME)
		    {
			    part_offset = fd->relsect;
			    break;
		    }
	}
	/* It's not an error if there is not a valid boot block. */

	/* Read the NeXT disk label.
	 * Since we can't count on it fitting in the sector cache,
	 * we'll put it elsewhere.
	 */
	dlp = (struct disk_label *)malloc(sizeof(*dlp) + BPS);
	for(n = 0, cp = (char *)dlp;
		n < ((sizeof(*dlp) + BPS - 1) / BPS);
		n++, cp += BPS) {
	    if (rc = Biosread(biosdev, DISKLABEL + part_offset + n))
		goto error;
	    bcopy(biosbuf, cp, BPS);
	}
	
	byte_swap_disklabel_in(dlp);
	
	/* Check label */
	
	if (dlp->dl_version != DL_V3) {
		error("bad disk label magic\n");
		goto error;
	}
	    
	label_secsize = dlp->dl_secsize;
	
	if ((dlp->dl_part[partition].p_base) < 0) {
		error("no such partition\n");
		goto error;
	}

	*boff = cached_boff = dlp->dl_front + dlp->dl_part[partition].p_base;

	if (!strcmp(name,"$LBL")) strcpy(name, dlp->dl_bootfile);

	free((char *)dlp);
	return 0;
error:
	free((char *)dlp);
	return -1;
}

#endif	SMALL


/* replace this function if you want to change
 * the way disk activity is indicated to the user.
 */
 
void
diskActivityHook(void)
{
    spinActivityIndicator();
}
Commit	Line	Data
14c7c974 A	1	/*
	2	* Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
4f6e3300 A	6	* Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
	7	* Reserved. This file contains Original Code and/or Modifications of
	8	* Original Code as defined in and that are subject to the Apple Public
	9	* Source License Version 1.1 (the "License"). You may not use this file
	10	* except in compliance with the License. Please obtain a copy of the
	11	* License at http://www.apple.com/publicsource and read it before using
	12	* this file.
14c7c974 A	13	*
14c7c974 A	14	* The Original Code and all software distributed under the License are
4f6e3300	15	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14c7c974 A	16	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
14c7c974 A	17	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
4f6e3300 A	18	* FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the
	19	* License for the specific language governing rights and limitations
	20	* under the License.
14c7c974 A	21	*
	22	* @APPLE_LICENSE_HEADER_END@
	23	*/
	24	/*
	25	* Mach Operating System
	26	* Copyright (c) 1990 Carnegie-Mellon University
	27	* Copyright (c) 1989 Carnegie-Mellon University
	28	* All rights reserved. The CMU software License Agreement specifies
	29	* the terms and conditions for use and redistribution.
	30	*/
	31
	32	/*
	33	* INTEL CORPORATION PROPRIETARY INFORMATION
	34	*
	35	* This software is supplied under the terms of a license agreement or
	36	* nondisclosure agreement with Intel Corporation and may not be copied
	37	* nor disclosed except in accordance with the terms of that agreement.
	38	*
	39	* Copyright 1988, 1989 Intel Corporation
	40	*/
	41
	42	/*
	43	* Copyright 1993 NeXT Computer, Inc.
	44	* All rights reserved.
	45	*/
	46
	47	#define DRIVER_PRIVATE
	48
	49	#import "sys/types.h"
f083c6c3	50	#import <sys/disk.h>
75b89a82	51	#import <dev/i386/disk.h>
14c7c974 A	52	#import "libsaio.h"
	53	#import "memory.h"
	54
	55	static Biosread(int biosdev, int secno);
	56	static read_label(char name, int biosdev, daddr_t boff, int partition);
	57	void diskActivityHook(void);
	58	extern void spinActivityIndicator(void);
	59
	60	/* diskinfo unpacking */
	61	#define SPT(di) ((di)&0xff)
	62	#define HEADS(di) ((((di)>>8)&0xff)+1)
	63	#define SPC(di) (SPT(di)*HEADS(di))
	64	#define BPS 512 /* sector size of the device */
	65	#define N_CACHE_SECS (BIOS_LEN / BPS)
	66
	67	#define DOS_BSIZE 512
	68	#define DISKLABEL 15 /* sector num of disk label */
	69
	70	char *devsw[] = {
	71	"sd",
	72	"hd",
	73	"fd",
	74	NULL
	75	};
	76
	77	struct diskinfo {
	78	int spt; /* sectors per track */
	79	int spc; /* sectors per cylinder */
	80	} diskinfo;
	81
	82	char *b[NBUFS];
	83	daddr_t blknos[NBUFS];
	84	struct iob iob[NFILES];
	85	int label_secsize;
	86	static int label_cached;
	87
	88	// intbuf is the whole buffer, biosbuf is the current cached sector
	89	static char * const intbuf = (char *)ptov(BIOS_ADDR);
	90	char *biosbuf;
	91
	92	void
	93	devopen(name, io)
	94	char * name;
	95	struct iob * io;
	96	{
	97	long di;
	98
	99	di = get_diskinfo(io->biosdev);
	100
	101	/* initialize disk parameters -- spt and spc */
	102	io->i_error = 0;
	103	io->dirbuf_blkno = -1;
	104
	105	diskinfo.spt = SPT(di);
	106	diskinfo.spc = diskinfo.spt * HEADS(di);
	107	if (read_label(name, io->biosdev, &io->i_boff, io->partition) < 0)
	108	{
	109	io->i_error = EIO;
	110	}
	111	}
	112
	113	void devflush()
	114	{
	115	Biosread(0,-1);
116	}
117
118
119	int devread(io)
120	struct iob *io;
121	{
122	long sector;
123	int offset;
124	int dev;
125
126	io->i_flgs \|= F_RDDATA;
127
128	/* assume the best */
129	io->i_error = 0;
130
131	dev = io->i_ino.i_dev;
132
133	sector = io->i_bn * (label_secsize/DOS_BSIZE);
134
135	for (offset = 0; offset < io->i_cc; offset += BPS) {
136
137	io->i_error = Biosread(io->biosdev, sector);
138	if (io->i_error) {
139	return(-1);
140	}
141
142	/* copy 1 sector from the internal buffer biosbuf into buf */
143	bcopy(biosbuf, &io->i_ma[offset], BPS);
144
145	sector++;
146	}
147
148	io->i_flgs &= ~F_TYPEMASK;
149	return (io->i_cc);
150	}
151
152	/* A haque: Biosread(0,-1) means flush the sector cache.
153	*/
154	static int
155	Biosread(int biosdev, int secno)
156	{
157	static int xbiosdev, xcyl=-1, xhead, xsec, xnsecs;
158
159	int rc;
160	int cyl, head, sec;
161	int spt, spc;
162	int tries = 0;
163
164	if (biosdev == 0 && secno == -1) {
165	xcyl = -1;
166	label_cached = 0;
167	return 0;
168	}
169	spt = diskinfo.spt;
170	spc = diskinfo.spc;
171
172	cyl = secno / spc;
173	head = (secno % spc) / spt;
174	sec = secno % spt;
175
176	if (biosdev == xbiosdev && cyl == xcyl && head == xhead &&
177	sec >= xsec && sec < (xsec + xnsecs))
178	{ // this sector is in intbuf cache
179	biosbuf = intbuf + (BPS * (sec-xsec));
180	return 0;
181	}
182
183	xcyl = cyl;
184	label_cached = 1;
185	xhead = head;
186	xsec = sec;
187	xbiosdev = biosdev;
188	xnsecs = ((sec + N_CACHE_SECS) > spt) ? (spt - sec) : N_CACHE_SECS;
189	biosbuf = intbuf;
190
191	while ((rc = biosread(biosdev,cyl,head,sec, xnsecs)) && (++tries < 5))
192	{
193	#ifndef SMALL
194	error(" biosread error 0x%x @ %d, C:%d H:%d S:%d\n",
195	rc, secno, cyl, head, sec);
196	#endif
197	sleep(1); // on disk errors, bleh!
198	}
199	diskActivityHook();
200	return rc;
201	}
202
203	// extern char name[];
204
205	#ifndef SMALL
206	static int
207	read_label(
208	char *name,
209	int biosdev,
210	daddr_t *boff,
211	int partition
212	)
213	{
214	struct disk_label *dlp;
215	struct fdisk_part *fd;
216	struct disk_blk0 *blk0;
217	char *cp;
218	int n, rc;
219	int part_offset = 0;
220	static int cached_boff;
221
222	if (label_cached) {
223	*boff = cached_boff;
224	return 0;
225	}
226
227	// read sector 0 into the internal buffer "biosbuf"
228	if ( rc = Biosread(biosdev, 0) )
229	return -1;
230
231	// Check for a valid boot block.
232	blk0 = (struct disk_blk0 *)biosbuf;
233	if (blk0->signature == DISK_SIGNATURE) {
234	// Check to see if the disk has been partitioned with FDISK
235	// to allow DOS and ufs filesystems to exist on the same spindle.
236	fd = (struct fdisk_part *)blk0->parts;
237	for ( n = 0; n < FDISK_NPART; n++, fd++)
238	if (fd->systid == FDISK_NEXTNAME)
239	{
240	part_offset = fd->relsect;
241	break;
242	}
243	}
244	/* It's not an error if there is not a valid boot block. */
245
246	/* Read the NeXT disk label.
247	* Since we can't count on it fitting in the sector cache,
248	* we'll put it elsewhere.
249	*/
250	dlp = (struct disk_label )malloc(sizeof(dlp) + BPS);
251	for(n = 0, cp = (char *)dlp;
252	n < ((sizeof(*dlp) + BPS - 1) / BPS);
253	n++, cp += BPS) {
254	if (rc = Biosread(biosdev, DISKLABEL + part_offset + n))
255	goto error;
256	bcopy(biosbuf, cp, BPS);
257	}
258
259	byte_swap_disklabel_in(dlp);
260
261	/* Check label */
262
263	if (dlp->dl_version != DL_V3) {
264	error("bad disk label magic\n");
265	goto error;
266	}
267
268	label_secsize = dlp->dl_secsize;
269
270	if ((dlp->dl_part[partition].p_base) < 0) {
271	error("no such partition\n");
272	goto error;
273	}
274
275	*boff = cached_boff = dlp->dl_front + dlp->dl_part[partition].p_base;
276
277	if (!strcmp(name,"$LBL")) strcpy(name, dlp->dl_bootfile);
278
279	free((char *)dlp);
280	return 0;
281	error:
282	free((char *)dlp);
283	return -1;
284	}
285
286	#endif SMALL
287
288
289	/* replace this function if you want to change
290	* the way disk activity is indicated to the user.
291	*/
292
293	void
294	diskActivityHook(void)
295	{
296	spinActivityIndicator();
297	}
298
299
300