pcd.c

arm平台上的uclinux系统全部源代码

void	cleanup_module(void)

{	int unit;

	unregister_blkdev(MAJOR_NR,name);
	
        for (unit=0;unit<PCD_UNITS;unit++) 
           if (PCD.present) pi_release(PI);
}

#endif

#define WR(c,r,v)       pi_write_regr(PI,c,r,v)
#define RR(c,r)         (pi_read_regr(PI,c,r))

static int pcd_wait( int unit, int go, int stop, char * fun, char * msg )

{	int j, r, e, s, p;

	j = 0;
	while ((((r=RR(1,6))&go)||(stop&&(!(r&stop))))&&(j++<PCD_SPIN))
		udelay(PCD_DELAY);

	if ((r&(IDE_ERR&stop))||(j>=PCD_SPIN)) {
	   s = RR(0,7);
	   e = RR(0,1);
	   p = RR(0,2);
       	   if (j >= PCD_SPIN) e |= 0x100;
           if (fun) printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
			   " loop=%d phase=%d\n",
			    PCD.name,fun,msg,r,s,e,j,p);
	   return (s<<8)+r;
	}
	return 0;
}

static int pcd_command( int unit, char * cmd, int dlen, char * fun )

{	pi_connect(PI);

        WR(0,6,0xa0 + 0x10*PCD.drive);

	if (pcd_wait(unit,IDE_BUSY|IDE_DRQ,0,fun,"before command")) {
		pi_disconnect(PI);
		return -1;
	}

        WR(0,4,dlen % 256);
        WR(0,5,dlen / 256);
        WR(0,7,0xa0);          /* ATAPI packet command */

        if (pcd_wait(unit,IDE_BUSY,IDE_DRQ,fun,"command DRQ")) {
		pi_disconnect(PI);
		return -1;
	}

        if (RR(0,2) != 1) {
           printk("%s: %s: command phase error\n",PCD.name,fun);
	   pi_disconnect(PI);
           return -1;
        }

	pi_write_block(PI,cmd,12);

	return 0;
}

static int pcd_completion( int unit, char * buf,  char * fun )

{	int r, d, p, n, k, j;

	r = -1; k = 0; j = 0;

	if (!pcd_wait(unit,IDE_BUSY,IDE_DRQ|IDE_READY|IDE_ERR,
						fun,"completion")) {
	    r = 0;
	    while (RR(0,7)&IDE_DRQ) {
	        d = (RR(0,4)+256*RR(0,5));
	        n = ((d+3)&0xfffc);
	        p = RR(0,2)&3;

	        if ((p == 2) && (n > 0) && (j == 0)) {
		    pi_read_block(PI,buf,n);
	            if (verbose > 1) 
			printk("%s: %s: Read %d bytes\n",PCD.name,fun,n);
		    r = 0; j++;
	        } else {
		    if (verbose > 1) 
		        printk("%s: %s: Unexpected phase %d, d=%d, k=%d\n",
					PCD.name,fun,p,d,k);
		    if ((verbose < 2) && !pcd_warned) {
	               	pcd_warned = 1;
			printk("%s: WARNING: ATAPI phase errors\n",PCD.name);
			}
		    udelay(1000);
	        } 
		if (k++ > PCD_TMO) {
			printk("%s: Stuck DRQ\n",PCD.name);
			break;
		}
	        if (pcd_wait(unit,IDE_BUSY,IDE_DRQ|IDE_READY|IDE_ERR,
				fun,"completion")) { 
			r = -1;
			break;
		}
	    }
	}
	
	pi_disconnect(PI); 

	return r;
}

static void pcd_req_sense( int unit, char *fun )

{	char	rs_cmd[12] = { 0x03,0,0,0,16,0,0,0,0,0,0,0 };
	char	buf[16];
	int 	r;

	r = pcd_command(unit,rs_cmd,16,"Request sense");
	udelay(1000);
	if (!r) pcd_completion(unit,buf,"Request sense");

	PCD.last_sense = -1;
	if (!r) {
            if (fun) printk("%s: %s: Sense key: %x, ASC: %x, ASQ: %x\n",
	                       PCD.name,fun,buf[2]&0xf,buf[12],buf[13]);
	    PCD.last_sense = (buf[2]&0xf) | ((buf[12]&0xff)<<8)
                                          | ((buf[13]&0xff)<<16) ;
        } 
}

static int pcd_atapi( int unit, char * cmd, int dlen, char * buf, char * fun )

{	int r;

	r = pcd_command(unit,cmd,dlen,fun);
	udelay(1000);
	if (!r) r = pcd_completion(unit,buf,fun);
	if (r) pcd_req_sense(unit,fun);
	
	return r;
}

