pcd.c

这个linux源代码是很全面的~基本完整了~使用c编译的~由于时间问题我没有亲自测试~但就算用来做参考资料也是非常好的

	        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);
			}
		    mdelay(1);
	        } 
		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, c;

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

	PCD.last_sense = -1;  c = 2;
	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]);
	    c = buf[2]&0xf;
	    PCD.last_sense = c | ((buf[12]&0xff)<<8) | ((buf[13]&0xff)<<16);
        } 
	if ((c == 2) || (c == 6)) PCD.changed = 1;
}

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

{	int r;

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

static int pcd_packet(struct cdrom_device_info *cdi,
				struct cdrom_generic_command *cgc)
{
	char	*un_cmd;
	int	unit = DEVICE_NR(cdi->dev);

	un_cmd = cgc->cmd;
	return pcd_atapi(unit,un_cmd,cgc->buflen,cgc->buffer, "generic packet");
}

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

static int pcd_media_changed(struct cdrom_device_info *cdi, int slot_nr)

{	int 	r;
	int	unit = DEVICE_NR(cdi->dev);

	r = PCD.changed;
	PCD.changed = 0;

	return r;    
}

static int pcd_lock_door(struct cdrom_device_info *cdi, int lock)

{	char	un_cmd[12] = { 0x1e,0,0,0,lock,0,0,0,0,0,0,0 };
        int     unit = DEVICE_NR(cdi->dev);

	return pcd_atapi(unit,un_cmd,0,pcd_scratch,
				lock?"lock door":"unlock door");
}

static int pcd_tray_move(struct cdrom_device_info *cdi, int position)

{	char	ej_cmd[12] = { 0x1b,0,0,0,3-position,0,0,0,0,0,0,0 };
	int	unit = DEVICE_NR(cdi->dev);

	return pcd_atapi(unit,ej_cmd,0,pcd_scratch,
				position?"eject":"close tray");
}

static void pcd_sleep( int cs )

{       current->state = TASK_INTERRUPTIBLE;
        schedule_timeout(cs);
}

static int pcd_reset( int unit )

{	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(20*HZ/1000);  		/* delay a bit */

	k = 0;
	while ((k++ < PCD_RESET_TMO) && (RR(1,6)&IDE_BUSY))
		pcd_sleep(HZ/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_drive_reset(struct cdrom_device_info *cdi)

{	return pcd_reset(DEVICE_NR(cdi->dev));
}

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(HZ);
        }
        return 0x000020;        /* timeout */
}

static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr)

{	char    rc_cmd[12] = { 0x25,0,0,0,0,0,0,0,0,0,0,0};
	int	unit = DEVICE_NR(cdi->dev);

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

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 CD-ROM\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 void pcd_probe_capabilities( void )

{	int	unit, r;
	char	buffer[32];
	char 	cmd[12]={0x5a,1<<3,0x2a,0,0,0,0,18,0,0,0,0};

	for (unit=0;unit<PCD_UNITS;unit++) {
		if (!PCD.present) continue;
		r = pcd_atapi(unit,cmd,18, buffer,"mode sense capabilities");
		if (r) continue;
		/* we should now have the cap page */
		if ((buffer[11] & 1) == 0)
			PCD.info.mask |= CDC_CD_R;
		if ((buffer[11] & 2) == 0)
			PCD.info.mask |= CDC_CD_RW;
		if ((buffer[12] & 1) == 0)
			PCD.info.mask |= CDC_PLAY_AUDIO;
		if ((buffer[14] & 1) == 0)
			PCD.info.mask |= CDC_LOCK;
		if ((buffer[14] & 8) == 0)
			PCD.info.mask |= CDC_OPEN_TRAY;
		if ((buffer[14] >> 6) == 0)
			PCD.info.mask |= CDC_CLOSE_TRAY;
	}
}

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 CD-ROM drive found\n",name);
	return -1;
}

/* I/O request processing */

static void do_pcd_request (request_queue_t * q)

