rzdisk.c

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

		    printstr("Set write cache enable (WCE) bit (y/n)? ");
		    if(confirm())
			ms.ms_page8.wce = 1;
		    else
			ms.ms_page8.wce = 0;
		}
		if(msc.ms_page8.wrp) {
		    printstr("Enter the write retention priority? ");
		    value = getinteger();
		    ms.ms_page8.wrp = value;
		}
		if(msc.ms_page8.drrp) {
		    printstr("Enter the demand read retention priority? ");
		    value = getinteger();
		    ms.ms_page8.drrp = value;
		}
		if(msc.ms_page8.dpftl1 || msc.ms_page8.dpftl0) {
		    printstr("Enter disable pre-fetch transfer length? ");
		    value = getinteger();
		    ms.ms_page8.dpftl1 = ((value >> 8) & 0xff);
		    ms.ms_page8.dpftl0 = ((value >> 0) & 0xff);
		}
		if(msc.ms_page8.minpf1 || msc.ms_page8.minpf0) {
		    printstr("Enter minimum pre-fetch value? ");
		    value = getinteger();
		    ms.ms_page8.minpf1 = ((value >> 8) & 0xff);
		    ms.ms_page8.minpf0 = ((value >> 0) & 0xff);
		}
		if(msc.ms_page8.maxpf1 || msc.ms_page8.maxpf0) {
		    printstr("Enter maximum pre-fetch value? ");
		    value = getinteger();
		    ms.ms_page8.maxpf1 = ((value >> 8) & 0xff);
		    ms.ms_page8.maxpf0 = ((value >> 0) & 0xff);
		}
		if(msc.ms_page8.maxpfc1 || msc.ms_page8.maxpfc0) {
		    printstr("Enter maximum pre-fetch ceiling value? ");
		    value = getinteger();
		    ms.ms_page8.maxpfc1 = ((value >> 8) & 0xff);
		    ms.ms_page8.maxpfc0 = ((value >> 0) & 0xff);
		}
	}
page37_ask:
	if(ms_page37.pgcode != 37)
		goto done_asking;
	printf("\nPage 37 DEC unique parameters:\n");
	printf("  PS\t\t\t\t\t%d\n", ms_page37.ps);
	printf("  Page code\t\t\t\t%d\n", ms_page37.pgcode);
	printf("  Page length\t\t\t\t%d\n", ms_page37.pglength);
	printf("  Spinup on power up\t\t\t%d\n", ms_page37.spinup);
	printstr("\nDo you want to change any fields in this page (y/n)? ");
	if(confirm()) {
		printstr("Have drive spinup on power on (y/n)? ");
		if(confirm())
		   	ms_page37.spinup = 0;
		else
		   	ms_page37.spinup = 1;
	}
done_asking:
	/*
	 * Cannot SAVE the parameters for the RRD40 disk.
	 */
	if(rrd40_disk)
		setps = 0;
	/*
	 * Can SAVE the parameters for the RZ22,RZ23,RZ55 disks.
	 */
	else {
		printstr("\nSAVE THE CHANGED VALUES ON DISK (y/n)? ");
		if(confirm())
			setps = 1;
		else
			setps = 0;
	}
	ms.ms_hdr.sense_len = 0;
	ms.ms_hdr.wp = 0;
	ms.ms_page1.ps = 0;
	ms.ms_page2.ps = 0;
	ms.ms_page3.ps = 0;
	ms.ms_page4.ps = 0;
	ms.ms_page8.ps = 0;
	ms.ms_page37.ps = 0;
	ms_page37.ps = 0;
	ms.ms_setps = setps;
	ms.ms_length = sizeof(ms) - 4;
	fix_mode_select_params();
	/* Adjust the length if no page 8 */
	if(ms.ms_page8.pgcode != 8) {
		ms.ms_length -= sizeof(ms.ms_page8);
		byteptr = (u_char *)&ms.ms_page8;
		bcopy((u_char *)&ms_page37, byteptr, sizeof(ms_page37));
	}
	else {
		ms.ms_page37 = ms_page37;
	}
	/* Adjust the length if no DEC unique page 37 */
	if(ms_page37.pgcode != 37)
		ms.ms_length -= sizeof(ms_page37);
	/* Adjust the length for the RZ22/RZ23 disks */
	if(rz22_rz23_disk) {
		ms.ms_length = ms.ms_length - sizeof(ms.ms_page2) -
			       sizeof(ms.ms_page3) - sizeof(ms.ms_page4);
		if(ms_page37.pgcode == 37) {
			byteptr = (u_char *)&ms.ms_page2;
			bcopy((char *)&ms_page37, byteptr, 
						sizeof(ms_page37));
		}
	}
	/* Adjust the length for the RRD40 disk */
	if(rrd40_disk) {
		ms.ms_length = ms.ms_length - sizeof(ms.ms_page2) -
				sizeof(ms.ms_page3) - sizeof(ms.ms_page4);
	}
	/*
	 * Change the disk drive parameters to their CHANGED values.
	 */
	printf("\nChanging disk drive parameters for device (%s).\n",
		rzdisk);
	if(execute_rzcmd(SCSI_MODE_SELECT, (char *)&ms) != SUCCESS) {
		if(geterror() != NO_ERROR)
			return;
	}
}