#define DBMSG(msg)	((verbose>1)?(msg):NULL)

static void pcd_lock(int unit)

{	char	lo_cmd[12] = { 0x1e,0,0,0,1,0,0,0,0,0,0,0 };
	char	cl_cmd[12] = { 0x1b,0,0,0,3,0,0,0,0,0,0,0 };

	pcd_atapi(unit,cl_cmd,0,pcd_scratch,DBMSG("cd1")); 
	pcd_atapi(unit,cl_cmd,0,pcd_scratch,DBMSG("cd2"));
	pcd_atapi(unit,cl_cmd,0,pcd_scratch,DBMSG("cd3"));
	pcd_atapi(unit,cl_cmd,0,pcd_scratch,DBMSG("cd4"));
	pcd_atapi(unit,cl_cmd,0,pcd_scratch,"close door");

        pcd_atapi(unit,lo_cmd,0,pcd_scratch,DBMSG("ld"));
        pcd_atapi(unit,lo_cmd,0,pcd_scratch,"lock door");
}

static void pcd_unlock( int unit )

{	char	un_cmd[12] = { 0x1e,0,0,0,0,0,0,0,0,0,0,0 };

	pcd_atapi(unit,un_cmd,0,pcd_scratch,"unlock door");
}

static void pcd_eject( int unit)

{	char	ej_cmd[12] = { 0x1b,0,0,0,2,0,0,0,0,0,0,0 };

	pcd_unlock(unit);
	pcd_atapi(unit,ej_cmd,0,pcd_scratch,"eject");
}

#define PCD_RESET_TMO	100		/* in tenths of a second */

static void pcd_sleep( int cs )

{       current->state = TASK_INTERRUPTIBLE;
        current->timeout = jiffies + cs;
        schedule();
}

static int pcd_reset( int unit )

/* the ATAPI standard actually specifies the contents of all 7 registers
   after a reset, but the specification is ambiguous concerning the last
   two bytes, and different drives interpret the standard differently.
*/

{	int	i, k, flg;
	int	expect[5] = {1,1,1,0x14,0xeb};

	pi_connect(PI);
	WR(0,6,0xa0 + 0x10*PCD.drive);
	WR(0,7,8);

	pcd_sleep(2);  		/* delay a bit*/

	k = 0;
	while ((k++ < PCD_RESET_TMO) && (RR(1,6)&IDE_BUSY))
		pcd_sleep(10);

	flg = 1;
	for(i=0;i<5;i++) flg &= (RR(0,i+1) == expect[i]);

	if (verbose) {
		printk("%s: Reset (%d) signature = ",PCD.name,k);
		for (i=0;i<5;i++) printk("%3x",RR(0,i+1));
		if (!flg) printk(" (incorrect)");
		printk("\n");
	}
	
	pi_disconnect(PI);
	return flg-1;	
}

static int pcd_ready_wait( int unit, int tmo )

{       char    tr_cmd[12] = {0,0,0,0,0,0,0,0,0,0,0,0};
        int     k, p;

        k = 0;
        while (k < tmo) {
          PCD.last_sense = 0;
          pcd_atapi(unit,tr_cmd,0,NULL,DBMSG("test unit ready"));
          p = PCD.last_sense;
          if (!p) return 0;
	  if (!(((p & 0xffff) == 0x0402)||((p & 0xff) == 6))) return p;
          k++;
          pcd_sleep(100);
        }
        return 0x000020;        /* timeout */
}

static int pcd_check_media( int unit )

{	char    rc_cmd[12] = { 0x25,0,0,0,0,0,0,0,0,0,0,0};

	pcd_ready_wait(unit,PCD_READY_TMO);
	return (pcd_atapi(unit,rc_cmd,8,pcd_scratch,DBMSG("check media")));
}

static int pcd_identify( int unit, char * id )

{	int k, s;
	char   id_cmd[12] = {0x12,0,0,0,36,0,0,0,0,0,0,0};

	pcd_bufblk = -1;

        s = pcd_atapi(unit,id_cmd,36,pcd_buffer,"identify");

	if (s) return -1;
	if ((pcd_buffer[0] & 0x1f) != 5) {
	  if (verbose) printk("%s: %s is not a CDrom\n",
			PCD.name,PCD.drive?"Slave":"Master");
	  return -1;
	}
	for (k=0;k<16;k++) id[k] = pcd_buffer[16+k]; id[16] = 0;
	k = 16; while ((k >= 0) && (id[k] <= 0x20)) { id[k] = 0; k--; }

	printk("%s: %s: %s\n",PCD.name,PCD.drive?"Slave":"Master",id);

	return 0;
}