{       int unit;

	if (pcd_busy) return;
        while (1) {
	    if (QUEUE_EMPTY || (CURRENT->rq_status == RQ_INACTIVE)) return;
	    INIT_REQUEST;
	    if (CURRENT->cmd == READ) {
		unit = MINOR(CURRENT->rq_dev);
		if (unit != pcd_unit) {
			pcd_bufblk = -1;
			pcd_unit = unit;
		}
	        pcd_sector = CURRENT->sector;
	        pcd_count = CURRENT->current_nr_sectors;
	        pcd_buf = CURRENT->buffer;
		pcd_busy = 1;
	        ps_set_intr(do_pcd_read,0,0,nice); 
		return;
	    } 
	    else end_request(0);
	}
}

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};
	unsigned 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(NULL);
		spin_unlock_irqrestore(&io_request_lock,saved_flags);
		return;
	}

	mdelay(1);

	ps_set_intr(do_pcd_read_drq,pcd_ready,PCD_TMO,nice);

}

static void do_pcd_read( void )


{	int	unit = pcd_unit;
	unsigned 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(NULL);
		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;
	unsigned long    saved_flags;

	if (pcd_completion(unit,pcd_buffer,"read block")) {
                if (pcd_retries < PCD_RETRIES) {
                        mdelay(1); 
                        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(NULL);
		spin_unlock_irqrestore(&io_request_lock,saved_flags);
		return;
	}

	do_pcd_read();
	spin_lock_irqsave(&io_request_lock,saved_flags);
	do_pcd_request(NULL);
	spin_unlock_irqrestore(&io_request_lock,saved_flags); 
}

/* the audio_ioctl stuff is adapted from sr_ioctl.c */

static int pcd_audio_ioctl(struct cdrom_device_info *cdi,
                                unsigned int cmd, void *arg)

{	int	unit = DEVICE_NR(cdi->dev);
 
    	switch (cmd) { 
    
    	case CDROMREADTOCHDR:
    
	{	char cmd[12]={GPCMD_READ_TOC_PMA_ATIP,0,0,0,0,0,0,0,12,0,0,0};
		struct cdrom_tochdr* tochdr = (struct cdrom_tochdr*)arg;
		char buffer[32];
		int r;
	
		r = pcd_atapi(unit,cmd,12,buffer,"read toc header");

		tochdr->cdth_trk0 = buffer[2];
		tochdr->cdth_trk1 = buffer[3];
	
		return r * EIO;
    	}
	
    	case CDROMREADTOCENTRY:

    	{	char cmd[12]={GPCMD_READ_TOC_PMA_ATIP,0,0,0,0,0,0,0,12,0,0,0};

		struct cdrom_tocentry* tocentry = (struct cdrom_tocentry*)arg;
		unsigned char buffer[32];
		int	r;
	
		cmd[1] = (tocentry->cdte_format == CDROM_MSF ? 0x02 : 0);
		cmd[6] = tocentry->cdte_track;
	
		r = pcd_atapi(unit,cmd,12,buffer,"read toc entry");

        	tocentry->cdte_ctrl = buffer[5] & 0xf;	
        	tocentry->cdte_adr = buffer[5] >> 4;
        	tocentry->cdte_datamode = (tocentry->cdte_ctrl & 0x04)?1:0;
		if (tocentry->cdte_format == CDROM_MSF) {
		    tocentry->cdte_addr.msf.minute = buffer[9];
	    	    tocentry->cdte_addr.msf.second = buffer[10];
	            tocentry->cdte_addr.msf.frame = buffer[11];
	        } else
	            tocentry->cdte_addr.lba = 
				(((((buffer[8] << 8) + buffer[9]) << 8)
                                       + buffer[10]) << 8) + buffer[11];
	
                return r * EIO;
        }

    	default:

        	return -ENOSYS;
    	}
}
	
static int pcd_get_mcn (struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)

{	char 	cmd[12]={GPCMD_READ_SUBCHANNEL,0,0x40,2,0,0,0,0,24,0,0,0};
        char 	buffer[32];
	int	k;
	int	unit = DEVICE_NR(cdi->dev);

        if (pcd_atapi(unit,cmd,24,buffer,"get mcn")) return -EIO;

	for (k=0;k<13;k++) mcn->medium_catalog_number[k] = buffer[k+9];
	mcn->medium_catalog_number[13] = 0;
	
	return 0;
}

/* end of pcd.c */

MODULE_LICENSE("GPL");