isp_inline.h

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

{
	if (ISP_IS_SBUS(isp)) {
		ISP_IOXGET_8(isp, &hpsrc->rqs_entry_type,
		    hpdst->rqs_entry_count);
		ISP_IOXGET_8(isp, &hpsrc->rqs_entry_count,
		    hpdst->rqs_entry_type);
		ISP_IOXGET_8(isp, &hpsrc->rqs_seqno,
		    hpdst->rqs_flags);
		ISP_IOXGET_8(isp, &hpsrc->rqs_flags,
		    hpdst->rqs_seqno);
	} else {
		ISP_IOXGET_8(isp, &hpsrc->rqs_entry_type,
		    hpdst->rqs_entry_type);
		ISP_IOXGET_8(isp, &hpsrc->rqs_entry_count,
		    hpdst->rqs_entry_count);
		ISP_IOXGET_8(isp, &hpsrc->rqs_seqno,
		    hpdst->rqs_seqno);
		ISP_IOXGET_8(isp, &hpsrc->rqs_flags,
		    hpdst->rqs_flags);
	}
}

static INLINE int
isp_get_response_type(struct ispsoftc *isp, isphdr_t *hp)
{
	u_int8_t type;
	if (ISP_IS_SBUS(isp)) {
		ISP_IOXGET_8(isp, &hp->rqs_entry_count, type);
	} else {
		ISP_IOXGET_8(isp, &hp->rqs_entry_type, type);
	}
	return ((int)type);
}

static INLINE void
isp_put_request(struct ispsoftc *isp, ispreq_t *rqsrc, ispreq_t *rqdst)
{
	int i;
	isp_copy_out_hdr(isp, &rqsrc->req_header, &rqdst->req_header);
	ISP_IOXPUT_32(isp, rqsrc->req_handle, &rqdst->req_handle);
	if (ISP_IS_SBUS(isp)) {
		ISP_IOXPUT_8(isp, rqsrc->req_lun_trn, &rqdst->req_target);
		ISP_IOXPUT_8(isp, rqsrc->req_target, &rqdst->req_lun_trn);
	} else {
		ISP_IOXPUT_8(isp, rqsrc->req_lun_trn, &rqdst->req_lun_trn);
		ISP_IOXPUT_8(isp, rqsrc->req_target, &rqdst->req_target);
	}
	ISP_IOXPUT_16(isp, rqsrc->req_cdblen, &rqdst->req_cdblen);
	ISP_IOXPUT_16(isp, rqsrc->req_flags, &rqdst->req_flags);
	ISP_IOXPUT_16(isp, rqsrc->req_time, &rqdst->req_time);
	ISP_IOXPUT_16(isp, rqsrc->req_seg_count, &rqdst->req_seg_count);
	for (i = 0; i < 12; i++) {
		ISP_IOXPUT_8(isp, rqsrc->req_cdb[i], &rqdst->req_cdb[i]);
	}
	for (i = 0; i < ISP_RQDSEG; i++) {
		ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_base,
		    &rqdst->req_dataseg[i].ds_base);
		ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_count,
		    &rqdst->req_dataseg[i].ds_count);
	}
}

static INLINE void
isp_put_request_t2(struct ispsoftc *isp, ispreqt2_t *tqsrc, ispreqt2_t *tqdst)
{
	int i;
	isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
	ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
	ISP_IOXPUT_8(isp, tqsrc->req_lun_trn, &tqdst->req_lun_trn);
	ISP_IOXPUT_8(isp, tqsrc->req_target, &tqdst->req_target);
	ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
	ISP_IOXPUT_16(isp, tqsrc->req_flags,  &tqdst->req_flags);
	ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2);
	ISP_IOXPUT_16(isp, tqsrc->req_time, &tqdst->req_time);
	ISP_IOXPUT_16(isp, tqsrc->req_seg_count, &tqdst->req_seg_count);
	for (i = 0; i < 16; i++) {
		ISP_IOXPUT_8(isp, tqsrc->req_cdb[i], &tqdst->req_cdb[i]);
	}
	ISP_IOXPUT_32(isp, tqsrc->req_totalcnt, &tqdst->req_totalcnt);
	for (i = 0; i < ISP_RQDSEG_T2; i++) {
		ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base,
		    &tqdst->req_dataseg[i].ds_base);
		ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
		    &tqdst->req_dataseg[i].ds_count);
	}
}

