ld -r xx xx.o -N"misc/scsi"

struct scsi_device {
        struct scsi_address           sd_address;    /* opaque address */
        dev_info_t                    *sd_dev;       /* device node */
        kmutex_t                      sd_mutex;
        void                          *sd_reserved;
        struct scsi_inquiry           *sd_inq;
        struct scsi_extended_sense    *sd_sense;
        caddr_t                       sd_private;
};

Data structure that is passed to the SCSI resource allocation routines.

Pointer to the target's dev_info structure.

Mutex for use by the target driver. This is initialized by the host bus adapter driver and can be used by the target driver as a per-device mutex. Do not hold this mutex across a call to scsi_transport(9F) or scsi_poll(9F). See Chapter 3, Multithreading for more information on mutexes.

Pointer for the target device's SCSI inquiry data. The scsi_probe(9F) routine allocates a buffer, fills it in with inquiry data, and attaches it to this field.

Pointer to a buffer to contain SCSI request sense data from the device. The target driver must allocate and manage this buffer itself; see "attach() Entry Point (SCSI Target Drivers)".

Pointer field for use by the target driver. It is commonly used to store a pointer to a private target driver state structure.

struct scsi_pkt {
        opaque_t  pkt_ha_private;        /* private data for host adapter */
        struct scsi_address pkt_address; /* destination packet is for */
        opaque_t  pkt_private;           /* private data for target driver */
        void     (*pkt_comp)(struct scsi_pkt *); /* completion routine */
        uint_t   pkt_flags;              /* flags */
        int      pkt_time;               /* time allotted to complete command */
        uchar_t  *pkt_scbp;              /* pointer to status block */
        uchar_t  *pkt_cdbp;              /* pointer to command block */
        ssize_t  pkt_resid;              /* data bytes not transferred */
        uint_t   pkt_state;              /* state of command */
        uint_t   pkt_statistics;         /* statistics */
        uchar_t  pkt_reason;             /* reason completion called */
};

Target device's address set by scsi_init_pkt(9F).

Place to store private data for the target driver. It is commonly used to save the buf(9S) pointer for the command.

Address of the completion routine. The host bus adapter driver calls this routine when it has transported the command. This does not mean that the command succeeded; the target might have been busy or might not have responded before the time-out time elapsed (see the description for pkt_time field). The target driver must supply a valid value in this field, though it can be NULL if the driver does not want to be notified.

Provides additional control information, for example, to transport the command without disconnect privileges (FLAG_NODISCON) or to disable callbacks (FLAG_NOINTR). See the scsi_pkt(9S) man page for details.

Time-out value (in seconds). If the command is not completed within this time, the host bus adapter calls the completion routine with pkt_reason set to CMD_TIMEOUT. The target driver should set this field to longer than the maximum time the command might take. If the timeout is zero, no timeout is requested. Timeout starts when the command is transmitted on the SCSI bus.

Pointer to the SCSI status completion block; this is filled in by the host bus adapter driver.

Pointer to the SCSI command descriptor block, the actual command to be sent to the target device. The host bus adapter driver does not interpret this field. The target driver must fill it in with a command that the target device can process.

Residual of the operation. When allocating DMA resources for a command scsi_init_pkt(9F), pkt_resid indicates the number of bytes for which DMA resources could not be allocated because of DMA hardware scatter-gather or other device limitations. After command transport, pkt_resid indicates the number of data bytes not transferred; this is filled in by the host bus adapter driver before the completion routine is called.

Indicates the state of the command. The host bus adapter driver fills in this field as the command progresses. One bit is set in this field for each of the five following command states:

• STATE_GOT_BUS - Acquired the bus

• STATE_GOT_TARGET - Selected the target

• STATE_SENT_CMD - Sent the command

• STATE_XFERRED_DATA - Transferred data (if appropriate)

• STATE_GOT_STATUS - Received status from the device

Contains transport-related statistics set by the host bus adapter driver.

Gives the reason the completion routine was called. The main function of the completion routine is to decode this field and take the appropriate action. If the command completed--in other words, if there were no transport errors--this field is set to CMD_CMPLT; other values in this field indicate an error. After a command is completed, the target driver should examine the pkt_scbp field for a check condition status. See the scsi_pkt(9S) man page for more information.

static int
xxprobe(dev_info_t *dip)
{
    struct scsi_device *sdp;
    int rval, target, lun;
    /*
     * Get a pointer to the scsi_device(9S) structure
     */
    sdp = (struct scsi_device *)ddi_get_driver_private(dip);

    target = sdp->sd_address.a_target;
    lun = sdp->sd_address.a_lun;
    /*
     * Call scsi_probe(9F) to send the Inquiry command. It will
     * fill in the sd_inq field of the scsi_device structure.
     */
    switch (scsi_probe(sdp, NULL_FUNC)) {
    case SCSIPROBE_FAILURE:
    case SCSIPROBE_NORESP:
    case SCSIPROBE_NOMEM:
           /*
            * In these cases, device may be powered off,
            * in which case we may be able to successfully
            * probe it at some future time - referred to
            * as `deferred attach'.
            */
            rval = DDI_PROBE_PARTIAL;
            break;
    case SCSIPROBE_NONCCS:
    default:
            /*
             * Device isn't of the type we can deal with,
             * and/or it will never be usable.
             */
            rval = DDI_PROBE_FAILURE;
            break;
    case SCSIPROBE_EXISTS:
            /*
             * There is a device at the target/lun address. Check
             * inq_dtype to make sure that it is the right device
             * type. See scsi_inquiry(9S)for possible device types.
             */
            switch (sdp->sd_inq->inq_dtype) {
            case DTYPE_PRINTER:
                scsi_log(sdp, "xx", SCSI_DEBUG,
                   "found %s device at target%d, lun%d\n",
                    scsi_dname((int)sdp->sd_inq->inq_dtype),
                    target, lun);
                rval = DDI_PROBE_SUCCESS;
                break;
            case DTYPE_NOTPRESENT:
            default:
                rval = DDI_PROBE_FAILURE;
                break;     
            }    
    }
    scsi_unprobe(sdp);
    return (rval);
}