vx32

sdscsi.c (7937B)

---

 #include "u.h"
 #include "lib.h"
 #include "mem.h"
 #include "dat.h"
 #include "fns.h"
 #include "io.h"
 #include "ureg.h"
 #include "error.h"
 
 #include "sd.h"
 
 static int
 scsitest(SDreq* r)
 {
 	r->write = 0;
 	memset(r->cmd, 0, sizeof(r->cmd));
 	r->cmd[1] = r->lun<<5;
 	r->clen = 6;
 	r->data = nil;
 	r->dlen = 0;
 	r->flags = 0;
 
 	r->status = ~0;
 
 	return r->unit->dev->ifc->rio(r);
 }
 
 int
 scsiverify(SDunit* unit)
 {
 	SDreq *r;
 	int i, status;
 	uchar *inquiry;
 
 	if((r = malloc(sizeof(SDreq))) == nil)
 		return 0;
 	if((inquiry = sdmalloc(sizeof(unit->inquiry))) == nil){
 		free(r);
 		return 0;
 	}
 	r->unit = unit;
 	r->lun = 0;		/* ??? */
 
 	memset(unit->inquiry, 0, sizeof(unit->inquiry));
 	r->write = 0;
 	r->cmd[0] = 0x12;
 	r->cmd[1] = r->lun<<5;
 	r->cmd[4] = sizeof(unit->inquiry)-1;
 	r->clen = 6;
 	r->data = inquiry;
 	r->dlen = sizeof(unit->inquiry)-1;
 	r->flags = 0;
 
 	r->status = ~0;
 	if(unit->dev->ifc->rio(r) != SDok){
 		free(r);
 		return 0;
 	}
 	memmove(unit->inquiry, inquiry, r->dlen);
 	free(inquiry);
 
 	status = 0;
 	for(i = 0; i < 3; i++){
 		while((status = scsitest(r)) == SDbusy)
 			;
 		if(status == SDok || status != SDcheck)
 			break;
 		if(!(r->flags & SDvalidsense))
 			break;
 		if((r->sense[2] & 0x0F) != 0x02)
 			continue;
 
 		/*
 		 * Unit is 'not ready'.
 		 * If it is in the process of becoming ready or needs
 		 * an initialising command, set status so it will be spun-up
 		 * below.
 		 * If there's no medium, that's OK too, but don't
 		 * try to spin it up.
 		 */
 		if(r->sense[12] == 0x04){
 			if(r->sense[13] == 0x02 || r->sense[13] == 0x01){
 				status = SDok;
 				break;
 			}
 		}
 		if(r->sense[12] == 0x3A)
 			break;
 	}
 
 	if(status == SDok){
 		/*
 		 * Try to ensure a direct-access device is spinning.
 		 * Don't wait for completion, ignore the result.
 		 */
 		if((unit->inquiry[0] & 0x1F) == 0){
 			memset(r->cmd, 0, sizeof(r->cmd));
 			r->write = 0;
 			r->cmd[0] = 0x1B;
 			r->cmd[1] = (r->lun<<5)|0x01;
 			r->cmd[4] = 1;
 			r->clen = 6;
 			r->data = nil;
 			r->dlen = 0;
 			r->flags = 0;
 
 			r->status = ~0;
 			unit->dev->ifc->rio(r);
 		}
 	}
 	free(r);
 
 	if(status == SDok || status == SDcheck)
 		return 1;
 	return 0;
 }
 
 static int
 scsirio(SDreq* r)
 {
 	/*
 	 * Perform an I/O request, returning
 	 *	-1	failure
 	 *	 0	ok
 	 *	 1	no medium present
 	 *	 2	retry
 	 * The contents of r may be altered so the
 	 * caller should re-initialise if necesary.
 	 */
 	r->status = ~0;
 	switch(r->unit->dev->ifc->rio(r)){
 	default:
 		break;
 	case SDcheck:
 		if(!(r->flags & SDvalidsense))
 			break;
 		switch(r->sense[2] & 0x0F){
 		case 0x00:		/* no sense */
 		case 0x01:		/* recovered error */
 			return 2;
 		case 0x06:		/* check condition */
 			/*
 			 * 0x28 - not ready to ready transition,
 			 *	  medium may have changed.
 			 * 0x29 - power on or some type of reset.
 			 */
 			if(r->sense[12] == 0x28 && r->sense[13] == 0)
 				return 2;
 			if(r->sense[12] == 0x29)
 				return 2;
 			break;
 		case 0x02:		/* not ready */
 			/*
 			 * If no medium present, bail out.
 			 * If unit is becoming ready, rather than not
 			 * not ready, wait a little then poke it again. 				 */
 			if(r->sense[12] == 0x3A)
 				break;
 			if(r->sense[12] != 0x04 || r->sense[13] != 0x01)
 				break;
 
 			while(waserror())
 				;
 			tsleep(&up->sleep, return0, 0, 500);
 			poperror();
 			scsitest(r);
 			return 2;
 		default:
 			break;
 		}
 		break;
 	case SDok:
 		return 0;
 	}
 	return -1;
 }
 
 int
 scsionline(SDunit* unit)
 {
 	SDreq *r;
 	uchar *p;
 	int ok, retries;
 
 	if((r = malloc(sizeof(SDreq))) == nil)
 		return 0;
 	if((p = sdmalloc(8)) == nil){
 		free(r);
 		return 0;
 	}
 
 	ok = 0;
 
 	r->unit = unit;
 	r->lun = 0;				/* ??? */
 	for(retries = 0; retries < 10; retries++){
 		/*
 		 * Read-capacity is mandatory for DA, WORM, CD-ROM and
 		 * MO. It may return 'not ready' if type DA is not
 		 * spun up, type MO or type CD-ROM are not loaded or just
 		 * plain slow getting their act together after a reset.
 		 */
 		r->write = 0;
 		memset(r->cmd, 0, sizeof(r->cmd));
 		r->cmd[0] = 0x25;
 		r->cmd[1] = r->lun<<5;
 		r->clen = 10;
 		r->data = p;
 		r->dlen = 8;
 		r->flags = 0;
 
 		r->status = ~0;
 		switch(scsirio(r)){
 		default:
 			break;
 		case 0:
 			unit->sectors = (p[0]<<24)|(p[1]<<16)|(p[2]<<8)|p[3];
 			unit->secsize = (p[4]<<24)|(p[5]<<16)|(p[6]<<8)|p[7];
 
 			/*
 			 * Some ATAPI CD readers lie about the block size.
 			 * Since we don't read audio via this interface
 			 * it's okay to always fudge this.
 			 */
 			if(unit->secsize == 2352)
 				unit->secsize = 2048;
 			/*
 			 * Devices with removable media may return 0 sectors
 			 * when they have empty media (e.g. sata dvd writers);
 			 * if so, keep the count zero.
 			 *
 			 * Read-capacity returns the LBA of the last sector,
 			 * therefore the number of sectors must be incremented.
 			 */
 			if(unit->sectors != 0)
 				unit->sectors++;
 			ok = 1;
 			break;
 		case 1:
 			ok = 1;
 			break;
 		case 2:
 			continue;
 		}
 		break;
 	}
 	free(p);
 	free(r);
 
 	if(ok)
 		return ok+retries;
 	else
 		return 0;
 }
 
 int
 scsiexec(SDunit* unit, int write, uchar* cmd, int clen, void* data, int* dlen)
 {
 	SDreq *r;
 	int status;
 
 	if((r = malloc(sizeof(SDreq))) == nil)
 		return SDmalloc;
 	r->unit = unit;
 	r->lun = cmd[1]>>5;		/* ??? */
 	r->write = write;
 	memmove(r->cmd, cmd, clen);
 	r->clen = clen;
 	r->data = data;
 	if(dlen)
 		r->dlen = *dlen;
 	r->flags = 0;
 
 	r->status = ~0;
 
 	/*
 	 * Call the device-specific I/O routine.
 	 * There should be no calls to 'error()' below this
 	 * which percolate back up.
 	 */
 	switch(status = unit->dev->ifc->rio(r)){
 	case SDok:
 		if(dlen)
 			*dlen = r->rlen;
 		/*FALLTHROUGH*/
 	case SDcheck:
 		/*FALLTHROUGH*/
 	default:
 		/*
 		 * It's more complicated than this. There are conditions
 		 * which are 'ok' but for which the returned status code
 		 * is not 'SDok'.
 		 * Also, not all conditions require a reqsense, might
 		 * need to do a reqsense here and make it available to the
 		 * caller somehow.
 		 *
 		 * Mañana.
 		 */
 		break;
 	}
 	sdfree(r);
 
 	return status;
 }
 
 static void
 scsifmt10(SDreq *r, int write, int lun, ulong nb, uvlong bno)
 {
 	uchar *c;
 
 	c = r->cmd;
 	if(write == 0)
 		c[0] = 0x28;
 	else
 		c[0] = 0x2A;
 	c[1] = lun<<5;
 	c[2] = bno>>24;
 	c[3] = bno>>16;
 	c[4] = bno>>8;
 	c[5] = bno;
 	c[6] = 0;
 	c[7] = nb>>8;
 	c[8] = nb;
 	c[9] = 0;
 
 	r->clen = 10;
 }
 
 static void
 scsifmt16(SDreq *r, int write, int lun, ulong nb, uvlong bno)
 {
 	uchar *c;
 
 	c = r->cmd;
 	if(write == 0)
 		c[0] = 0x88;
 	else
 		c[0] = 0x8A;
 	c[1] = lun<<5;		/* so wrong */
 	c[2] = bno>>56;
 	c[3] = bno>>48;
 	c[4] = bno>>40;
 	c[5] = bno>>32;
 	c[6] = bno>>24;
 	c[7] = bno>>16;
 	c[8] = bno>>8;
 	c[9] = bno;
 	c[10] = nb>>24;
 	c[11] = nb>>16;
 	c[12] = nb>>8;
 	c[13] = nb;
 	c[14] = 0;
 	c[15] = 0;
 
 	r->clen = 16;
 }
 
 long
 scsibio(SDunit* unit, int lun, int write, void* data, long nb, uvlong bno)
 {
 	SDreq *r;
 	long rlen;
 
 	if((r = malloc(sizeof(SDreq))) == nil)
 		error(Enomem);
 	r->unit = unit;
 	r->lun = lun;
 again:
 	r->write = write;
 	if(bno >= (1ULL<<32))
 		scsifmt16(r, write, lun, nb, bno);
 	else
 		scsifmt10(r, write, lun, nb, bno);
 	r->data = data;
 	r->dlen = nb*unit->secsize;
 	r->flags = 0;
 
 	r->status = ~0;
 	switch(scsirio(r)){
 	default:
 		rlen = -1;
 		break;
 	case 0:
 		rlen = r->rlen;
 		break;
 	case 2:
 		rlen = -1;
 		if(!(r->flags & SDvalidsense))
 			break;
 		switch(r->sense[2] & 0x0F){
 		default:
 			break;
 		case 0x01:		/* recovered error */
 			print("%s: recovered error at sector %llud\n",
 				unit->perm.name, bno);
 			rlen = r->rlen;
 			break;
 		case 0x06:		/* check condition */
 			/*
 			 * Check for a removeable media change.
 			 * If so, mark it by zapping the geometry info
 			 * to force an online request.
 			 */
 			if(r->sense[12] != 0x28 || r->sense[13] != 0)
 				break;
 			if(unit->inquiry[1] & 0x80)
 				unit->sectors = 0;
 			break;
 		case 0x02:		/* not ready */
 			/*
 			 * If unit is becoming ready,
 			 * rather than not not ready, try again.
 			 */
 			if(r->sense[12] == 0x04 && r->sense[13] == 0x01)
 				goto again;
 			break;
 		}
 		break;
 	}
 	free(r);
 
 	return rlen;
 }