static INLINE void
isp_put_request_t3(struct ispsoftc *isp, ispreqt3_t *tqsrc, ispreqt3_t *tqdst)
{
	int i;
	isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
	ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
	ISP_IOXPUT_8(isp, tqsrc->req_lun_trn, &tqdst->req_lun_trn);
	ISP_IOXPUT_8(isp, tqsrc->req_target, &tqdst->req_target);
	ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
	ISP_IOXPUT_16(isp, tqsrc->req_flags,  &tqdst->req_flags);
	ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2);
	ISP_IOXPUT_16(isp, tqsrc->req_time, &tqdst->req_time);
	ISP_IOXPUT_16(isp, tqsrc->req_seg_count, &tqdst->req_seg_count);
	for (i = 0; i < 16; i++) {
		ISP_IOXPUT_8(isp, tqsrc->req_cdb[i], &tqdst->req_cdb[i]);
	}
	ISP_IOXPUT_32(isp, tqsrc->req_totalcnt, &tqdst->req_totalcnt);
	for (i = 0; i < ISP_RQDSEG_T2; i++) {
		ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base,
		    &tqdst->req_dataseg[i].ds_base);
		ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_basehi,
		    &tqdst->req_dataseg[i].ds_basehi);
		ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
		    &tqdst->req_dataseg[i].ds_count);
	}
}

static INLINE void
isp_put_extended_request(struct ispsoftc *isp, ispextreq_t *xqsrc,
    ispextreq_t *xqdst)
{
	int i;
	isp_copy_out_hdr(isp, &xqsrc->req_header, &xqdst->req_header);
	ISP_IOXPUT_32(isp, xqsrc->req_handle, &xqdst->req_handle);
	if (ISP_IS_SBUS(isp)) {
		ISP_IOXPUT_8(isp, xqsrc->req_lun_trn, &xqdst->req_target);
		ISP_IOXPUT_8(isp, xqsrc->req_target, &xqdst->req_lun_trn);
	} else {
		ISP_IOXPUT_8(isp, xqsrc->req_lun_trn, &xqdst->req_lun_trn);
		ISP_IOXPUT_8(isp, xqsrc->req_target, &xqdst->req_target);
	}
	ISP_IOXPUT_16(isp, xqsrc->req_cdblen, &xqdst->req_cdblen);
	ISP_IOXPUT_16(isp, xqsrc->req_flags, &xqdst->req_flags);
	ISP_IOXPUT_16(isp, xqsrc->req_time, &xqdst->req_time);
	ISP_IOXPUT_16(isp, xqsrc->req_seg_count, &xqdst->req_seg_count);
	for (i = 0; i < 44; i++) {
		ISP_IOXPUT_8(isp, xqsrc->req_cdb[i], &xqdst->req_cdb[i]);
	}
}

static INLINE void
isp_put_cont_req(struct ispsoftc *isp, ispcontreq_t *cqsrc, ispcontreq_t *cqdst)
{
	int i;
	isp_copy_out_hdr(isp, &cqsrc->req_header, &cqdst->req_header);
	for (i = 0; i < ISP_CDSEG; i++) {
		ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_base,
		    &cqdst->req_dataseg[i].ds_base);
		ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_count,
		    &cqdst->req_dataseg[i].ds_count);
	}
}

static INLINE void
isp_put_cont64_req(struct ispsoftc *isp, ispcontreq64_t *cqsrc,
    ispcontreq64_t *cqdst)
{
	int i;
	isp_copy_out_hdr(isp, &cqsrc->req_header, &cqdst->req_header);
	for (i = 0; i < ISP_CDSEG64; i++) {
		ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_base,
		    &cqdst->req_dataseg[i].ds_base);
		ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_basehi,
		    &cqdst->req_dataseg[i].ds_basehi);
		ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_count,
		    &cqdst->req_dataseg[i].ds_count);
	}
}

