scsi_disk.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

				iox->io_cnt) != 0){
		    reterr = EFAULT;
		    break;
		}
		if ((reterr = rzcommand (dev, SZ_WRITEL, 1, 0)) == EINTR) {
			break;
		}
		if(sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf("rzspecial: %s unit %d: write lond data failed\n",
		    sc->sc_device[targid], unit);
		    reterr = EIO;
		    break;
	        }
		break;
	
	case SCSI_READ_LONG:
		iox = (struct io_uxfer *)data;
		if( iox->io_cnt > sizeof(*dd) ){
		    reterr = EINVAL;
		    break;
		}
		bcopy(data, sc->sc_rzparams[targid], sizeof(*iox));
		if ((reterr = rzcommand (dev, SZ_READL, 1, 0)) == EINTR) {
			break;
		}
		if(sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf("rzspecial: %s unit %d: read lond data failed\n",
		    sc->sc_device[targid], unit);
		    reterr = EIO;
		    break;
	        }
		/*
		 * Copy out the read long data to user space.
		 */
		if(copyout(sc->sc_rzaddr[targid], iox->io_addr, 
				iox->io_cnt) != 0)
		    reterr = EFAULT;
		break;

	case SCSI_VERIFY_DATA:
		bcopy(data, sc->sc_rzparams[targid], sizeof(*vp));
		if ((reterr = rzcommand (dev, SZ_VFY_DATA, 1, 0)) == EINTR) {
			break;
		}
		if(sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf("rzspecial: %s unit %d: verify data failed\n",
		    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;
	
	case SCSI_MODE_SENSE:
		if ((reterr = rzcommand (dev, SZ_MODSNS, 1, 0)) == EINTR) {
			break;
		}
		if(sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf("rzspecial: %s unit %d: mode sense failed\n",
		    sc->sc_device[targid], unit);
		    reterr = EIO;
		    break;
	        }
		/*
		 * Copy out the mode sense data to user space.
		 */
		if(copyout(sc->sc_rzaddr[targid], msp->msp_addr, 
				msp->msp_length) != 0)
		    reterr = EFAULT;
		break;
	
	case SCSI_MODE_SELECT:
		/*
		 * Must be super user to CHANGE the disk parameters.
		 */
		if ( !(sc->sc_devtyp[targid] & SZ_CDROM) && !suser() ) {
		    	reterr = EACCES;
			break;
		}
		/*
		 * Copy in the mode select data from user space.
		 */
		if(copyin(msp->msp_addr, sc->sc_rzaddr[targid],
				msp->msp_length) != 0) {
			reterr = EFAULT;
			break;
		}
		if ((reterr = rzcommand (dev, SZ_MODSEL, 1, 0)) == EINTR) {
			break;
		}
		if(sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf("rzspecial: %s unit %d: mode select failed\n",
		    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;

	case SCSI_GET_SENSE:
		es = (struct extended_sense *)data;
		bcopy((char *)&sc->sc_rzsns[targid], data, sizeof(*es));
		bzero((char *)&sc->sc_rzsns[targid], 
				sizeof(sc->sc_rzsns[targid]));
		break;

	case SCSI_GET_INQUIRY_DATA:
		if ((reterr = rzcommand (dev, SZ_INQ, 1, 0)) == EINTR) {
			break;
		}
		if(sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf("rzspecial: %s unit %d: inquiry failed\n",
		    sc->sc_device[targid], unit);
		    reterr = EIO;
		    break;
	        }
		if(copyout(sc->sc_rzaddr[targid], msp->msp_addr, 
				msp->msp_length) != 0)
		    reterr = EFAULT;
		break;
	
	case SCSI_READ_CAPACITY: {
		struct read_capacity *capacity;

		if ((reterr = rzcommand (dev, SZ_RDCAP, 1, 0)) == EINTR) {
			break;
		}
		if (sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf ("rzspecial: %s unit %d: read capacity failed\n",
					    sc->sc_device[targid], unit);
		    reterr = EIO;
		    break;
		}
		capacity = (struct read_capacity *)&sc->sz_dat[targid];
		bcopy (capacity, data, sizeof(*capacity));
		break;
	}
	case SCSI_ALLOW_REMOVAL:
		if ((reterr = rzcommand (dev, SZ_MEDREMOVAL, SZ_ALLOW_REMOVAL, 0)) == EINTR) {
			break;
		}
		if(sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf ("rzspecial: %s unit %d: allow removal failed\n",
					    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;

	case SCSI_PREVENT_REMOVAL:
		if ((reterr = rzcommand (dev, SZ_MEDREMOVAL, SZ_PREVENT_REMOVAL, 0)) == EINTR) {
			break;
		}
		if(sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf ("rzspecial: %s unit %d: prevent removal failed\n",
					    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;

	case SCSI_SEND_DIAGNOSTIC: {
		struct diagnostic_params *dp;

		dp = (struct diagnostic_params *)sc->sc_rzparams[targid];
		bcopy (data, dp, sizeof(*dp));
		if (dp->dp_length > rzaddr_length) {
			reterr = EINVAL;
			break;
		}
		/*
		 * Copy in the Diagnostic data (if any) from user space.
		 */
		if (dp->dp_length && dp->dp_buffer) {
		    if (copyin (dp->dp_buffer, sc->sc_rzaddr[targid],
				dp->dp_length) != 0) {
			reterr = EFAULT;
			break;
		    }
		}
		if ((reterr = rzcommand (dev, SZ_SNDDIAG, 1, 0)) == EINTR) {
			break;
		}
		if (sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf("rzspecial: %s unit %d: send diagnostic failed\n",
				    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;
	}
	case SCSI_RECEIVE_DIAGNOSTIC: {
		struct diagnostic_params *dp;

		dp = (struct diagnostic_params *)sc->sc_rzparams[targid];
		bcopy (data, dp, sizeof(*dp));
		if (dp->dp_length > rzaddr_length) {
			reterr = EINVAL;
			break;
		}
		if ((reterr = rzcommand (dev, SZ_RECDIAG, 1, 0)) == EINTR) {
			break;
		}
		if (sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf("rzspecial: %s unit %d: receive diagnostic failed\n",
				    sc->sc_device[targid], unit);
		    reterr = EIO;
		    break;
	        }
		/*
		 * Copy out the Diagnostic data (if any) to user space.
		 */
		if (dp->dp_length && dp->dp_buffer) {
		    if (copyout (sc->sc_rzaddr[targid], dp->dp_buffer,
				dp->dp_length) != 0) {
			reterr = EFAULT;
		    }
		}
		break;
	}
	case CDROM_EJECT_CADDY:
		if ((reterr = rzcommand (dev, SZ_P_EJECT, 1, 0)) == EINTR) {
			break;
		}
		if(sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf ("rzspecial: %s unit %d: eject failed\n",
					    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;

	case CDROM_PAUSE_PLAY:
		if ((reterr = rzcommand (dev, SZ_PAUSE_RESUME, SZ_AUDIO_PAUSE, 0)) == EINTR) {
			break;
		}
		if(sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf ("rzspecial: %s unit %d: pause failed\n",
					    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;

	case CDROM_RESUME_PLAY:
		if ((reterr = rzcommand (dev, SZ_PAUSE_RESUME, SZ_AUDIO_RESUME, 0)) == EINTR) {
			break;
		}
		if(sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf ("rzspecial: %s unit %d: resume failed\n",
					    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;

	case CDROM_PLAY_AUDIO:
	case CDROM_PLAY_VAUDIO: {
		register struct cd_play_audio *pa;
		int scsi_cmd;

		pa = (struct cd_play_audio *) data;
		bcopy (data, sc->sc_rzparams[targid], sizeof(*pa));
		if (cmd == CDROM_PLAY_AUDIO) {
			scsi_cmd = SZ_PLAY_AUDIO;
		} else {
			scsi_cmd = SZ_PLAY_VAUDIO;
		}
		if ((reterr = rzcommand (dev, scsi_cmd, 1, 0)) == EINTR) {
			break;
		}
		if (sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf ("rzspecial: %s unit %d: play audio failed\n",
					    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;
	}
	case CDROM_PLAY_MSF:
	case CDROM_PLAY_AUDIO_MSF: {
		register struct cd_play_audio_msf *msf;
		int scsi_cmd;

		msf = (struct cd_play_audio_msf *) data;
		bcopy (data, sc->sc_rzparams[targid], sizeof(*msf));
		if (cmd == CDROM_PLAY_MSF) {
			scsi_cmd = SZ_PLAY_MSF;
		} else {
			scsi_cmd = SZ_PLAY_AUDIO_MSF;
		}
		if ((reterr = rzcommand (dev, scsi_cmd, 1, 0)) == EINTR) {
			break;
		}
		if (sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf ("rzspecial: %s unit %d: play audio MSF failed\n",
					    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;
	}
	case CDROM_PLAY_AUDIO_TI: {
		register struct cd_play_audio_ti *ti;

		ti = (struct cd_play_audio_ti *) data;
		bcopy (data, sc->sc_rzparams[targid], sizeof(*ti));
		if ((reterr = rzcommand (dev, SZ_PLAY_AUDIO_TI, 1, 0)) == EINTR) {
			break;
		}
		if (sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf ("rzspecial: %s unit %d: play audio track/index failed\n",
					    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;
	}
	case CDROM_PLAY_AUDIO_TR: {
		register struct cd_play_audio_tr *tr;

		tr = (struct cd_play_audio_tr *) data;
		bcopy (data, sc->sc_rzparams[targid], sizeof(*tr));
		if ((reterr = rzcommand (dev, SZ_PLAY_TRACK_REL, 1, 0)) == EINTR) {
			break;
		}
		if (sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf ("rzspecial: %s unit %d: play track relative failed\n",
					    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;
	}
	case CDROM_PLAY_TRACK: {
		register struct cd_play_track *pt;

		pt = (struct cd_play_track *) data;
		bcopy (data, sc->sc_rzparams[targid], sizeof(*pt));
		if ((reterr = rzcommand (dev, SZ_PLAY_TRACK, 1, 0)) == EINTR) {
			break;
		}
		if (sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf ("rzspecial: %s unit %d: play track failed\n",
					    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;
	}
	case SCSI_START_UNIT:
		if ((reterr = rzcommand (dev, SZ_P_SSUNIT, SZ_START_UNIT, 0)) == EINTR) {
			break;
		}
		if (sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf ("rzspecial: %s unit %d: start failed\n",
					    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;

	case SCSI_STOP_UNIT:
		if ((reterr = rzcommand (dev, SZ_P_SSUNIT, SZ_STOP_UNIT, 0)) == EINTR) {
			break;
		}
		if (sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf ("rzspecial: %s unit %d: stop failed\n",
					    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;

	case SCSI_SEEK_POSITION: {
		u_long seek_address;

		seek_address = *(u_long *) data;
		if ((reterr = rzcommand (dev, SZ_SEEK_10, seek_address, 0)) == EINTR) {
			break;
		}
		if (sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf ("rzspecial: %s unit %d: seek position\n",
					    sc->sc_device[targid], unit);
		    reterr = EIO;
	        }
		break;
	}
	case CDROM_TOC_HEADER: {
		register struct cd_toc *toc;
		register struct cd_toc_header *th;

		toc = (struct cd_toc *)sc->sc_rzparams[targid];
		th = (struct cd_toc_header *)sc->sc_rzaddr[targid];
		toc->toc_starting_track = 0;
		toc->toc_alloc_length = sizeof(*th);
		if ((reterr = rzcommand (dev, SZ_READ_TOC, 1, 0)) == EINTR) {
			break;
		}
		if (sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf("rzspecial: %s unit %d: read TOC failed\n",
				    sc->sc_device[targid], unit);
		    reterr = EIO;
		    break;
	        }
		bcopy (th, data, sizeof(*th));
		break;
	}
	case CDROM_TOC_ENTRYS: {
		register struct cd_toc *toc;
		register struct cd_toc_header *th;
		int toc_length;

		toc = (struct cd_toc *)sc->sc_rzparams[targid];
		bcopy (data, toc, sizeof(*toc));
		if (toc->toc_alloc_length > rzaddr_length) {
			reterr = EINVAL;
			break;
		}
		if ((reterr = rzcommand (dev, SZ_READ_TOC, 1, 0)) == EINTR) {
			break;
		}
		if (sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf("rzspecial: %s unit %d: read TOC entry failed\n",
				    sc->sc_device[targid], unit);
		    reterr = EIO;
		    break;
	        }
		th = (struct cd_toc_header *)sc->sc_rzaddr[targid];
		/*
		 * Calculate the TOC length.
		 */
		toc_length = (int) (((th->th_data_len1 << 8) +
			      th->th_data_len0) + sizeof(*th)) & 0xffff;

		if (toc_length > rzaddr_length) {
		    PRINTD (targid, 0x20,
	     ("rzspecial: toc_length (%d) > rzaddr_length (%d), adjusting...\n",
						toc_length, rzaddr_length));
		    toc_length = rzaddr_length;
		}
		/*
		 * Copy out the TOC header & entries to user space.
		 */
		if (copyout (th, toc->toc_buffer, toc_length) != 0) {
		    reterr = EFAULT;
		}
		break;
	}
	case CDROM_READ_SUBCHANNEL: {
		register struct cd_sub_channel *sch;
		register struct cd_subc_header *sh;
		int subc_length;

		sch = (struct cd_sub_channel *)sc->sc_rzparams[targid];
		bcopy (data, sch, sizeof(*sch));
		if (sch->sch_alloc_length > rzaddr_length) {
			reterr = EINVAL;
			break;
		}
		if ((reterr = rzcommand (dev, SZ_READ_SUBCHAN, 1, 0)) == EINTR) {
			break;
		}
		if (sc->sc_c_status[targid] != SZ_GOOD) {
		    mprintf("rzspecial: %s unit %d: read sub-channel failed\n",
				    sc->sc_device[targid], unit);
		    reterr = EIO;
		    break;
	        }
		sh = (struct cd_subc_header *)sc->sc_rzaddr[targid];
		/*
		 * Calculate the Sub-Channel length.
		 */
		subc_length = (int) (((sh->sh_data_len1 << 8) +
				sh->sh_data_len0) + sizeof(*sh)) & 0xffff;

		if (subc_length > rzaddr_length) {
		    mprintf("rzspecial: %s unit %d: subc_length (%d) > rzaddr_length (%d)\n",
		    sc->sc_device[targid], unit, subc_length, rzaddr_length);
		    reterr = EFAULT;
		    break;
		}
		/*
		 * Copy out the Sub-Channel information to user space.
		 */
		if (copyout (sh, sch->sch_buffer, subc_length) != 0) {
		    reterr = EFAULT;