2 * Copyright (c) 2004-07 Applied Micro Circuits Corporation.
3 * Copyright (c) 2004-05 Vinod Kashyap
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
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.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * AMCC'S 3ware driver for 9000 series storage controllers.
33 * Author: Vinod Kashyap
34 * Modifications by: Adam Radford
35 * Modifications by: Manjunath Ranganathaiah
40 * Common Layer miscellaneous functions.
44 #include "tw_osl_share.h"
45 #include "tw_cl_share.h"
46 #include "tw_cl_fwif.h"
47 #include "tw_cl_ioctl.h"
49 #include "tw_cl_externs.h"
50 #include "tw_osl_ioctl.h"
54 /* AEN severity table. */
55 TW_INT8 *tw_cli_severity_string_table[] = {
57 TW_CL_SEVERITY_ERROR_STRING,
58 TW_CL_SEVERITY_WARNING_STRING,
59 TW_CL_SEVERITY_INFO_STRING,
60 TW_CL_SEVERITY_DEBUG_STRING,
67 * Function name: tw_cli_drain_complete_queue
68 * Description: This function gets called during a controller reset.
69 * It errors back to the OS Layer, all those requests that
70 * are in the complete queue, at the time of the reset.
71 * Any CL internal requests will be simply freed.
73 * Input: ctlr -- ptr to CL internal ctlr context
78 tw_cli_drain_complete_queue(struct tw_cli_ctlr_context *ctlr)
80 struct tw_cli_req_context *req;
81 struct tw_cl_req_packet *req_pkt;
83 tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
85 /* Walk the busy queue. */
86 while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_COMPLETE_Q))) {
87 if (req->flags & TW_CLI_REQ_FLAGS_INTERNAL) {
89 * It's an internal request. Set the appropriate
90 * error and call the CL internal callback if there's
91 * one. If the request originator is polling for
92 * completion, he should be checking req->error to
93 * determine that the request did not go through.
94 * The request originators are responsible for the
97 req->error_code = TW_CL_ERR_REQ_BUS_RESET;
98 if (req->tw_cli_callback)
99 req->tw_cli_callback(req);
101 if ((req_pkt = req->orig_req)) {
102 /* It's a SCSI request. Complete it. */
103 tw_cli_dbg_printf(2, ctlr->ctlr_handle,
105 "Completing complete request %p "
108 req_pkt->status = TW_CL_ERR_REQ_BUS_RESET;
109 req_pkt->tw_osl_callback(req->req_handle);
111 tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
119 * Function name: tw_cli_drain_busy_queue
120 * Description: This function gets called during a controller reset.
121 * It errors back to the OS Layer, all those requests that
122 * were pending with the firmware, at the time of the
125 * Input: ctlr -- ptr to CL internal ctlr context
130 tw_cli_drain_busy_queue(struct tw_cli_ctlr_context *ctlr)
132 struct tw_cli_req_context *req;
133 struct tw_cl_req_packet *req_pkt;
135 tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
137 /* Walk the busy queue. */
138 while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_BUSY_Q))) {
139 if (req->flags & TW_CLI_REQ_FLAGS_INTERNAL) {
141 * It's an internal request. Set the appropriate
142 * error and call the CL internal callback if there's
143 * one. If the request originator is polling for
144 * completion, he should be checking req->error to
145 * determine that the request did not go through.
146 * The request originators are responsible for the
149 req->error_code = TW_CL_ERR_REQ_BUS_RESET;
150 if (req->tw_cli_callback)
151 req->tw_cli_callback(req);
153 if ((req_pkt = req->orig_req)) {
154 /* It's a SCSI request. Complete it. */
155 tw_cli_dbg_printf(2, ctlr->ctlr_handle,
157 "Completing busy request %p on reset",
159 req_pkt->status = TW_CL_ERR_REQ_BUS_RESET;
160 req_pkt->tw_osl_callback(req->req_handle);
162 tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
170 * Function name: tw_cli_drain_pending_queue
171 * Description: This function gets called during a controller reset.
172 * It errors back to the OS Layer, all those requests that
173 * were in the pending queue, at the time of the reset.
175 * Input: ctlr -- ptr to CL internal ctlr context
181 tw_cli_drain_pending_queue(struct tw_cli_ctlr_context *ctlr)
183 struct tw_cli_req_context *req;
184 struct tw_cl_req_packet *req_pkt;
186 tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
189 * Pull requests off the pending queue, and complete them.
191 while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_PENDING_Q))) {
192 if (req->flags & TW_CLI_REQ_FLAGS_INTERNAL) {
194 * It's an internal request. Set the appropriate
195 * error and call the CL internal callback if there's
196 * one. If the request originator is polling for
197 * completion, he should be checking req->error to
198 * determine that the request did not go through.
199 * The request originators are responsible for the
202 req->error_code = TW_CL_ERR_REQ_BUS_RESET;
203 if (req->tw_cli_callback)
204 req->tw_cli_callback(req);
206 if ((req_pkt = req->orig_req)) {
207 /* It's an external request. Complete it. */
208 tw_cli_dbg_printf(2, ctlr->ctlr_handle,
210 "Completing pending request %p "
212 req_pkt->status = TW_CL_ERR_REQ_BUS_RESET;
213 req_pkt->tw_osl_callback(req->req_handle);
215 tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
223 * Function name: tw_cli_drain_response_queue
224 * Description: Drain the controller response queue.
226 * Input: ctlr -- ptr to per ctlr structure
228 * Return value: 0 -- success
232 tw_cli_drain_response_queue(struct tw_cli_ctlr_context *ctlr)
235 TW_UINT32 status_reg;
237 tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
240 status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr->ctlr_handle);
242 if (tw_cli_check_ctlr_state(ctlr, status_reg))
243 return(TW_OSL_EGENFAILURE);
245 if (status_reg & TWA_STATUS_RESPONSE_QUEUE_EMPTY)
246 return(TW_OSL_ESUCCESS); /* no more response queue entries */
248 resp = TW_CLI_READ_RESPONSE_QUEUE(ctlr->ctlr_handle);
255 * Function name: tw_cli_find_response
256 * Description: Find a particular response in the ctlr response queue.
258 * Input: ctlr -- ptr to per ctlr structure
259 * req_id -- request id of the response to look for
261 * Return value: 0 -- success
265 tw_cli_find_response(struct tw_cli_ctlr_context *ctlr, TW_INT32 req_id)
269 TW_UINT32 status_reg;
271 tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
274 status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr->ctlr_handle);
276 if (tw_cli_check_ctlr_state(ctlr, status_reg))
277 return(TW_OSL_EGENFAILURE);
279 if (status_reg & TWA_STATUS_RESPONSE_QUEUE_EMPTY)
280 return(TW_OSL_ENOTTY); /* no more response queue entries */
282 if (ctlr->device_id == TW_CL_DEVICE_ID_9K) {
283 resp = TW_CLI_READ_RESPONSE_QUEUE(ctlr->ctlr_handle);
284 resp_id = GET_RESP_ID(resp);
286 resp = TW_CLI_READ_LARGE_RESPONSE_QUEUE(
288 resp_id = GET_LARGE_RESP_ID(resp);
290 if (resp_id == req_id)
291 return(TW_OSL_ESUCCESS); /* found the req_id */
298 * Function name: tw_cli_drain_aen_queue
299 * Description: Fetches all un-retrieved AEN's posted by fw.
301 * Input: ctlr -- ptr to CL internal ctlr context
303 * Return value: 0 -- success
307 tw_cli_drain_aen_queue(struct tw_cli_ctlr_context *ctlr)
309 struct tw_cli_req_context *req;
310 struct tw_cl_command_header *cmd_hdr;
315 tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
318 if ((req = tw_cli_get_request(ctlr
320 error = TW_OSL_EBUSY;
324 req->flags |= TW_CLI_REQ_FLAGS_INTERNAL;
325 req->tw_cli_callback = TW_CL_NULL;
326 if ((error = tw_cli_send_scsi_cmd(req,
327 0x03 /* REQUEST_SENSE */))) {
328 tw_cli_dbg_printf(1, ctlr->ctlr_handle,
330 "Cannot send command to fetch aen");
334 end_time = tw_osl_get_local_time() +
335 TW_CLI_REQUEST_TIMEOUT_PERIOD;
337 if ((error = req->error_code))
339 * This will take care of completion due to
340 * a reset, or a failure in
341 * tw_cli_submit_pending_queue.
345 tw_cli_process_resp_intr(req->ctlr);
347 if ((req->state != TW_CLI_REQ_STATE_BUSY) &&
348 (req->state != TW_CLI_REQ_STATE_PENDING))
350 } while (tw_osl_get_local_time() <= end_time);
352 if (req->state != TW_CLI_REQ_STATE_COMPLETE) {
353 error = TW_OSL_ETIMEDOUT;
357 if ((error = req->cmd_pkt->command.cmd_pkt_9k.status)) {
358 cmd_hdr = &req->cmd_pkt->cmd_hdr;
359 tw_cli_create_ctlr_event(ctlr,
360 TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
365 aen_code = tw_cli_manage_aen(ctlr, req);
366 if (aen_code == TWA_AEN_QUEUE_EMPTY)
368 if (aen_code == TWA_AEN_SYNC_TIME_WITH_HOST)
371 ctlr->state &= ~TW_CLI_CTLR_STATE_INTERNAL_REQ_BUSY;
372 tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
378 ctlr->state &= ~TW_CLI_CTLR_STATE_INTERNAL_REQ_BUSY;
379 tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
387 * Function name: tw_cli_find_aen
388 * Description: Reports whether a given AEN ever occurred.
390 * Input: ctlr -- ptr to CL internal ctlr context
391 * aen_code-- AEN to look for
393 * Return value: 0 -- success
397 tw_cli_find_aen(struct tw_cli_ctlr_context *ctlr, TW_UINT16 aen_code)
399 TW_UINT32 last_index;
402 tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
404 if (ctlr->aen_q_wrapped)
405 last_index = ctlr->aen_head;
411 i = (i + ctlr->max_aens_supported - 1) %
412 ctlr->max_aens_supported;
413 if (ctlr->aen_queue[i].aen_code == aen_code)
414 return(TW_OSL_ESUCCESS);
415 } while (i != last_index);
417 return(TW_OSL_EGENFAILURE);
423 * Function name: tw_cli_poll_status
424 * Description: Poll for a given status to show up in the firmware
427 * Input: ctlr -- ptr to CL internal ctlr context
428 * status -- status to look for
429 * timeout -- max # of seconds to wait before giving up
431 * Return value: 0 -- success
435 tw_cli_poll_status(struct tw_cli_ctlr_context *ctlr, TW_UINT32 status,
439 TW_UINT32 status_reg;
441 tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
443 end_time = tw_osl_get_local_time() + timeout;
445 status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr->ctlr_handle);
446 if ((status_reg & status) == status)
447 /* got the required bit(s) */
448 return(TW_OSL_ESUCCESS);
451 * The OSL should not define TW_OSL_CAN_SLEEP if it calls
452 * tw_cl_deferred_interrupt from within the ISR and not a
453 * lower interrupt level, since, in that case, we might end
454 * up here, and try to sleep (within an ISR).
456 #ifndef TW_OSL_CAN_SLEEP
457 /* OSL doesn't support sleeping; will spin. */
459 #else /* TW_OSL_CAN_SLEEP */
461 /* Will spin if initializing, sleep otherwise. */
462 if (!(ctlr->state & TW_CLI_CTLR_STATE_ACTIVE))
465 tw_osl_sleep(ctlr->ctlr_handle,
466 &(ctlr->sleep_handle), 1 /* ms */);
469 * Will always spin for now (since reset holds a spin lock).
470 * We could free io_lock after the call to TW_CLI_SOFT_RESET,
471 * so we could sleep here. To block new requests (since
472 * the lock will have been released) we could use the
473 * ...RESET_IN_PROGRESS flag. Need to revisit.
477 #endif /* TW_OSL_CAN_SLEEP */
478 } while (tw_osl_get_local_time() <= end_time);
480 return(TW_OSL_ETIMEDOUT);
486 * Function name: tw_cl_create_event
487 * Description: Creates and queues ctlr/CL/OSL AEN's to be
488 * supplied to user-space tools on request.
489 * Also notifies OS Layer.
490 * Input: ctlr -- ptr to CL internal ctlr context
491 * queue_event-- TW_CL_TRUE --> queue event;
492 * TW_CL_FALSE--> don't queue event
493 * (simply notify OSL)
494 * event_src -- source of event
495 * event_code -- AEN/error code
496 * severity -- severity of event
497 * severity_str--Text description of severity
498 * event_desc -- standard string related to the event/error
499 * event_specific_desc -- format string for additional
500 * info about the event
501 * ... -- additional arguments conforming to the format
502 * specified by event_specific_desc
507 tw_cl_create_event(struct tw_cl_ctlr_handle *ctlr_handle,
508 TW_UINT8 queue_event, TW_UINT8 event_src, TW_UINT16 event_code,
509 TW_UINT8 severity, TW_UINT8 *severity_str, TW_UINT8 *event_desc,
510 TW_UINT8 *event_specific_desc, ...)
512 struct tw_cli_ctlr_context *ctlr = ctlr_handle->cl_ctlr_ctxt;
513 struct tw_cl_event_packet event_pkt;
514 struct tw_cl_event_packet *event;
518 tw_cli_dbg_printf(8, ctlr_handle, tw_osl_cur_func(), "entered");
520 if ((ctlr) && (queue_event)) {
521 /* Protect access to ctlr->aen_head. */
522 tw_osl_get_lock(ctlr_handle, ctlr->gen_lock);
524 aen_head = ctlr->aen_head;
525 ctlr->aen_head = (aen_head + 1) % ctlr->max_aens_supported;
527 /* Queue the event. */
528 event = &(ctlr->aen_queue[aen_head]);
529 tw_osl_memzero(event->parameter_data,
530 sizeof(event->parameter_data));
532 if (event->retrieved == TW_CL_AEN_NOT_RETRIEVED)
533 ctlr->aen_q_overflow = TW_CL_TRUE;
534 event->sequence_id = ++(ctlr->aen_cur_seq_id);
535 if ((aen_head + 1) == ctlr->max_aens_supported) {
536 tw_cli_dbg_printf(4, ctlr->ctlr_handle,
537 tw_osl_cur_func(), "AEN queue wrapped");
538 ctlr->aen_q_wrapped = TW_CL_TRUE;
541 /* Free access to ctlr->aen_head. */
542 tw_osl_free_lock(ctlr_handle, ctlr->gen_lock);
545 tw_osl_memzero(event, sizeof(struct tw_cl_event_packet));
548 event->event_src = event_src;
549 event->time_stamp_sec = (TW_UINT32)tw_osl_get_local_time();
550 event->aen_code = event_code;
551 event->severity = severity;
552 tw_osl_strcpy(event->severity_str, severity_str);
553 event->retrieved = TW_CL_AEN_NOT_RETRIEVED;
555 va_start(ap, event_specific_desc);
556 tw_osl_vsprintf(event->parameter_data, event_specific_desc, ap);
559 event->parameter_len =
560 (TW_UINT8)(tw_osl_strlen(event->parameter_data));
561 tw_osl_strcpy(event->parameter_data + event->parameter_len + 1,
563 event->parameter_len += (1 + tw_osl_strlen(event_desc));
565 tw_cli_dbg_printf(4, ctlr_handle, tw_osl_cur_func(),
566 "event = %x %x %x %x %x %x %x\n %s",
568 event->time_stamp_sec,
573 event->parameter_len,
574 event->parameter_data);
576 tw_osl_notify_event(ctlr_handle, event);
582 * Function name: tw_cli_get_request
583 * Description: Gets a request pkt from the free queue.
585 * Input: ctlr -- ptr to CL internal ctlr context
586 * req_pkt -- ptr to OSL built req_pkt, if there's one
588 * Return value: ptr to request pkt -- success
589 * TW_CL_NULL -- failure
591 struct tw_cli_req_context *
592 tw_cli_get_request(struct tw_cli_ctlr_context *ctlr
595 struct tw_cli_req_context *req;
597 tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
600 /* Get a free request packet. */
601 req = tw_cli_req_q_remove_head(ctlr, TW_CLI_FREE_Q);
604 /* Initialize some fields to their defaults. */
606 req->req_handle = TW_CL_NULL;
607 req->data = TW_CL_NULL;
610 req->state = TW_CLI_REQ_STATE_INIT; /* req being initialized */
613 req->orig_req = TW_CL_NULL;
614 req->tw_cli_callback = TW_CL_NULL;
617 * Look at the status field in the command packet to see how
618 * it completed the last time it was used, and zero out only
619 * the portions that might have changed. Note that we don't
620 * care to zero out the sglist.
622 if (req->cmd_pkt->command.cmd_pkt_9k.status)
623 tw_osl_memzero(req->cmd_pkt,
624 sizeof(struct tw_cl_command_header) +
625 28 /* max bytes before sglist */);
627 tw_osl_memzero(&(req->cmd_pkt->command),
628 28 /* max bytes before sglist */);
637 * Function name: tw_cli_dbg_printf
638 * Description: Calls OSL print function if dbg_level is appropriate
640 * Input: dbg_level -- Determines whether or not to print
641 * ctlr_handle -- controller handle
642 * cur_func -- text name of calling function
643 * fmt -- format string for the arguments to follow
644 * ... -- variable number of arguments, to be printed
645 * based on the fmt string
650 tw_cli_dbg_printf(TW_UINT8 dbg_level,
651 struct tw_cl_ctlr_handle *ctlr_handle, const TW_INT8 *cur_func,
655 TW_INT8 print_str[256];
658 tw_osl_memzero(print_str, 256);
659 if (dbg_level <= TW_OSL_DEBUG_LEVEL_FOR_CL) {
660 tw_osl_sprintf(print_str, "%s: ", cur_func);
663 tw_osl_vsprintf(print_str + tw_osl_strlen(print_str), fmt, ap);
666 tw_osl_strcpy(print_str + tw_osl_strlen(print_str), "\n");
667 tw_osl_dbg_printf(ctlr_handle, print_str);
669 #endif /* TW_OSL_DEBUG */
675 * Function name: tw_cli_notify_ctlr_info
676 * Description: Notify OSL of controller info (fw/BIOS versions, etc.).
678 * Input: ctlr -- ptr to CL internal ctlr context
683 tw_cli_notify_ctlr_info(struct tw_cli_ctlr_context *ctlr)
686 TW_INT8 bios_ver[16];
687 TW_INT8 ctlr_model[16];
689 TW_UINT8 num_ports = 0;
691 tw_cli_dbg_printf(5, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
693 /* Get the port count. */
694 error[0] = tw_cli_get_param(ctlr, TWA_PARAM_CONTROLLER_TABLE,
695 TWA_PARAM_CONTROLLER_PORT_COUNT, &num_ports,
698 /* Get the firmware and BIOS versions. */
699 error[0] = tw_cli_get_param(ctlr, TWA_PARAM_VERSION_TABLE,
700 TWA_PARAM_VERSION_FW, fw_ver, 16, TW_CL_NULL);
701 error[1] = tw_cli_get_param(ctlr, TWA_PARAM_VERSION_TABLE,
702 TWA_PARAM_VERSION_BIOS, bios_ver, 16, TW_CL_NULL);
703 error[2] = tw_cli_get_param(ctlr, TWA_PARAM_VERSION_TABLE,
704 TWA_PARAM_CTLR_MODEL, ctlr_model, 16, TW_CL_NULL);
706 tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
707 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
708 0x1300, 0x3, TW_CL_SEVERITY_INFO_STRING,
709 "Controller details:",
710 "Model %.16s, %d ports, Firmware %.16s, BIOS %.16s",
711 error[2]?(TW_INT8 *)TW_CL_NULL:ctlr_model,
713 error[0]?(TW_INT8 *)TW_CL_NULL:fw_ver,
714 error[1]?(TW_INT8 *)TW_CL_NULL:bios_ver);
720 * Function name: tw_cli_check_ctlr_state
721 * Description: Makes sure that the fw status register reports a
724 * Input: ctlr -- ptr to CL internal ctlr context
725 * status_reg-- value in the status register
727 * Return value: 0 -- no errors
731 tw_cli_check_ctlr_state(struct tw_cli_ctlr_context *ctlr, TW_UINT32 status_reg)
733 struct tw_cl_ctlr_handle *ctlr_handle = ctlr->ctlr_handle;
734 TW_INT32 error = TW_OSL_ESUCCESS;
736 tw_cli_dbg_printf(8, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
738 /* Check if the 'micro-controller ready' bit is not set. */
739 if ((status_reg & TWA_STATUS_EXPECTED_BITS) !=
740 TWA_STATUS_EXPECTED_BITS) {
743 tw_osl_memzero(desc, 200);
744 if ((status_reg & TWA_STATUS_MICROCONTROLLER_READY) ||
746 TW_CLI_CTLR_STATE_RESET_PHASE1_IN_PROGRESS))) {
747 tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
748 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
749 0x1301, 0x1, TW_CL_SEVERITY_ERROR_STRING,
750 "Missing expected status bit(s)",
751 "status reg = 0x%x; Missing bits: %s",
753 tw_cli_describe_bits (~status_reg &
754 TWA_STATUS_EXPECTED_BITS, desc));
755 error = TW_OSL_EGENFAILURE;
759 /* Check if any error bits are set. */
760 if ((status_reg & TWA_STATUS_UNEXPECTED_BITS) != 0) {
763 tw_osl_memzero(desc, 200);
765 /* Skip queue error msgs during 9650SE/9690SA reset */
766 if (((ctlr->device_id != TW_CL_DEVICE_ID_9K_E) &&
767 (ctlr->device_id != TW_CL_DEVICE_ID_9K_SA)) ||
768 ((ctlr->state & TW_CLI_CTLR_STATE_RESET_IN_PROGRESS) == 0) ||
769 ((status_reg & TWA_STATUS_QUEUE_ERROR_INTERRUPT) == 0))
770 tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
771 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
772 0x1302, 0x1, TW_CL_SEVERITY_ERROR_STRING,
773 "Unexpected status bit(s)",
774 "status reg = 0x%x Unexpected bits: %s",
775 status_reg & TWA_STATUS_UNEXPECTED_BITS,
776 tw_cli_describe_bits(status_reg &
777 TWA_STATUS_UNEXPECTED_BITS, desc));
779 if (status_reg & TWA_STATUS_PCI_PARITY_ERROR_INTERRUPT) {
780 tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
781 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
782 0x1303, 0x1, TW_CL_SEVERITY_ERROR_STRING,
783 "PCI parity error: clearing... "
784 "Re-seat/move/replace card",
785 "status reg = 0x%x %s",
787 tw_cli_describe_bits(status_reg, desc));
788 TW_CLI_WRITE_CONTROL_REGISTER(ctlr->ctlr_handle,
789 TWA_CONTROL_CLEAR_PARITY_ERROR);
791 #ifdef TW_OSL_PCI_CONFIG_ACCESSIBLE
792 tw_osl_write_pci_config(ctlr->ctlr_handle,
793 TW_CLI_PCI_CONFIG_STATUS_OFFSET,
794 TWA_PCI_CONFIG_CLEAR_PARITY_ERROR, 2);
795 #endif /* TW_OSL_PCI_CONFIG_ACCESSIBLE */
799 if (status_reg & TWA_STATUS_PCI_ABORT_INTERRUPT) {
800 tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
801 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
802 0x1304, 0x1, TW_CL_SEVERITY_ERROR_STRING,
803 "PCI abort: clearing... ",
804 "status reg = 0x%x %s",
806 tw_cli_describe_bits(status_reg, desc));
807 TW_CLI_WRITE_CONTROL_REGISTER(ctlr->ctlr_handle,
808 TWA_CONTROL_CLEAR_PCI_ABORT);
810 #ifdef TW_OSL_PCI_CONFIG_ACCESSIBLE
811 tw_osl_write_pci_config(ctlr->ctlr_handle,
812 TW_CLI_PCI_CONFIG_STATUS_OFFSET,
813 TWA_PCI_CONFIG_CLEAR_PCI_ABORT, 2);
814 #endif /* TW_OSL_PCI_CONFIG_ACCESSIBLE */
818 if (status_reg & TWA_STATUS_QUEUE_ERROR_INTERRUPT) {
819 /* Skip queue error msgs during 9650SE/9690SA reset */
820 if (((ctlr->device_id != TW_CL_DEVICE_ID_9K_E) &&
821 (ctlr->device_id != TW_CL_DEVICE_ID_9K_SA)) ||
822 ((ctlr->state & TW_CLI_CTLR_STATE_RESET_IN_PROGRESS) == 0))
823 tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
824 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
825 0x1305, 0x1, TW_CL_SEVERITY_ERROR_STRING,
826 "Controller queue error: clearing... ",
827 "status reg = 0x%x %s",
829 tw_cli_describe_bits(status_reg, desc));
830 TW_CLI_WRITE_CONTROL_REGISTER(ctlr->ctlr_handle,
831 TWA_CONTROL_CLEAR_QUEUE_ERROR);
834 if (status_reg & TWA_STATUS_MICROCONTROLLER_ERROR) {
835 tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
836 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
837 0x1307, 0x1, TW_CL_SEVERITY_ERROR_STRING,
838 "Micro-controller error! ",
839 "status reg = 0x%x %s",
841 tw_cli_describe_bits(status_reg, desc));
842 error = TW_OSL_EGENFAILURE;
851 * Function name: tw_cli_describe_bits
852 * Description: Given the value of the status register, returns a
853 * string describing the meaning of each set bit.
855 * Input: reg -- status register value
856 * Output: Pointer to a string describing each set bit
857 * Return value: Pointer to the string describing each set bit
860 tw_cli_describe_bits(TW_UINT32 reg, TW_INT8 *str)
862 tw_osl_strcpy(str, "[");
864 if (reg & TWA_STATUS_COMMAND_QUEUE_EMPTY)
865 tw_osl_strcpy(&str[tw_osl_strlen(str)], "CMD_Q_EMPTY,");
866 if (reg & TWA_STATUS_MICROCONTROLLER_READY)
867 tw_osl_strcpy(&str[tw_osl_strlen(str)], "MC_RDY,");
868 if (reg & TWA_STATUS_RESPONSE_QUEUE_EMPTY)
869 tw_osl_strcpy(&str[tw_osl_strlen(str)], "RESP_Q_EMPTY,");
870 if (reg & TWA_STATUS_COMMAND_QUEUE_FULL)
871 tw_osl_strcpy(&str[tw_osl_strlen(str)], "CMD_Q_FULL,");
872 if (reg & TWA_STATUS_RESPONSE_INTERRUPT)
873 tw_osl_strcpy(&str[tw_osl_strlen(str)], "RESP_INTR,");
874 if (reg & TWA_STATUS_COMMAND_INTERRUPT)
875 tw_osl_strcpy(&str[tw_osl_strlen(str)], "CMD_INTR,");
876 if (reg & TWA_STATUS_ATTENTION_INTERRUPT)
877 tw_osl_strcpy(&str[tw_osl_strlen(str)], "ATTN_INTR,");
878 if (reg & TWA_STATUS_HOST_INTERRUPT)
879 tw_osl_strcpy(&str[tw_osl_strlen(str)], "HOST_INTR,");
880 if (reg & TWA_STATUS_PCI_ABORT_INTERRUPT)
881 tw_osl_strcpy(&str[tw_osl_strlen(str)], "PCI_ABRT,");
882 if (reg & TWA_STATUS_MICROCONTROLLER_ERROR)
883 tw_osl_strcpy(&str[tw_osl_strlen(str)], "MC_ERR,");
884 if (reg & TWA_STATUS_QUEUE_ERROR_INTERRUPT)
885 tw_osl_strcpy(&str[tw_osl_strlen(str)], "Q_ERR,");
886 if (reg & TWA_STATUS_PCI_PARITY_ERROR_INTERRUPT)
887 tw_osl_strcpy(&str[tw_osl_strlen(str)], "PCI_PERR");
889 tw_osl_strcpy(&str[tw_osl_strlen(str)], "]");
898 * Function name: tw_cl_print_ctlr_stats
899 * Description: Prints the current status of the controller.
901 * Input: ctlr_handle-- controller handle
906 tw_cl_print_ctlr_stats(struct tw_cl_ctlr_handle *ctlr_handle)
908 struct tw_cli_ctlr_context *ctlr =
909 (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
910 TW_UINT32 status_reg;
913 tw_cli_dbg_printf(7, ctlr->ctlr_handle, "", "entered");
915 /* Print current controller details. */
916 tw_cli_dbg_printf(0, ctlr_handle, "", "cl_ctlr_ctxt = %p", ctlr);
918 tw_osl_memzero(desc, 200);
919 status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr_handle);
920 tw_cli_dbg_printf(0, ctlr_handle, "", "status reg = 0x%x %s",
921 status_reg, tw_cli_describe_bits(status_reg, desc));
923 tw_cli_dbg_printf(0, ctlr_handle, "", "CLq type current max");
924 tw_cli_dbg_printf(0, ctlr_handle, "", "free %04d %04d",
925 ctlr->q_stats[TW_CLI_FREE_Q].cur_len,
926 ctlr->q_stats[TW_CLI_FREE_Q].max_len);
927 tw_cli_dbg_printf(0, ctlr_handle, "", "busy %04d %04d",
928 ctlr->q_stats[TW_CLI_BUSY_Q].cur_len,
929 ctlr->q_stats[TW_CLI_BUSY_Q].max_len);
930 tw_cli_dbg_printf(0, ctlr_handle, "", "pending %04d %04d",
931 ctlr->q_stats[TW_CLI_PENDING_Q].cur_len,
932 ctlr->q_stats[TW_CLI_PENDING_Q].max_len);
933 tw_cli_dbg_printf(0, ctlr_handle, "", "complete %04d %04d",
934 ctlr->q_stats[TW_CLI_COMPLETE_Q].cur_len,
935 ctlr->q_stats[TW_CLI_COMPLETE_Q].max_len);
936 tw_cli_dbg_printf(0, ctlr_handle, "", "AEN queue head %d tail %d",
937 ctlr->aen_head, ctlr->aen_tail);
943 * Function name: tw_cl_reset_stats
944 * Description: Resets CL maintained statistics for the controller.
946 * Input: ctlr_handle-- controller handle
951 tw_cl_reset_stats(struct tw_cl_ctlr_handle *ctlr_handle)
953 struct tw_cli_ctlr_context *ctlr =
954 (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
956 tw_cli_dbg_printf(7, ctlr_handle, tw_osl_cur_func(), "entered");
957 ctlr->q_stats[TW_CLI_FREE_Q].max_len = 0;
958 ctlr->q_stats[TW_CLI_BUSY_Q].max_len = 0;
959 ctlr->q_stats[TW_CLI_PENDING_Q].max_len = 0;
960 ctlr->q_stats[TW_CLI_COMPLETE_Q].max_len = 0;
966 * Function name: tw_cli_print_req_info
967 * Description: Prints CL internal details of a given request.
969 * Input: req -- ptr to CL internal request context
974 tw_cl_print_req_info(struct tw_cl_req_handle *req_handle)
976 struct tw_cli_req_context *req = req_handle->cl_req_ctxt;
977 struct tw_cli_ctlr_context *ctlr = req->ctlr;
978 struct tw_cl_ctlr_handle *ctlr_handle = ctlr->ctlr_handle;
979 struct tw_cl_command_packet *cmd_pkt = req->cmd_pkt;
980 struct tw_cl_command_9k *cmd9k;
981 union tw_cl_command_7k *cmd7k;
984 TW_UINT32 sgl_entries;
987 tw_cli_dbg_printf(0, ctlr_handle, tw_osl_cur_func(),
988 "CL details for request:");
989 tw_cli_dbg_printf(0, ctlr_handle, tw_osl_cur_func(),
990 "req_handle = %p, ctlr = %p,\n"
991 "cmd_pkt = %p, cmd_pkt_phys = 0x%llx,\n"
992 "data = %p, length = 0x%x, data_phys = 0x%llx,\n"
993 "state = 0x%x, flags = 0x%x, error = 0x%x,\n"
994 "orig_req = %p, callback = %p, req_id = 0x%x,\n"
995 "next_req = %p, prev_req = %p",
997 cmd_pkt, req->cmd_pkt_phys,
998 req->data, req->length, req->data_phys,
999 req->state, req->flags, req->error_code,
1000 req->orig_req, req->tw_cli_callback, req->request_id,
1001 req->link.next, req->link.prev);
1003 if (req->flags & TW_CLI_REQ_FLAGS_9K) {
1004 cmd9k = &(cmd_pkt->command.cmd_pkt_9k);
1005 sgl = cmd9k->sg_list;
1006 sgl_entries = TW_CL_SWAP16(
1007 GET_SGL_ENTRIES(cmd9k->lun_h4__sgl_entries));
1008 tw_cli_dbg_printf(0, ctlr_handle, tw_osl_cur_func(),
1009 "9K cmd: opcode = 0x%x, unit = 0x%x, req_id = 0x%x,\n"
1010 "status = 0x%x, sgl_offset = 0x%x, sgl_entries = 0x%x",
1011 GET_OPCODE(cmd9k->res__opcode),
1013 TW_CL_SWAP16(GET_REQ_ID(cmd9k->lun_l4__req_id)),
1018 cdb = (TW_UINT8 *)(cmd9k->cdb);
1019 tw_cli_dbg_printf(0, ctlr_handle, tw_osl_cur_func(),
1020 "CDB: %x %x %x %x %x %x %x %x"
1021 "%x %x %x %x %x %x %x %x",
1022 cdb[0], cdb[1], cdb[2], cdb[3],
1023 cdb[4], cdb[5], cdb[6], cdb[7],
1024 cdb[8], cdb[9], cdb[10], cdb[11],
1025 cdb[12], cdb[13], cdb[14], cdb[15]);
1027 cmd7k = &(cmd_pkt->command.cmd_pkt_7k);
1028 sgl = cmd7k->param.sgl;
1029 sgl_entries = (cmd7k->generic.size -
1030 GET_SGL_OFF(cmd7k->generic.sgl_off__opcode)) /
1031 ((ctlr->flags & TW_CL_64BIT_ADDRESSES) ? 3 : 2);
1032 tw_cli_dbg_printf(0, ctlr_handle, tw_osl_cur_func(),
1033 "7K cmd: opcode = 0x%x, sgl_offset = 0x%x,\n"
1034 "size = 0x%x, req_id = 0x%x, unit = 0x%x,\n"
1035 "status = 0x%x, flags = 0x%x, count = 0x%x",
1036 GET_OPCODE(cmd7k->generic.sgl_off__opcode),
1037 GET_SGL_OFF(cmd7k->generic.sgl_off__opcode),
1038 cmd7k->generic.size,
1039 TW_CL_SWAP16(cmd7k->generic.request_id),
1040 GET_UNIT(cmd7k->generic.host_id__unit),
1041 cmd7k->generic.status,
1042 cmd7k->generic.flags,
1043 TW_CL_SWAP16(cmd7k->generic.count));
1046 tw_cli_dbg_printf(0, ctlr_handle, tw_osl_cur_func(), "SG entries:");
1048 if (ctlr->flags & TW_CL_64BIT_ADDRESSES) {
1049 struct tw_cl_sg_desc64 *sgl64 = (struct tw_cl_sg_desc64 *)sgl;
1051 for (i = 0; i < sgl_entries; i++) {
1052 tw_cli_dbg_printf(0, ctlr_handle, tw_osl_cur_func(),
1054 sgl64[i].address, sgl64[i].length);
1057 struct tw_cl_sg_desc32 *sgl32 = (struct tw_cl_sg_desc32 *)sgl;
1059 for (i = 0; i < sgl_entries; i++) {
1060 tw_cli_dbg_printf(0, ctlr_handle, tw_osl_cur_func(),
1062 sgl32[i].address, sgl32[i].length);
1067 #endif /* TW_OSL_DEBUG */