static INLINE void
isp_get_response(struct ispsoftc *isp, ispstatusreq_t *spsrc,
    ispstatusreq_t *spdst)
{
	int i;
	isp_copy_in_hdr(isp, &spsrc->req_header, &spdst->req_header);
	ISP_IOXGET_32(isp, &spsrc->req_handle, spdst->req_handle);
	ISP_IOXGET_16(isp, &spsrc->req_scsi_status, spdst->req_scsi_status);
	ISP_IOXGET_16(isp, &spsrc->req_completion_status,
	    spdst->req_completion_status);
	ISP_IOXGET_16(isp, &spsrc->req_state_flags, spdst->req_state_flags);
	ISP_IOXGET_16(isp, &spsrc->req_status_flags, spdst->req_status_flags);
	ISP_IOXGET_16(isp, &spsrc->req_time, spdst->req_time);
	ISP_IOXGET_16(isp, &spsrc->req_sense_len, spdst->req_sense_len);
	ISP_IOXGET_32(isp, &spsrc->req_resid, spdst->req_resid);
	for (i = 0; i < 8; i++) {
		ISP_IOXGET_8(isp, &spsrc->req_response[i],
		    spdst->req_response[i]);
	}
	for (i = 0; i < 32; i++) {
		ISP_IOXGET_8(isp, &spsrc->req_sense_data[i],
		    spdst->req_sense_data[i]);
	}
}

static INLINE void
isp_get_response_x(struct ispsoftc *isp, ispstatus_cont_t *cpsrc,
    ispstatus_cont_t *cpdst)
{
	int i;
	isp_copy_in_hdr(isp, &cpsrc->req_header, &cpdst->req_header);
	for (i = 0; i < 60; i++) {
		ISP_IOXGET_8(isp, &cpsrc->req_sense_data[i],
		    cpdst->req_sense_data[i]);
	}
}

static INLINE void
isp_get_rio2(struct ispsoftc *isp, isp_rio2_t *r2src, isp_rio2_t *r2dst)
{
	int i;
	isp_copy_in_hdr(isp, &r2src->req_header, &r2dst->req_header);
	if (r2dst->req_header.rqs_seqno > 30)
		r2dst->req_header.rqs_seqno = 30;
	for (i = 0; i < r2dst->req_header.rqs_seqno; i++) {
		ISP_IOXGET_16(isp, &r2src->req_handles[i],
		    r2dst->req_handles[i]);
	}
	while (i < 30) {
		r2dst->req_handles[i++] = 0;
	}
}

static INLINE void
isp_put_icb(struct ispsoftc *isp, isp_icb_t *Is, isp_icb_t *Id)
{
	int i;
	ISP_SWAP8(Is->icb_version, Is->_reserved0);
	ISP_IOXPUT_8(isp, Is->icb_version, &Id->icb_version);
	ISP_IOXPUT_8(isp, Is->_reserved0, &Id->_reserved0);
	ISP_IOXPUT_16(isp, Is->icb_fwoptions, &Id->icb_fwoptions);
	ISP_IOXPUT_16(isp, Is->icb_maxfrmlen, &Id->icb_maxfrmlen);
	ISP_IOXPUT_16(isp, Is->icb_maxalloc, &Id->icb_maxalloc);
	ISP_IOXPUT_16(isp, Is->icb_execthrottle, &Id->icb_execthrottle);
	ISP_SWAP8(Is->icb_retry_count, Is->icb_retry_delay);
	ISP_IOXPUT_8(isp, Is->icb_retry_count, &Id->icb_retry_count);
	ISP_IOXPUT_8(isp, Is->icb_retry_delay, &Id->icb_retry_delay);
	for (i = 0; i < 8; i++) {
		ISP_IOXPUT_8(isp, Is->icb_portname[i], &Id->icb_portname[i]);
	}
	ISP_IOXPUT_16(isp, Is->icb_hardaddr, &Id->icb_hardaddr);
	ISP_SWAP8(Is->icb_iqdevtype, Is->icb_logintime);
	ISP_IOXPUT_8(isp, Is->icb_iqdevtype, &Id->icb_iqdevtype);
	ISP_IOXPUT_8(isp, Is->icb_logintime, &Id->icb_logintime);
	for (i = 0; i < 8; i++) {
		ISP_IOXPUT_8(isp, Is->icb_nodename[i], &Id->icb_nodename[i]);
	}
	ISP_IOXPUT_16(isp, Is->icb_rqstout, &Id->icb_rqstout);
	ISP_IOXPUT_16(isp, Is->icb_rspnsin, &Id->icb_rspnsin);
	ISP_IOXPUT_16(isp, Is->icb_rqstqlen, &Id->icb_rqstqlen);
	ISP_IOXPUT_16(isp, Is->icb_rsltqlen, &Id->icb_rsltqlen);
	for (i = 0; i < 4; i++) {
		ISP_IOXPUT_16(isp, Is->icb_rqstaddr[i], &Id->icb_rqstaddr[i]);
	}
	for (i = 0; i < 4; i++) {
		ISP_IOXPUT_16(isp, Is->icb_respaddr[i], &Id->icb_respaddr[i]);
	}
	ISP_IOXPUT_16(isp, Is->icb_lunenables, &Id->icb_lunenables);
	ISP_SWAP8(Is->icb_ccnt, Is->icb_icnt);
	ISP_IOXPUT_8(isp, Is->icb_ccnt, &Id->icb_ccnt);
	ISP_IOXPUT_8(isp, Is->icb_icnt, &Id->icb_icnt);
	ISP_IOXPUT_16(isp, Is->icb_lunetimeout, &Id->icb_lunetimeout);
	ISP_IOXPUT_16(isp, Is->icb_xfwoptions, &Id->icb_xfwoptions);
	ISP_SWAP8(Is->icb_racctimer, Is->icb_idelaytimer);
	ISP_IOXPUT_8(isp, Is->icb_racctimer, &Id->icb_racctimer);
	ISP_IOXPUT_8(isp, Is->icb_idelaytimer, &Id->icb_idelaytimer);
	ISP_IOXPUT_16(isp, Is->icb_zfwoptions, &Id->icb_zfwoptions);
}

