For kmalloc(), MALLOC() and contigmalloc(), use M_ZERO instead of
[dragonfly.git] / sys / dev / raid / twa / twa_cam.c
1 /*-
2  * Copyright (c) 2003-04 3ware, Inc.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  *      $FreeBSD$
27  * $DragonFly: src/sys/dev/raid/twa/twa_cam.c,v 1.5 2008/01/05 14:02:38 swildner Exp $
28  */
29
30 /*
31  * 3ware driver for 9000 series storage controllers.
32  *
33  * Author: Vinod Kashyap
34  */
35
36
37 #include "twa_includes.h"
38
39 #include <bus/cam/cam.h>
40 #include <bus/cam/cam_ccb.h>
41 #include <bus/cam/cam_sim.h>
42 #include <bus/cam/cam_xpt_sim.h>
43 #include <bus/cam/cam_xpt_periph.h>
44 #include <bus/cam/cam_debug.h>
45 #include <bus/cam/cam_periph.h>
46
47 #include <bus/cam/scsi/scsi_all.h>
48 #include <bus/cam/scsi/scsi_message.h>
49
50 static int      twa_execute_scsi(struct twa_request *tr, union ccb *ccb);
51 static void     twa_action(struct cam_sim *sim, union ccb *ccb);
52 static void     twa_poll(struct cam_sim *sim);
53 static void     twa_async(void *callback_arg, u_int32_t code, struct cam_path *path, void *arg);
54 static void     twa_bus_scan_cb(struct cam_periph *periph, union ccb *ccb);
55
56
57
58 /*
59  * Function name:       twa_cam_setup
60  * Description:         Attaches the driver to CAM.
61  *
62  * Input:               sc      -- ptr to per ctlr structure
63  * Output:              None
64  * Return value:        0       -- success
65  *                      non-zero-- failure
66  */
67 int
68 twa_cam_setup(struct twa_softc *sc)
69 {
70         struct cam_devq         *devq;
71         struct ccb_setasync     csa;
72
73         twa_dbg_dprint(3, sc, "sc = %p", sc);
74         /*
75          * Create the device queue for our SIM.
76          */
77         devq = cam_simq_alloc(TWA_Q_LENGTH);
78         if (devq == NULL)
79                 return(ENOMEM);
80
81         /*
82          * Create a SIM entry.  Though we can support TWA_Q_LENGTH simultaneous
83          * requests, we claim to be able to handle only (TWA_Q_LENGTH - 1), so
84          * that we always have a request packet available to service attention
85          * interrupts.
86          */
87         twa_dbg_dprint(3, sc, "Calling cam_sim_alloc");
88         sc->twa_sim = cam_sim_alloc(twa_action, twa_poll, "twa", sc,
89                                         device_get_unit(sc->twa_bus_dev),
90                                         TWA_Q_LENGTH - 1, 1, devq);
91         cam_simq_release(devq);
92         if (sc->twa_sim == NULL) {
93                 return(ENOMEM);
94         }
95
96         /*
97          * Register the bus.
98          */
99         twa_dbg_dprint(3, sc, "Calling xpt_bus_register");
100         if (xpt_bus_register(sc->twa_sim, 0) != CAM_SUCCESS) {
101                 cam_sim_free(sc->twa_sim);
102                 sc->twa_sim = NULL; /* so twa_cam_detach will not try to free it */
103                 return(ENXIO);
104         }
105
106         twa_dbg_dprint(3, sc, "Calling xpt_create_path");
107         if (xpt_create_path(&sc->twa_path, NULL,
108                                 cam_sim_path(sc->twa_sim),
109                                 CAM_TARGET_WILDCARD,
110                                 CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
111                 xpt_bus_deregister(cam_sim_path (sc->twa_sim));
112                 cam_sim_free(sc->twa_sim); /* passing TRUE will free the devq as well */
113                 return(ENXIO);
114         }
115
116         twa_dbg_dprint(3, sc, "Calling xpt_setup_ccb");
117         xpt_setup_ccb(&csa.ccb_h, sc->twa_path, 5);
118         csa.ccb_h.func_code = XPT_SASYNC_CB;
119         csa.event_enable = AC_FOUND_DEVICE | AC_LOST_DEVICE;
120         csa.callback = twa_async;
121         csa.callback_arg = sc;
122         xpt_action((union ccb *)&csa);
123
124         twa_dbg_dprint(3, sc, "Calling twa_request_bus_scan");
125         /*
126          * Request a bus scan, so that CAM gets to know of
127          * the logical units that we control.
128          */
129         twa_request_bus_scan(sc);
130         twa_dbg_dprint(3, sc, "Exiting");
131         return(0);
132 }
133
134
135
136 /*
137  * Function name:       twa_cam_detach
138  * Description:         Detaches the driver from CAM.
139  *
140  * Input:               sc      -- ptr to per ctlr structure
141  * Output:              None
142  * Return value:        None
143  */
144 void
145 twa_cam_detach(struct twa_softc *sc)
146 {
147         if (sc->twa_path)
148                 xpt_free_path(sc->twa_path);
149         if (sc->twa_sim) {
150                 xpt_bus_deregister(cam_sim_path(sc->twa_sim));
151                 cam_sim_free(sc->twa_sim); /* passing TRUE will free the devq as well */
152         }
153 }
154
155
156
157 /*
158  * Function name:       twa_send_scsi_cmd
159  * Description:         Sends down a scsi cmd to fw.
160  *
161  * Input:               tr      -- ptr to request pkt
162  *                      cmd     -- opcode of scsi cmd to send
163  * Output:              None
164  * Return value:        0       -- success
165  *                      non-zero-- failure
166  */
167 int
168 twa_send_scsi_cmd(struct twa_request *tr, int cmd)
169 {
170         union ccb       ccb;
171
172         bzero(&ccb, sizeof(union ccb));
173         ccb.csio.cdb_io.cdb_bytes[0] = (u_int8_t)cmd;
174         ccb.csio.cdb_io.cdb_bytes[4] = 128;
175         ccb.csio.cdb_len = 16;
176         ccb.csio.data_ptr = kmalloc(TWA_SECTOR_SIZE, M_DEVBUF, M_INTWAIT|M_ZERO);
177         ccb.csio.dxfer_len = TWA_SECTOR_SIZE;
178
179         ccb.ccb_h.target_id = 0;
180         ccb.ccb_h.flags |= CAM_DIR_IN;
181
182         if (twa_execute_scsi(tr, &ccb))
183                 return(EIO);
184         return(0);
185 }
186
187
188
189 /*
190  * Function name:       twa_execute_scsi
191  * Description:         Build a fw cmd, based on a CAM style ccb, and
192  *                      send it down.
193  *
194  * Input:               tr      -- ptr to request pkt
195  *                      ccb     -- ptr to CAM style ccb
196  * Output:              None
197  * Return value:        0       -- success
198  *                      non-zero-- failure
199  */
200 int
201 twa_execute_scsi(struct twa_request *tr, union ccb *ccb)
202 {
203         struct twa_softc                *sc = tr->tr_sc;
204         struct twa_command_packet       *cmdpkt;
205         struct twa_command_9k           *cmd9k;
206         struct ccb_hdr                  *ccb_h = &(ccb->ccb_h);
207         struct ccb_scsiio               *csio = &(ccb->csio);
208         int                             error;
209
210         twa_dbg_dprint(3, sc, "SCSI I/O request 0x%x", 
211                                 csio->cdb_io.cdb_bytes[0]);
212
213         if (ccb_h->target_id >= TWA_MAX_UNITS) {
214                 twa_dbg_dprint(3, sc, "Invalid target. PTL = %x %x %x",
215                         ccb_h->path_id, ccb_h->target_id, ccb_h->target_lun);
216                 ccb_h->status |= CAM_TID_INVALID;
217                 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL)
218                         xpt_done(ccb);
219                 return(1);
220         }
221         if (ccb_h->target_lun != 0) {
222                 twa_dbg_dprint(3, sc, "Invalid lun. PTL = %x %x %x",
223                         ccb_h->path_id, ccb_h->target_id, ccb_h->target_lun);
224                 ccb_h->status |= CAM_LUN_INVALID;
225                 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL)
226                         xpt_done(ccb);
227                 return(1);
228         }
229
230         if(ccb_h->flags & CAM_CDB_PHYS) {
231                 twa_printf(sc, "Physical CDB address!\n");
232                 ccb_h->status = CAM_REQ_CMP_ERR;
233                 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL)
234                         xpt_done(ccb);
235                 return(1);
236         }
237
238         /*
239          * We are going to work on this request.  Mark it as enqueued (though
240          * we don't actually queue it...)
241          */
242         ccb_h->status |= CAM_SIM_QUEUED;
243
244         if((ccb_h->flags & CAM_DIR_MASK) != CAM_DIR_NONE) {
245                 if(ccb_h->flags & CAM_DIR_IN)
246                         tr->tr_flags |= TWA_CMD_DATA_IN;
247                 else
248                         tr->tr_flags |= TWA_CMD_DATA_OUT;
249         }
250
251         cmdpkt = tr->tr_command;
252
253         cmdpkt->cmd_hdr.header_desc.size_header = 128;
254                 
255         cmd9k = &(cmdpkt->command.cmd_pkt_9k);
256         cmd9k->command.opcode = TWA_OP_EXECUTE_SCSI_COMMAND;
257         cmd9k->unit = ccb_h->target_id;
258         cmd9k->request_id = tr->tr_request_id;
259         cmd9k->status = 0;
260         cmd9k->sgl_offset = 16; /* offset from end of hdr = max cdb len */
261
262         if(ccb_h->flags & CAM_CDB_POINTER)
263                 bcopy(csio->cdb_io.cdb_ptr, cmd9k->cdb, csio->cdb_len);
264         else
265                 bcopy(csio->cdb_io.cdb_bytes, cmd9k->cdb, csio->cdb_len);
266
267         if (!(ccb_h->flags & CAM_DATA_PHYS)) {
268                 /* Virtual data addresses.  Need to convert them... */
269                 twa_dbg_dprint(3, sc, "XPT_SCSI_IO: Single virtual address!");
270                 if (!(ccb_h->flags & CAM_SCATTER_VALID)) {
271                         if (csio->dxfer_len > TWA_MAX_IO_SIZE) {
272                                 twa_printf(sc, "I/O size %d too big.\n",
273                                                         csio->dxfer_len);
274                                 ccb_h->status = CAM_REQ_TOO_BIG;
275                                 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL)
276                                         xpt_done(ccb);
277                                 return(1);
278                         }
279
280                         if ((tr->tr_length = csio->dxfer_len)) {
281                                 tr->tr_data = csio->data_ptr;
282                                 cmd9k->sgl_entries = 1;
283                         }
284                 } else {
285                         twa_printf(sc, "twa_execute_scsi: XPT_SCSI_IO: Got SGList!\n");
286                         ccb_h->status = CAM_REQ_CMP_ERR;
287                         if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL) {
288                                 xpt_done(ccb);
289                         }
290                         return(1);
291                 }
292         } else {
293                 /* Data addresses are physical. */
294                 twa_printf(sc, "twa_execute_scsi: XPT_SCSI_IO: Physical data addresses!\n");
295                 ccb_h->status = CAM_REQ_CMP_ERR;
296                 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL) {
297                         ccb_h->status |= CAM_RELEASE_SIMQ;
298                         ccb_h->status &= ~CAM_SIM_QUEUED;
299                         xpt_done(ccb);
300                 }
301                 return(1);
302         }
303
304         tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_9K;
305         /* twa_setup_data_dmamap will fill in the SGL, and submit the I/O. */
306         error = twa_map_request(tr);
307         return(error);
308 }
309
310
311
312 /*
313  * Function name:       twa_action
314  * Description:         Driver entry point for CAM's use.
315  *
316  * Input:               sim     -- sim corresponding to the ctlr
317  *                      ccb     -- ptr to CAM request
318  * Output:              None
319  * Return value:        None
320  */
321 void
322 twa_action(struct cam_sim *sim, union ccb *ccb)
323 {
324         struct twa_softc        *sc = (struct twa_softc *)cam_sim_softc(sim);
325         struct ccb_hdr          *ccb_h = &(ccb->ccb_h);
326
327         switch (ccb_h->func_code) {
328         case XPT_SCSI_IO:       /* SCSI I/O */
329         {
330                 struct twa_request      *tr;
331
332                 if ((sc->twa_state & TWA_STATE_SIMQ_FROZEN) ||
333                                 ((tr = twa_get_request(sc)) == NULL)) {
334                         twa_dbg_dprint(2, sc, "simq frozen/Cannot get request pkt.");
335                         /*
336                          * Freeze the simq to maintain ccb ordering.  The next
337                          * ccb that gets completed will unfreeze the simq.
338                          */
339                         twa_disallow_new_requests(sc);
340                         ccb_h->status |= CAM_REQUEUE_REQ;
341                         xpt_done(ccb);
342                         break;
343                 }
344                 tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_EXTERNAL;
345                 tr->tr_private = ccb;
346                 tr->tr_callback = twa_complete_io;
347                 if (twa_execute_scsi(tr, ccb))
348                         twa_release_request(tr);
349                 break;
350         }
351
352         case XPT_ABORT:
353                 twa_dbg_dprint(2, sc, "Abort request");
354                 ccb_h->status = CAM_UA_ABORT;
355                 xpt_done(ccb);
356                 break;
357
358         case XPT_RESET_BUS:
359                 twa_printf(sc, "Reset Bus request from CAM...\n");
360                 if (twa_reset(sc)) {
361                         twa_printf(sc, "Reset Bus failed!\n");
362                         ccb_h->status = CAM_REQ_CMP_ERR;
363                 }
364                 else
365                         ccb_h->status = CAM_REQ_CMP;
366
367                 xpt_done(ccb);
368                 break;
369
370         case XPT_SET_TRAN_SETTINGS:
371                 twa_dbg_dprint(3, sc, "XPT_SET_TRAN_SETTINGS");
372
373                 /*
374                  * This command is not supported, since it's very specific
375                  * to SCSI, and we are doing ATA.
376                  */
377                 ccb_h->status = CAM_FUNC_NOTAVAIL;
378                 xpt_done(ccb);
379                 break;
380
381         case XPT_GET_TRAN_SETTINGS: 
382         {
383                 struct ccb_trans_settings       *cts = &ccb->cts;
384
385                 twa_dbg_dprint(3, sc, "XPT_GET_TRAN_SETTINGS");
386                 cts->valid = (CCB_TRANS_DISC_VALID | CCB_TRANS_TQ_VALID);
387                 cts->flags &= ~(CCB_TRANS_DISC_ENB | CCB_TRANS_TAG_ENB);
388                 ccb_h->status = CAM_REQ_CMP;
389                 xpt_done(ccb);
390                 break;
391         }
392
393         case XPT_CALC_GEOMETRY:
394         {
395                 struct ccb_calc_geometry        *geom;
396
397                 twa_dbg_dprint(3, sc, "XPT_CALC_GEOMETRY request");
398                 geom = &ccb->ccg;
399
400                 if (geom->volume_size > 0x200000) /* 1 GB */ {
401                         geom->heads = 255;
402                         geom->secs_per_track = 63;
403                 } else {
404                         geom->heads = 64;
405                         geom->secs_per_track = 32;
406                 }
407                 geom->cylinders = geom->volume_size /
408                                         (geom->heads * geom->secs_per_track);
409                 ccb_h->status = CAM_REQ_CMP;
410                 xpt_done(ccb);
411                 break;
412         }
413
414         case XPT_PATH_INQ:    /* Path inquiry -- get twa properties */
415         {
416                 struct ccb_pathinq      *path_inq = &ccb->cpi;
417
418                 twa_dbg_dprint(3, sc, "XPT_PATH_INQ request");
419
420                 path_inq->version_num = 1;
421                 path_inq->hba_inquiry = 0;
422                 path_inq->target_sprt = 0;
423                 path_inq->hba_misc = 0;
424                 path_inq->hba_eng_cnt = 0;
425                 path_inq->max_target = TWA_MAX_UNITS;
426                 path_inq->max_lun = 0;
427                 path_inq->unit_number = cam_sim_unit(sim);
428                 path_inq->bus_id = cam_sim_bus(sim);
429                 path_inq->initiator_id = 12;
430                 path_inq->base_transfer_speed = 100000;
431                 strncpy(path_inq->sim_vid, "FreeBSD", SIM_IDLEN);
432                 strncpy(path_inq->hba_vid, "3ware", HBA_IDLEN);
433                 strncpy(path_inq->dev_name, cam_sim_name(sim), DEV_IDLEN);
434                 ccb_h->status = CAM_REQ_CMP;
435                 xpt_done(ccb);
436                 break;
437         }
438
439         default:
440                 twa_dbg_dprint(3, sc, "func_code = %x", ccb_h->func_code);
441                 ccb_h->status = CAM_REQ_INVALID;
442                 xpt_done(ccb);
443                 break;
444         }
445 }
446
447
448
449 /*
450  * Function name:       twa_poll
451  * Description:         Driver entry point called when interrupts are not available.
452  *
453  * Input:               sim     -- sim corresponding to the controller
454  * Output:              None
455  * Return value:        None
456  */
457 void
458 twa_poll(struct cam_sim *sim)
459 {
460 #ifdef TWA_DEBUG
461         struct twa_softc *sc = (struct twa_softc *)cam_sim_softc(sim);
462 #endif /* TWA_DEBUG */
463
464         twa_dbg_dprint(3, sc, "Entering sc = %p", sc);
465         twa_interrupt(cam_sim_softc(sim));
466         twa_dbg_dprint(3, sc, "Exiting sc = %p", sc);
467 }
468
469
470
471 /*
472  * Function name:       twa_async
473  * Description:         Driver entry point for CAM to notify driver of special
474  *                      events.  We don't use this for now.
475  *
476  * Input:               callback_arg    -- ptr to per ctlr structure
477  *                      code            -- code associated with the event
478  *                      path            -- cam path
479  *                      arg             -- 
480  * Output:              None
481  * Return value:        0       -- success
482  *                      non-zero-- failure
483  */
484 void
485 twa_async(void *callback_arg, u_int32_t code, 
486                         struct cam_path *path, void *arg)
487 {
488 #ifdef TWA_DEBUG
489         struct twa_softc *sc = (struct twa_softc *)callback_arg;
490 #endif /* TWA_DEBUG */
491
492         twa_dbg_dprint(3, sc, "sc = %p, code = %x, path = %p, arg = %p",
493                                 sc, code, path, arg);
494 }
495
496
497
498 /*
499  * Function name:       twa_request_bus_scan
500  * Description:         Requests CAM for a scan of the bus.
501  *
502  * Input:               sc      -- ptr to per ctlr structure
503  * Output:              None
504  * Return value:        None
505  */
506 void
507 twa_request_bus_scan(struct twa_softc *sc)
508 {
509         struct cam_path *path;
510         union ccb       *ccb;
511
512         if ((ccb = kmalloc(sizeof(union ccb), M_TEMP, M_WAITOK|M_ZERO)) == NULL)
513                 return;
514         if (xpt_create_path(&path, xpt_periph, cam_sim_path(sc->twa_sim),
515                         CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP)
516                 return;
517
518         xpt_setup_ccb(&ccb->ccb_h, path, 5);
519         ccb->ccb_h.func_code = XPT_SCAN_BUS;
520         ccb->ccb_h.cbfcnp = twa_bus_scan_cb;
521         ccb->crcn.flags = CAM_FLAG_NONE;
522         xpt_action(ccb);
523 }
524
525
526
527 /*
528  * Function name:       twa_bus_scan_cb
529  * Description:         Callback from CAM on a bus scan request.
530  *
531  * Input:               periph  -- we don't use this
532  *                      ccb     -- bus scan request ccb that we sent to CAM
533  * Output:              None
534  * Return value:        None
535  */
536 static void
537 twa_bus_scan_cb(struct cam_periph *periph, union ccb *ccb)
538 {
539         twa_dbg_print(3, "ccb = %p\n", ccb);
540         if (ccb->ccb_h.status != CAM_REQ_CMP)
541                 kprintf("cam_scan_callback: failure status = %x\n",
542                                         ccb->ccb_h.status);
543         else
544                 twa_dbg_print(3, "success");
545
546         xpt_free_path(ccb->ccb_h.path);
547         kfree(ccb, M_TEMP);
548 }
549
550
551
552 /*
553  * Function name:       twa_scsi_complete
554  * Description:         Called to complete CAM scsi requests.
555  *
556  * Input:               tr      -- ptr to request pkt to be completed
557  * Output:              None
558  * Return value:        None
559  */
560 void
561 twa_scsi_complete(struct twa_request *tr)
562 {
563         struct twa_softc                *sc = tr->tr_sc;
564         struct twa_command_header       *cmd_hdr = &(tr->tr_command->cmd_hdr);
565         struct twa_command_9k           *cmd = &(tr->tr_command->command.cmd_pkt_9k);
566         union ccb                       *ccb = (union ccb *)(tr->tr_private);
567         u_int16_t                       error;
568         u_int8_t                        *cdb;
569
570         if (tr->tr_error) {
571                 if (tr->tr_error == EBUSY)
572                         ccb->ccb_h.status |= CAM_REQUEUE_REQ;
573                 else if (tr->tr_error == EFBIG)
574                         ccb->ccb_h.status = CAM_REQ_TOO_BIG;
575                 else
576                         ccb->ccb_h.status = CAM_REQ_CMP_ERR;
577         } else {
578                 if (cmd->status) {
579                         twa_dbg_dprint(1, sc, "req_id = 0x%x, status = 0x%x",
580                                                 cmd->request_id,
581                                                 cmd->status);
582
583                         error = cmd_hdr->status_block.error;
584                         if ((error == TWA_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) ||
585                                         (error == TWA_ERROR_UNIT_OFFLINE)) {
586                                 twa_dbg_dprint(3, sc, "Unsupported unit. PTL = %x %x %x",
587                                                         ccb->ccb_h.path_id,
588                                                         ccb->ccb_h.target_id,
589                                                         ccb->ccb_h.target_lun);
590                                 ccb->ccb_h.status |= CAM_TID_INVALID;
591                         } else {
592                                 twa_dbg_dprint(2, sc, "cmd = %x %x %x %x %x %x %x",
593                                                 cmd->command.opcode,
594                                                 cmd->command.reserved,
595                                                 cmd->unit,
596                                                 cmd->request_id,
597                                                 cmd->status,
598                                                 cmd->sgl_offset,
599                                                 cmd->sgl_entries);
600
601                                 cdb = (u_int8_t *)(cmd->cdb);
602                                 twa_dbg_dprint(2, sc, "cdb = %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x",
603                                         cdb[0], cdb[1], cdb[2], cdb[3], cdb[4], cdb[5], cdb[6], cdb[7],
604                                         cdb[8], cdb[9], cdb[10], cdb[11], cdb[12], cdb[13], cdb[14], cdb[15]);
605
606                                 cmd_hdr->err_specific_desc[sizeof(cmd_hdr->err_specific_desc) - 1] = '\0';
607                                 /* 
608                                  * Print the error. Firmware doesn't yet support
609                                  * the 'Mode Sense' cmd.  Don't print if the cmd
610                                  * is 'Mode Sense', and the error is 'Invalid field
611                                  * in CDB'.
612                                  */
613                                 if (! ((cdb[0] == 0x1A) && (error == 0x10D)))
614                                         twa_printf(sc, "SCSI cmd = 0x%x: ERROR: (0x%02X: 0x%04X): %s: %s\n",
615                                                 cdb[0],
616                                                 TWA_MESSAGE_SOURCE_CONTROLLER_ERROR,
617                                                 error,
618                                                 twa_find_msg_string(twa_error_table, error),
619                                                 cmd_hdr->err_specific_desc);
620                         }
621
622                         bcopy(cmd_hdr->sense_data, &(ccb->csio.sense_data),
623                                                 TWA_SENSE_DATA_LENGTH);
624                         ccb->csio.sense_len = TWA_SENSE_DATA_LENGTH;
625                         ccb->ccb_h.status |= CAM_SCSI_STATUS_ERROR | CAM_AUTOSNS_VALID;
626                 } else
627                         ccb->ccb_h.status = CAM_REQ_CMP;
628
629                 ccb->csio.scsi_status = cmd->status;
630                 /* If simq is frozen, unfreeze it. */
631                 if (sc->twa_state & TWA_STATE_SIMQ_FROZEN)
632                         twa_allow_new_requests(sc, (void *)ccb);
633         }
634
635         ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
636         xpt_done(ccb);
637 }
638
639
640
641 /*
642  * Function name:       twa_drain_busy_queue
643  * Description:         This function gets called after a controller reset.
644  *                      It errors back to CAM, all those requests that were
645  *                      pending with the firmware, at the time of the reset.
646  *
647  * Input:               sc      -- ptr to per ctlr structure
648  * Output:              None
649  * Return value:        None
650  */
651 void
652 twa_drain_busy_queue(struct twa_softc *sc)
653 {
654         struct twa_request      *tr;
655         union ccb               *ccb;
656
657         /* Walk the busy queue. */
658         while ((tr = twa_dequeue_busy(sc))) {
659                 twa_unmap_request(tr);
660                 if ((tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_INTERNAL) ||
661                         (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_IOCTL)) {
662                         /* It's an internal/ioctl request.  Simply free it. */
663                         if (tr->tr_data)
664                                 kfree(tr->tr_data, M_DEVBUF);
665                 } else {
666                         if ((ccb = tr->tr_private)) {
667                                 /* It's a SCSI request.  Complete it. */
668                                 ccb->ccb_h.status = CAM_SCSI_BUS_RESET |
669                                                         CAM_RELEASE_SIMQ;
670                                 ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
671                                 xpt_done(ccb);
672                         }
673                 }
674                 twa_release_request(tr);
675         }
676 }
677
678
679
680 /*
681  * Function name:       twa_allow_new_requests
682  * Description:         Sets the appropriate status bits in a ccb such that,
683  *                      when the ccb is completed by a call to xpt_done,
684  *                      CAM knows that it's ok to unfreeze the flow of new
685  *                      requests to this controller, if the flow is frozen.
686  *
687  * Input:               sc      -- ptr to per ctlr structure
688  *                      ccb     -- ptr to CAM request
689  * Output:              None
690  * Return value:        None
691  */
692 void
693 twa_allow_new_requests(struct twa_softc *sc, void *ccb)
694 {
695         ((union ccb *)(ccb))->ccb_h.status |= CAM_RELEASE_SIMQ;
696         sc->twa_state &= ~TWA_STATE_SIMQ_FROZEN;
697 }
698
699
700
701 /*
702  * Function name:       twa_disallow_new_requests
703  * Description:         Calls the appropriate CAM function, so as to freeze
704  *                      the flow of new requests from CAM to this controller.
705  *
706  * Input:               sc      -- ptr to per ctlr structure
707  * Output:              None
708  * Return value:        None
709  */
710 void
711 twa_disallow_new_requests(struct twa_softc *sc)
712 {
713         xpt_freeze_simq(sc->twa_sim, 1);
714         sc->twa_state |= TWA_STATE_SIMQ_FROZEN;
715 }