2 * Copyright (c) 2001-2003 Thomas Quinot <thomas@cuivre.fr.eu.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer,
10 * without modification, immediately at the beginning of the file.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 * $FreeBSD: src/sys/dev/ata/atapi-cam.c,v 1.44 2006/03/31 08:09:05 sos Exp $
29 * $DragonFly: src/sys/dev/disk/nata/atapi-cam.c,v 1.10.2.1 2008/11/19 08:31:26 hasso Exp $
35 #include <sys/param.h>
37 #include <sys/libkern.h>
38 #include <sys/lock.h> /* for {get,rel}_mplock() */
39 #include <sys/malloc.h>
40 #include <sys/module.h>
42 #include <sys/spinlock.h>
43 #include <sys/spinlock2.h>
44 #include <sys/queue.h>
45 #include <sys/systm.h>
46 #include <sys/thread2.h>
48 #include <bus/cam/cam.h>
49 #include <bus/cam/cam_ccb.h>
50 #include <bus/cam/cam_periph.h>
51 #include <bus/cam/cam_sim.h>
52 #include <bus/cam/cam_xpt_sim.h>
53 #include <bus/cam/cam_debug.h>
54 #include <bus/cam/scsi/scsi_all.h>
59 /* private data associated with an ATA bus */
60 struct atapi_xpt_softc
{
61 struct ata_device atapi_cam_dev
; /* must be first */
64 struct ata_channel
*ata_ch
;
65 struct cam_path
*path
;
68 #define BUS_REGISTERED 0x01
69 #define RESOURCE_SHORTAGE 0x02
70 #define DETACHING 0x04
72 TAILQ_HEAD(,atapi_hcb
) pending_hcbs
;
73 struct ata_device
*atadev
[2];
74 struct spinlock state_lock
;
77 /* hardware command descriptor block */
79 struct atapi_xpt_softc
*softc
;
87 #define AUTOSENSE 0x0002
89 TAILQ_ENTRY(atapi_hcb
) chain
;
92 enum reinit_reason
{ ATTACH
, RESET
};
95 static void atapi_cam_identify(device_t
*dev
, device_t parent
);
96 static int atapi_cam_probe(device_t dev
);
97 static int atapi_cam_attach(device_t dev
);
98 static int atapi_cam_detach(device_t dev
);
99 static int atapi_cam_reinit(device_t dev
);
101 /* CAM XPT methods */
102 static void atapi_action(struct cam_sim
*, union ccb
*);
103 static void atapi_poll(struct cam_sim
*);
104 static void atapi_async(void *, u_int32_t
, struct cam_path
*, void *);
105 static void atapi_cb(struct ata_request
*);
108 static int atapi_cam_event_handler(module_t mod
, int what
, void *arg
);
110 /* internal functions */
111 static void reinit_bus(struct atapi_xpt_softc
*scp
, enum reinit_reason reason
);
112 static void setup_async_cb(struct atapi_xpt_softc
*, uint32_t);
113 static void cam_rescan_callback(struct cam_periph
*, union ccb
*);
114 static void cam_rescan(struct cam_sim
*);
115 static void free_hcb_and_ccb_done(struct atapi_hcb
*, u_int32_t
);
116 static struct atapi_hcb
*allocate_hcb(struct atapi_xpt_softc
*, int, int, union ccb
*);
117 static void free_hcb(struct atapi_hcb
*hcb
);
118 static void free_softc(struct atapi_xpt_softc
*scp
);
120 static MALLOC_DEFINE(M_ATACAM
, "ata_cam", "ATA driver CAM-XPT layer");
122 static device_method_t atapi_cam_methods
[] = {
123 DEVMETHOD(device_identify
, atapi_cam_identify
),
124 DEVMETHOD(device_probe
, atapi_cam_probe
),
125 DEVMETHOD(device_attach
, atapi_cam_attach
),
126 DEVMETHOD(device_detach
, atapi_cam_detach
),
127 DEVMETHOD(ata_reinit
, atapi_cam_reinit
),
131 static driver_t atapi_cam_driver
= {
134 sizeof(struct atapi_xpt_softc
)
137 static devclass_t atapi_cam_devclass
;
138 DRIVER_MODULE(atapicam
, ata
,
141 atapi_cam_event_handler
,
143 MODULE_VERSION(atapicam
, 1);
144 MODULE_DEPEND(atapicam
, ata
, 1, 1, 1);
145 MODULE_DEPEND(atapicam
, cam
, 1, 1, 1);
148 atapi_cam_identify(device_t
*dev
, device_t parent
)
150 struct atapi_xpt_softc
*scp
=
151 kmalloc(sizeof(struct atapi_xpt_softc
), M_ATACAM
, M_INTWAIT
|M_ZERO
);
154 /* Assume one atapicam instance per parent channel instance. */
155 child
= device_add_child(parent
, "atapicam", -1);
157 /* XXX TGEN Use device_printf()? */
158 kprintf("atapi_cam_identify: out of memory, can't add child");
159 kfree(scp
, M_ATACAM
);
162 scp
->atapi_cam_dev
.unit
= -1;
163 scp
->atapi_cam_dev
.dev
= child
;
165 device_set_softc(child
, scp
);
169 atapi_cam_probe(device_t dev
)
171 struct ata_device
*atadev
= device_get_softc (dev
);
173 KASSERT(atadev
!= NULL
, ("expect valid struct ata_device"));
174 if (atadev
->unit
< 0) {
175 device_set_desc(dev
, "ATAPI CAM Attachment");
183 atapi_cam_attach(device_t dev
)
185 struct atapi_xpt_softc
*scp
= NULL
;
186 struct cam_devq
*devq
= NULL
;
187 struct cam_sim
*sim
= NULL
;
188 struct cam_path
*path
= NULL
;
191 scp
= (struct atapi_xpt_softc
*)device_get_softc(dev
);
193 device_printf(dev
, "Cannot get softc\n");
197 spin_init(&scp
->state_lock
);
200 scp
->parent
= device_get_parent(dev
);
201 scp
->ata_ch
= device_get_softc(scp
->parent
);
202 TAILQ_INIT(&scp
->pending_hcbs
);
203 unit
= device_get_unit(dev
);
205 if ((devq
= cam_simq_alloc(16)) == NULL
) {
210 if ((sim
= cam_sim_alloc(atapi_action
, atapi_poll
, "ata",
211 (void *)scp
, unit
, &sim_mplock
, 1, 1, devq
)) == NULL
) {
217 if (xpt_bus_register(sim
, 0) != CAM_SUCCESS
) {
221 scp
->flags
|= BUS_REGISTERED
;
223 if (xpt_create_path(&path
, /*periph*/ NULL
,
224 cam_sim_path(sim
), CAM_TARGET_WILDCARD
,
225 CAM_LUN_WILDCARD
) != CAM_REQ_CMP
) {
231 CAM_DEBUG(path
, CAM_DEBUG_TRACE
, ("Registered SIM for ata%d\n", unit
));
233 setup_async_cb(scp
, AC_LOST_DEVICE
);
234 reinit_bus(scp
, ATTACH
);
245 atapi_cam_detach(device_t dev
)
247 struct atapi_xpt_softc
*scp
= device_get_softc(dev
);
250 xpt_freeze_simq(scp
->sim
, 1 /*count*/);
252 spin_lock_wr(&scp
->state_lock
);
253 scp
->flags
|= DETACHING
;
254 spin_unlock_wr(&scp
->state_lock
);
260 atapi_cam_reinit(device_t dev
) {
261 struct atapi_xpt_softc
*scp
= device_get_softc(dev
);
264 * scp might be null if the bus is being reinitialised during
265 * the boot-up sequence, before the ATAPI bus is registered.
269 reinit_bus(scp
, RESET
);
275 reinit_bus(struct atapi_xpt_softc
*scp
, enum reinit_reason reason
) {
276 struct ata_device
*old_atadev
[2], *atadev
;
278 int nchildren
, i
, dev_changed
;
280 if (device_get_children(scp
->parent
, &children
, &nchildren
) != 0) {
284 spin_lock_wr(&scp
->state_lock
);
285 old_atadev
[0] = scp
->atadev
[0];
286 old_atadev
[1] = scp
->atadev
[1];
287 scp
->atadev
[0] = NULL
;
288 scp
->atadev
[1] = NULL
;
290 for (i
= 0; i
< nchildren
; i
++) {
291 /* XXX Does the child need to actually be attached yet? */
292 if (children
[i
] != NULL
) {
293 atadev
= device_get_softc(children
[i
]);
294 if ((atadev
->unit
== ATA_MASTER
) &&
295 (scp
->ata_ch
->devices
& ATA_ATAPI_MASTER
) != 0)
296 scp
->atadev
[0] = atadev
;
297 if ((atadev
->unit
== ATA_SLAVE
) &&
298 (scp
->ata_ch
->devices
& ATA_ATAPI_SLAVE
) != 0)
299 scp
->atadev
[1] = atadev
;
302 dev_changed
= (old_atadev
[0] != scp
->atadev
[0])
303 || (old_atadev
[1] != scp
->atadev
[1]);
304 spin_unlock_wr(&scp
->state_lock
);
305 kfree(children
, M_TEMP
);
309 xpt_async(AC_BUS_RESET
, scp
->path
, NULL
);
316 cam_rescan(scp
->sim
);
322 setup_async_cb(struct atapi_xpt_softc
*scp
, uint32_t events
)
324 struct ccb_setasync csa
;
327 xpt_setup_ccb(&csa
.ccb_h
, scp
->path
, /*priority*/ 5);
328 csa
.ccb_h
.func_code
= XPT_SASYNC_CB
;
329 csa
.event_enable
= events
;
330 csa
.callback
= &atapi_async
;
331 csa
.callback_arg
= scp
->sim
;
332 xpt_action((union ccb
*) &csa
);
337 atapi_action(struct cam_sim
*sim
, union ccb
*ccb
)
339 struct atapi_xpt_softc
*softc
= (struct atapi_xpt_softc
*)cam_sim_softc(sim
);
340 struct ccb_hdr
*ccb_h
= &ccb
->ccb_h
;
341 struct atapi_hcb
*hcb
= NULL
;
342 struct ata_request
*request
= NULL
;
343 int unit
= cam_sim_unit(sim
);
344 int bus
= cam_sim_bus(sim
);
348 switch (ccb_h
->func_code
) {
350 struct ccb_pathinq
*cpi
= &ccb
->cpi
;
351 int tid
= ccb_h
->target_id
;
353 cpi
->version_num
= 1;
354 cpi
->hba_inquiry
= 0;
355 cpi
->target_sprt
= 0;
356 cpi
->hba_misc
= PIM_NO_6_BYTE
;
357 cpi
->hba_eng_cnt
= 0;
358 bzero(cpi
->vuhba_flags
, sizeof(cpi
->vuhba_flags
));
361 cpi
->async_flags
= 0;
363 cpi
->initiator_id
= 7;
364 strncpy(cpi
->sim_vid
, "FreeBSD", sizeof(cpi
->sim_vid
));
365 strncpy(cpi
->hba_vid
, "ATAPI", sizeof(cpi
->hba_vid
));
366 strncpy(cpi
->dev_name
, cam_sim_name(sim
), sizeof cpi
->dev_name
);
367 cpi
->unit_number
= cam_sim_unit(sim
);
368 cpi
->bus_id
= cam_sim_bus(sim
);
369 cpi
->base_transfer_speed
= 3300;
370 cpi
->transport
= XPORT_ATA
;
371 cpi
->transport_version
= 2;
372 cpi
->protocol
= PROTO_SCSI
;
373 cpi
->protocol_version
= SCSI_REV_2
;
375 if (softc
->ata_ch
&& tid
!= CAM_TARGET_WILDCARD
) {
376 spin_lock_wr(&softc
->state_lock
);
377 if (softc
->atadev
[tid
] == NULL
) {
378 ccb
->ccb_h
.status
= CAM_DEV_NOT_THERE
;
380 spin_unlock_wr(&softc
->state_lock
);
383 switch (softc
->atadev
[ccb_h
->target_id
]->mode
) {
385 cpi
->base_transfer_speed
= 5200;
388 cpi
->base_transfer_speed
= 7000;
391 cpi
->base_transfer_speed
= 11000;
396 cpi
->base_transfer_speed
= 16000;
399 cpi
->base_transfer_speed
= 33000;
402 cpi
->base_transfer_speed
= 66000;
405 cpi
->base_transfer_speed
= 100000;
408 cpi
->base_transfer_speed
= 133000;
413 spin_unlock_wr(&softc
->state_lock
);
415 ccb
->ccb_h
.status
= CAM_REQ_CMP
;
420 case XPT_RESET_DEV
: {
421 int tid
= ccb_h
->target_id
;
423 CAM_DEBUG(ccb
->ccb_h
.path
, CAM_DEBUG_SUBTRACE
, ("dev reset\n"));
424 ata_controlcmd(softc
->atadev
[tid
]->dev
, ATA_DEVICE_RESET
, 0, 0, 0);
425 ccb
->ccb_h
.status
= CAM_REQ_CMP
;
431 CAM_DEBUG(ccb
->ccb_h
.path
, CAM_DEBUG_SUBTRACE
, ("bus reset\n"));
432 ata_reinit(softc
->parent
);
433 ccb
->ccb_h
.status
= CAM_REQ_CMP
;
437 case XPT_SET_TRAN_SETTINGS
:
438 /* ignore these, we're not doing SCSI here */
439 CAM_DEBUG(ccb
->ccb_h
.path
, CAM_DEBUG_SUBTRACE
,
440 ("SET_TRAN_SETTINGS not supported\n"));
441 ccb
->ccb_h
.status
= CAM_FUNC_NOTAVAIL
;
445 case XPT_GET_TRAN_SETTINGS
: {
446 struct ccb_trans_settings
*cts
= &ccb
->cts
;
447 cts
->protocol
= PROTO_SCSI
;
448 cts
->protocol_version
= SCSI_REV_2
;
449 cts
->transport
= XPORT_ATA
;
450 cts
->transport_version
= XPORT_VERSION_UNSPECIFIED
;
451 cts
->proto_specific
.valid
= 0;
452 cts
->xport_specific
.valid
= 0;
453 /* nothing more to do */
454 ccb
->ccb_h
.status
= CAM_REQ_CMP
;
455 CAM_DEBUG(ccb
->ccb_h
.path
, CAM_DEBUG_SUBTRACE
, ("GET_TRAN_SETTINGS\n"));
460 case XPT_CALC_GEOMETRY
: {
461 CAM_DEBUG(ccb
->ccb_h
.path
, CAM_DEBUG_SUBTRACE
, ("CALC_GEOMETRY\n"));
462 cam_calc_geometry(&ccb
->ccg
, /*extended*/1);
468 struct ccb_scsiio
*csio
= &ccb
->csio
;
469 int tid
= ccb_h
->target_id
, lid
= ccb_h
->target_lun
;
470 int request_flags
= ATA_R_ATAPI
;
472 CAM_DEBUG(ccb_h
->path
, CAM_DEBUG_SUBTRACE
, ("XPT_SCSI_IO\n"));
474 spin_lock_wr(&softc
->state_lock
);
475 if (softc
->flags
& DETACHING
) {
476 ccb
->ccb_h
.status
= CAM_REQ_ABORTED
;
478 spin_unlock_wr(&softc
->state_lock
);
482 if (softc
->atadev
[tid
] == NULL
) {
483 ccb
->ccb_h
.status
= CAM_DEV_NOT_THERE
;
485 spin_unlock_wr(&softc
->state_lock
);
489 /* check that this request was not aborted already */
490 if ((ccb_h
->status
& CAM_STATUS_MASK
) != CAM_REQ_INPROG
) {
491 kprintf("XPT_SCSI_IO received but already in progress?\n");
493 spin_unlock_wr(&softc
->state_lock
);
497 CAM_DEBUG(ccb_h
->path
, CAM_DEBUG_SUBTRACE
,
498 ("SCSI IO received for invalid lun %d\n", lid
));
501 if (csio
->cdb_len
> sizeof request
->u
.atapi
.ccb
) {
502 CAM_DEBUG(ccb_h
->path
, CAM_DEBUG_SUBTRACE
,
503 ("CAM CCB too long for ATAPI"));
506 if ((ccb_h
->flags
& CAM_SCATTER_VALID
)) {
507 /* scatter-gather not supported */
508 xpt_print_path(ccb_h
->path
);
509 kprintf("ATAPI/CAM does not support scatter-gather yet!\n");
513 switch (ccb_h
->flags
& CAM_DIR_MASK
) {
515 request_flags
|= ATA_R_READ
;
518 request_flags
|= ATA_R_WRITE
;
521 /* No flags need to be set */
524 device_printf(softc
->dev
, "unknown IO operation\n");
528 if ((hcb
= allocate_hcb(softc
, unit
, bus
, ccb
)) == NULL
) {
529 kprintf("cannot allocate ATAPI/CAM hcb\n");
532 if ((request
= ata_alloc_request()) == NULL
) {
533 kprintf("cannot allocate ATAPI/CAM request\n");
537 bcopy((ccb_h
->flags
& CAM_CDB_POINTER
) ?
538 csio
->cdb_io
.cdb_ptr
: csio
->cdb_io
.cdb_bytes
,
539 request
->u
.atapi
.ccb
, csio
->cdb_len
);
541 if (CAM_DEBUGGED(ccb_h
->path
, CAM_DEBUG_CDB
)) {
542 char cdb_str
[(SCSI_MAX_CDBLEN
* 3) + 1];
544 kprintf("atapi_action: hcb@%p: %s\n", hcb
,
545 scsi_cdb_string(request
->u
.atapi
.ccb
, cdb_str
, sizeof(cdb_str
)));
547 if (CAM_DEBUGGED(ccb_h
->path
, CAM_DEBUG_SUBTRACE
)) {
548 request_flags
|= ATA_R_DEBUG
;
552 len
= csio
->dxfer_len
;
553 buf
= csio
->data_ptr
;
555 /* some SCSI commands require special processing */
556 switch (request
->u
.atapi
.ccb
[0]) {
559 * many ATAPI devices seem to report more than
560 * SHORT_INQUIRY_LENGTH bytes of available INQUIRY
561 * information, but respond with some incorrect condition
562 * when actually asked for it, so we are going to pretend
563 * that only SHORT_INQUIRY_LENGTH are expected, anyway.
565 struct scsi_inquiry
*inq
= (struct scsi_inquiry
*) &request
->u
.atapi
.ccb
[0];
567 if (inq
->byte2
== 0 && inq
->page_code
== 0 &&
568 inq
->length
> SHORT_INQUIRY_LENGTH
) {
570 len
= inq
->length
= SHORT_INQUIRY_LENGTH
;
578 CAM_DEBUG(ccb_h
->path
, CAM_DEBUG_SUBTRACE
,
579 ("Translating %s into _10 equivalent\n",
580 (request
->u
.atapi
.ccb
[0] == READ_6
) ? "READ_6" : "WRITE_6"));
581 request
->u
.atapi
.ccb
[0] |= 0x20;
582 request
->u
.atapi
.ccb
[9] = request
->u
.atapi
.ccb
[5];
583 request
->u
.atapi
.ccb
[8] = request
->u
.atapi
.ccb
[4];
584 request
->u
.atapi
.ccb
[7] = 0;
585 request
->u
.atapi
.ccb
[6] = 0;
586 request
->u
.atapi
.ccb
[5] = request
->u
.atapi
.ccb
[3];
587 request
->u
.atapi
.ccb
[4] = request
->u
.atapi
.ccb
[2];
588 request
->u
.atapi
.ccb
[3] = request
->u
.atapi
.ccb
[1] & 0x1f;
589 request
->u
.atapi
.ccb
[2] = 0;
590 request
->u
.atapi
.ccb
[1] = 0;
594 if ((ccb_h
->flags
& CAM_DIR_MASK
) == CAM_DIR_IN
&& (len
& 1)) {
595 /* ATA always transfers an even number of bytes */
596 buf
= hcb
->dxfer_alloc
=
597 kmalloc(++len
, M_ATACAM
, M_INTWAIT
| M_ZERO
);
601 * Don't allow DMA for requests with length not multiple of 16 bytes.
602 * Some ATAPI devices don't like it.
604 if ((softc
->atadev
[tid
]->mode
>= ATA_DMA
) && len
> 0 && !(len
& 15))
605 request_flags
|= ATA_R_DMA
;
607 request
->dev
= softc
->atadev
[tid
]->dev
;
608 request
->driver
= hcb
;
610 request
->bytecount
= len
;
611 request
->transfersize
= min(request
->bytecount
,
612 min(softc
->ata_ch
->dma
->max_iosize
, 65534));
613 request
->timeout
= ccb_h
->timeout
/ 1000; /* XXX lost granularity */
614 request
->callback
= &atapi_cb
;
615 request
->flags
= request_flags
;
618 * no retries are to be performed at the ATA level; any retries
619 * will be done by CAM .
621 request
->retries
= 0;
623 TAILQ_INSERT_TAIL(&softc
->pending_hcbs
, hcb
, chain
);
624 hcb
->flags
|= QUEUED
;
625 ccb_h
->status
|= CAM_SIM_QUEUED
;
626 spin_unlock_wr(&softc
->state_lock
);
628 ata_queue_request(request
);
633 CAM_DEBUG(ccb_h
->path
, CAM_DEBUG_SUBTRACE
,
634 ("unsupported function code 0x%02x\n", ccb_h
->func_code
));
642 ata_free_request(request
);
645 spin_unlock_wr(&softc
->state_lock
);
647 xpt_print_path(ccb_h
->path
);
648 kprintf("out of memory, freezing queue.\n");
649 softc
->flags
|= RESOURCE_SHORTAGE
;
650 xpt_freeze_simq(sim
, /*count*/ 1);
652 ccb_h
->status
= CAM_REQUEUE_REQ
;
657 spin_unlock_wr(&softc
->state_lock
);
658 ccb_h
->status
= CAM_REQ_INVALID
;
664 atapi_poll(struct cam_sim
*sim
)
666 /* do nothing - we do not actually service any interrupts */
667 kprintf("atapi_poll called!\n");
671 atapi_cb(struct ata_request
*request
)
673 struct atapi_xpt_softc
*scp
;
674 struct atapi_hcb
*hcb
;
675 struct ccb_scsiio
*csio
;
678 hcb
= (struct atapi_hcb
*)request
->driver
;
680 csio
= &hcb
->ccb
->csio
;
683 # define err (request->u.atapi.sense.key)
684 if (CAM_DEBUGGED(csio
->ccb_h
.path
, CAM_DEBUG_CDB
)) {
685 kprintf("atapi_cb: hcb@%p sense = %02x: sk = %01x%s%s%s\n",
686 hcb
, err
, err
& 0x0f,
687 (err
& 0x80) ? ", Filemark" : "",
688 (err
& 0x40) ? ", EOM" : "",
689 (err
& 0x20) ? ", ILI" : "");
690 device_printf(request
->dev
,
691 "cmd %s status %02x result %02x error %02x\n",
692 ata_cmd2str(request
),
693 request
->status
, request
->result
, request
->error
);
697 if ((hcb
->flags
& AUTOSENSE
) != 0) {
698 rc
= CAM_SCSI_STATUS_ERROR
;
699 if (request
->result
== 0) {
700 csio
->ccb_h
.status
|= CAM_AUTOSNS_VALID
;
702 } else if (request
->result
!= 0) {
703 if ((request
->flags
& ATA_R_TIMEOUT
) != 0) {
704 rc
= CAM_CMD_TIMEOUT
;
706 rc
= CAM_SCSI_STATUS_ERROR
;
707 csio
->scsi_status
= SCSI_STATUS_CHECK_COND
;
709 if ((csio
->ccb_h
.flags
& CAM_DIS_AUTOSENSE
) == 0) {
711 static const int8_t ccb
[16] = { ATAPI_REQUEST_SENSE
, 0, 0, 0,
712 sizeof(struct atapi_sense
), 0, 0, 0, 0, 0, 0,
715 bcopy (ccb
, request
->u
.atapi
.ccb
, sizeof ccb
);
716 request
->data
= (caddr_t
)&csio
->sense_data
;
717 request
->bytecount
= sizeof(struct atapi_sense
);
718 request
->transfersize
= min(request
->bytecount
, 65534);
719 request
->timeout
= csio
->ccb_h
.timeout
/ 1000;
720 request
->retries
= 2;
721 request
->flags
= ATA_R_QUIET
|ATA_R_ATAPI
|ATA_R_IMMEDIATE
;
722 hcb
->flags
|= AUTOSENSE
;
724 ata_queue_request(request
);
728 * Use auto-sense data from the ATA layer, if it has
729 * issued a REQUEST SENSE automatically and that operation
730 * returned without error.
732 if (request
->u
.atapi
.sense
.key
!= 0 && request
->error
== 0) {
733 bcopy (&request
->u
.atapi
.sense
, &csio
->sense_data
, sizeof(struct atapi_sense
));
734 csio
->ccb_h
.status
|= CAM_AUTOSNS_VALID
;
741 csio
->scsi_status
= SCSI_STATUS_OK
;
742 if (((csio
->ccb_h
.flags
& CAM_DIR_MASK
) == CAM_DIR_IN
) &&
743 hcb
->dxfer_alloc
!= NULL
)
745 bcopy(hcb
->dxfer_alloc
, csio
->data_ptr
, csio
->dxfer_len
);
749 spin_lock_wr(&scp
->state_lock
);
750 free_hcb_and_ccb_done(hcb
, rc
);
751 spin_unlock_wr(&scp
->state_lock
);
753 ata_free_request(request
);
757 free_hcb_and_ccb_done(struct atapi_hcb
*hcb
, u_int32_t status
)
759 struct atapi_xpt_softc
*softc
;
768 /* we're about to free a hcb, so the shortage has ended */
769 if (softc
->flags
& RESOURCE_SHORTAGE
) {
770 softc
->flags
&= ~RESOURCE_SHORTAGE
;
771 status
|= CAM_RELEASE_SIMQ
;
775 status
| (ccb
->ccb_h
.status
& ~(CAM_STATUS_MASK
| CAM_SIM_QUEUED
));
780 atapi_async(void *callback_arg
, u_int32_t code
,
781 struct cam_path
* path
, void *arg
)
783 struct atapi_xpt_softc
*softc
;
789 sim
= (struct cam_sim
*) callback_arg
;
790 softc
= (struct atapi_xpt_softc
*) cam_sim_softc(sim
);
793 targ
= xpt_path_target_id(path
);
794 xpt_print_path(path
);
796 kprintf("Lost host adapter\n");
798 kprintf("Lost target %d???\n", targ
);
809 cam_rescan_callback(struct cam_periph
*periph
, union ccb
*ccb
)
811 if (ccb
->ccb_h
.status
!= CAM_REQ_CMP
) {
812 CAM_DEBUG(ccb
->ccb_h
.path
, CAM_DEBUG_TRACE
,
813 ("Rescan failed, 0x%04x\n", ccb
->ccb_h
.status
));
815 CAM_DEBUG(ccb
->ccb_h
.path
, CAM_DEBUG_TRACE
,
816 ("Rescan succeeded\n"));
818 xpt_free_path(ccb
->ccb_h
.path
);
819 kfree(ccb
, M_ATACAM
);
823 cam_rescan(struct cam_sim
*sim
)
825 struct cam_path
*path
;
826 union ccb
*ccb
= kmalloc(sizeof(union ccb
), M_ATACAM
, M_WAITOK
| M_ZERO
);
829 if (xpt_create_path(&path
, xpt_periph
, cam_sim_path(sim
),
830 CAM_TARGET_WILDCARD
, CAM_LUN_WILDCARD
) != CAM_REQ_CMP
) {
832 kfree(ccb
, M_ATACAM
);
836 CAM_DEBUG(path
, CAM_DEBUG_TRACE
, ("Rescanning ATAPI bus.\n"));
837 xpt_setup_ccb(&ccb
->ccb_h
, path
, 5/*priority (low)*/);
838 ccb
->ccb_h
.func_code
= XPT_SCAN_BUS
;
839 ccb
->ccb_h
.cbfcnp
= cam_rescan_callback
;
840 ccb
->crcn
.flags
= CAM_FLAG_NONE
;
842 /* scan is in progress now */
846 static struct atapi_hcb
*
847 allocate_hcb(struct atapi_xpt_softc
*softc
, int unit
, int bus
, union ccb
*ccb
)
849 struct atapi_hcb
*hcb
= (struct atapi_hcb
*)
850 kmalloc(sizeof(struct atapi_hcb
), M_ATACAM
, M_INTWAIT
| M_ZERO
);
860 free_hcb(struct atapi_hcb
*hcb
)
862 if ((hcb
->flags
& QUEUED
) != 0)
863 TAILQ_REMOVE(&hcb
->softc
->pending_hcbs
, hcb
, chain
);
864 if (hcb
->dxfer_alloc
!= NULL
)
865 kfree(hcb
->dxfer_alloc
, M_ATACAM
);
866 kfree(hcb
, M_ATACAM
);
870 free_softc(struct atapi_xpt_softc
*scp
)
872 struct atapi_hcb
*hcb
;
875 spin_lock_wr(&scp
->state_lock
);
876 TAILQ_FOREACH(hcb
, &scp
->pending_hcbs
, chain
) {
877 free_hcb_and_ccb_done(hcb
, CAM_UNREC_HBA_ERROR
);
879 spin_unlock_wr(&scp
->state_lock
);
881 if (scp
->path
!= NULL
) {
882 setup_async_cb(scp
, 0);
883 xpt_free_path(scp
->path
);
885 if ((scp
->flags
& BUS_REGISTERED
) != 0) {
886 if (xpt_bus_deregister(cam_sim_path(scp
->sim
)) == CAM_REQ_CMP
)
887 scp
->flags
&= ~BUS_REGISTERED
;
889 if (scp
->sim
!= NULL
) {
890 if ((scp
->flags
& BUS_REGISTERED
) == 0)
891 cam_sim_free(scp
->sim
);
893 kprintf("Can't free %s SIM (still registered)\n",
894 cam_sim_name(scp
->sim
));
897 spin_uninit(&scp
->state_lock
);
902 atapi_cam_event_handler(module_t mod
, int what
, void *arg
) {
908 if (devclass_get_devices(atapi_cam_devclass
, &devlist
, &devcount
)
911 if (devlist
!= NULL
) {
912 while (devlist
!= NULL
&& devcount
> 0) {
913 device_t child
= devlist
[--devcount
];
914 struct atapi_xpt_softc
*scp
= device_get_softc(child
);
916 device_delete_child(device_get_parent(child
),child
);
918 kfree(scp
, M_ATACAM
);
920 kfree(devlist
, M_TEMP
);