fix_mode_select_params()
{

	ms.ms_desc.density_code &= msc.ms_desc.density_code;
	ms.ms_desc.nblks2 &= msc.ms_desc.nblks2;
	ms.ms_desc.nblks1 &= msc.ms_desc.nblks1;
	ms.ms_desc.nblks0 &= msc.ms_desc.nblks0;
	ms.ms_page1.flags &= msc.ms_page1.flags;
	ms.ms_page1.retry_count &= msc.ms_page1.retry_count;
	ms.ms_page1.correct_span &= msc.ms_page1.correct_span;
	ms.ms_page1.head_offset &= msc.ms_page1.head_offset;
	ms.ms_page1.data_strobe &= msc.ms_page1.data_strobe;
	ms.ms_page1.recovery_time &= msc.ms_page1.recovery_time;
	ms.ms_page2.bus_fratio &= msc.ms_page2.bus_fratio;
	ms.ms_page2.bus_eratio &= msc.ms_page2.bus_eratio;
	ms.ms_page2.bus_inactive1 &= msc.ms_page2.bus_inactive1;
	ms.ms_page2.bus_inactive0 &= msc.ms_page2.bus_inactive0;
	ms.ms_page2.disconn_time1 &= msc.ms_page2.disconn_time1;
	ms.ms_page2.disconn_time0 &= msc.ms_page2.disconn_time0;
	ms.ms_page2.conn_time1 &= msc.ms_page2.conn_time1;
	ms.ms_page2.conn_time0 &= msc.ms_page2.conn_time0;
	ms.ms_page3.tpz1 &= msc.ms_page3.tpz1;
	ms.ms_page3.tpz0 &= msc.ms_page3.tpz0;
	ms.ms_page3.aspz1 &= msc.ms_page3.aspz1;
	ms.ms_page3.aspz0 &= msc.ms_page3.aspz0;
	ms.ms_page3.atpz1 &= msc.ms_page3.atpz1;
	ms.ms_page3.atpz0 &= msc.ms_page3.atpz0;
	ms.ms_page3.atpv1 &= msc.ms_page3.atpv1;
	ms.ms_page3.atpv0 &= msc.ms_page3.atpv0;
	ms.ms_page3.spt1 &= msc.ms_page3.spt1;
	ms.ms_page3.spt0 &= msc.ms_page3.spt0;
	ms.ms_page3.bps1 &= msc.ms_page3.bps1;
	ms.ms_page3.bps0 &= msc.ms_page3.bps0;
	ms.ms_page3.interleave1 &= msc.ms_page3.interleave1;
	ms.ms_page3.interleave0 &= msc.ms_page3.interleave0;
	ms.ms_page3.track_skew1 &= msc.ms_page3.track_skew1;
	ms.ms_page3.track_skew0 &= msc.ms_page3.track_skew0;
	ms.ms_page3.cylinder_skew1 &= msc.ms_page3.cylinder_skew1;
	ms.ms_page3.cylinder_skew0 &= msc.ms_page3.cylinder_skew0;
	ms.ms_page3.flags &= msc.ms_page3.flags;
	ms.ms_page4.ncyl2 &= msc.ms_page4.ncyl2;
	ms.ms_page4.ncyl1 &= msc.ms_page4.ncyl1;
	ms.ms_page4.ncyl0 &= msc.ms_page4.ncyl0;
	ms.ms_page4.nheads &= msc.ms_page4.nheads;
	ms.ms_page4.wprecomp2 &= msc.ms_page4.wprecomp2;
	ms.ms_page4.wprecomp1 &= msc.ms_page4.wprecomp1;
	ms.ms_page4.wprecomp0 &= msc.ms_page4.wprecomp0;
	ms.ms_page4.rwc2 &= msc.ms_page4.rwc2;
	ms.ms_page4.rwc1 &= msc.ms_page4.rwc1;
	ms.ms_page4.rwc0 &= msc.ms_page4.rwc0;
	ms.ms_page4.dsr1 &= msc.ms_page4.dsr1;
	ms.ms_page4.dsr0 &= msc.ms_page4.dsr0;
	ms.ms_page4.lzc1 &= msc.ms_page4.lzc1;
	ms.ms_page4.lzc0 &= msc.ms_page4.lzc0;
	ms.ms_page8.rc &= msc.ms_page8.rc;
	ms.ms_page8.ms &= msc.ms_page8.ms;
	ms.ms_page8.wce &= msc.ms_page8.wce;
	ms.ms_page8.wrp &= msc.ms_page8.wrp;
	ms.ms_page8.drrp &= msc.ms_page8.drrp;
	ms.ms_page8.dpftl1 &= msc.ms_page8.dpftl1;
	ms.ms_page8.dpftl0 &= msc.ms_page8.dpftl0;
	ms.ms_page8.minpf1 &= msc.ms_page8.minpf1;
	ms.ms_page8.minpf0 &= msc.ms_page8.minpf0;
	ms.ms_page8.maxpf1 &= msc.ms_page8.maxpf1;
	ms.ms_page8.maxpf0 &= msc.ms_page8.maxpf0;
	ms.ms_page8.maxpfc1 &= msc.ms_page8.maxpfc1;
	ms.ms_page8.maxpfc0 &= msc.ms_page8.maxpfc0;
}

