Autoconfiguration for SCSI Target Drivers
SCSI target drivers must implement the standard autoconfiguration routines _init(9E), _fini(9E), and _info(9E).
See Loadable Driver Interfaces for more information.
The following routines are also required, but these routines must perform specific SCSI
and SCSA processing:
probe() Entry Point (SCSI Target Drivers)
SCSI target devices are not self-identifying, so target drivers must have a probe(9E)
routine. This routine must determine whether the expected type of device is present
and responding.
The general structure and the return codes of the probe(9E) routine
are the same as the structure and return codes for other device drivers.
SCSI target drivers must use the scsi_probe(9F) routine in their probe(9E)
entry point. scsi_probe(9F) sends a SCSI inquiry command to the device and
returns a code that indicates the result. If the SCSI inquiry command is
successful, scsi_probe(9F) allocates a scsi_inquiry(9S) structure and fills the structure in with
the device's inquiry data. Upon return from scsi_probe(9F), the sd_inq field of
the scsi_device(9S) structure points to this scsi_inquiry(9S) structure.
Because probe(9E) must be stateless, the target driver must call scsi_unprobe(9F)
before probe(9E) returns, even if scsi_probe(9F) fails.
Example 17-1 shows a typical probe(9E) routine. The routine in the example retrieves the scsi_device(9S)
structure from the private field of its dev_info structure. The routine also retrieves the
device's SCSI target and logical unit numbers for printing in messages. The
probe(9E) routine then calls scsi_probe(9F) to verify that the expected device, a printer
in this case, is present.
If successful, scsi_probe(9F) attaches the device's SCSI inquiry data in a
scsi_inquiry(9S) structure to the sd_inq field of the scsi_device(9S) structure. The driver can then
determine whether the device type is a printer, which is reported in the
inq_dtype field. If the device is a printer, the type is reported with
scsi_log(9F), using scsi_dname(9F) to convert the device type into a string.
Example 17-1 SCSI Target Driver probe(9E) Routine
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 might be powered off,
* in which case we might 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);
}A more thorough probe(9E) routine could check scsi_inquiry(9S) to make sure
that the device is of the type expected by a particular driver.
attach() Entry Point (SCSI Target Drivers)
After the probe(9E) routine has verified that the expected device is present, attach(9E)
is called. attach() performs these tasks:
Allocates and initializes any per-instance data.
Creates minor device node information.
Restores the hardware state of a device after a suspension of the device or the system. See attach() Entry Point for details.
A SCSI target driver needs to call scsi_probe(9F) again to retrieve the
device's inquiry data. The driver must also create a SCSI request sense packet.
If the attach is successful, the attach() function should not call scsi_unprobe(9F).
Three routines are used to create the request sense packet: scsi_alloc_consistent_buf(9F), scsi_init_pkt(9F),
and scsi_setup_cdb(9F). scsi_alloc_consistent_buf(9F) allocates a buffer that is suitable for consistent DMA. scsi_alloc_consistent_buf()
then returns a pointer to a buf(9S) structure. The advantage of a
consistent buffer is that no explicit synchronization of the data is required. In
other words, the target driver can access the data after the callback. The
sd_sense element of the device's scsi_device(9S) structure must be initialized with the address
of the sense buffer. scsi_init_pkt(9F) creates and partially initializes a scsi_pkt(9S) structure. scsi_setup_cdb(9F)
creates a SCSI command descriptor block, in this case by creating a SCSI
request sense command.
Note that a SCSI device is not self-identifying and does not have a
reg property. As a result, the driver must set the pm-hardware-state property. Setting
pm-hardware-state informs the framework that this device needs to be suspended and then
resumed.
The following example shows the SCSI target driver's attach() routine.
Example 17-2 SCSI Target Driver attach(9E) Routine
static int
xxattach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
struct xxstate *xsp;
struct scsi_pkt *rqpkt = NULL;
struct scsi_device *sdp;
struct buf *bp = NULL;
int instance;
instance = ddi_get_instance(dip);
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
/* For information, see the "Directory Memory Access (DMA)" */
/* chapter in this book. */
default:
return (DDI_FAILURE);
}
/*
* Allocate a state structure and initialize it.
*/
xsp = ddi_get_soft_state(statep, instance);
sdp = (struct scsi_device *)ddi_get_driver_private(dip);
/*
* Cross-link the state and scsi_device(9S) structures.
*/
sdp->sd_private = (caddr_t)xsp;
xsp->sdp = sdp;
/*
* Call scsi_probe(9F) again to get and validate inquiry data.
* Allocate a request sense buffer. The buf(9S) structure
* is set to NULL to tell the routine to allocate a new one.
* The callback function is set to NULL_FUNC to tell the
* routine to return failure immediately if no
* resources are available.
*/
bp = scsi_alloc_consistent_buf(&sdp->sd_address, NULL,
SENSE_LENGTH, B_READ, NULL_FUNC, NULL);
if (bp == NULL)
goto failed;
/*
* Create a Request Sense scsi_pkt(9S) structure.
*/
rqpkt = scsi_init_pkt(&sdp->sd_address, NULL, bp,
CDB_GROUP0, 1, 0, PKT_CONSISTENT, NULL_FUNC, NULL);
if (rqpkt == NULL)
goto failed;
/*
* scsi_alloc_consistent_buf(9F) returned a buf(9S) structure.
* The actual buffer address is in b_un.b_addr.
*/
sdp->sd_sense = (struct scsi_extended_sense *)bp->b_un.b_addr;
/*
* Create a Group0 CDB for the Request Sense command
*/
if (scsi_setup_cdb((union scsi_cdb *)rqpkt->pkt_cdbp,
SCMD_REQUEST_SENSE, 0, SENSE__LENGTH, 0) == 0)
goto failed;;
/*
* Fill in the rest of the scsi_pkt structure.
* xxcallback() is the private command completion routine.
*/
rqpkt->pkt_comp = xxcallback;
rqpkt->pkt_time = 30; /* 30 second command timeout */
rqpkt->pkt_flags |= FLAG_SENSING;
xsp->rqs = rqpkt;
xsp->rqsbuf = bp;
/*
* Create minor nodes, report device, and do any other initialization. */
* Since the device does not have the 'reg' property,
* cpr will not call its DDI_SUSPEND/DDI_RESUME entries.
* The following code is to tell cpr that this device
* needs to be suspended and resumed.
*/
(void) ddi_prop_update_string(device, dip,
"pm-hardware-state", "needs-suspend-resume");
xsp->open = 0;
return (DDI_SUCCESS);
failed:
if (bp)
scsi_free_consistent_buf(bp);
if (rqpkt)
scsi_destroy_pkt(rqpkt);
sdp->sd_private = (caddr_t)NULL;
sdp->sd_sense = NULL;
scsi_unprobe(sdp);
/* Free any other resources, such as the state structure. */
return (DDI_FAILURE);
}
detach() Entry Point (SCSI Target Drivers)
The detach(9E) entry point is the inverse of attach(9E). detach() must free all
resources that were allocated in attach(). If successful, the detach should call
scsi_unprobe(9F). The following example shows a target driver detach() routine.
Example 17-3 SCSI Target Driver detach(9E) Routine
static int
xxdetach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
struct xxstate *xsp;
switch (cmd) {
case DDI_DETACH:
/*
* Normal detach(9E) operations, such as getting a
* pointer to the state structure
*/
scsi_free_consistent_buf(xsp->rqsbuf);
scsi_destroy_pkt(xsp->rqs);
xsp->sdp->sd_private = (caddr_t)NULL;
xsp->sdp->sd_sense = NULL;
scsi_unprobe(xsp->sdp);
/*
* Remove minor nodes.
* Free resources, such as the state structure and properties.
*/
return (DDI_SUCCESS);
case DDI_SUSPEND:
/* For information, see the "Directory Memory Access (DMA)" */
/* chapter in this book. */
default:
return (DDI_FAILURE);
}
}
getinfo() Entry Point (SCSI Target Drivers)
The getinfo(9E) routine for SCSI target drivers is much the same as for
other drivers (see getinfo() Entry Point for more information on DDI_INFO_DEVT2INSTANCE case). However, in the
DDI_INFO_DEVT2DEVINFO case of the getinfo() routine, the target driver must return a pointer
to its dev_info node. This pointer can be saved in the driver state
structure or can be retrieved from the sd_dev field of the scsi_device(9S)
structure. The following example shows an alternative SCSI target driver getinfo() code fragment.
Example 17-4 Alternative SCSI Target Driver getinfo() Code Fragment
case DDI_INFO_DEVT2DEVINFO:
dev = (dev_t)arg;
instance = getminor(dev);
xsp = ddi_get_soft_state(statep, instance);
if (xsp == NULL)
return (DDI_FAILURE);
*result = (void *)xsp->sdp->sd_dev;
return (DDI_SUCCESS);
