/* * Copyright (c) 2004-07 Applied Micro Circuits Corporation. * Copyright (c) 2004-05 Vinod Kashyap * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD: src/sys/dev/twa/tw_cl_io.c,v 1.7 2010/08/30 19:15:04 delphij Exp $ */ /* * AMCC'S 3ware driver for 9000 series storage controllers. * * Author: Vinod Kashyap * Modifications by: Adam Radford * Modifications by: Manjunath Ranganathaiah */ /* * Common Layer I/O functions. */ #include "tw_osl_share.h" #include "tw_cl_share.h" #include "tw_cl_fwif.h" #include "tw_cl_ioctl.h" #include "tw_cl.h" #include "tw_cl_externs.h" #include "tw_osl_ioctl.h" #include #include #include /* * Function name: tw_cl_start_io * Description: Interface to OS Layer for accepting SCSI requests. * * Input: ctlr_handle -- controller handle * req_pkt -- OSL built request packet * req_handle -- request handle * Output: None * Return value: 0 -- success * non-zero-- failure */ TW_INT32 tw_cl_start_io(struct tw_cl_ctlr_handle *ctlr_handle, struct tw_cl_req_packet *req_pkt, struct tw_cl_req_handle *req_handle) { struct tw_cli_ctlr_context *ctlr; struct tw_cli_req_context *req; struct tw_cl_command_9k *cmd; struct tw_cl_scsi_req_packet *scsi_req; TW_INT32 error = TW_CL_ERR_REQ_SUCCESS; tw_cli_dbg_printf(10, ctlr_handle, tw_osl_cur_func(), "entered"); ctlr = (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt); /* * If working with a firmware version that does not support multiple * luns, and this request is directed at a non-zero lun, error it * back right away. */ if ((req_pkt->gen_req_pkt.scsi_req.lun) && (ctlr->working_srl < TWA_MULTI_LUN_FW_SRL)) { req_pkt->status |= (TW_CL_ERR_REQ_INVALID_LUN | TW_CL_ERR_REQ_SCSI_ERROR); req_pkt->tw_osl_callback(req_handle); return(TW_CL_ERR_REQ_SUCCESS); } if ((req = tw_cli_get_request(ctlr )) == TW_CL_NULL) { tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(), "Out of request context packets: returning busy"); return(TW_OSL_EBUSY); } req_handle->cl_req_ctxt = req; req->req_handle = req_handle; req->orig_req = req_pkt; req->tw_cli_callback = tw_cli_complete_io; req->flags |= TW_CLI_REQ_FLAGS_EXTERNAL; req->flags |= TW_CLI_REQ_FLAGS_9K; scsi_req = &(req_pkt->gen_req_pkt.scsi_req); /* Build the cmd pkt. */ cmd = &(req->cmd_pkt->command.cmd_pkt_9k); req->cmd_pkt->cmd_hdr.header_desc.size_header = 128; cmd->res__opcode = BUILD_RES__OPCODE(0, TWA_FW_CMD_EXECUTE_SCSI); cmd->unit = (TW_UINT8)(scsi_req->unit); cmd->lun_l4__req_id = TW_CL_SWAP16( BUILD_LUN_L4__REQ_ID(scsi_req->lun, req->request_id)); cmd->status = 0; cmd->sgl_offset = 16; /* offset from end of hdr = max cdb len */ tw_osl_memcpy(cmd->cdb, scsi_req->cdb, scsi_req->cdb_len); if (req_pkt->flags & TW_CL_REQ_CALLBACK_FOR_SGLIST) { TW_UINT32 num_sgl_entries; req_pkt->tw_osl_sgl_callback(req_handle, cmd->sg_list, &num_sgl_entries); cmd->lun_h4__sgl_entries = TW_CL_SWAP16(BUILD_LUN_H4__SGL_ENTRIES(scsi_req->lun, num_sgl_entries)); } else { cmd->lun_h4__sgl_entries = TW_CL_SWAP16(BUILD_LUN_H4__SGL_ENTRIES(scsi_req->lun, scsi_req->sgl_entries)); tw_cli_fill_sg_list(ctlr, scsi_req->sg_list, cmd->sg_list, scsi_req->sgl_entries); } if (((TW_CL_Q_FIRST_ITEM(&(ctlr->req_q_head[TW_CLI_PENDING_Q]))) != TW_CL_NULL) || (ctlr->reset_in_progress)) { tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q); TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle, TWA_CONTROL_UNMASK_COMMAND_INTERRUPT); } else if ((error = tw_cli_submit_cmd(req))) { tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(), "Could not start request. request = %p, error = %d", req, error); tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q); } return(error); } /* * Function name: tw_cli_submit_cmd * Description: Submits a cmd to firmware. * * Input: req -- ptr to CL internal request context * Output: None * Return value: 0 -- success * non-zero-- failure */ TW_INT32 tw_cli_submit_cmd(struct tw_cli_req_context *req) { struct tw_cli_ctlr_context *ctlr = req->ctlr; struct tw_cl_ctlr_handle *ctlr_handle = ctlr->ctlr_handle; TW_UINT32 status_reg; TW_INT32 error = 0; tw_cli_dbg_printf(10, ctlr_handle, tw_osl_cur_func(), "entered"); /* Serialize access to the controller cmd queue. */ tw_osl_get_lock(ctlr_handle, ctlr->io_lock); /* For 9650SE first write low 4 bytes */ if ((ctlr->device_id == TW_CL_DEVICE_ID_9K_E) || (ctlr->device_id == TW_CL_DEVICE_ID_9K_SA)) tw_osl_write_reg(ctlr_handle, TWA_COMMAND_QUEUE_OFFSET_LOW, (TW_UINT32)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)), 4); status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr_handle); if (status_reg & TWA_STATUS_COMMAND_QUEUE_FULL) { struct tw_cl_req_packet *req_pkt = (struct tw_cl_req_packet *)(req->orig_req); tw_cli_dbg_printf(7, ctlr_handle, tw_osl_cur_func(), "Cmd queue full"); if ((req->flags & TW_CLI_REQ_FLAGS_INTERNAL) || ((req_pkt) && (req_pkt->flags & TW_CL_REQ_RETRY_ON_BUSY)) ) { if (req->state != TW_CLI_REQ_STATE_PENDING) { tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(), "pending internal/ioctl request"); req->state = TW_CLI_REQ_STATE_PENDING; tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q); /* Unmask command interrupt. */ TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle, TWA_CONTROL_UNMASK_COMMAND_INTERRUPT); } else error = TW_OSL_EBUSY; } else { error = TW_OSL_EBUSY; } } else { tw_cli_dbg_printf(10, ctlr_handle, tw_osl_cur_func(), "Submitting command"); /* Insert command into busy queue */ req->state = TW_CLI_REQ_STATE_BUSY; tw_cli_req_q_insert_tail(req, TW_CLI_BUSY_Q); if ((ctlr->device_id == TW_CL_DEVICE_ID_9K_E) || (ctlr->device_id == TW_CL_DEVICE_ID_9K_SA)) { /* Now write the high 4 bytes */ tw_osl_write_reg(ctlr_handle, TWA_COMMAND_QUEUE_OFFSET_HIGH, (TW_UINT32)(((TW_UINT64)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)))>>32), 4); } else { if (ctlr->flags & TW_CL_64BIT_ADDRESSES) { /* First write the low 4 bytes, then the high 4. */ tw_osl_write_reg(ctlr_handle, TWA_COMMAND_QUEUE_OFFSET_LOW, (TW_UINT32)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)), 4); tw_osl_write_reg(ctlr_handle, TWA_COMMAND_QUEUE_OFFSET_HIGH, (TW_UINT32)(((TW_UINT64)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)))>>32), 4); } else tw_osl_write_reg(ctlr_handle, TWA_COMMAND_QUEUE_OFFSET, (TW_UINT32)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)), 4); } } tw_osl_free_lock(ctlr_handle, ctlr->io_lock); return(error); } /* * Function name: tw_cl_fw_passthru * Description: Interface to OS Layer for accepting firmware * passthru requests. * Input: ctlr_handle -- controller handle * req_pkt -- OSL built request packet * req_handle -- request handle * Output: None * Return value: 0 -- success * non-zero-- failure */ TW_INT32 tw_cl_fw_passthru(struct tw_cl_ctlr_handle *ctlr_handle, struct tw_cl_req_packet *req_pkt, struct tw_cl_req_handle *req_handle) { struct tw_cli_ctlr_context *ctlr; struct tw_cli_req_context *req; union tw_cl_command_7k *cmd_7k; struct tw_cl_command_9k *cmd_9k; struct tw_cl_passthru_req_packet *pt_req; TW_UINT8 opcode; TW_UINT8 sgl_offset; TW_VOID *sgl = TW_CL_NULL; TW_INT32 error = TW_CL_ERR_REQ_SUCCESS; tw_cli_dbg_printf(5, ctlr_handle, tw_osl_cur_func(), "entered"); ctlr = (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt); if ((req = tw_cli_get_request(ctlr )) == TW_CL_NULL) { tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(), "Out of request context packets: returning busy"); return(TW_OSL_EBUSY); } req_handle->cl_req_ctxt = req; req->req_handle = req_handle; req->orig_req = req_pkt; req->tw_cli_callback = tw_cli_complete_io; req->flags |= TW_CLI_REQ_FLAGS_PASSTHRU; pt_req = &(req_pkt->gen_req_pkt.pt_req); tw_osl_memcpy(req->cmd_pkt, pt_req->cmd_pkt, pt_req->cmd_pkt_length); /* Build the cmd pkt. */ if ((opcode = GET_OPCODE(((TW_UINT8 *) (pt_req->cmd_pkt))[sizeof(struct tw_cl_command_header)])) == TWA_FW_CMD_EXECUTE_SCSI) { TW_UINT16 lun_l4, lun_h4; tw_cli_dbg_printf(5, ctlr_handle, tw_osl_cur_func(), "passthru: 9k cmd pkt"); req->flags |= TW_CLI_REQ_FLAGS_9K; cmd_9k = &(req->cmd_pkt->command.cmd_pkt_9k); lun_l4 = GET_LUN_L4(cmd_9k->lun_l4__req_id); lun_h4 = GET_LUN_H4(cmd_9k->lun_h4__sgl_entries); cmd_9k->lun_l4__req_id = TW_CL_SWAP16( BUILD_LUN_L4__REQ_ID(lun_l4, req->request_id)); if (pt_req->sgl_entries) { cmd_9k->lun_h4__sgl_entries = TW_CL_SWAP16(BUILD_LUN_H4__SGL_ENTRIES(lun_h4, pt_req->sgl_entries)); sgl = (TW_VOID *)(cmd_9k->sg_list); } } else { tw_cli_dbg_printf(5, ctlr_handle, tw_osl_cur_func(), "passthru: 7k cmd pkt"); cmd_7k = &(req->cmd_pkt->command.cmd_pkt_7k); cmd_7k->generic.request_id = (TW_UINT8)(TW_CL_SWAP16(req->request_id)); if ((sgl_offset = GET_SGL_OFF(cmd_7k->generic.sgl_off__opcode))) { if (ctlr->device_id == TW_CL_DEVICE_ID_9K_SA) sgl = (((TW_UINT32 *)cmd_7k) + cmd_7k->generic.size); else sgl = (((TW_UINT32 *)cmd_7k) + sgl_offset); cmd_7k->generic.size += pt_req->sgl_entries * ((ctlr->flags & TW_CL_64BIT_ADDRESSES) ? 3 : 2); } } if (sgl) tw_cli_fill_sg_list(ctlr, pt_req->sg_list, sgl, pt_req->sgl_entries); if (((TW_CL_Q_FIRST_ITEM(&(ctlr->req_q_head[TW_CLI_PENDING_Q]))) != TW_CL_NULL) || (ctlr->reset_in_progress)) { tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q); TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle, TWA_CONTROL_UNMASK_COMMAND_INTERRUPT); } else if ((error = tw_cli_submit_cmd(req))) { tw_cl_create_event(ctlr_handle, TW_CL_FALSE, TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR, 0x1100, 0x1, TW_CL_SEVERITY_ERROR_STRING, "Failed to start passthru command", "error = %d", error); tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q); } return(error); } /* * Function name: tw_cl_ioctl * Description: Handler of CL supported ioctl cmds. * * Input: ctlr -- ptr to per ctlr structure * cmd -- ioctl cmd * buf -- ptr to buffer in kernel memory, which is * a copy of the input buffer in user-space * Output: buf -- ptr to buffer in kernel memory, which will * need to be copied to the output buffer in * user-space * Return value: 0 -- success * non-zero-- failure */ TW_INT32 tw_cl_ioctl(struct tw_cl_ctlr_handle *ctlr_handle, u_long cmd, TW_VOID *buf) { struct tw_cli_ctlr_context *ctlr = (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt); struct tw_cl_ioctl_packet *user_buf = (struct tw_cl_ioctl_packet *)buf; struct tw_cl_event_packet event_buf; TW_INT32 event_index; TW_INT32 start_index; TW_INT32 error = TW_OSL_ESUCCESS; tw_cli_dbg_printf(5, ctlr_handle, tw_osl_cur_func(), "entered"); /* Serialize access to the AEN queue and the ioctl lock. */ tw_osl_get_lock(ctlr_handle, ctlr->gen_lock); switch (cmd) { case TW_CL_IOCTL_GET_FIRST_EVENT: tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(), "Get First Event"); if (ctlr->aen_q_wrapped) { if (ctlr->aen_q_overflow) { /* * The aen queue has wrapped, even before some * events have been retrieved. Let the caller * know that he missed out on some AEN's. */ user_buf->driver_pkt.status = TW_CL_ERROR_AEN_OVERFLOW; ctlr->aen_q_overflow = TW_CL_FALSE; } else user_buf->driver_pkt.status = 0; event_index = ctlr->aen_head; } else { if (ctlr->aen_head == ctlr->aen_tail) { user_buf->driver_pkt.status = TW_CL_ERROR_AEN_NO_EVENTS; break; } user_buf->driver_pkt.status = 0; event_index = ctlr->aen_tail; /* = 0 */ } tw_osl_memcpy(user_buf->data_buf, &(ctlr->aen_queue[event_index]), sizeof(struct tw_cl_event_packet)); ctlr->aen_queue[event_index].retrieved = TW_CL_AEN_RETRIEVED; break; case TW_CL_IOCTL_GET_LAST_EVENT: tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(), "Get Last Event"); if (ctlr->aen_q_wrapped) { if (ctlr->aen_q_overflow) { /* * The aen queue has wrapped, even before some * events have been retrieved. Let the caller * know that he missed out on some AEN's. */ user_buf->driver_pkt.status = TW_CL_ERROR_AEN_OVERFLOW; ctlr->aen_q_overflow = TW_CL_FALSE; } else user_buf->driver_pkt.status = 0; } else { if (ctlr->aen_head == ctlr->aen_tail) { user_buf->driver_pkt.status = TW_CL_ERROR_AEN_NO_EVENTS; break; } user_buf->driver_pkt.status = 0; } event_index = (ctlr->aen_head - 1 + ctlr->max_aens_supported) % ctlr->max_aens_supported; tw_osl_memcpy(user_buf->data_buf, &(ctlr->aen_queue[event_index]), sizeof(struct tw_cl_event_packet)); ctlr->aen_queue[event_index].retrieved = TW_CL_AEN_RETRIEVED; break; case TW_CL_IOCTL_GET_NEXT_EVENT: tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(), "Get Next Event"); user_buf->driver_pkt.status = 0; if (ctlr->aen_q_wrapped) { tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(), "Get Next Event: wrapped"); if (ctlr->aen_q_overflow) { /* * The aen queue has wrapped, even before some * events have been retrieved. Let the caller * know that he missed out on some AEN's. */ tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(), "Get Next Event: overflow"); user_buf->driver_pkt.status = TW_CL_ERROR_AEN_OVERFLOW; ctlr->aen_q_overflow = TW_CL_FALSE; } start_index = ctlr->aen_head; } else { if (ctlr->aen_head == ctlr->aen_tail) { tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(), "Get Next Event: empty queue"); user_buf->driver_pkt.status = TW_CL_ERROR_AEN_NO_EVENTS; break; } start_index = ctlr->aen_tail; /* = 0 */ } tw_osl_memcpy(&event_buf, user_buf->data_buf, sizeof(struct tw_cl_event_packet)); event_index = (start_index + event_buf.sequence_id - ctlr->aen_queue[start_index].sequence_id + 1) % ctlr->max_aens_supported; tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(), "Get Next Event: si = %x, ei = %x, ebsi = %x, " "sisi = %x, eisi = %x", start_index, event_index, event_buf.sequence_id, ctlr->aen_queue[start_index].sequence_id, ctlr->aen_queue[event_index].sequence_id); if (! (ctlr->aen_queue[event_index].sequence_id > event_buf.sequence_id)) { /* * We don't have any event matching the criterion. So, * we have to report TW_CL_ERROR_NO_EVENTS. If we also * encountered an overflow condition above, we cannot * report both conditions during this call. We choose * to report NO_EVENTS this time, and an overflow the * next time we are called. */ if (user_buf->driver_pkt.status == TW_CL_ERROR_AEN_OVERFLOW) { /* * Make a note so we report the overflow * next time. */ ctlr->aen_q_overflow = TW_CL_TRUE; } user_buf->driver_pkt.status = TW_CL_ERROR_AEN_NO_EVENTS; break; } /* Copy the event -- even if there has been an overflow. */ tw_osl_memcpy(user_buf->data_buf, &(ctlr->aen_queue[event_index]), sizeof(struct tw_cl_event_packet)); ctlr->aen_queue[event_index].retrieved = TW_CL_AEN_RETRIEVED; break; case TW_CL_IOCTL_GET_PREVIOUS_EVENT: tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(), "Get Previous Event"); user_buf->driver_pkt.status = 0; if (ctlr->aen_q_wrapped) { if (ctlr->aen_q_overflow) { /* * The aen queue has wrapped, even before some * events have been retrieved. Let the caller * know that he missed out on some AEN's. */ user_buf->driver_pkt.status = TW_CL_ERROR_AEN_OVERFLOW; ctlr->aen_q_overflow = TW_CL_FALSE; } start_index = ctlr->aen_head; } else { if (ctlr->aen_head == ctlr->aen_tail) { user_buf->driver_pkt.status = TW_CL_ERROR_AEN_NO_EVENTS; break; } start_index = ctlr->aen_tail; /* = 0 */ } tw_osl_memcpy(&event_buf, user_buf->data_buf, sizeof(struct tw_cl_event_packet)); event_index = (start_index + event_buf.sequence_id - ctlr->aen_queue[start_index].sequence_id - 1) % ctlr->max_aens_supported; if (! (ctlr->aen_queue[event_index].sequence_id < event_buf.sequence_id)) { /* * We don't have any event matching the criterion. So, * we have to report TW_CL_ERROR_NO_EVENTS. If we also * encountered an overflow condition above, we cannot * report both conditions during this call. We choose * to report NO_EVENTS this time, and an overflow the * next time we are called. */ if (user_buf->driver_pkt.status == TW_CL_ERROR_AEN_OVERFLOW) { /* * Make a note so we report the overflow * next time. */ ctlr->aen_q_overflow = TW_CL_TRUE; } user_buf->driver_pkt.status = TW_CL_ERROR_AEN_NO_EVENTS; break; } /* Copy the event -- even if there has been an overflow. */ tw_osl_memcpy(user_buf->data_buf, &(ctlr->aen_queue[event_index]), sizeof(struct tw_cl_event_packet)); ctlr->aen_queue[event_index].retrieved = TW_CL_AEN_RETRIEVED; break; case TW_CL_IOCTL_GET_LOCK: { struct tw_cl_lock_packet lock_pkt; TW_TIME cur_time; tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(), "Get ioctl lock"); cur_time = tw_osl_get_local_time(); tw_osl_memcpy(&lock_pkt, user_buf->data_buf, sizeof(struct tw_cl_lock_packet)); if ((ctlr->ioctl_lock.lock == TW_CLI_LOCK_FREE) || (lock_pkt.force_flag) || (cur_time >= ctlr->ioctl_lock.timeout)) { tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(), "GET_LOCK: Getting lock!"); ctlr->ioctl_lock.lock = TW_CLI_LOCK_HELD; ctlr->ioctl_lock.timeout = cur_time + (lock_pkt.timeout_msec / 1000); lock_pkt.time_remaining_msec = lock_pkt.timeout_msec; user_buf->driver_pkt.status = 0; } else { tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(), "GET_LOCK: Lock already held!"); lock_pkt.time_remaining_msec = (TW_UINT32)( (ctlr->ioctl_lock.timeout - cur_time) * 1000); user_buf->driver_pkt.status = TW_CL_ERROR_IOCTL_LOCK_ALREADY_HELD; } tw_osl_memcpy(user_buf->data_buf, &lock_pkt, sizeof(struct tw_cl_lock_packet)); break; } case TW_CL_IOCTL_RELEASE_LOCK: tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(), "Release ioctl lock"); if (ctlr->ioctl_lock.lock == TW_CLI_LOCK_FREE) { tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(), "twa_ioctl: RELEASE_LOCK: Lock not held!"); user_buf->driver_pkt.status = TW_CL_ERROR_IOCTL_LOCK_NOT_HELD; } else { tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(), "RELEASE_LOCK: Releasing lock!"); ctlr->ioctl_lock.lock = TW_CLI_LOCK_FREE; user_buf->driver_pkt.status = 0; } break; case TW_CL_IOCTL_GET_COMPATIBILITY_INFO: { struct tw_cl_compatibility_packet comp_pkt; tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(), "Get compatibility info"); tw_osl_memcpy(comp_pkt.driver_version, TW_OSL_DRIVER_VERSION_STRING, sizeof(TW_OSL_DRIVER_VERSION_STRING)); comp_pkt.working_srl = ctlr->working_srl; comp_pkt.working_branch = ctlr->working_branch; comp_pkt.working_build = ctlr->working_build; comp_pkt.driver_srl_high = TWA_CURRENT_FW_SRL; comp_pkt.driver_branch_high = TWA_CURRENT_FW_BRANCH(ctlr->arch_id); comp_pkt.driver_build_high = TWA_CURRENT_FW_BUILD(ctlr->arch_id); comp_pkt.driver_srl_low = TWA_BASE_FW_SRL; comp_pkt.driver_branch_low = TWA_BASE_FW_BRANCH; comp_pkt.driver_build_low = TWA_BASE_FW_BUILD; comp_pkt.fw_on_ctlr_srl = ctlr->fw_on_ctlr_srl; comp_pkt.fw_on_ctlr_branch = ctlr->fw_on_ctlr_branch; comp_pkt.fw_on_ctlr_build = ctlr->fw_on_ctlr_build; user_buf->driver_pkt.status = 0; /* Copy compatibility information to user space. */ tw_osl_memcpy(user_buf->data_buf, &comp_pkt, (sizeof(struct tw_cl_compatibility_packet) < user_buf->driver_pkt.buffer_length) ? sizeof(struct tw_cl_compatibility_packet) : user_buf->driver_pkt.buffer_length); break; } default: /* Unknown opcode. */ tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(), "Unknown ioctl cmd 0x%lx", cmd); error = TW_OSL_ENOTTY; } tw_osl_free_lock(ctlr_handle, ctlr->gen_lock); return(error); } /* * Function name: tw_cli_get_param * Description: Get a firmware parameter. * * Input: ctlr -- ptr to per ctlr structure * table_id -- parameter table # * param_id -- index of the parameter in the table * param_size -- size of the parameter in bytes * callback -- ptr to function, if any, to be called * back on completion; TW_CL_NULL if no callback. * Output: param_data -- param value * Return value: 0 -- success * non-zero-- failure */ TW_INT32 tw_cli_get_param(struct tw_cli_ctlr_context *ctlr, TW_INT32 table_id, TW_INT32 param_id, TW_VOID *param_data, TW_INT32 param_size, TW_VOID (* callback)(struct tw_cli_req_context *req)) { struct tw_cli_req_context *req; union tw_cl_command_7k *cmd; struct tw_cl_param_9k *param = TW_CL_NULL; TW_INT32 error = TW_OSL_EBUSY; tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered"); /* Get a request packet. */ if ((req = tw_cli_get_request(ctlr )) == TW_CL_NULL) goto out; /* Make sure this is the only CL internal request at this time. */ if (ctlr->internal_req_busy) { error = TW_OSL_EBUSY; goto out; } ctlr->internal_req_busy = TW_CL_TRUE; req->data = ctlr->internal_req_data; req->data_phys = ctlr->internal_req_data_phys; req->length = TW_CLI_SECTOR_SIZE; req->flags |= TW_CLI_REQ_FLAGS_INTERNAL; /* Initialize memory to read data into. */ param = (struct tw_cl_param_9k *)(req->data); tw_osl_memzero(param, sizeof(struct tw_cl_param_9k) - 1 + param_size); /* Build the cmd pkt. */ cmd = &(req->cmd_pkt->command.cmd_pkt_7k); req->cmd_pkt->cmd_hdr.header_desc.size_header = 128; cmd->param.sgl_off__opcode = BUILD_SGL_OFF__OPCODE(2, TWA_FW_CMD_GET_PARAM); cmd->param.request_id = (TW_UINT8)(TW_CL_SWAP16(req->request_id)); cmd->param.host_id__unit = BUILD_HOST_ID__UNIT(0, 0); cmd->param.param_count = TW_CL_SWAP16(1); if (ctlr->flags & TW_CL_64BIT_ADDRESSES) { ((struct tw_cl_sg_desc64 *)(cmd->param.sgl))[0].address = TW_CL_SWAP64(req->data_phys); ((struct tw_cl_sg_desc64 *)(cmd->param.sgl))[0].length = TW_CL_SWAP32(req->length); cmd->param.size = 2 + 3; } else { ((struct tw_cl_sg_desc32 *)(cmd->param.sgl))[0].address = TW_CL_SWAP32(req->data_phys); ((struct tw_cl_sg_desc32 *)(cmd->param.sgl))[0].length = TW_CL_SWAP32(req->length); cmd->param.size = 2 + 2; } /* Specify which parameter we need. */ param->table_id = TW_CL_SWAP16(table_id | TWA_9K_PARAM_DESCRIPTOR); param->parameter_id = (TW_UINT8)(param_id); param->parameter_size_bytes = TW_CL_SWAP16(param_size); /* Submit the command. */ if (callback == TW_CL_NULL) { /* There's no call back; wait till the command completes. */ error = tw_cli_submit_and_poll_request(req, TW_CLI_REQUEST_TIMEOUT_PERIOD); if (error) goto out; if ((error = cmd->param.status)) { #if 0 tw_cli_create_ctlr_event(ctlr, TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR, &(req->cmd_pkt->cmd_hdr)); #endif // 0 goto out; } tw_osl_memcpy(param_data, param->data, param_size); ctlr->internal_req_busy = TW_CL_FALSE; tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q); } else { /* There's a call back. Simply submit the command. */ req->tw_cli_callback = callback; if ((error = tw_cli_submit_cmd(req))) goto out; } return(0); out: tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE, TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR, 0x1101, 0x1, TW_CL_SEVERITY_ERROR_STRING, "get_param failed", "error = %d", error); if (param) ctlr->internal_req_busy = TW_CL_FALSE; if (req) tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q); return(1); } /* * Function name: tw_cli_set_param * Description: Set a firmware parameter. * * Input: ctlr -- ptr to per ctlr structure * table_id -- parameter table # * param_id -- index of the parameter in the table * param_size -- size of the parameter in bytes * callback -- ptr to function, if any, to be called * back on completion; TW_CL_NULL if no callback. * Output: None * Return value: 0 -- success * non-zero-- failure */ TW_INT32 tw_cli_set_param(struct tw_cli_ctlr_context *ctlr, TW_INT32 table_id, TW_INT32 param_id, TW_INT32 param_size, TW_VOID *data, TW_VOID (* callback)(struct tw_cli_req_context *req)) { struct tw_cli_req_context *req; union tw_cl_command_7k *cmd; struct tw_cl_param_9k *param = TW_CL_NULL; TW_INT32 error = TW_OSL_EBUSY; tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered"); /* Get a request packet. */ if ((req = tw_cli_get_request(ctlr )) == TW_CL_NULL) goto out; /* Make sure this is the only CL internal request at this time. */ if (ctlr->internal_req_busy) { error = TW_OSL_EBUSY; goto out; } ctlr->internal_req_busy = TW_CL_TRUE; req->data = ctlr->internal_req_data; req->data_phys = ctlr->internal_req_data_phys; req->length = TW_CLI_SECTOR_SIZE; req->flags |= TW_CLI_REQ_FLAGS_INTERNAL; /* Initialize memory to send data using. */ param = (struct tw_cl_param_9k *)(req->data); tw_osl_memzero(param, sizeof(struct tw_cl_param_9k) - 1 + param_size); /* Build the cmd pkt. */ cmd = &(req->cmd_pkt->command.cmd_pkt_7k); req->cmd_pkt->cmd_hdr.header_desc.size_header = 128; cmd->param.sgl_off__opcode = BUILD_SGL_OFF__OPCODE(2, TWA_FW_CMD_SET_PARAM); cmd->param.request_id = (TW_UINT8)(TW_CL_SWAP16(req->request_id)); cmd->param.host_id__unit = BUILD_HOST_ID__UNIT(0, 0); cmd->param.param_count = TW_CL_SWAP16(1); if (ctlr->flags & TW_CL_64BIT_ADDRESSES) { ((struct tw_cl_sg_desc64 *)(cmd->param.sgl))[0].address = TW_CL_SWAP64(req->data_phys); ((struct tw_cl_sg_desc64 *)(cmd->param.sgl))[0].length = TW_CL_SWAP32(req->length); cmd->param.size = 2 + 3; } else { ((struct tw_cl_sg_desc32 *)(cmd->param.sgl))[0].address = TW_CL_SWAP32(req->data_phys); ((struct tw_cl_sg_desc32 *)(cmd->param.sgl))[0].length = TW_CL_SWAP32(req->length); cmd->param.size = 2 + 2; } /* Specify which parameter we want to set. */ param->table_id = TW_CL_SWAP16(table_id | TWA_9K_PARAM_DESCRIPTOR); param->parameter_id = (TW_UINT8)(param_id); param->parameter_size_bytes = TW_CL_SWAP16(param_size); tw_osl_memcpy(param->data, data, param_size); /* Submit the command. */ if (callback == TW_CL_NULL) { /* There's no call back; wait till the command completes. */ error = tw_cli_submit_and_poll_request(req, TW_CLI_REQUEST_TIMEOUT_PERIOD); if (error) goto out; if ((error = cmd->param.status)) { #if 0 tw_cli_create_ctlr_event(ctlr, TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR, &(req->cmd_pkt->cmd_hdr)); #endif // 0 goto out; } ctlr->internal_req_busy = TW_CL_FALSE; tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q); } else { /* There's a call back. Simply submit the command. */ req->tw_cli_callback = callback; if ((error = tw_cli_submit_cmd(req))) goto out; } return(error); out: tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE, TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR, 0x1102, 0x1, TW_CL_SEVERITY_ERROR_STRING, "set_param failed", "error = %d", error); if (param) ctlr->internal_req_busy = TW_CL_FALSE; if (req) tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q); return(error); } /* * Function name: tw_cli_submit_and_poll_request * Description: Sends down a firmware cmd, and waits for the completion * in a tight loop. * * Input: req -- ptr to request pkt * timeout -- max # of seconds to wait before giving up * Output: None * Return value: 0 -- success * non-zero-- failure */ TW_INT32 tw_cli_submit_and_poll_request(struct tw_cli_req_context *req, TW_UINT32 timeout) { struct tw_cli_ctlr_context *ctlr = req->ctlr; TW_TIME end_time; TW_INT32 error; tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered"); /* * If the cmd queue is full, tw_cli_submit_cmd will queue this * request in the pending queue, since this is an internal request. */ if ((error = tw_cli_submit_cmd(req))) { tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE, TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR, 0x1103, 0x1, TW_CL_SEVERITY_ERROR_STRING, "Failed to start internal request", "error = %d", error); return(error); } /* * Poll for the response until the command gets completed, or there's * a timeout. */ end_time = tw_osl_get_local_time() + timeout; do { if ((error = req->error_code)) /* * This will take care of completion due to a reset, * or a failure in tw_cli_submit_pending_queue. * The caller should do the clean-up. */ return(error); /* See if the command completed. */ tw_cli_process_resp_intr(ctlr); if ((req->state != TW_CLI_REQ_STATE_BUSY) && (req->state != TW_CLI_REQ_STATE_PENDING)) return(req->state != TW_CLI_REQ_STATE_COMPLETE); } while (tw_osl_get_local_time() <= end_time); /* Time out! */ tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE, TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR, 0x1104, 0x1, TW_CL_SEVERITY_ERROR_STRING, "Internal request timed out", "request = %p", req); /* * We will reset the controller only if the request has already been * submitted, so as to not lose the request packet. If a busy request * timed out, the reset will take care of freeing resources. If a * pending request timed out, we will free resources for that request, * right here, thereby avoiding a reset. So, the caller is expected * to NOT cleanup when TW_OSL_ETIMEDOUT is returned. */ /* * We have to make sure that this timed out request, if it were in the * pending queue, doesn't get submitted while we are here, from * tw_cli_submit_pending_queue. There could be a race in that case. * Need to revisit. */ if (req->state == TW_CLI_REQ_STATE_PENDING) { tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(), "Removing request from pending queue"); /* * Request was never submitted. Clean up. Note that we did * not do a reset. So, we have to remove the request ourselves * from the pending queue (as against tw_cli_drain_pendinq_queue * taking care of it). */ tw_cli_req_q_remove_item(req, TW_CLI_PENDING_Q); if ((TW_CL_Q_FIRST_ITEM(&(ctlr->req_q_head[TW_CLI_PENDING_Q]))) == TW_CL_NULL) TW_CLI_WRITE_CONTROL_REGISTER(ctlr->ctlr_handle, TWA_CONTROL_MASK_COMMAND_INTERRUPT); if (req->data) ctlr->internal_req_busy = TW_CL_FALSE; tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q); } return(TW_OSL_ETIMEDOUT); } /* * Function name: tw_cl_reset_ctlr * Description: Soft resets and then initializes the controller; * drains any incomplete requests. * * Input: ctlr -- ptr to per ctlr structure * req_handle -- ptr to request handle * Output: None * Return value: 0 -- success * non-zero-- failure */ TW_INT32 tw_cl_reset_ctlr(struct tw_cl_ctlr_handle *ctlr_handle) { struct tw_cli_ctlr_context *ctlr = (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt); struct twa_softc *sc = ctlr_handle->osl_ctlr_ctxt; struct tw_cli_req_context *req; TW_INT32 reset_attempt = 1; TW_INT32 error = 0; tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(), "entered"); ctlr->reset_in_progress = TW_CL_TRUE; twa_teardown_intr(sc); /* * Error back all requests in the complete, busy, and pending queues. * If any request is already on its way to getting submitted, it's in * none of these queues and so, will not be completed. That request * will continue its course and get submitted to the controller after * the reset is done (and io_lock is released). */ tw_cli_drain_complete_queue(ctlr); tw_cli_drain_busy_queue(ctlr); tw_cli_drain_pending_queue(ctlr); ctlr->internal_req_busy = TW_CL_FALSE; ctlr->get_more_aens = TW_CL_FALSE; /* Soft reset the controller. */ while (reset_attempt <= TW_CLI_MAX_RESET_ATTEMPTS) { if ((error = tw_cli_soft_reset(ctlr))) { tw_cl_create_event(ctlr_handle, TW_CL_FALSE, TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT, 0x1105, 0x1, TW_CL_SEVERITY_ERROR_STRING, "Controller reset failed", "error = %d; attempt %d", error, reset_attempt++); reset_attempt++; continue; } /* Re-establish logical connection with the controller. */ if ((error = tw_cli_init_connection(ctlr, (TW_UINT16)(ctlr->max_simult_reqs), 0, 0, 0, 0, 0, TW_CL_NULL, TW_CL_NULL, TW_CL_NULL, TW_CL_NULL, TW_CL_NULL))) { tw_cl_create_event(ctlr_handle, TW_CL_FALSE, TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT, 0x1106, 0x1, TW_CL_SEVERITY_ERROR_STRING, "Can't initialize connection after reset", "error = %d", error); reset_attempt++; continue; } #ifdef TW_OSL_DEBUG tw_cl_create_event(ctlr_handle, TW_CL_FALSE, TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT, 0x1107, 0x3, TW_CL_SEVERITY_INFO_STRING, "Controller reset done!", " "); #endif /* TW_OSL_DEBUG */ break; } /* End of while */ /* Move commands from the reset queue to the pending queue. */ while ((req = tw_cli_req_q_remove_head(ctlr, TW_CLI_RESET_Q)) != TW_CL_NULL) { tw_osl_timeout(req->req_handle); tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q); } twa_setup_intr(sc); tw_cli_enable_interrupts(ctlr); if ((TW_CL_Q_FIRST_ITEM(&(ctlr->req_q_head[TW_CLI_PENDING_Q]))) != TW_CL_NULL) TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle, TWA_CONTROL_UNMASK_COMMAND_INTERRUPT); ctlr->reset_in_progress = TW_CL_FALSE; ctlr->reset_needed = TW_CL_FALSE; /* Request for a bus re-scan. */ tw_osl_scan_bus(ctlr_handle); return(error); } TW_VOID tw_cl_set_reset_needed(struct tw_cl_ctlr_handle *ctlr_handle) { struct tw_cli_ctlr_context *ctlr = (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt); ctlr->reset_needed = TW_CL_TRUE; } TW_INT32 tw_cl_is_reset_needed(struct tw_cl_ctlr_handle *ctlr_handle) { struct tw_cli_ctlr_context *ctlr = (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt); return(ctlr->reset_needed); } TW_INT32 tw_cl_is_active(struct tw_cl_ctlr_handle *ctlr_handle) { struct tw_cli_ctlr_context *ctlr = (struct tw_cli_ctlr_context *) (ctlr_handle->cl_ctlr_ctxt); return(ctlr->active); } /* * Function name: tw_cli_soft_reset * Description: Does the actual soft reset. * * Input: ctlr -- ptr to per ctlr structure * Output: None * Return value: 0 -- success * non-zero-- failure */ TW_INT32 tw_cli_soft_reset(struct tw_cli_ctlr_context *ctlr) { struct tw_cl_ctlr_handle *ctlr_handle = ctlr->ctlr_handle; int found; int loop_count; TW_UINT32 error; tw_cli_dbg_printf(1, ctlr_handle, tw_osl_cur_func(), "entered"); tw_cl_create_event(ctlr_handle, TW_CL_FALSE, TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT, 0x1108, 0x3, TW_CL_SEVERITY_INFO_STRING, "Resetting controller...", " "); /* Don't let any new commands get submitted to the controller. */ tw_osl_get_lock(ctlr_handle, ctlr->io_lock); TW_CLI_SOFT_RESET(ctlr_handle); if ((ctlr->device_id == TW_CL_DEVICE_ID_9K_X) || (ctlr->device_id == TW_CL_DEVICE_ID_9K_E) || (ctlr->device_id == TW_CL_DEVICE_ID_9K_SA)) { /* * There's a hardware bug in the G133 ASIC, which can lead to * PCI parity errors and hangs, if the host accesses any * registers when the firmware is resetting the hardware, as * part of a hard/soft reset. The window of time when the * problem can occur is about 10 ms. Here, we will handshake * with the firmware to find out when the firmware is pulling * down the hardware reset pin, and wait for about 500 ms to * make sure we don't access any hardware registers (for * polling) during that window. */ ctlr->reset_phase1_in_progress = TW_CL_TRUE; loop_count = 0; do { found = (tw_cli_find_response(ctlr, TWA_RESET_PHASE1_NOTIFICATION_RESPONSE) == TW_OSL_ESUCCESS); tw_osl_delay(10); loop_count++; error = 0x7888; } while (!found && (loop_count < 6000000)); /* Loop for no more than 60 seconds */ if (!found) { tw_cl_create_event(ctlr_handle, TW_CL_FALSE, TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT, 0x1109, 0x1, TW_CL_SEVERITY_ERROR_STRING, "Missed firmware handshake after soft-reset", "error = %d", error); tw_osl_free_lock(ctlr_handle, ctlr->io_lock); return(error); } tw_osl_delay(TWA_RESET_PHASE1_WAIT_TIME_MS * 1000); ctlr->reset_phase1_in_progress = TW_CL_FALSE; } if ((error = tw_cli_poll_status(ctlr, TWA_STATUS_MICROCONTROLLER_READY | TWA_STATUS_ATTENTION_INTERRUPT, TW_CLI_RESET_TIMEOUT_PERIOD))) { tw_cl_create_event(ctlr_handle, TW_CL_FALSE, TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT, 0x1109, 0x1, TW_CL_SEVERITY_ERROR_STRING, "Micro-ctlr not ready/No attn intr after reset", "error = %d", error); tw_osl_free_lock(ctlr_handle, ctlr->io_lock); return(error); } TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle, TWA_CONTROL_CLEAR_ATTENTION_INTERRUPT); if ((error = tw_cli_drain_response_queue(ctlr))) { tw_cl_create_event(ctlr_handle, TW_CL_FALSE, TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR, 0x110A, 0x1, TW_CL_SEVERITY_ERROR_STRING, "Can't drain response queue after reset", "error = %d", error); tw_osl_free_lock(ctlr_handle, ctlr->io_lock); return(error); } tw_osl_free_lock(ctlr_handle, ctlr->io_lock); if ((error = tw_cli_drain_aen_queue(ctlr))) { tw_cl_create_event(ctlr_handle, TW_CL_FALSE, TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR, 0x110B, 0x1, TW_CL_SEVERITY_ERROR_STRING, "Can't drain AEN queue after reset", "error = %d", error); return(error); } if ((error = tw_cli_find_aen(ctlr, TWA_AEN_SOFT_RESET))) { tw_cl_create_event(ctlr_handle, TW_CL_FALSE, TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT, 0x110C, 0x1, TW_CL_SEVERITY_ERROR_STRING, "Reset not reported by controller", "error = %d", error); return(error); } return(TW_OSL_ESUCCESS); } /* * Function name: tw_cli_send_scsi_cmd * Description: Sends down a scsi cmd to fw. * * Input: req -- ptr to request pkt * cmd -- opcode of scsi cmd to send * Output: None * Return value: 0 -- success * non-zero-- failure */ TW_INT32 tw_cli_send_scsi_cmd(struct tw_cli_req_context *req, TW_INT32 cmd) { struct tw_cl_command_packet *cmdpkt; struct tw_cl_command_9k *cmd9k; struct tw_cli_ctlr_context *ctlr; TW_INT32 error; ctlr = req->ctlr; tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered"); /* Make sure this is the only CL internal request at this time. */ if (ctlr->internal_req_busy) return(TW_OSL_EBUSY); ctlr->internal_req_busy = TW_CL_TRUE; req->data = ctlr->internal_req_data; req->data_phys = ctlr->internal_req_data_phys; tw_osl_memzero(req->data, TW_CLI_SECTOR_SIZE); req->length = TW_CLI_SECTOR_SIZE; /* Build the cmd pkt. */ cmdpkt = req->cmd_pkt; cmdpkt->cmd_hdr.header_desc.size_header = 128; cmd9k = &(cmdpkt->command.cmd_pkt_9k); cmd9k->res__opcode = BUILD_RES__OPCODE(0, TWA_FW_CMD_EXECUTE_SCSI); cmd9k->unit = 0; cmd9k->lun_l4__req_id = TW_CL_SWAP16(req->request_id); cmd9k->status = 0; cmd9k->sgl_offset = 16; /* offset from end of hdr = max cdb len */ cmd9k->lun_h4__sgl_entries = TW_CL_SWAP16(1); if (req->ctlr->flags & TW_CL_64BIT_ADDRESSES) { ((struct tw_cl_sg_desc64 *)(cmd9k->sg_list))[0].address = TW_CL_SWAP64(req->data_phys); ((struct tw_cl_sg_desc64 *)(cmd9k->sg_list))[0].length = TW_CL_SWAP32(req->length); } else { ((struct tw_cl_sg_desc32 *)(cmd9k->sg_list))[0].address = TW_CL_SWAP32(req->data_phys); ((struct tw_cl_sg_desc32 *)(cmd9k->sg_list))[0].length = TW_CL_SWAP32(req->length); } cmd9k->cdb[0] = (TW_UINT8)cmd; cmd9k->cdb[4] = 128; if ((error = tw_cli_submit_cmd(req))) if (error != TW_OSL_EBUSY) { tw_cli_dbg_printf(1, ctlr->ctlr_handle, tw_osl_cur_func(), "Failed to start SCSI command " "(request = %p, error = %d)", req, error); return(TW_OSL_EIO); } return(TW_OSL_ESUCCESS); } /* * Function name: tw_cli_get_aen * Description: Sends down a Request Sense cmd to fw to fetch an AEN. * * Input: ctlr -- ptr to per ctlr structure * Output: None * Return value: 0 -- success * non-zero-- failure */ TW_INT32 tw_cli_get_aen(struct tw_cli_ctlr_context *ctlr) { struct tw_cli_req_context *req; TW_INT32 error; tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered"); if ((req = tw_cli_get_request(ctlr )) == TW_CL_NULL) return(TW_OSL_EBUSY); req->flags |= TW_CLI_REQ_FLAGS_INTERNAL; req->flags |= TW_CLI_REQ_FLAGS_9K; req->tw_cli_callback = tw_cli_aen_callback; if ((error = tw_cli_send_scsi_cmd(req, 0x03 /* REQUEST_SENSE */))) { tw_cli_dbg_printf(1, ctlr->ctlr_handle, tw_osl_cur_func(), "Could not send SCSI command " "(request = %p, error = %d)", req, error); if (req->data) ctlr->internal_req_busy = TW_CL_FALSE; tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q); } return(error); } /* * Function name: tw_cli_fill_sg_list * Description: Fills in the scatter/gather list. * * Input: ctlr -- ptr to per ctlr structure * sgl_src -- ptr to fill the sg list from * sgl_dest-- ptr to sg list * nsegments--# of segments * Output: None * Return value: None */ TW_VOID tw_cli_fill_sg_list(struct tw_cli_ctlr_context *ctlr, TW_VOID *sgl_src, TW_VOID *sgl_dest, TW_INT32 num_sgl_entries) { TW_INT32 i; tw_cli_dbg_printf(10, ctlr->ctlr_handle, tw_osl_cur_func(), "entered"); if (ctlr->flags & TW_CL_64BIT_ADDRESSES) { struct tw_cl_sg_desc64 *sgl_s = (struct tw_cl_sg_desc64 *)sgl_src; struct tw_cl_sg_desc64 *sgl_d = (struct tw_cl_sg_desc64 *)sgl_dest; tw_cli_dbg_printf(10, ctlr->ctlr_handle, tw_osl_cur_func(), "64 bit addresses"); for (i = 0; i < num_sgl_entries; i++) { sgl_d[i].address = TW_CL_SWAP64(sgl_s->address); sgl_d[i].length = TW_CL_SWAP32(sgl_s->length); sgl_s++; if (ctlr->flags & TW_CL_64BIT_SG_LENGTH) sgl_s = (struct tw_cl_sg_desc64 *) (((TW_INT8 *)(sgl_s)) + 4); } } else { struct tw_cl_sg_desc32 *sgl_s = (struct tw_cl_sg_desc32 *)sgl_src; struct tw_cl_sg_desc32 *sgl_d = (struct tw_cl_sg_desc32 *)sgl_dest; tw_cli_dbg_printf(10, ctlr->ctlr_handle, tw_osl_cur_func(), "32 bit addresses"); for (i = 0; i < num_sgl_entries; i++) { sgl_d[i].address = TW_CL_SWAP32(sgl_s[i].address); sgl_d[i].length = TW_CL_SWAP32(sgl_s[i].length); } } }