get_inquiry_info()
{
    
    char hold[20];
    int i;

	printf("\nGetting inquiry data info from device (%s).\n", rzdisk);
	bzero((char *)&inq, sizeof(inq));
	if(execute_rzcmd(SCSI_GET_INQUIRY_DATA, (char *)&inq) != SUCCESS) {
		if(geterror() != NO_ERROR)
			return;
	}
    	printf("\nDump of Inquiry Data:\n");
    	printf("  Peripheral Device Type\t\t0x%x\n",inq.perfdt);
    	printf("  Device Type Qualifier\t\t\t0x%x\n",inq.devtq);
    	printf("  Removable Medium\t\t\t0x%x\n",inq.rmb);
    	printf("  Version\t\t\t\t0x%x\n",inq.version);
    	for(i=0; i<8; i++)
		hold[i] = inq.vndrid[i];
    	hold[i] = '\0';
    	printf("  Vendor Identificaton\t\t\t%s\n", hold);
    	for(i=0; i<16; i++)
		hold[i] = inq.prodid[i];
    	hold[i] = '\0';
    	printf("  Product Identification\t\t%s\n", hold);
    	for(i=0; i<4; i++)
		hold[i] = inq.revlvl[i];
    	hold[i] = '\0';
    	printf("  Revision Level\t\t\t%s\n", hold);
}