static int pcd_probe( int unit, int ms, char * id )

/*	returns  0, with id set if drive is detected
	        -1, if drive detection failed
*/

{	if (ms == -1) {
            for (PCD.drive=0;PCD.drive<=1;PCD.drive++)
	       if (!pcd_reset(unit) && !pcd_identify(unit,id)) 
		  return 0;
	} else {
	    PCD.drive = ms;
            if (!pcd_reset(unit) && !pcd_identify(unit,id)) 
		return 0;
	}
	return -1;
}

static int pcd_detect( void )

{	char    id[18];
	int	k, unit;

	printk("%s: %s version %s, major %d, nice %d\n",
		name,name,PCD_VERSION,major,nice);

	k = 0;
	if (pcd_drive_count == 0) {  /* nothing spec'd - so autoprobe for 1 */
	    unit = 0;
	    if (pi_init(PI,1,-1,-1,-1,-1,-1,pcd_buffer,
                     PI_PCD,verbose,PCD.name)) {
		if (!pcd_probe(unit,-1,id)) {
			PCD.present = 1;
			k++;
		} else pi_release(PI);
	    }

	} else for (unit=0;unit<PCD_UNITS;unit++) if (DU[D_PRT])
	    if (pi_init(PI,0,DU[D_PRT],DU[D_MOD],DU[D_UNI],
                        DU[D_PRO],DU[D_DLY],pcd_buffer,PI_PCD,verbose,
                        PCD.name)) {
		if (!pcd_probe(unit,DU[D_SLV],id)) {
                        PCD.present = 1;
                        k++;
                } else pi_release(PI);
            }

	if (k) return 0;
	
	printk("%s: No CDrom drive found\n",name);
	return -1;
}

/* I/O request processing */

static int pcd_ready( void )

{	int	unit = pcd_unit;

	return (((RR(1,6)&(IDE_BUSY|IDE_DRQ))==IDE_DRQ)) ;
}

static void pcd_transfer( void )

{	int	k, o;

	while (pcd_count && (pcd_sector/4 == pcd_bufblk)) {
		o = (pcd_sector % 4) * 512;
		for(k=0;k<512;k++) pcd_buf[k] = pcd_buffer[o+k];
		pcd_count--;
		pcd_buf += 512;
		pcd_sector++;
	}
}

static void pcd_start( void )

{	int	unit = pcd_unit;
	int	b, i;
	char	rd_cmd[12] = {0xa8,0,0,0,0,0,0,0,0,1,0,0};
	long    saved_flags;

	pcd_bufblk = pcd_sector / 4;
        b = pcd_bufblk;
	for(i=0;i<4;i++) { 
	   rd_cmd[5-i] = b & 0xff;
	   b = b >> 8;
	}

	if (pcd_command(unit,rd_cmd,2048,"read block")) {
		pcd_bufblk = -1; 
		spin_lock_irqsave(&io_request_lock,saved_flags);
		pcd_busy = 0;
		end_request(0);
		do_pcd_request();
		spin_unlock_irqrestore(&io_request_lock,saved_flags);
		return;
	}

	udelay(1000);

	ps_set_intr(do_pcd_read_drq,pcd_ready,PCD_TMO,nice);

}

static void do_pcd_read( void )


{	int	unit = pcd_unit;
	long    saved_flags;

	pcd_busy = 1;
	pcd_retries = 0;
	pcd_transfer();
	if (!pcd_count) {
		spin_lock_irqsave(&io_request_lock,saved_flags);
		end_request(1);
		pcd_busy = 0;
		do_pcd_request();
		spin_unlock_irqrestore(&io_request_lock,saved_flags);
		return;
	}

	pi_do_claimed(PI,pcd_start);
}

static void do_pcd_read_drq( void )

{	int	unit = pcd_unit;
	long    saved_flags;

	if (pcd_completion(unit,pcd_buffer,"read block")) {
                if (pcd_retries < PCD_RETRIES) {
                        udelay(1000);
                        pcd_retries++;
			pi_do_claimed(PI,pcd_start);
                        return;
                        }
		spin_lock_irqsave(&io_request_lock,saved_flags);
		pcd_busy = 0;
		pcd_bufblk = -1;
		end_request(0);
		do_pcd_request();
		spin_unlock_irqrestore(&io_request_lock,saved_flags);
		return;
	}

	do_pcd_read();
	spin_lock_irqsave(&io_request_lock,saved_flags);
	do_pcd_request();
	spin_unlock_irqrestore(&io_request_lock,saved_flags); 
}
	
/* end of pcd.c */