static INLINE void
isp_get_pdb(struct ispsoftc *isp, isp_pdb_t *src, isp_pdb_t *dst)
{
	int i;
	ISP_IOXGET_16(isp, &src->pdb_options, dst->pdb_options);
        ISP_IOXGET_8(isp, &src->pdb_mstate, dst->pdb_mstate);
        ISP_IOXGET_8(isp, &src->pdb_sstate, dst->pdb_sstate);
	for (i = 0; i < 4; i++) {
		ISP_IOXGET_8(isp, &src->pdb_hardaddr_bits[i],
		    dst->pdb_hardaddr_bits[i]);
	}
	for (i = 0; i < 4; i++) {
		ISP_IOXGET_8(isp, &src->pdb_portid_bits[i],
		    dst->pdb_portid_bits[i]);
	}
	for (i = 0; i < 8; i++) {
		ISP_IOXGET_8(isp, &src->pdb_nodename[i], dst->pdb_nodename[i]);
	}
	for (i = 0; i < 8; i++) {
		ISP_IOXGET_8(isp, &src->pdb_portname[i], dst->pdb_portname[i]);
	}
	ISP_IOXGET_16(isp, &src->pdb_execthrottle, dst->pdb_execthrottle);
	ISP_IOXGET_16(isp, &src->pdb_exec_count, dst->pdb_exec_count);
	ISP_IOXGET_8(isp, &src->pdb_retry_count, dst->pdb_retry_count);
	ISP_IOXGET_8(isp, &src->pdb_retry_delay, dst->pdb_retry_delay);
	ISP_IOXGET_16(isp, &src->pdb_resalloc, dst->pdb_resalloc);
	ISP_IOXGET_16(isp, &src->pdb_curalloc, dst->pdb_curalloc);
	ISP_IOXGET_16(isp, &src->pdb_qhead, dst->pdb_qhead);
	ISP_IOXGET_16(isp, &src->pdb_qtail, dst->pdb_qtail);
	ISP_IOXGET_16(isp, &src->pdb_tl_next, dst->pdb_tl_next);
	ISP_IOXGET_16(isp, &src->pdb_tl_last, dst->pdb_tl_last);
	ISP_IOXGET_16(isp, &src->pdb_features, dst->pdb_features);
	ISP_IOXGET_16(isp, &src->pdb_pconcurrnt, dst->pdb_pconcurrnt);
	ISP_IOXGET_16(isp, &src->pdb_roi, dst->pdb_roi);
	ISP_IOXGET_8(isp, &src->pdb_target, dst->pdb_target);
	ISP_IOXGET_8(isp, &src->pdb_initiator, dst->pdb_initiator);
	ISP_IOXGET_16(isp, &src->pdb_rdsiz, dst->pdb_rdsiz);
	ISP_IOXGET_16(isp, &src->pdb_ncseq, dst->pdb_ncseq);
	ISP_IOXGET_16(isp, &src->pdb_noseq, dst->pdb_noseq);
	ISP_IOXGET_16(isp, &src->pdb_labrtflg, dst->pdb_labrtflg);
	ISP_IOXGET_16(isp, &src->pdb_lstopflg, dst->pdb_lstopflg);
	ISP_IOXGET_16(isp, &src->pdb_sqhead, dst->pdb_sqhead);
	ISP_IOXGET_16(isp, &src->pdb_sqtail, dst->pdb_sqtail);
	ISP_IOXGET_16(isp, &src->pdb_ptimer, dst->pdb_ptimer);
	ISP_IOXGET_16(isp, &src->pdb_nxt_seqid, dst->pdb_nxt_seqid);
	ISP_IOXGET_16(isp, &src->pdb_fcount, dst->pdb_fcount);
	ISP_IOXGET_16(isp, &src->pdb_prli_len, dst->pdb_prli_len);
	ISP_IOXGET_16(isp, &src->pdb_prli_svc0, dst->pdb_prli_svc0);
	ISP_IOXGET_16(isp, &src->pdb_prli_svc3, dst->pdb_prli_svc3);
	ISP_IOXGET_16(isp, &src->pdb_loopid, dst->pdb_loopid);
	ISP_IOXGET_16(isp, &src->pdb_il_ptr, dst->pdb_il_ptr);
	ISP_IOXGET_16(isp, &src->pdb_sl_ptr, dst->pdb_sl_ptr);
}


/*
 * CT_HDR canonicalization- only needed for SNS responses
 */
static INLINE void
isp_get_ct_hdr(struct ispsoftc *isp, ct_hdr_t *src, ct_hdr_t *dst)
{
	ISP_IOXGET_8(isp, &src->ct_revision, dst->ct_revision);
	ISP_IOXGET_8(isp, &src->ct_portid[0], dst->ct_portid[0]);
	ISP_IOXGET_8(isp, &src->ct_portid[1], dst->ct_portid[1]);
	ISP_IOXGET_8(isp, &src->ct_portid[2], dst->ct_portid[2]);
	ISP_IOXGET_8(isp, &src->ct_fcs_type, dst->ct_fcs_type);
	ISP_IOXGET_8(isp, &src->ct_fcs_subtype, dst->ct_fcs_subtype);
	ISP_IOXGET_8(isp, &src->ct_options, dst->ct_options);
	ISP_IOXGET_8(isp, &src->ct_res0, dst->ct_res0);
	ISP_IOXGET_16(isp, &src->ct_response, dst->ct_response);
	dst->ct_response = (dst->ct_response << 8) | (dst->ct_response >> 8);
	ISP_IOXGET_16(isp, &src->ct_resid, dst->ct_resid);
	dst->ct_resid = (dst->ct_resid << 8) | (dst->ct_resid >> 8);
	ISP_IOXGET_8(isp, &src->ct_res1, dst->ct_res1);
	ISP_IOXGET_8(isp, &src->ct_reason, dst->ct_reason);
	ISP_IOXGET_8(isp, &src->ct_explanation, dst->ct_explanation);
	ISP_IOXGET_8(isp, &src->ct_vunique, dst->ct_vunique);
}

/*
 * Generic SNS request - not particularly useful since the per-command data
 * isn't always 16 bit words.
 */
static INLINE void
isp_put_sns_request(struct ispsoftc *isp, sns_screq_t *src, sns_screq_t *dst)
{
	int i, nw = (int) src->snscb_sblen;
	ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
	for (i = 0; i < 4; i++) {
		ISP_IOXPUT_16(isp, src->snscb_addr[i], &dst->snscb_addr[i]);
	}
	ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
	for (i = 0; i < nw; i++) {
		ISP_IOXPUT_16(isp, src->snscb_data[i], &dst->snscb_data[i]);
	}
	
}

static INLINE void
isp_put_gid_ft_request(struct ispsoftc *isp, sns_gid_ft_req_t *src,
    sns_gid_ft_req_t *dst)
{
	ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
	ISP_IOXPUT_16(isp, src->snscb_res0, &dst->snscb_res0);
	ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
	ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);