get_drive_parameters(page_control)
{

	char strtype[20];
	struct page_code_1 ms_page1;
	struct page_code_2 ms_page2;
	struct page_code_3 ms_page3;
	struct page_code_4 ms_page4;
	struct page_code_8 ms_page8;
	struct page_code_37 ms_page37;
	u_char *byteptr;
	int i;

	bzero((char *)&ms, sizeof(ms));
	ms.ms_pgcode = 0x3f;
	ms.ms_length = sizeof(ms) - 4;
	ms.ms_pgctrl = page_control;
	/*
	 * Get the CURRENT, DEFAULT, SAVED, or CHANGEABLE disk drive
	 * parameters based on the page control value.
	 */
	if(page_control == CURRENT_VALUES)
	    strcpy(strtype,"CURRENT");
	else if(page_control == DEFAULT_VALUES)
	    strcpy(strtype,"DEFAULT");
	else if(page_control == SAVED_VALUES)
	    strcpy(strtype,"SAVED");
	else if(page_control == CHANGED_VALUES)
	    strcpy(strtype,"CHANGEABLE");
	printf("\nGetting %s disk drive parameters from device (%s).\n",
			strtype,rzdisk);
	if(execute_rzcmd(SCSI_MODE_SENSE, (char *)&ms) != SUCCESS) {
		if(geterror() != NO_ERROR)
			return;
	}
	/*
	 * Display the parameters to the user. All parameters are
	 * displayed in (Decimal), all flags in (Hex). If the page
	 * code is CHANGEABLE then all fields are displayed in (Hex)
	 * to show the bit pattern of all the bits that can be changed.
	 */
	printf("\nMode sense header:\n");
	printf("  Sense data length\t\t\t%d\n", ms.ms_hdr.sense_len);
	printf("  Medium type\t\t\t\t%d\n", ms.ms_hdr.medium_type);
	printf("  WP\t\t\t\t\t0x%02x\n", ms.ms_hdr.wp);
	printf("  Block descriptor length\t\t%d\n", ms.ms_hdr.blk_des_len);

	printf("\nBlock descriptor:\n");
	printf("  Density code\t\t\t\t%d\n", ms.ms_desc.density_code);
	printf("  Number of blocks\t\t\t%d\n", 
			((ms.ms_desc.nblks2<<16) + 
				(ms.ms_desc.nblks1<<8) + ms.ms_desc.nblks0));
	if(page_control == CHANGED_VALUES && ms.ms_desc.blklen2 == 0xff &&
		ms.ms_desc.blklen1 == 0xff && ms.ms_desc.blklen0 == 0xff) {
		printf("  Block length\t\t\t\t0x%x\n", 
			((ms.ms_desc.blklen2<<16) + 
				(ms.ms_desc.blklen1<<8) + ms.ms_desc.blklen0));
	}
	else {
		printf("  Block length\t\t\t\t%d\n", 
			((ms.ms_desc.blklen2<<16) + 
				(ms.ms_desc.blklen1<<8) + ms.ms_desc.blklen0));
	}
page1_display:
	byteptr = (u_char *)&ms.ms_page1;
	ms_page1 = *((struct page_code_1 *)byteptr);
	if(ms_page1.pgcode == 1) {
		if(ms_page1.pglength == 0) {
			byteptr += 2;
			goto page2_display;
		}
		if(!moreoutput())
			return;
	    	printf("\nPage 1 error recovery parameters:\n");
	    	printf("  PS\t\t\t\t\t%d\n", ms_page1.ps);
	    	printf("  Page code\t\t\t\t%d\n", ms_page1.pgcode);
	    	printf("  Page length\t\t\t\t%d\n", ms_page1.pglength);
		if(page_control == CHANGED_VALUES) {
	    		printf("  Flags\t\t\t\t\t0x%x\n", ms_page1.flags);
	    		printf("  Retry count\t\t\t\t0x%x\n", 
					ms_page1.retry_count);
	    		printf("  Correction span\t\t\t0x%x\n", 
					ms_page1.correct_span);
	    		printf("  Head offset count\t\t\t0x%x\n", 
					ms_page1.head_offset);
	    		printf("  Data strobe offset count\t\t0x%x\n", 
					ms_page1.data_strobe);
	    		printf("  Recovery time limit\t\t\t0x%x\n", 
					ms_page1.recovery_time);
		}
		else {
	    		printf("  Flags\t\t\t\t\t0x%02x\n", ms_page1.flags);
	    		printf("  Retry count\t\t\t\t%d\n", 
					ms_page1.retry_count);
	    		printf("  Correction span\t\t\t%d\n", 
					ms_page1.correct_span);
	    		printf("  Head offset count\t\t\t%d\n", 
					ms_page1.head_offset);
	    		printf("  Data strobe offset count\t\t%d\n", 
					ms_page1.data_strobe);
	    		printf("  Recovery time limit\t\t\t%d\n", 
					ms_page1.recovery_time);
		}
		byteptr += sizeof(ms_page1);
	}
	
page2_display:
	ms_page2 = *((struct page_code_2 *)byteptr);
	if(ms_page2.pgcode == 2) {
		if(ms_page2.pglength == 0) {
			byteptr += 2;
			goto page3_display;
		}
		if(!moreoutput())
			return;
		printf("\nPage 2 disconnect/reconnect parameters:\n");
		printf("  PS\t\t\t\t\t%d\n", ms_page2.ps);
		printf("  Page code\t\t\t\t%d\n", ms_page2.pgcode);
		printf("  Page length\t\t\t\t%d\n", ms_page2.pglength);
		if(page_control == CHANGED_VALUES) {
			printf("  Buffer full ratio\t\t\t0x%x\n", 
				ms_page2.bus_fratio);
			printf("  Buffer empty ratio\t\t\t0x%x\n", 
				ms_page2.bus_eratio);
			printf("  Bus inactivity limit\t\t\t0x%x\n", 
				((ms_page2.bus_inactive1<<8) +
					ms_page2.bus_inactive0));
			printf("  Disconnect time limit\t\t\t0x%x\n",
				((ms_page2.disconn_time1<<8) +
					ms_page2.disconn_time0));
			printf("  Connect time limit\t\t\t0x%x\n", 
				((ms_page2.conn_time1<<8) +
					ms_page2.conn_time0));
		}
		else {
			printf("  Buffer full ratio\t\t\t%d\n", 
				ms_page2.bus_fratio);
			printf("  Buffer empty ratio\t\t\t%d\n", 
				ms_page2.bus_eratio);
			printf("  Bus inactivity limit\t\t\t%d\n", 
				((ms_page2.bus_inactive1<<8) +
					ms_page2.bus_inactive0));
			printf("  Disconnect time limit\t\t\t%d\n",
				((ms_page2.disconn_time1<<8) +
					ms_page2.disconn_time0));
			printf("  Connect time limit\t\t\t%d\n", 
				((ms_page2.conn_time1<<8) +
					ms_page2.conn_time0));
		}
		byteptr += sizeof(ms_page2);
	}
	
page3_display:
	ms_page3 = *((struct page_code_3 *)byteptr);
	if(ms_page3.pgcode == 3) {
		if(ms_page3.pglength == 0) {
			byteptr += 2;
			goto page4_display;
		}
		if(!moreoutput())
			return;
		printf("\nPage 3 direct-access device format parameters:\n");
		printf("  PS\t\t\t\t\t%d\n", ms_page3.ps);
		printf("  Page code\t\t\t\t%d\n", ms_page3.pgcode);
		printf("  Page length\t\t\t\t%d\n", ms_page3.pglength);
		if(page_control == CHANGED_VALUES) {
			printf("  Tracks per zone\t\t\t0x%x\n", 
				((ms_page3.tpz1<<8) + ms_page3.tpz0));
			printf("  Alternate sectors per zone\t\t0x%x\n", 
				((ms_page3.aspz1<<8) + ms_page3.aspz0));
			printf("  Alternate tracks per zone\t\t0x%x\n", 
				((ms_page3.atpz1<<8) + ms_page3.atpz0));
			printf("  Alternate tracks per volume\t\t0x%x\n", 
				((ms_page3.atpv1<<8) + ms_page3.atpv0));
			printf("  Sectors per track\t\t\t0x%x\n", 
				((ms_page3.spt1<<8) + ms_page3.spt0));
			printf("  Data bytes per phy sector\t\t0x%x\n", 
				((ms_page3.bps1<<8) + ms_page3.bps0));
			printf("  Interleave\t\t\t\t0x%x\n", 
				((ms_page3.interleave1<<8) + 
					ms_page3.interleave0));
			printf("  Track skew\t\t\t\t0x%x\n", 
				((ms_page3.track_skew1<<8) + 
					ms_page3.track_skew0));
			printf("  Cylinder skew\t\t\t\t0x%x\n", 
				((ms_page3.cylinder_skew1<<8) + 
					ms_page3.cylinder_skew0));
			printf("  Flags\t\t\t\t\t0x%x\n", ms_page3.flags);
		}
		else {
			printf("  Tracks per zone\t\t\t%d\n", 
				((ms_page3.tpz1<<8) + ms_page3.tpz0));
			printf("  Alternate sectors per zone\t\t%d\n", 
				((ms_page3.aspz1<<8) + ms_page3.aspz0));
			printf("  Alternate tracks per zone\t\t%d\n", 
				((ms_page3.atpz1<<8) + ms_page3.atpz0));
			printf("  Alternate tracks per volume\t\t%d\n", 
				((ms_page3.atpv1<<8) + ms_page3.atpv0));
			printf("  Sectors per track\t\t\t%d\n", 
				((ms_page3.spt1<<8) + ms_page3.spt0));
			printf("  Data bytes per phy sector\t\t%d\n", 
				((ms_page3.bps1<<8) + ms_page3.bps0));
			printf("  Interleave\t\t\t\t%d\n", 
				((ms_page3.interleave1<<8) + 
					ms_page3.interleave0));
			printf("  Track skew\t\t\t\t%d\n", 
				((ms_page3.track_skew1<<8) + 
					ms_page3.track_skew0));
			printf("  Cylinder skew\t\t\t\t%d\n", 
				((ms_page3.cylinder_skew1<<8) + 
					ms_page3.cylinder_skew0));
			printf("  Flags\t\t\t\t\t0x%02x\n", ms_page3.flags);
		}
		byteptr += sizeof(ms_page3);
	}
	
page4_display: