?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bmake-ify mr_sas
[unleashed.git] / usr / src / uts / common / io / cpqary3 / cpqary3_transport.c
blobf79814f8c749f02356948191f2b2d3b4ce329467
1 /*
2 * This file and its contents are supplied under the terms of the
3 * Common Development and Distribution License ("CDDL"), version 1.0.
4 * You may only use this file in accordance with the terms of version
5 * 1.0 of the CDDL.
6 *
7 * A full copy of the text of the CDDL should have accompanied this
8 * source. A copy of the CDDL is also available via the Internet at
9 * http://www.illumos.org/license/CDDL.
10 */
11
12 /*
13 * Copyright (C) 2013 Hewlett-Packard Development Company, L.P.
14 */
15
16 #include <sys/sdt.h>
17 #include "cpqary3.h"
18
19 /*
20 * Local Functions Definitions
21 */
22
23 static int cpqary3_tgt_init(dev_info_t *, dev_info_t *, scsi_hba_tran_t *,
24 struct scsi_device *);
25 static int cpqary3_tgt_probe(struct scsi_device *, int (*)());
26 static int cpqary3_transport(struct scsi_address *, struct scsi_pkt *);
27 static int cpqary3_reset(struct scsi_address *, int);
28 static int cpqary3_abort(struct scsi_address *, struct scsi_pkt *);
29 static int cpqary3_getcap(struct scsi_address *, char *, int);
30 static int cpqary3_setcap(struct scsi_address *, char *, int, int);
31 static int cpqary3_dma_alloc(cpqary3_t *, struct scsi_pkt *,
32 struct buf *, int, int (*)());
33 static int cpqary3_dma_move(struct scsi_pkt *, struct buf *, cpqary3_t *);
34 static int cpqary3_handle_flag_nointr(cpqary3_cmdpvt_t *, struct scsi_pkt *);
35 static int cpqary3_poll(cpqary3_t *, uint32_t);
36 static void cpqary3_dmafree(struct scsi_address *, struct scsi_pkt *);
37 static void cpqary3_dma_sync(struct scsi_address *, struct scsi_pkt *);
38 static void cpqary3_destroy_pkt(struct scsi_address *, struct scsi_pkt *);
39 static struct scsi_pkt *cpqary3_init_pkt(struct scsi_address *,
40 struct scsi_pkt *, struct buf *, int, int, int, int, int (*callback)(),
41 caddr_t);
42 static int cpqary3_additional_cmd(struct scsi_pkt *scsi_pktp, cpqary3_t *);
43 void cpqary3_oscmd_complete(cpqary3_cmdpvt_t *);
44 static uint8_t cpqary3_is_scsi_read_write(struct scsi_pkt *scsi_pktp);
45
46 /*
47 * External Variable Declarations
48 */
49
50 extern ddi_dma_attr_t cpqary3_dma_attr;
51
52 /*
53 * Function : cpqary3_init_hbatran
54 * Description : This routine initializes the transport vector in the
55 * SCSA architecture for entry ponts in this driver.
56 * Called By : cpqary3_attach()
57 * Parameters : per_controller
58 * Calls : None
59 * Return Values: None
60 */
61 void
62 cpqary3_init_hbatran(cpqary3_t *ctlr)
63 {
64 scsi_hba_tran_t *hba_tran;
65
66 ASSERT(ctlr != NULL);
67
68 hba_tran = ctlr->hba_tran;
69
70 /*
71 * Memory for the transport vector has been allocated by now.
72 * initialize all the entry points in this vector
73 */
74
75 hba_tran->tran_hba_private = (void *)ctlr;
76
77 /* Target Driver Instance Initialization */
78 hba_tran->tran_tgt_init = cpqary3_tgt_init;
79 hba_tran->tran_tgt_probe = cpqary3_tgt_probe;
80
81 /* Resource Allocation */
82 hba_tran->tran_init_pkt = cpqary3_init_pkt;
83 hba_tran->tran_destroy_pkt = cpqary3_destroy_pkt;
84 hba_tran->tran_sync_pkt = cpqary3_dma_sync;
85 hba_tran->tran_dmafree = cpqary3_dmafree;
86
87 /* Command Transport */
88 hba_tran->tran_start = cpqary3_transport;
89
90 /* Capability Management */
91 hba_tran->tran_getcap = cpqary3_getcap;
92 hba_tran->tran_setcap = cpqary3_setcap;
93
94 /* Abort and Reset */
95 hba_tran->tran_reset = cpqary3_reset;
96 hba_tran->tran_abort = cpqary3_abort;
97 }
98
99 /*
100 * Function : cpqary3_tgt_init ()
101 * Description : This routine validates the target ID.
102 * Called By : cpqary3_init_hbatran()
103 * Parameters : HBA-instance, target instance, transport vector,
104 * scsi-device structure
105 * Calls : cpqary3_detect_target_geometry(),
106 * cpqary3_probe4targets()
107 * Return Values: DDI_SUCCESS : A Target exists at this ID.
108 * DDI_FAILURE : No such target exists.
109 */
110 /* ARGSUSED */
111 static int
112 cpqary3_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
113 scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
114 {
115 uint32_t tid = SD2TGT(sd);
116 uint32_t lun = SD2LUN(sd);
117 cpqary3_t *ctlr;
118
119 ctlr = (cpqary3_t *)hba_tran->tran_hba_private;
120
121 /* HPQacucli Changes */
122
123 extern int8_t cpqary3_detect_target_geometry(cpqary3_t *);
124 if ((CPQARY3_SUCCESS == cpqary3_probe4targets(ctlr)) &&
125 (ctlr->num_of_targets > 0)) {
126 (void) cpqary3_detect_target_geometry(ctlr);
127 }
128
129 /* HPQacucli Changes */
130 /*
131 * Validate the Target ID
132 * Validate Lun --Ver1.10--
133 * If not a valid target id, return FAILURE.
134 * Derieve the per-controller
135 */
136
137 if ((tid >= CPQARY3_MAX_TGT) || (lun != 0)) {
138 DTRACE_PROBE2(tgt_init_notsup,
139 cpqary3_t *, ctlr, uint32_t, tid);
140 return (DDI_FAILURE);
141 }
142
143 /*
144 * Check to see if a target structure corrresponding to this
145 * target Id exists.(support only for Logical Drives and Controller)
146 * if target exists, update target flags, return SUCCESS
147 * is target does not exist, return FAILURE
148 */
149
150 mutex_enter(&ctlr->sw_mutex);
151
152 if (!(ctlr->cpqary3_tgtp[tid])) {
153 mutex_exit(&ctlr->sw_mutex);
154 return (DDI_FAILURE);
155 }
156
157 ctlr->cpqary3_tgtp[tid]->tgt_dip = tgt_dip;
158 ctlr->cpqary3_tgtp[tid]->ctlr_flags = CPQARY3_CAP_DISCON_ENABLED |
159 CPQARY3_CAP_SYNC_ENABLED | CPQARY3_CAP_WIDE_XFER_ENABLED |
160 CPQARY3_CAP_ARQ_ENABLED;
161
162 mutex_exit(&ctlr->sw_mutex);
163
164 DTRACE_PROBE1(tgt_init_done, uint32_t, tid);
165
166 return (DDI_SUCCESS);
167 }
168
169 /*
170 * Function : cpqary3_tgt_probe()
171 * Description : This routine probes into the Target Details.
172 * Called By : cpqary3_init_hbatran()
173 * Parameters : scsi-device structure, calling function if any
174 * Calls : None
175 * Return Values: value returned by scsi_hba_probe()
176 */
177 static int
178 cpqary3_tgt_probe(struct scsi_device *sd, int (*waitfunc)())
179 {
180 #ifdef CPQARY3_DEBUG
181 int status;
182 #endif
183
184 /*
185 * Probe for the presence of the target, using the scsi_hba_probe().
186 * It inturn issues the SCSI inquiry command that is serviced by our
187 * driver
188 */
189
190 /* HPQacucli Changes */
191 extern int8_t cpqary3_detect_target_geometry(cpqary3_t *);
192 struct scsi_hba_tran *hba_tran = sd->sd_address.a_hba_tran;
193 cpqary3_t *ctlr = hba_tran->tran_hba_private;
194
195 if ((CPQARY3_SUCCESS == cpqary3_probe4targets(ctlr)) &&
196 (ctlr->num_of_targets > 0)) {
197 (void) cpqary3_detect_target_geometry(ctlr);
198 }
199 /* HPQacucli Changes */
200
201 return (scsi_hba_probe(sd, waitfunc));
202
203 #ifdef CPQARY3_DEBUG
204
205 /* Comment the previous line of code */
206 status = scsi_hba_probe(sd, waitfunc);
207 cmn_err(CE_CONT, "CPQary3 : _tgt_probe : target = %d \n", SD2TGT(sd));
208 cmn_err(CE_CONT, "CPQary3 : _tgt_probe : scsi_hba_probe returned %d \n",
209 status);
210 cmn_err(CE_CONT, "CPQary3 : _tgt_probe : Leaving \n");
211 return (status);
212
213 #endif
214 }
215
216 /*
217 * Function : cpqary3_init_pkt
218 * Description : This routine allocates resources for a SCSI packet.
219 * Called By : cpqary3_init_pkt()
220 * Parameters : SCSI address, SCSI packet, buffer, CDB length,
221 * SCB length, driver private length, flags modifier,
222 * callback function, arguement for the callback function
223 * Calls : cpqary3_dma_alloc(), cpqary3_dma_move()
224 * Return Values: allocated SCSI packet / NULL
225 */
226 /* ARGSUSED */
227 static struct scsi_pkt *
228 cpqary3_init_pkt(struct scsi_address *sa, struct scsi_pkt *scsi_pktp,
229 struct buf *bp, int cmdlen, int statuslen, int tgtlen,
230 int flags, int (*callback)(), caddr_t arg)
231 {
232 cpqary3_t *cpqary3p;
233 dev_info_t *dip;
234 cpqary3_pkt_t *cpqary3_pktp;
235 struct scsi_pkt *new_scsi_pktp;
236
237 ASSERT(callback == NULL_FUNC || callback == SLEEP_FUNC);
238
239 cpqary3p = SA2CTLR(sa);
240 dip = cpqary3p->dip;
241
242 /*
243 * If the SCSI packet is NULL, allocate frresh resources to it.
244 * Else, get the next available resources for the same
245 */
246
247 if (!scsi_pktp) {
248 scsi_pktp = scsi_hba_pkt_alloc(dip, sa, cmdlen, statuslen,
249 tgtlen, sizeof (cpqary3_pkt_t), callback, NULL);
250 if (!scsi_pktp)
251 return (NULL);
252
253 cpqary3_pktp = (cpqary3_pkt_t *)scsi_pktp->pkt_ha_private;
254 bzero(cpqary3_pktp, sizeof (cpqary3_pkt_t));
255
256 cpqary3_pktp->scsi_cmd_pkt = scsi_pktp;
257
258 /*
259 * Store the CDB length and sense data length in the
260 * pkt private
261 */
262 cpqary3_pktp->cdb_len = cmdlen;
263 cpqary3_pktp->scb_len = statuslen;
264 cpqary3_pktp->cmd_dmahandle = NULL;
265 cpqary3_pktp->memp = (cpqary3_cmdpvt_t *)NULL;
266
267 /*
268 * Initialize to NULL all the fields of scsi_pktp, except
269 * pkt_scbp, pkt_cdbp, pkt_ha_private and pkt_private members.
270 */
271 scsi_pktp->pkt_address = *sa;
272 scsi_pktp->pkt_comp = (void (*) ())NULL;
273 scsi_pktp->pkt_flags = 0;
274 scsi_pktp->pkt_time = 0;
275 scsi_pktp->pkt_resid = 0;
276 scsi_pktp->pkt_statistics = 0;
277 scsi_pktp->pkt_state = 0;
278 scsi_pktp->pkt_reason = 0;
279
280 if (flags & PKT_CONSISTENT)
281 cpqary3_pktp->cmd_flags |= DDI_DMA_CONSISTENT;
282
283 if (flags & PKT_DMA_PARTIAL)
284 cpqary3_pktp->cmd_flags |= DDI_DMA_PARTIAL;
285
286 new_scsi_pktp = scsi_pktp;
287 } else {
288 new_scsi_pktp = NULL;
289 cpqary3_pktp = (cpqary3_pkt_t *)scsi_pktp->pkt_ha_private;
290 }
291
292 cpqary3_pktp->bf = bp;
293
294 /*
295 * If any I/O is desired, Allocate/Move DMA resources for the SCSI
296 * packet
297 * If first time allocation for this SCSI packet, allocate fresh DMA
298 * Else, move the already allocated DMA resources
299 */
300 if (bp && bp->b_bcount != 0) { /* I/O is desired */
301 if (!cpqary3_pktp->cmd_dmahandle) { /* First time allocation */
302 if (cpqary3_dma_alloc(cpqary3p, scsi_pktp,
303 bp, flags, callback) == CPQARY3_FAILURE) {
304 if (new_scsi_pktp)
305 scsi_hba_pkt_free(sa, new_scsi_pktp);
306 return (NULL);
307 }
308 } else {
309 ASSERT(new_scsi_pktp == NULL);
310 if (CPQARY3_FAILURE ==
311 cpqary3_dma_move(scsi_pktp, bp, cpqary3p)) {
312 return (NULL);
313 }
314 }
315 }
316
317 return (scsi_pktp);
318 }
319
320 /*
321 * Function : cpqary3_dma_alloc()
322 * Description : This routine services requests for memory (dynamic)
323 * as and when required by the OS.
324 * Called By : cpqary3_init_pkt()
325 * Parameters : per-controller, SCSI packet, buffer, flag modifier,
326 * callback function
327 * Calls : None
328 * Return Values: SUCCESS / FAILURE
329 */
330 static int
331 cpqary3_dma_alloc(cpqary3_t *cpqary3p, struct scsi_pkt *scsi_pktp,
332 struct buf *bp, int flags, int (*callback)())
333 {
334 int32_t (*cb)(caddr_t);
335 int32_t retvalue;
336 uint32_t i = 0;
337 uint32_t dma_flags;
338 cpqary3_pkt_t *cpqary3_pktp;
339 ddi_dma_attr_t tmp_dma_attr;
340
341 cpqary3_pktp = (cpqary3_pkt_t *)scsi_pktp->pkt_ha_private;
342
343 ASSERT(callback == NULL_FUNC || callback == SLEEP_FUNC);
344 /*
345 * Record the direction of the data transfer, so that it
346 * can be used in appropriate synchronization during cpqary3_sync_pkt()
347 */
348 if (bp->b_flags & B_READ) {
349 cpqary3_pktp->cmd_flags &= ~CFLAG_DMASEND;
350 dma_flags = DDI_DMA_READ;
351 } else {
352 cpqary3_pktp->cmd_flags |= CFLAG_DMASEND;
353 dma_flags = DDI_DMA_WRITE;
354 }
355
356 if (flags & PKT_CONSISTENT) {
357 cpqary3_pktp->cmd_flags |= CFLAG_CMDIOPB;
358 dma_flags |= DDI_DMA_CONSISTENT;
359 }
360
361 if (flags & PKT_DMA_PARTIAL) {
362 dma_flags |= DDI_DMA_PARTIAL;
363 }
364
365 tmp_dma_attr = cpqary3_dma_attr;
366
367 /* SG */
368 tmp_dma_attr.dma_attr_sgllen = cpqary3p->sg_cnt;
369 /* SG */
370
371 cb = (callback == NULL_FUNC) ? DDI_DMA_DONTWAIT : DDI_DMA_SLEEP;
372
373 /*
374 * DMA resources are allocated thru a 2 step protocol :
375 * - allocate a DMA handle
376 * - bind the buffer to the handle
377 * If both the steps succeed, we have succeeded in allocating resources
378 */
379
380 if (DDI_SUCCESS != (retvalue = ddi_dma_alloc_handle(cpqary3p->dip,
381 &tmp_dma_attr, cb, CPQARY3_DMA_NO_CALLBACK,
382 &cpqary3_pktp->cmd_dmahandle))) {
383 switch (retvalue) {
384 case DDI_DMA_NORESOURCES:
385 /*
386 * No Resources are available to be allocated
387 */
388 bioerror(bp, CPQARY3_BUFFER_ERROR_CLEAR);
389 break;
390
391 case DDI_DMA_BADATTR:
392 /*
393 * The attributes stated in our DMA attribute
394 * structure is such that potential DMA resources can
395 * not be allocated.
396 */
397 cmn_err(CE_CONT, "CPQary3: DmaAlloc: "
398 "AllocHandle Failed BadAttr\n");
399 bioerror(bp, EFAULT);
400 break;
401
402 default:
403 /*
404 * There is no other possible return value
405 */
406 cmn_err(CE_WARN,
407 "CPQary3: dma_alloc: Unexpected Return Value %x "
408 "From call to Allocate DMA Handle \n", retvalue);
409 break;
410 }
411 return (CPQARY3_FAILURE);
412 }
413
414 retvalue = ddi_dma_buf_bind_handle(cpqary3_pktp->cmd_dmahandle, bp,
415 dma_flags, cb, CPQARY3_DMA_NO_CALLBACK,
416 &cpqary3_pktp->cmd_dmacookies[0], &cpqary3_pktp->cmd_ncookies);
417
418 switch (retvalue) {
419 case DDI_DMA_PARTIAL_MAP :
420 case DDI_DMA_MAPPED :
421 if (DDI_DMA_PARTIAL_MAP == retvalue) {
422 if (ddi_dma_numwin(cpqary3_pktp->cmd_dmahandle,
423 &cpqary3_pktp->cmd_nwin) == DDI_FAILURE) {
424 cmn_err(CE_PANIC, "CPQary3: Retrieval of DMA "
425 "windows number failed");
426 }
427
428 if (ddi_dma_getwin(cpqary3_pktp->cmd_dmahandle,
429 cpqary3_pktp->cmd_curwin,
430 &cpqary3_pktp->cmd_dma_offset,
431 &cpqary3_pktp->cmd_dma_len,
432 &cpqary3_pktp->cmd_dmacookies[0],
433 &cpqary3_pktp->cmd_ncookies) == DDI_FAILURE) {
434 cmn_err(CE_PANIC, "CPQary3: Activation of New "
435 "DMA Window Failed");
436 }
437 } else {
438 cpqary3_pktp->cmd_nwin = 1;
439 cpqary3_pktp->cmd_dma_len = 0;
440 cpqary3_pktp->cmd_dma_offset = 0;
441 }
442
443 cpqary3_pktp->cmd_dmacount = 0;
444 i = 0;
445 for (;;) {
446 cpqary3_pktp->cmd_dmacount +=
447 cpqary3_pktp->cmd_dmacookies[i++].dmac_size;
448 /* SG */
449 /* Check Out for Limits */
450 if (i == cpqary3p->sg_cnt ||
451 i == cpqary3_pktp->cmd_ncookies)
452 break;
453 /* SG */
454
455 ddi_dma_nextcookie(cpqary3_pktp->cmd_dmahandle,
456 &cpqary3_pktp->cmd_dmacookies[i]);
457 }
458
459 cpqary3_pktp->cmd_cookie = i;
460 cpqary3_pktp->cmd_cookiecnt = i;
461 cpqary3_pktp->cmd_flags |= CFLAG_DMAVALID;
462
463 scsi_pktp->pkt_resid =
464 bp->b_bcount - cpqary3_pktp->cmd_dmacount;
465
466 return (CPQARY3_SUCCESS);
467
468 case DDI_DMA_NORESOURCES:
469 bioerror(bp, CPQARY3_BUFFER_ERROR_CLEAR);
470 break;
471
472 case DDI_DMA_NOMAPPING:
473 bioerror(bp, EFAULT);
474 break;
475
476 case DDI_DMA_TOOBIG:
477 bioerror(bp, EINVAL);
478 break;
479
480 case DDI_DMA_INUSE:
481 cmn_err(CE_PANIC, "CPQary3: Another I/O transaction "
482 "is using the DMA handle");
483
484 default:
485 cmn_err(CE_PANIC, "CPQary3: Unexpected ERROR "
486 "returned from Call to Bind Buffer "
487 "to Handle : 0x%X", i);
488 }
489
490 ddi_dma_free_handle(&cpqary3_pktp->cmd_dmahandle);
491 cpqary3_pktp->cmd_dmahandle = NULL;
492 cpqary3_pktp->cmd_flags &= ~CFLAG_DMAVALID;
493
494 return (CPQARY3_FAILURE);
495
496 }
497
498 /*
499 * Function : cpqary3_dma_move()
500 * Description : This routine gets the next DMA window.
501 * Called By : cpqary3_init_pkt()
502 * Parameters : per-controller, SCSI packet, buffer
503 * Calls : None
504 * Return Values: SUCCESS / FAILURE
505 */
506 static int
507 cpqary3_dma_move(struct scsi_pkt *scsi_pktp, struct buf *bp,
508 cpqary3_t *cpqary3p)
509 {
510 uint32_t i = 0;
511 cpqary3_pkt_t *cpqary3_pktp;
512
513 cpqary3_pktp = PKT2PVTPKT(scsi_pktp);
514
515 /*
516 * If there are no more cookies remaining in this window,
517 * must move to the next window first.
518 */
519 if (cpqary3_pktp->cmd_cookie == cpqary3_pktp->cmd_ncookies) {
520 /* For small pkts, leave things where they are */
521 if ((cpqary3_pktp->cmd_curwin == cpqary3_pktp->cmd_nwin) &&
522 (cpqary3_pktp->cmd_nwin == 1))
523 return (CPQARY3_SUCCESS);
524
525 /* Shall not be able to move if last window */
526 if (++cpqary3_pktp->cmd_curwin >= cpqary3_pktp->cmd_nwin)
527 return (CPQARY3_FAILURE);
528
529 if (ddi_dma_getwin(cpqary3_pktp->cmd_dmahandle,
530 cpqary3_pktp->cmd_curwin, &cpqary3_pktp->cmd_dma_offset,
531 &cpqary3_pktp->cmd_dma_len,
532 &cpqary3_pktp->cmd_dmacookies[0],
533 &cpqary3_pktp->cmd_ncookies) == DDI_FAILURE)
534 return (CPQARY3_FAILURE);
535
536 cpqary3_pktp->cmd_cookie = 0;
537 } else {
538 /* Still more cookies in this window - get the next one */
539 ddi_dma_nextcookie(cpqary3_pktp->cmd_dmahandle,
540 &cpqary3_pktp->cmd_dmacookies[0]);
541 }
542
543 /* Get remaining cookies in this window, up to our maximum */
544 for (;;) {
545 cpqary3_pktp->cmd_dmacount +=
546 cpqary3_pktp->cmd_dmacookies[i++].dmac_size;
547 cpqary3_pktp->cmd_cookie++;
548 /* SG */
549 /* no. of DATA SEGMENTS */
550 if (i == cpqary3p->sg_cnt ||
551 cpqary3_pktp->cmd_cookie == cpqary3_pktp->cmd_ncookies)
552 break;
553 /* SG */
554
555 ddi_dma_nextcookie(cpqary3_pktp->cmd_dmahandle,
556 &cpqary3_pktp->cmd_dmacookies[i]);
557 }
558
559 cpqary3_pktp->cmd_cookiecnt = i;
560 scsi_pktp->pkt_resid = bp->b_bcount - cpqary3_pktp->cmd_dmacount;
561
562 return (CPQARY3_SUCCESS);
563
564 }
565
566 /*
567 * Function : cpqary3_transport()
568 * Description : This routine services requests from the OS that are
569 * directed towards the targets.(any SCSI command)
570 * Called By : kernel
571 * Parameters : SCSI address, SCSI packet, buffer
572 * Calls : cpqary3_build_iop, cpqary3_add2submitted
573 * Return Values: TRAN_ACCEPT : The driver accepts the command.
574 * TRAN_BUSY : Required resources not available
575 * at the moment.
576 * TRAN_FATAL_ERROR: A target no longer exists.
577 */
578 static int
579 cpqary3_transport(struct scsi_address *sa, struct scsi_pkt *scsi_pktp)
580 {
581 cpqary3_t *ctlr;
582 cpqary3_pkt_t *cpqary3_pktp;
583 cpqary3_tgt_t *tgtp;
584 cpqary3_cmdpvt_t *memp;
585
586 ASSERT(sa != NULL);
587 ctlr = SA2CTLR(sa);
588 cpqary3_pktp = PKT2PVTPKT(scsi_pktp);
589 tgtp = ctlr->cpqary3_tgtp[SA2TGT(sa)];
590
591 if (!tgtp)
592 return (TRAN_FATAL_ERROR);
593
594 if (tgtp->type == CPQARY3_TARGET_NONE)
595 return (TRAN_FATAL_ERROR);
596
597 if (cpqary3_additional_cmd(scsi_pktp, ctlr))
598 return (TRAN_ACCEPT);
599
600 /*
601 * Attempt to occupy a free command memory block
602 * If not successful, return TRAN_BUSY
603 * Else, build the Command
604 * Submit it to the controller
605 * If NO_INTR flag is set, wait for the completion of the command and
606 * when the command completes, update packet values appropriately and
607 * return TRAN_ACCEPT.
608 * Make an entry in the submitted Q
609 * return TRAN_ACCEPT
610 */
611
612 if (NULL == (memp = cpqary3_cmdlist_occupy(ctlr)))
613 return (TRAN_BUSY);
614
615 cpqary3_pktp->memp = memp;
616 memp->pvt_pkt = cpqary3_pktp;
617
618 if ((cpqary3_pktp->cmd_flags & DDI_DMA_CONSISTENT) &&
619 cpqary3_pktp->cmd_dmahandle) {
620 (void) ddi_dma_sync(cpqary3_pktp->cmd_dmahandle, 0, 0,
621 DDI_DMA_SYNC_FORDEV);
622 }
623 /* SG */
624 ASSERT(cpqary3_pktp->cmd_cookiecnt <= ctlr->sg_cnt);
625 /* SG */
626
627 /* PERF */
628 memp->complete = cpqary3_oscmd_complete;
629 /* PERF */
630
631 switch (cpqary3_build_cmdlist(memp, SA2TGT(sa))) {
632 case CPQARY3_SUCCESS :
633 if (scsi_pktp->pkt_flags & FLAG_NOINTR) {
634 return (cpqary3_handle_flag_nointr(memp, scsi_pktp));
635 }
636 cpqary3_pktp->cmd_start_time = ddi_get_lbolt();
637 mutex_enter(&ctlr->hw_mutex);
638 /* CONTROLLER_LOCKUP */
639 if (EIO == cpqary3_submit(ctlr, memp->cmdlist_phyaddr)) {
640 mutex_exit(&ctlr->hw_mutex);
641 cpqary3_cmdlist_release(memp, CPQARY3_HOLD_SW_MUTEX);
642 return (TRAN_FATAL_ERROR);
643 }
644 /* CONTROLLER_LOCKUP */
645 mutex_exit(&ctlr->hw_mutex);
646 break;
647 case CPQARY3_FAILURE :
648 cpqary3_cmdlist_release(memp, CPQARY3_HOLD_SW_MUTEX);
649 return (TRAN_FATAL_ERROR);
650 default: /* Never occurs */
651 cmn_err(CE_NOTE, "CPQary3 : Transport : Unexpected Error");
652 return (TRAN_FATAL_ERROR);
653 }
654
655 return (TRAN_ACCEPT);
656 }
657
658 /*
659 * Function : cpqary3_dmafree
660 * Description : This routine de-allocates previously allocated
661 * DMA resources.
662 * Called By : kernel
663 * Parameters : SCSI address, SCSI packet
664 * Calls : None
665 * Return Values: None
666 */
667 /* ARGSUSED */
668 static void
669 cpqary3_dmafree(struct scsi_address *sa, struct scsi_pkt *scsi_pktp)
670 {
671 cpqary3_pkt_t *cpqary3_pktp;
672
673 cpqary3_pktp = PKT2PVTPKT(scsi_pktp);
674
675 /*
676 * If any DMA was succesfully attempted earlier, free all allocated
677 * resources
678 */
679
680 if (cpqary3_pktp->cmd_flags & CFLAG_DMAVALID) {
681 if (!cpqary3_pktp->cmd_dmahandle) {
682 DTRACE_PROBE(dmafree_null);
683 return;
684 }
685 cpqary3_pktp->cmd_flags &= ~CFLAG_DMAVALID;
686 (void) ddi_dma_unbind_handle(cpqary3_pktp->cmd_dmahandle);
687 ddi_dma_free_handle(&cpqary3_pktp->cmd_dmahandle);
688 cpqary3_pktp->cmd_dmahandle = NULL;
689 }
690 }
691
692 /*
693 * Function : cpqary3_dma_sync
694 * Description : This routine synchronizes the CPU's / HBA's view of
695 * the data associated with the pkt, typically by calling
696 * ddi_dma_sync().
697 * Called By : kernel
698 * Parameters : SCSI address, SCSI packet
699 * Calls : None
700 * Return Values: None
701 */
702 /* ARGSUSED */
703 static void
704 cpqary3_dma_sync(struct scsi_address *sa, struct scsi_pkt *scsi_pktp)
705 {
706 cpqary3_pkt_t *cpqary3_pktp = PKT2PVTPKT(scsi_pktp);
707
708 /*
709 * Check whether DMA was attempted successfully earlier
710 * If yes and
711 * if the command flags is write, then synchronise the device else
712 * synchronise the CPU
713 */
714
715 if (cpqary3_pktp->cmd_flags & CFLAG_DMAVALID) {
716 (void) ddi_dma_sync(cpqary3_pktp->cmd_dmahandle,
717 cpqary3_pktp->cmd_dma_offset, cpqary3_pktp->cmd_dma_len,
718 (cpqary3_pktp->cmd_flags & CFLAG_DMASEND) ?
719 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU);
720 }
721 }
722
723 /*
724 * Function : cpqary3_destroy_pkt
725 * Description : This routine de-allocates previously allocated
726 * resources for the SCSI packet.
727 * Called By : kernel
728 * Parameters : SCSI address, SCSI packet
729 * Calls : None
730 * Return Values: None
731 */
732 static void
733 cpqary3_destroy_pkt(struct scsi_address *sa, struct scsi_pkt *scsi_pktp)
734 {
735 cpqary3_pkt_t *cpqary3_pktp;
736
737 cpqary3_pktp = PKT2PVTPKT(scsi_pktp);
738
739 /*
740 * Deallocate DMA Resources, if allocated.
741 * Free the SCSI Packet.
742 */
743
744 if (cpqary3_pktp->cmd_flags & CFLAG_DMAVALID) {
745 if (!cpqary3_pktp->cmd_dmahandle) {
746 DTRACE_PROBE(dmafree_null);
747 } else {
748 cpqary3_pktp->cmd_flags &= ~CFLAG_DMAVALID;
749
750 (void) ddi_dma_unbind_handle(
751 cpqary3_pktp->cmd_dmahandle);
752 ddi_dma_free_handle(&cpqary3_pktp->cmd_dmahandle);
753
754 cpqary3_pktp->cmd_dmahandle = NULL;
755 }
756 }
757
758 scsi_hba_pkt_free(sa, scsi_pktp);
759 }
760
761 /*
762 * Function : cpqary3_reset
763 * Description : This routine resets a SCSI bus/target.
764 * Called By : kernel
765 * Parameters : SCSI address, reset level required
766 * Calls : None
767 * Return Values: SUCCESS
768 */
769 /* ARGSUSED */
770 static int
771 cpqary3_reset(struct scsi_address *sa, int level)
772 {
773 /*
774 * Fix for Crash seen during RAID 0 Drive removal -
775 * just return CPQARY3_SUCCESS on reset request
776 */
777 return (CPQARY3_SUCCESS);
778 }
779
780 /*
781 * Function : cpqary3_abort()
782 * Description : This routine aborts a particular command or all commands
783 * directed towards a target.
784 * Called By : kernel
785 * Parameters : SCSI address, SCSI packet
786 * Calls : None
787 * Return Values: SUCCESS / FAILURE
788 * [ abort of concernd command(s) was a success or
789 * a failure. ]
790 */
791 static int
792 cpqary3_abort(struct scsi_address *sa, struct scsi_pkt *scsi_pktp)
793 {
794 uint32_t tid;
795 cpqary3_t *ctlr;
796
797 ASSERT(sa != NULL);
798 tid = SA2TGT(sa);
799 ctlr = SA2CTLR(sa);
800
801 /*
802 * If SCSI packet exists, abort that particular command.
803 * Else, abort all existing commands to the target
804 * In either of the cases, we shall have to wait after the abort
805 * functions are called to return the status.
806 */
807
808 if (!scsi_pktp) {
809 return (cpqary3_send_abortcmd(ctlr, tid,
810 (CommandList_t *)NULL));
811 } else {
812 return (cpqary3_send_abortcmd(ctlr, tid, SP2CMD(scsi_pktp)));
813 }
814 }
815
816 /*
817 * Function : cpqary3_getcap
818 * Description : This routine is called to get the current value of a
819 * capability.(SCSI transport capability)
820 * Called By : kernel
821 * Parameters : SCSI address, capability identifier, target(s) affected
822 * Calls : None
823 * Return Values: current value of capability / -1 (if unsupported)
824 */
825 static int
826 cpqary3_getcap(struct scsi_address *sa, char *capstr, int tgtonly)
827 {
828 int index;
829 cpqary3_t *ctlr = SA2CTLR(sa);
830 cpqary3_tgt_t *tgtp = ctlr->cpqary3_tgtp[SA2TGT(sa)];
831
832 /*
833 * If requested Capability is not supported, return -1.
834 */
835 if (DDI_FAILURE == (index = scsi_hba_lookup_capstr(capstr)))
836 return (CAP_NOT_DEFINED);
837
838 /*
839 * Getting capability for a particulat target is supported
840 * the generic form of tran_getcap() is unsupported(for all targets)
841 * If directed towards a particular target, return current capability.
842 */
843 if (tgtonly == 0) { /* all targets */
844 DTRACE_PROBE1(getcap_alltgt, int, index);
845 return (CAP_NOT_DEFINED);
846 }
847
848 DTRACE_PROBE1(getcap_index, int, index);
849
850 switch (index) {
851 case SCSI_CAP_DMA_MAX:
852 return ((int)cpqary3_dma_attr.dma_attr_maxxfer);
853 case SCSI_CAP_DISCONNECT:
854 return (tgtp->ctlr_flags & CPQARY3_CAP_DISCON_ENABLED);
855 case SCSI_CAP_SYNCHRONOUS:
856 return (tgtp->ctlr_flags & CPQARY3_CAP_SYNC_ENABLED);
857 case SCSI_CAP_WIDE_XFER:
858 return (tgtp->ctlr_flags & CPQARY3_CAP_WIDE_XFER_ENABLED);
859 case SCSI_CAP_ARQ:
860 return ((tgtp->ctlr_flags & CPQARY3_CAP_ARQ_ENABLED) ? 1 : 0);
861 case SCSI_CAP_INITIATOR_ID:
862 return (CTLR_SCSI_ID);
863 case SCSI_CAP_UNTAGGED_QING:
864 return (1);
865 case SCSI_CAP_TAGGED_QING:
866 return (1);
867 case SCSI_CAP_SECTOR_SIZE:
868 return (cpqary3_dma_attr.dma_attr_granular);
869 case SCSI_CAP_TOTAL_SECTORS:
870 return (CAP_NOT_DEFINED);
871 case SCSI_CAP_GEOMETRY:
872 return (cpqary3_target_geometry(sa));
873 case SCSI_CAP_RESET_NOTIFICATION:
874 return (0);
875 default:
876 return (CAP_NOT_DEFINED);
877 }
878 }
879
880 /*
881 * Function : cpqary3_setcap
882 * Description : This routine is called to set the current value of a
883 * capability.(SCSI transport capability)
884 * Called By : kernel
885 * Parameters : SCSI address, capability identifier,
886 * new capability value, target(s) affected
887 * Calls : None
888 * Return Values: SUCCESS / FAILURE / -1 (if capability is unsupported)
889 */
890 /* ARGSUSED */
891 static int
892 cpqary3_setcap(struct scsi_address *sa, char *capstr, int value, int tgtonly)
893 {
894 int index;
895 int retstatus = CAP_NOT_DEFINED;
896
897 /*
898 * If requested Capability is not supported, return -1.
899 */
900 if ((index = scsi_hba_lookup_capstr(capstr)) == DDI_FAILURE)
901 return (retstatus);
902
903 /*
904 * Setting capability for a particulat target is supported
905 * the generic form of tran_setcap() is unsupported(for all targets)
906 * If directed towards a particular target, set & return current
907 * capability.
908 */
909 if (!tgtonly) {
910 DTRACE_PROBE1(setcap_alltgt, int, index);
911 return (retstatus);
912 }
913
914 DTRACE_PROBE1(setcap_index, int, index);
915
916 switch (index) {
917 case SCSI_CAP_DMA_MAX:
918 return (CAP_CHG_NOT_ALLOWED);
919 case SCSI_CAP_DISCONNECT:
920 return (CAP_CHG_NOT_ALLOWED);
921 case SCSI_CAP_SYNCHRONOUS:
922 return (CAP_CHG_NOT_ALLOWED);
923 case SCSI_CAP_WIDE_XFER:
924 return (CAP_CHG_NOT_ALLOWED);
925 case SCSI_CAP_ARQ:
926 return (1);
927 case SCSI_CAP_INITIATOR_ID:
928 return (CAP_CHG_NOT_ALLOWED);
929 case SCSI_CAP_UNTAGGED_QING:
930 return (1);
931 case SCSI_CAP_TAGGED_QING:
932 return (1);
933 case SCSI_CAP_SECTOR_SIZE:
934 return (CAP_CHG_NOT_ALLOWED);
935 case SCSI_CAP_TOTAL_SECTORS:
936 return (CAP_CHG_NOT_ALLOWED);
937 case SCSI_CAP_GEOMETRY:
938 return (CAP_CHG_NOT_ALLOWED);
939 case SCSI_CAP_RESET_NOTIFICATION:
940 return (CAP_CHG_NOT_ALLOWED);
941 default:
942 return (CAP_NOT_DEFINED);
943 }
944 }
945
946 /*
947 * Function : cpqary3_handle_flag_nointr
948 * Description : This routine is called to handle submission and
949 * subsequently poll for the completion of a command,
950 * when its FLAG_NOINTR bit is set.
951 * Called By : cpqary3_transport()
952 * Parameters : command private structure, SCSI packet
953 * Calls : cpqary3_intr_onoff, cpqary3_retrieve,
954 * cpqary3_submit, cpqary3_poll
955 * Return Values: TRAN_ACCEPT
956 */
957 static int
958 cpqary3_handle_flag_nointr(cpqary3_cmdpvt_t *memp, struct scsi_pkt *scsi_pktp)
959 {
960 uint32_t tag;
961 uint32_t simple_tag;
962 uint32_t i;
963 cpqary3_t *ctlr;
964 cpqary3_cmdpvt_t *cpqary3_cmdpvtp;
965 uint32_t CmdsOutMax;
966 uint32_t no_cmds;
967
968 RETURN_FAILURE_IF_NULL(memp);
969 tag = memp->tag.tag_value;
970 ctlr = memp->ctlr;
971 ctlr->poll_flag = CPQARY3_FALSE;
972
973 /*
974 * Before sumitting this command, ensure all commands pending
975 * with the controller are completed.
976 */
977
978 cpqary3_intr_onoff(ctlr, CPQARY3_INTR_DISABLE);
979 if (ctlr->host_support & 0x4)
980 cpqary3_lockup_intr_onoff(ctlr, CPQARY3_LOCKUP_INTR_DISABLE);
981
982 no_cmds = (uint32_t)((ctlr->ctlr_maxcmds / 3) * NO_OF_CMDLIST_IN_A_BLK);
983 mutex_enter(&ctlr->sw_mutex);
984
985 for (;;) {
986 ctlr->poll_flag = CPQARY3_FALSE;
987 for (i = 0; i < no_cmds; i++) {
988 cpqary3_cmdpvtp = &ctlr->cmdmemlistp->pool[i];
989 ASSERT(cpqary3_cmdpvtp != NULL);
990
991 if ((tag != cpqary3_cmdpvtp->tag.tag_value) &&
992 (cpqary3_cmdpvtp->occupied == CPQARY3_OCCUPIED)) {
993 if (ctlr->noe_support == 1) {
994 if ((cpqary3_cmdpvtp->cmdlist_memaddr->
995 Header.Tag.drvinfo_n_err ==
996 CPQARY3_NOECMD_SUCCESS) ||
997 (cpqary3_cmdpvtp->cmdpvt_flag ==
998 CPQARY3_TIMEOUT)) {
999 continue;
1000 }
1001 } else {
1002 if (cpqary3_cmdpvtp->cmdpvt_flag ==
1003 CPQARY3_TIMEOUT) {
1004 continue;
1005 }
1006 }
1007 ctlr->poll_flag = CPQARY3_TRUE;
1008 }
1009 /* NOE */
1010
1011 if (ctlr->poll_flag == CPQARY3_TRUE) {
1012 break;
1013 }
1014 }
1015
1016 if (ctlr->poll_flag == CPQARY3_TRUE) {
1017 if (!(ctlr->bddef->bd_flags & SA_BD_SAS)) {
1018 while ((simple_tag =
1019 ddi_get32(ctlr->opq_handle,
1020 (uint32_t *)ctlr->opq)) != 0xFFFFFFFF) {
1021 CmdsOutMax = ctlr->ctlr_maxcmds;
1022 if ((simple_tag >>
1023 CPQARY3_GET_MEM_TAG) >=
1024 ((CmdsOutMax / 3) * 3)) {
1025 cmn_err(CE_WARN,
1026 "CPQary3 : HBA returned "
1027 "Spurious Tag");
1028 return (CPQARY3_FAILURE);
1029 }
1030
1031 cpqary3_cmdpvtp =
1032 &ctlr->cmdmemlistp->pool[
1033 simple_tag >> CPQARY3_GET_MEM_TAG];
1034 cpqary3_cmdpvtp->cmdlist_memaddr->
1035 Header.Tag.drvinfo_n_err =
1036 (simple_tag & 0xF) >> 1;
1037 cpqary3_cmdpvtp->complete(
1038 cpqary3_cmdpvtp);
1039 }
1040 } else {
1041 mutex_exit(&ctlr->sw_mutex);
1042 if (CPQARY3_SUCCESS != cpqary3_retrieve(ctlr)) {
1043 drv_usecwait(1000);
1044 }
1045 mutex_enter(&ctlr->sw_mutex); /* Changes */
1046 }
1047 } else {
1048 break;
1049 }
1050 }
1051
1052 mutex_enter(&ctlr->hw_mutex);
1053 if (EIO == cpqary3_submit(ctlr, memp->cmdlist_phyaddr)) {
1054 mutex_exit(&ctlr->hw_mutex);
1055 mutex_exit(&ctlr->sw_mutex);
1056 cpqary3_cmdlist_release(memp, CPQARY3_HOLD_SW_MUTEX);
1057 return (TRAN_FATAL_ERROR);
1058 }
1059
1060 if (CPQARY3_FAILURE == cpqary3_poll(ctlr, tag)) {
1061 scsi_pktp->pkt_reason = CMD_TIMEOUT;
1062 scsi_pktp->pkt_statistics = STAT_TIMEOUT;
1063 scsi_pktp->pkt_state = 0;
1064 mutex_exit(&ctlr->hw_mutex);
1065 mutex_exit(&ctlr->sw_mutex);
1066 cpqary3_cmdlist_release(memp, CPQARY3_HOLD_SW_MUTEX);
1067 cpqary3_intr_onoff(ctlr, CPQARY3_INTR_ENABLE);
1068 if (ctlr->host_support & 0x4)
1069 cpqary3_lockup_intr_onoff(ctlr,
1070 CPQARY3_LOCKUP_INTR_ENABLE);
1071 return (TRAN_ACCEPT);
1072 } else {
1073 mutex_exit(&ctlr->hw_mutex);
1074 mutex_exit(&ctlr->sw_mutex);
1075 cpqary3_intr_onoff(ctlr, CPQARY3_INTR_ENABLE);
1076 if (ctlr->host_support & 0x4) {
1077 cpqary3_lockup_intr_onoff(ctlr,
1078 CPQARY3_LOCKUP_INTR_ENABLE);
1079 }
1080 return (TRAN_ACCEPT);
1081 }
1082 }
1083
1084 /*
1085 * Function : cpqary3_poll
1086 * Description : This routine polls for the completion of a command.
1087 * Called By : cpqary3_handle_flag_nointr
1088 * Parameters : per controller, tag of the command to be polled
1089 * Calls : cpqary3_poll_retrieve
1090 * Return Values: TRAN_ACCEPT
1091 */
1092 static int
1093 cpqary3_poll(cpqary3_t *ctlr, uint32_t tag)
1094 {
1095 uint32_t ii = 0;
1096
1097 RETURN_FAILURE_IF_NULL(ctlr);
1098
1099 /*
1100 * POLL for the completion of the said command
1101 * Since, we had ensured that controller is empty, we need not
1102 * check for the complete Retrieved Q.
1103 * However, we just check the Retrieved Q and complete all
1104 * commands in it, inclusive of the polled command.
1105 * if the polled command is completed, send back a success.
1106 */
1107
1108 for (;;) { /* this function is called with both the locks held */
1109 if (CPQARY3_SUCCESS != cpqary3_poll_retrieve(ctlr, tag)) {
1110 ii++;
1111 if (ii > 120000)
1112 return (CPQARY3_FAILURE);
1113 drv_usecwait(500);
1114 continue;
1115 }
1116 break;
1117 }
1118
1119 return (CPQARY3_SUCCESS);
1120 }
1121
1122 static int
1123 cpqary3_additional_cmd(struct scsi_pkt *scsi_pktp, cpqary3_t *ctlr)
1124 {
1125 struct scsi_arq_status *arqstat;
1126 /* LINTED: alignment */
1127 arqstat = (struct scsi_arq_status *)(scsi_pktp->pkt_scbp);
1128
1129 switch (scsi_pktp->pkt_cdbp[0]) {
1130 case 0x35: /* Synchronize Cache */
1131
1132 cpqary3_flush_cache(ctlr);
1133
1134 scsi_pktp->pkt_reason = CMD_CMPLT;
1135 scsi_pktp->pkt_statistics = 0;
1136 scsi_pktp->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
1137 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
1138
1139 if (scsi_pktp->pkt_comp) {
1140 (*scsi_pktp->pkt_comp)(scsi_pktp);
1141 }
1142
1143 return (1);
1144
1145 case 0x04: /* Format Unit */
1146 cmn_err(CE_NOTE, "The FORMAT UNIT is not supported by this "
1147 "device If this option is selected from the format utility "
1148 "do not continue further. Please refer to cpqary3 driver "
1149 "man pages for details.");
1150
1151 return (0);
1152 case SCSI_LOG_SENSE:
1153 case SCSI_MODE_SELECT:
1154 case SCSI_PERSISTENT_RESERVE_IN:
1155 arqstat->sts_status.sts_chk = 1; /* CHECK CONDITION */
1156 arqstat->sts_rqpkt_reason = CMD_CMPLT;
1157 arqstat->sts_rqpkt_resid = 0;
1158 arqstat->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
1159 STATE_SENT_CMD | STATE_XFERRED_DATA;
1160 arqstat->sts_rqpkt_statistics = 0;
1161 arqstat->sts_sensedata.es_valid = 1;
1162 arqstat->sts_sensedata.es_class = CLASS_EXTENDED_SENSE;
1163 arqstat->sts_sensedata.es_key = KEY_ILLEGAL_REQUEST;
1164 scsi_pktp->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
1165 STATE_SENT_CMD | STATE_XFERRED_DATA;
1166
1167 if (scsi_pktp->pkt_comp) {
1168 (*scsi_pktp->pkt_comp)(scsi_pktp);
1169 }
1170 return (1);
1171 }
1172
1173 return (0);
1174 }
1175
1176 /* PERF */
1177 /*
1178 * Function : cpqary3_oscmd_complete
1179 * Description : This routine processes the
1180 * completed OS commands and
1181 * initiates any callback that is needed.
1182 * Called By : cpqary3_transport
1183 * Parameters : per-command
1184 * Calls : cpqary3_ioctl_send_bmiccmd,
1185 * cpqary3_ioctl_send_scsicmd,
1186 * cpqary3_send_abortcmd, cpqary3_flush_cache,
1187 * cpqary3_probe4LVs,
1188 * cpqary3_probe4Tapes, cpqary3_synccmd_complete,
1189 * cpqary3_detect_target_geometry,
1190 * cpqary3_detect_target_geometry
1191 * Return Values: None
1192 */
1193 void
1194 cpqary3_oscmd_complete(cpqary3_cmdpvt_t *cpqary3_cmdpvtp)
1195 {
1196 cpqary3_t *cpqary3p;
1197 ErrorInfo_t *errorinfop;
1198 CommandList_t *cmdlistp;
1199 struct scsi_pkt *scsi_pktp;
1200
1201 ASSERT(cpqary3_cmdpvtp != NULL);
1202
1203 if (CPQARY3_TIMEOUT == cpqary3_cmdpvtp->cmdpvt_flag) {
1204 cpqary3_cmdlist_release(cpqary3_cmdpvtp,
1205 CPQARY3_NO_MUTEX);
1206 return;
1207 }
1208
1209 cpqary3p = cpqary3_cmdpvtp->ctlr;
1210 cmdlistp = cpqary3_cmdpvtp->cmdlist_memaddr;
1211 errorinfop = cpqary3_cmdpvtp->errorinfop;
1212
1213 if (cmdlistp->Header.Tag.drvinfo_n_err == CPQARY3_OSCMD_SUCCESS) {
1214 scsi_pktp = cpqary3_cmdpvtp->pvt_pkt->scsi_cmd_pkt;
1215 scsi_pktp->pkt_reason = CMD_CMPLT;
1216 scsi_pktp->pkt_statistics = 0;
1217 scsi_pktp->pkt_state = STATE_GOT_BUS |
1218 STATE_GOT_TARGET | STATE_SENT_CMD |
1219 STATE_XFERRED_DATA | STATE_GOT_STATUS;
1220
1221 if (cpqary3_cmdpvtp->pvt_pkt->scsi_cmd_pkt->pkt_flags &
1222 FLAG_NOINTR) {
1223 cpqary3_cmdlist_release(cpqary3_cmdpvtp,
1224 CPQARY3_NO_MUTEX);
1225 } else {
1226 cpqary3_cmdlist_release(cpqary3_cmdpvtp,
1227 CPQARY3_NO_MUTEX);
1228
1229 if (scsi_pktp->pkt_comp) {
1230 mutex_exit(&cpqary3p->sw_mutex);
1231 (*scsi_pktp->pkt_comp)(scsi_pktp);
1232 mutex_enter(&cpqary3p->sw_mutex);
1233 }
1234 }
1235 return;
1236 } else {
1237 scsi_pktp = cpqary3_cmdpvtp->pvt_pkt->scsi_cmd_pkt;
1238 }
1239
1240 switch (errorinfop->CommandStatus) {
1241 case CISS_CMD_DATA_OVERRUN :
1242 scsi_pktp->pkt_reason = CMD_DATA_OVR;
1243 scsi_pktp->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
1244 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
1245 break;
1246
1247 case CISS_CMD_INVALID :
1248 DTRACE_PROBE1(invalid_cmd, struct scsi_pkt *, scsi_pktp);
1249 scsi_pktp->pkt_reason = CMD_BADMSG;
1250 scsi_pktp->pkt_state = STATE_GOT_BUS |STATE_GOT_TARGET |
1251 STATE_SENT_CMD | STATE_GOT_STATUS;
1252 break;
1253
1254 case CISS_CMD_PROTOCOL_ERR :
1255 scsi_pktp->pkt_reason = CMD_BADMSG;
1256 scsi_pktp->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
1257 STATE_SENT_CMD | STATE_GOT_STATUS;
1258 break;
1259
1260 case CISS_CMD_HARDWARE_ERR:
1261 case CISS_CMD_CONNECTION_LOST:
1262 scsi_pktp->pkt_reason = CMD_INCOMPLETE;
1263 scsi_pktp->pkt_state = 0;
1264 break;
1265
1266 case CISS_CMD_ABORTED:
1267 case CISS_CMD_UNSOLICITED_ABORT:
1268 scsi_pktp->pkt_reason = CMD_ABORTED;
1269 scsi_pktp->pkt_statistics = STAT_ABORTED;
1270 scsi_pktp->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
1271 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
1272 break;
1273
1274 case CISS_CMD_ABORT_FAILED:
1275 break;
1276
1277 case CISS_CMD_TIMEOUT:
1278 scsi_pktp->pkt_reason = CMD_TIMEOUT;
1279 scsi_pktp->pkt_statistics = STAT_TIMEOUT;
1280 scsi_pktp->pkt_state = 0;
1281 break;
1282
1283 case CISS_CMD_DATA_UNDERRUN: /* Significant ONLY for Read & Write */
1284 if (cpqary3_is_scsi_read_write(scsi_pktp)) {
1285 scsi_pktp->pkt_reason = CMD_CMPLT;
1286 scsi_pktp->pkt_statistics = 0;
1287 scsi_pktp->pkt_state =
1288 STATE_GOT_BUS | STATE_GOT_TARGET | STATE_SENT_CMD |
1289 STATE_XFERRED_DATA | STATE_GOT_STATUS;
1290 break;
1291 }
1292 /* FALLTHROUGH */
1293 case CISS_CMD_SUCCESS:
1294 case CISS_CMD_TARGET_STATUS:
1295 scsi_pktp->pkt_reason = CMD_CMPLT;
1296 scsi_pktp->pkt_statistics = 0;
1297 scsi_pktp->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
1298 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
1299 break;
1300
1301 default: /* Should never Occur !!! */
1302 scsi_pktp->pkt_reason = CMD_TRAN_ERR;
1303 break;
1304 }
1305
1306
1307 /*
1308 * if ever a command completes with a CHECK CONDITION or a
1309 * COMMAND_TERMINATED SCSI status, Update the sense data.
1310 * NOTE : The CISS_CMD_INVALID command status would always result in a
1311 * CHECK CONDITION and hence reach this part of the code.
1312 */
1313
1314 if ((errorinfop->ScsiStatus == SCSI_CHECK_CONDITION) ||
1315 (errorinfop->ScsiStatus == SCSI_COMMAND_TERMINATED)) {
1316 if (errorinfop->SenseLen) {
1317 struct scsi_arq_status *arq_statusp;
1318 arq_statusp =
1319 /* LINTED: alignment */
1320 (struct scsi_arq_status *)scsi_pktp->pkt_scbp;
1321
1322 if ((errorinfop->ScsiStatus == SCSI_CHECK_CONDITION)) {
1323 arq_statusp->sts_status.sts_chk = (uint8_t)1;
1324 } else {
1325 arq_statusp->sts_status.sts_chk = (uint8_t)1;
1326 arq_statusp->sts_status.sts_scsi2 = (uint8_t)1;
1327 }
1328 bzero((void *)&(arq_statusp->sts_rqpkt_status),
1329 sizeof (struct scsi_status));
1330 arq_statusp->sts_rqpkt_reason = CMD_CMPLT;
1331 arq_statusp->sts_rqpkt_resid = 0;
1332 arq_statusp->sts_rqpkt_state = scsi_pktp->pkt_state;
1333 arq_statusp->sts_rqpkt_statistics =
1334 scsi_pktp->pkt_statistics;
1335 bcopy((caddr_t)&errorinfop->SenseInfo[0],
1336 (caddr_t)(&arq_statusp->sts_sensedata),
1337 CPQARY3_MIN(errorinfop->SenseLen,
1338 cpqary3_cmdpvtp->pvt_pkt->scb_len));
1339 scsi_pktp->pkt_state |= STATE_ARQ_DONE;
1340 }
1341 }
1342
1343 if (cpqary3_cmdpvtp->pvt_pkt->scsi_cmd_pkt->pkt_flags & FLAG_NOINTR) {
1344 cpqary3_cmdlist_release(cpqary3_cmdpvtp, CPQARY3_NO_MUTEX);
1345 } else {
1346 cpqary3_cmdlist_release(cpqary3_cmdpvtp, CPQARY3_NO_MUTEX);
1347
1348 if (scsi_pktp->pkt_comp) {
1349 mutex_exit(&cpqary3p->sw_mutex);
1350 (*scsi_pktp->pkt_comp)(scsi_pktp);
1351 mutex_enter(&cpqary3p->sw_mutex);
1352 }
1353 }
1354 }
1355
1356 static uint8_t
1357 cpqary3_is_scsi_read_write(struct scsi_pkt *scsi_pktp)
1358 {
1359 /*
1360 * In the scsi packet structure, the first byte is the SCSI Command
1361 * OpCode. We check to see if it is any one of the SCSI Read or Write
1362 * opcodes.
1363 */
1364
1365 switch (scsi_pktp->pkt_cdbp[0]) {
1366 case SCSI_READ_6:
1367 case SCSI_READ_10:
1368 case SCSI_READ_12:
1369 case SCSI_WRITE_6:
1370 case SCSI_WRITE_10:
1371 case SCSI_WRITE_12:
1372 return (1);
1373
1374 default:
1375 return (0);
1376 }
1377 }
Unleashed OS