Home | History | Annotate | Line # | Download | only in libtos 
      1 /*	$NetBSD: diskio.c,v 1.4 2014/03/26 18:04:34 christos Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1995 Waldi Ravens.
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. All advertising materials mentioning features or use of this software
     16  *    must display the following acknowledgement:
     17  *        This product includes software developed by Waldi Ravens.
     18  * 4. The name of the author may not be used to endorse or promote products
     19  *    derived from this software without specific prior written permission.
     20  *
     21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     31  */
     32 
     33 #include <sys/types.h>
     34 #include <stdlib.h>
     35 #include <string.h>
     36 #include <ctype.h>
     37 #include <stdio.h>
     38 #include <xhdi.h>
     39 #include "libtos.h"
     40 #include "diskio.h"
     41 #include "ahdilbl.h"
     42 #include <osbind.h>
     43 
     44 struct pun_info {
     45 	u_int16_t	puns;
     46 	u_int8_t	pun[16];
     47 	u_int32_t	part_start[16];
     48 	u_int32_t	P_cookie;
     49 	u_int32_t	*P_cookptr;
     50 	u_int16_t	P_version;
     51 	u_int16_t	P_max_sector;
     52 	u_int32_t	reserved[16];
     53 };
     54 
     55 static char *	strbd    PROTO((char *, ...));
     56 static int	setmami  PROTO((disk_t *, char *));
     57 static int	setnames PROTO((disk_t *));
     58 static int	setsizes PROTO((disk_t *));
     59 static int	ahdi_compatible PROTO((void));
     60 
     61 disk_t *
     62 disk_open(char *name)
     63 {
     64 	disk_t	*dd;
     65 
     66 	dd = xmalloc(sizeof *dd);
     67 	memset(dd, 0, sizeof *dd);
     68 
     69 	if (setmami(dd, name) || setnames(dd) || setsizes(dd)) {
     70 		disk_close(dd);
     71 		return(NULL);
     72 	}
     73 	return(dd);
     74 }
     75 
     76 void
     77 disk_close(disk_t *dd)
     78 {
     79 	if (dd) {
     80 		free(dd->product);
     81 		free(dd->sname);
     82 		free(dd->fname);
     83 		if (dd->xtra_info != NULL)
     84 			free(dd->xtra_info);
     85 		free(dd);
     86 	}
     87 }
     88 
     89 void *
     90 disk_read(dd, start, count)
     91 	disk_t	*dd;
     92 	u_int	start,
     93 		count;
     94 {
     95 	char	*buffer;
     96 	int	bdev;
     97 	long	e;
     98 
     99 	buffer = xmalloc(count * dd->bsize);
    100 
    101 	e = XHReadWrite(dd->major, dd->minor, 0, start, count, buffer);
    102 	if (!e)
    103 		return(buffer);
    104 	if (e == -32 || (e == -1 && XHGetVersion() == -1)) {
    105 		if (!ahdi_compatible())
    106 		    fatal(-1, "AHDI 3.0 compatible harddisk driver required");
    107 		bdev = BIOSDEV(dd->major, dd->minor);
    108 		if (bdev && !bios_read(buffer, start, count, bdev))
    109 			return(buffer);
    110 	}
    111 
    112 	free(buffer);
    113 	return(NULL);
    114 }
    115 
    116 int
    117 disk_write(dd, start, count, buffer)
    118 	disk_t	*dd;
    119 	u_int	start,
    120 		count;
    121 	void	*buffer;
    122 {
    123 	int	bdev;
    124 	long	e;
    125 
    126 	e = XHReadWrite(dd->major, dd->minor, 1, start, count, buffer);
    127 	if (e == -32 || (e == -1 && XHGetVersion() == -1)) {
    128 		if (!ahdi_compatible())
    129 		    fatal(-1, "AHDI 3.0 compatible harddisk driver required");
    130 		bdev = BIOSDEV(dd->major, dd->minor);
    131 		if (bdev)
    132 			e = bios_write(buffer, start, count, bdev);
    133 	}
    134 
    135 	return((int)e);
    136 }
    137 
    138 static int
    139 ahdi_compatible(void)
    140 {
    141 	static int	ahdi_compat;
    142 
    143 	if (!ahdi_compat) {
    144 		long		oldsp = Super(0L);
    145 		struct pun_info	*punp = *((struct pun_info **)0x0516);
    146 		(void)Super(oldsp);
    147 		if (punp && punp->P_cookie == 0x41484449
    148 				&& punp->P_cookptr == &punp->P_cookie
    149 				&& punp->P_version >= 0x0300)
    150 			ahdi_compat = 1;
    151 	}
    152 	return(ahdi_compat);
    153 }
    154 
    155 static int
    156 setmami(disk_t *dd, char *name)
    157 {
    158 	char	*p = name;
    159 	u_int	target, lun;
    160 	bus_t	bus;
    161 
    162 	if (*p == 'i') {
    163 		bus = IDE;
    164 		if (*++p < '0' || *p > '1') {
    165 			if (*p)
    166 			    error(-1, "%s: invalid IDE target `%c'", name, *p);
    167 			else
    168 			    error(-1, "%s: missing IDE target", name);
    169 			return(-1);
    170 		}
    171 		target = *p++ - '0';
    172 		lun = 0;
    173 	} else {
    174 		char	*b;
    175 
    176 		if (*p == 'a') {
    177 			bus = ACSI;
    178 			b = "ACSI";
    179 		} else if (*p == 's') {
    180 			bus = SCSI;
    181 			b = "SCSI";
    182 		} else {
    183 			error(-1, "%s: invalid DISK argument", name);
    184 			return(-1);
    185 		}
    186 		if (*++p < '0' || *p > '7') {
    187 			if (*p)
    188 				error(-1, "%s: invalid %s target `%c'", name,
    189 									b, *p);
    190 			else
    191 				error(-1, "%s: missing %s target", name, b);
    192 			return(-1);
    193 		}
    194 		target = *p++ - '0';
    195 
    196 		if (*p < '0' || *p > '7') {
    197 			if (*p) {
    198 				error(-1, "%s: invalid %s lun `%c'", name,
    199 								     b, *p);
    200 				return(-1);
    201 			}
    202 			lun = 0;
    203 		} else
    204 			lun = *p++ - '0';
    205 	}
    206 	if (*p) {
    207 		error(-1, "%s: invalid DISK argument", name);
    208 		return(-1);
    209 	}
    210 	dd->major = MAJOR(bus, target, lun);
    211 	dd->minor = MINOR(bus, target, lun);
    212 	return(0);
    213 }
    214 
    215 static int
    216 setnames(disk_t *dd)
    217 {
    218 	char	sn[16], us[16], ls[16], *bs;
    219 	int	b, u, l;
    220 
    221 	b = BUS(dd->major, dd->minor);
    222 	u = TARGET(dd->major, dd->minor);
    223 	l = LUN(dd->major, dd->minor);
    224 
    225 	switch (b) {
    226 	case IDE:	bs = "IDE";
    227 			break;
    228 	case ACSI:	bs = "ACSI";
    229 			break;
    230 	case SCSI:	bs = "SCSI";
    231 			break;
    232 	default:	error(-1, "invalid bus no. %d", b);
    233 			return(-1);
    234 	}
    235 
    236 	if (u < 0 || u > 7 || (b == IDE && u > 1)) {
    237 		error(-1, "invalid %s target `%d'", bs, u);
    238 		return(-1);
    239 	}
    240 	snprintf(us, sizeof(us), " target %d", u);
    241 
    242 	if (l < 0 || l > 7 || (b == IDE && l > 0)) {
    243 		error(-1, "invalid %s lun `%d'", bs, l);
    244 		return(-1);
    245 	}
    246 	if (b == IDE) {
    247 		snprintf(sn, sizeof(sn), "i%d", u);
    248 		ls[0] = '\0';
    249 	} else {
    250 		snprintf(sn, sizeof(sn), "%c%d%d", tolower(*bs), u, l);
    251 		snprintf(ls, sizeof(ls), " lun %d", l);
    252 	}
    253 
    254 	dd->fname = strbd(bs, us, ls, NULL);
    255 	dd->sname = strbd(sn, NULL);
    256 	return(0);
    257 }
    258 
    259 static int
    260 setsizes(disk_t *dd)
    261 {
    262 	if (XHGetVersion() != -1) {
    263 	    char	*p, prod[1024];
    264 
    265 	    if (XHInqTarget2(dd->major, dd->minor, &dd->bsize, NULL, prod,
    266 								sizeof(prod))) {
    267 		if (XHInqTarget(dd->major, dd->minor, &dd->bsize, NULL, prod)) {
    268 			error(-1, "%s: device not configured", dd->sname);
    269 			return(-1);
    270 		}
    271 	    }
    272 	    p = strrchr(prod, '\0');
    273 	    while (isspace(*--p))
    274 		*p = '\0';
    275 	    dd->product = strbd(prod, NULL);
    276 	    if (!XHGetCapacity(dd->major, dd->minor, &dd->msize, &dd->bsize))
    277 		return(0);
    278 	} else {
    279 	    dd->product = strbd("unknown", NULL);
    280 	    dd->bsize = AHDI_BSIZE;		/* XXX */
    281 	}
    282 
    283 	/* Trial&error search for last sector on medium */
    284 	{
    285 		u_int	u, l, m;
    286 		void	*p, (*oldvec)();
    287 
    288 		/* turn off etv_critic handler */
    289 		oldvec = Setexc(257, bios_critic);
    290 
    291 		u = (u_int)-2; l = 0;
    292 		while (u != l) {
    293 			m = l + ((u - l + 1) / 2);
    294 			p = disk_read(dd, m, 1);
    295 			free(p);
    296 			if (p == NULL)
    297 				u = m - 1;
    298 			else
    299 				l = m;
    300 		}
    301 
    302 		/* turn on etv_critic handler */
    303 		(void)Setexc(257, oldvec);
    304 
    305 		if (l) {
    306 			dd->msize = l + 1;
    307 			return(0);
    308 		}
    309 		error(-1, "%s: device not configured", dd->sname);
    310 		return(-1);
    311 	}
    312 }
    313 
    314 static char *
    315 strbd(char *string1)
    316 {
    317 	char		*p, *result;
    318 	size_t		length = 1;
    319 	va_list		ap;
    320 
    321 	va_start(ap, string1);
    322 	for (p = string1; p; p = va_arg(ap, char *))
    323 		length += strlen(p);
    324 	va_end(ap);
    325 
    326 	*(result = xmalloc(length)) = '\0';
    327 
    328 	va_start(ap, string1);
    329 	for (p = string1; p; p = va_arg(ap, char *))
    330 		strcat(result, p);
    331 	va_end(ap);
    332 
    333 	return(result);
    334 }
    335