sys/dev/raid/twa/tw_cl_io.c

   1 /*
   2  * Copyright (c) 2004-07 Applied Micro Circuits Corporation.
   3  * Copyright (c) 2004-05 Vinod Kashyap
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   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.
  14  *
  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
  25  * SUCH DAMAGE.
  26  *
  27  *      $FreeBSD: src/sys/dev/twa/tw_cl_io.c,v 1.6 2010/06/09 21:40:38 delphij Exp $
  28  */
  29
  30 /*
  31  * AMCC'S 3ware driver for 9000 series storage controllers.
  32  *
  33  * Author: Vinod Kashyap
  34  * Modifications by: Adam Radford
  35  * Modifications by: Manjunath Ranganathaiah
  36  */
  37
  38
  39 /*
  40  * Common Layer I/O functions.
  41  */
  42
  43
  44 #include "tw_osl_share.h"
  45 #include "tw_cl_share.h"
  46 #include "tw_cl_fwif.h"
  47 #include "tw_cl_ioctl.h"
  48 #include "tw_cl.h"
  49 #include "tw_cl_externs.h"
  50 #include "tw_osl_ioctl.h"
  51
  52 #include <bus/cam/cam.h>
  53 #include <bus/cam/cam_ccb.h>
  54 #include <bus/cam/cam_xpt_sim.h>
  55
  56
  57
  58 /*
  59  * Function name:       tw_cl_start_io
  60  * Description:         Interface to OS Layer for accepting SCSI requests.
  61  *
  62  * Input:               ctlr_handle     -- controller handle
  63  *                      req_pkt         -- OSL built request packet
  64  *                      req_handle      -- request handle
  65  * Output:              None
  66  * Return value:        0       -- success
  67  *                      non-zero-- failure
  68  */
  69 TW_INT32
  70 tw_cl_start_io(struct tw_cl_ctlr_handle *ctlr_handle,
  71         struct tw_cl_req_packet *req_pkt, struct tw_cl_req_handle *req_handle)
  72 {
  73         struct tw_cli_ctlr_context              *ctlr;
  74         struct tw_cli_req_context               *req;
  75         struct tw_cl_command_9k                 *cmd;
  76         struct tw_cl_scsi_req_packet            *scsi_req;
  77         TW_INT32                                error;
  78
  79         tw_cli_dbg_printf(10, ctlr_handle, tw_osl_cur_func(), "entered");
  80
  81         ctlr = (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
  82
  83         if (ctlr->reset_in_progress) {
  84                 tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
  85                         "I/O during reset: returning busy.");
  86                 return(TW_OSL_EBUSY);
  87         }
  88
  89         /*
  90          * If working with a firmware version that does not support multiple
  91          * luns, and this request is directed at a non-zero lun, error it
  92          * back right away.
  93          */
  94         if ((req_pkt->gen_req_pkt.scsi_req.lun) &&
  95                 (ctlr->working_srl < TWA_MULTI_LUN_FW_SRL)) {
  96                 req_pkt->status |= (TW_CL_ERR_REQ_INVALID_LUN |
  97                         TW_CL_ERR_REQ_SCSI_ERROR);
  98                 req_pkt->tw_osl_callback(req_handle);
  99                 return(TW_CL_ERR_REQ_SUCCESS);
 100         }
 101
 102         if ((req = tw_cli_get_request(ctlr
 103                 )) == TW_CL_NULL) {
 104                 tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
 105                         "Out of request context packets: returning busy");
 106                 return(TW_OSL_EBUSY);
 107         }
 108
 109         req_handle->cl_req_ctxt = req;
 110         req->req_handle = req_handle;
 111         req->orig_req = req_pkt;
 112         req->tw_cli_callback = tw_cli_complete_io;
 113
 114         req->flags |= TW_CLI_REQ_FLAGS_EXTERNAL;
 115         req->flags |= TW_CLI_REQ_FLAGS_9K;
 116
 117         scsi_req = &(req_pkt->gen_req_pkt.scsi_req);
 118
 119         /* Build the cmd pkt. */
 120         cmd = &(req->cmd_pkt->command.cmd_pkt_9k);
 121
 122         req->cmd_pkt->cmd_hdr.header_desc.size_header = 128;
 123
 124         cmd->res__opcode = BUILD_RES__OPCODE(0, TWA_FW_CMD_EXECUTE_SCSI);
 125         cmd->unit = (TW_UINT8)(scsi_req->unit);
 126         cmd->lun_l4__req_id = TW_CL_SWAP16(
 127                 BUILD_LUN_L4__REQ_ID(scsi_req->lun, req->request_id));
 128         cmd->status = 0;
 129         cmd->sgl_offset = 16; /* offset from end of hdr = max cdb len */
 130         tw_osl_memcpy(cmd->cdb, scsi_req->cdb, scsi_req->cdb_len);
 131
 132         if (req_pkt->flags & TW_CL_REQ_CALLBACK_FOR_SGLIST) {
 133                 TW_UINT32       num_sgl_entries;
 134
 135                 req_pkt->tw_osl_sgl_callback(req_handle, cmd->sg_list,
 136                         &num_sgl_entries);
 137                 cmd->lun_h4__sgl_entries =
 138                         TW_CL_SWAP16(BUILD_LUN_H4__SGL_ENTRIES(scsi_req->lun,
 139                                 num_sgl_entries));
 140         } else {
 141                 cmd->lun_h4__sgl_entries =
 142                         TW_CL_SWAP16(BUILD_LUN_H4__SGL_ENTRIES(scsi_req->lun,
 143                                 scsi_req->sgl_entries));
 144                 tw_cli_fill_sg_list(ctlr, scsi_req->sg_list,
 145                         cmd->sg_list, scsi_req->sgl_entries);
 146         }
 147
 148         if ((error = tw_cli_submit_cmd(req))) {
 149                 tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
 150                         "Could not start request. request = %p, error = %d",
 151                         req, error);
 152                 tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
 153         }
 154         return(error);
 155 }
 156
 157
 158
 159 /*
 160  * Function name:       tw_cli_submit_cmd
 161  * Description:         Submits a cmd to firmware.
 162  *
 163  * Input:               req     -- ptr to CL internal request context
 164  * Output:              None
 165  * Return value:        0       -- success
 166  *                      non-zero-- failure
 167  */
 168 TW_INT32
 169 tw_cli_submit_cmd(struct tw_cli_req_context *req)
 170 {
 171         struct tw_cli_ctlr_context      *ctlr = req->ctlr;
 172         struct tw_cl_ctlr_handle        *ctlr_handle = ctlr->ctlr_handle;
 173         TW_UINT32                       status_reg;
 174         TW_INT32                        error;
 175
 176         tw_cli_dbg_printf(10, ctlr_handle, tw_osl_cur_func(), "entered");
 177
 178         /* Serialize access to the controller cmd queue. */
 179         tw_osl_get_lock(ctlr_handle, ctlr->io_lock);
 180
 181         /* For 9650SE first write low 4 bytes */
 182         if ((ctlr->device_id == TW_CL_DEVICE_ID_9K_E) ||
 183             (ctlr->device_id == TW_CL_DEVICE_ID_9K_SA))
 184                 tw_osl_write_reg(ctlr_handle,
 185                                  TWA_COMMAND_QUEUE_OFFSET_LOW,
 186                                  (TW_UINT32)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)), 4);
 187
 188         /* Check to see if we can post a command. */
 189         status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr_handle);
 190         if ((error = tw_cli_check_ctlr_state(ctlr, status_reg)))
 191                 goto out;
 192
 193         if (status_reg & TWA_STATUS_COMMAND_QUEUE_FULL) {
 194                 struct tw_cl_req_packet *req_pkt =
 195                         (struct tw_cl_req_packet *)(req->orig_req);
 196
 197                 tw_cli_dbg_printf(7, ctlr_handle, tw_osl_cur_func(),
 198                         "Cmd queue full");
 199
 200                 if ((req->flags & TW_CLI_REQ_FLAGS_INTERNAL)
 201                         || ((req_pkt) &&
 202                         (req_pkt->flags & TW_CL_REQ_RETRY_ON_BUSY))
 203                         ) {
 204                         if (req->state != TW_CLI_REQ_STATE_PENDING) {
 205                                 tw_cli_dbg_printf(2, ctlr_handle,
 206                                         tw_osl_cur_func(),
 207                                         "pending internal/ioctl request");
 208                                 req->state = TW_CLI_REQ_STATE_PENDING;
 209                                 tw_cli_req_q_insert_tail(req, TW_CLI_PENDING_Q);
 210                                 error = 0;
 211                                 /* Unmask command interrupt. */
 212                                 TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle,
 213                                         TWA_CONTROL_UNMASK_COMMAND_INTERRUPT);
 214                         } else
 215                                 error = TW_OSL_EBUSY;
 216                 } else {
 217                         tw_osl_ctlr_busy(ctlr_handle, req->req_handle);
 218                         error = TW_OSL_EBUSY;
 219                 }
 220         } else {
 221                 tw_cli_dbg_printf(10, ctlr_handle, tw_osl_cur_func(),
 222                         "Submitting command");
 223
 224                 /* Insert command into busy queue */
 225                 req->state = TW_CLI_REQ_STATE_BUSY;
 226                 tw_cli_req_q_insert_tail(req, TW_CLI_BUSY_Q);
 227
 228                 if ((ctlr->device_id == TW_CL_DEVICE_ID_9K_E) ||
 229                     (ctlr->device_id == TW_CL_DEVICE_ID_9K_SA)) {
 230                         /* Now write the high 4 bytes */
 231                         tw_osl_write_reg(ctlr_handle,
 232                                          TWA_COMMAND_QUEUE_OFFSET_HIGH,
 233                                          (TW_UINT32)(((TW_UINT64)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)))>>32), 4);
 234                 } else {
 235                         if (ctlr->flags & TW_CL_64BIT_ADDRESSES) {
 236                                 /* First write the low 4 bytes, then the high 4. */
 237                                 tw_osl_write_reg(ctlr_handle,
 238                                                  TWA_COMMAND_QUEUE_OFFSET_LOW,
 239                                                  (TW_UINT32)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)), 4);
 240                                 tw_osl_write_reg(ctlr_handle,
 241                                                  TWA_COMMAND_QUEUE_OFFSET_HIGH,
 242                                                  (TW_UINT32)(((TW_UINT64)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)))>>32), 4);
 243                         } else
 244                                 tw_osl_write_reg(ctlr_handle,
 245                                                  TWA_COMMAND_QUEUE_OFFSET,
 246                                                  (TW_UINT32)(req->cmd_pkt_phys + sizeof(struct tw_cl_command_header)), 4);
 247                 }
 248         }
 249 out:
 250         tw_osl_free_lock(ctlr_handle, ctlr->io_lock);
 251
 252         return(error);
 253 }
 254
 255
 256
 257 /*
 258  * Function name:       tw_cl_fw_passthru
 259  * Description:         Interface to OS Layer for accepting firmware
 260  *                      passthru requests.
 261  * Input:               ctlr_handle     -- controller handle
 262  *                      req_pkt         -- OSL built request packet
 263  *                      req_handle      -- request handle
 264  * Output:              None
 265  * Return value:        0       -- success
 266  *                      non-zero-- failure
 267  */
 268 TW_INT32
 269 tw_cl_fw_passthru(struct tw_cl_ctlr_handle *ctlr_handle,
 270         struct tw_cl_req_packet *req_pkt, struct tw_cl_req_handle *req_handle)
 271 {
 272         struct tw_cli_ctlr_context              *ctlr;
 273         struct tw_cli_req_context               *req;
 274         union tw_cl_command_7k                  *cmd_7k;
 275         struct tw_cl_command_9k                 *cmd_9k;
 276         struct tw_cl_passthru_req_packet        *pt_req;
 277         TW_UINT8                                opcode;
 278         TW_UINT8                                sgl_offset;
 279         TW_VOID                                 *sgl = TW_CL_NULL;
 280         TW_INT32                                error;
 281
 282         tw_cli_dbg_printf(5, ctlr_handle, tw_osl_cur_func(), "entered");
 283
 284         ctlr = (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
 285
 286         if (ctlr->reset_in_progress) {
 287                 tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
 288                         "Passthru request during reset: returning busy.");
 289                 return(TW_OSL_EBUSY);
 290         }
 291
 292         if ((req = tw_cli_get_request(ctlr
 293                 )) == TW_CL_NULL) {
 294                 tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
 295                         "Out of request context packets: returning busy");
 296                 return(TW_OSL_EBUSY);
 297         }
 298
 299         req_handle->cl_req_ctxt = req;
 300         req->req_handle = req_handle;
 301         req->orig_req = req_pkt;
 302         req->tw_cli_callback = tw_cli_complete_io;
 303
 304         req->flags |= (TW_CLI_REQ_FLAGS_EXTERNAL | TW_CLI_REQ_FLAGS_PASSTHRU);
 305
 306         pt_req = &(req_pkt->gen_req_pkt.pt_req);
 307
 308         tw_osl_memcpy(req->cmd_pkt, pt_req->cmd_pkt,
 309                 pt_req->cmd_pkt_length);
 310         /* Build the cmd pkt. */
 311         if ((opcode = GET_OPCODE(((TW_UINT8 *)
 312                 (pt_req->cmd_pkt))[sizeof(struct tw_cl_command_header)]))
 313                         == TWA_FW_CMD_EXECUTE_SCSI) {
 314                 TW_UINT16       lun_l4, lun_h4;
 315
 316                 tw_cli_dbg_printf(5, ctlr_handle, tw_osl_cur_func(),
 317                         "passthru: 9k cmd pkt");
 318                 req->flags |= TW_CLI_REQ_FLAGS_9K;
 319                 cmd_9k = &(req->cmd_pkt->command.cmd_pkt_9k);
 320                 lun_l4 = GET_LUN_L4(cmd_9k->lun_l4__req_id);
 321                 lun_h4 = GET_LUN_H4(cmd_9k->lun_h4__sgl_entries);
 322                 cmd_9k->lun_l4__req_id = TW_CL_SWAP16(
 323                         BUILD_LUN_L4__REQ_ID(lun_l4, req->request_id));
 324                 if (pt_req->sgl_entries) {
 325                         cmd_9k->lun_h4__sgl_entries =
 326                                 TW_CL_SWAP16(BUILD_LUN_H4__SGL_ENTRIES(lun_h4,
 327                                         pt_req->sgl_entries));
 328                         sgl = (TW_VOID *)(cmd_9k->sg_list);
 329                 }
 330         } else {
 331                 tw_cli_dbg_printf(5, ctlr_handle, tw_osl_cur_func(),
 332                         "passthru: 7k cmd pkt");
 333                 cmd_7k = &(req->cmd_pkt->command.cmd_pkt_7k);
 334                 cmd_7k->generic.request_id =
 335                         (TW_UINT8)(TW_CL_SWAP16(req->request_id));
 336                 if ((sgl_offset =
 337                         GET_SGL_OFF(cmd_7k->generic.sgl_off__opcode))) {
 338                         if (ctlr->device_id == TW_CL_DEVICE_ID_9K_SA)
 339                                 sgl = (((TW_UINT32 *)cmd_7k) + cmd_7k->generic.size);
 340                         else
 341                                 sgl = (((TW_UINT32 *)cmd_7k) + sgl_offset);
 342                         cmd_7k->generic.size += pt_req->sgl_entries *
 343                                 ((ctlr->flags & TW_CL_64BIT_ADDRESSES) ? 3 : 2);
 344                 }
 345         }
 346
 347         if (sgl)
 348                 tw_cli_fill_sg_list(ctlr, pt_req->sg_list,
 349                         sgl, pt_req->sgl_entries);
 350
 351         if ((error = tw_cli_submit_cmd(req))) {
 352                 tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 353                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 354                         0x1100, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 355                         "Failed to start passthru command",
 356                         "error = %d", error);
 357                 tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
 358         }
 359         return(error);
 360 }
 361
 362
 363
 364 /*
 365  * Function name:       tw_cl_ioctl
 366  * Description:         Handler of CL supported ioctl cmds.
 367  *
 368  * Input:               ctlr    -- ptr to per ctlr structure
 369  *                      cmd     -- ioctl cmd
 370  *                      buf     -- ptr to buffer in kernel memory, which is
 371  *                                 a copy of the input buffer in user-space
 372  * Output:              buf     -- ptr to buffer in kernel memory, which will
 373  *                                 need to be copied to the output buffer in
 374  *                                 user-space
 375  * Return value:        0       -- success
 376  *                      non-zero-- failure
 377  */
 378 TW_INT32
 379 tw_cl_ioctl(struct tw_cl_ctlr_handle *ctlr_handle, u_long cmd, TW_VOID *buf)
 380 {
 381         struct tw_cli_ctlr_context      *ctlr =
 382                 (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
 383         struct tw_cl_ioctl_packet       *user_buf =
 384                 (struct tw_cl_ioctl_packet *)buf;
 385         struct tw_cl_event_packet       event_buf;
 386         TW_INT32                        event_index;
 387         TW_INT32                        start_index;
 388         TW_INT32                        error = TW_OSL_ESUCCESS;
 389
 390         tw_cli_dbg_printf(5, ctlr_handle, tw_osl_cur_func(), "entered");
 391
 392         /* Serialize access to the AEN queue and the ioctl lock. */
 393         tw_osl_get_lock(ctlr_handle, ctlr->gen_lock);
 394
 395         switch (cmd) {
 396         case TW_CL_IOCTL_GET_FIRST_EVENT:
 397                 tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(),
 398                         "Get First Event");
 399
 400                 if (ctlr->aen_q_wrapped) {
 401                         if (ctlr->aen_q_overflow) {
 402                                 /*
 403                                  * The aen queue has wrapped, even before some
 404                                  * events have been retrieved.  Let the caller
 405                                  * know that he missed out on some AEN's.
 406                                  */
 407                                 user_buf->driver_pkt.status =
 408                                         TW_CL_ERROR_AEN_OVERFLOW;
 409                                 ctlr->aen_q_overflow = TW_CL_FALSE;
 410                         } else
 411                                 user_buf->driver_pkt.status = 0;
 412                         event_index = ctlr->aen_head;
 413                 } else {
 414                         if (ctlr->aen_head == ctlr->aen_tail) {
 415                                 user_buf->driver_pkt.status =
 416                                         TW_CL_ERROR_AEN_NO_EVENTS;
 417                                 break;
 418                         }
 419                         user_buf->driver_pkt.status = 0;
 420                         event_index = ctlr->aen_tail;   /* = 0 */
 421                 }
 422                 tw_osl_memcpy(user_buf->data_buf,
 423                         &(ctlr->aen_queue[event_index]),
 424                         sizeof(struct tw_cl_event_packet));
 425
 426                 ctlr->aen_queue[event_index].retrieved = TW_CL_AEN_RETRIEVED;
 427
 428                 break;
 429
 430
 431         case TW_CL_IOCTL_GET_LAST_EVENT:
 432                 tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(),
 433                         "Get Last Event");
 434
 435                 if (ctlr->aen_q_wrapped) {
 436                         if (ctlr->aen_q_overflow) {
 437                                 /*
 438                                  * The aen queue has wrapped, even before some
 439                                  * events have been retrieved.  Let the caller
 440                                  * know that he missed out on some AEN's.
 441                                  */
 442                                 user_buf->driver_pkt.status =
 443                                         TW_CL_ERROR_AEN_OVERFLOW;
 444                                 ctlr->aen_q_overflow = TW_CL_FALSE;
 445                         } else
 446                                 user_buf->driver_pkt.status = 0;
 447                 } else {
 448                         if (ctlr->aen_head == ctlr->aen_tail) {
 449                                 user_buf->driver_pkt.status =
 450                                         TW_CL_ERROR_AEN_NO_EVENTS;
 451                                 break;
 452                         }
 453                         user_buf->driver_pkt.status = 0;
 454                 }
 455                 event_index = (ctlr->aen_head - 1 + ctlr->max_aens_supported) %
 456                         ctlr->max_aens_supported;
 457
 458                 tw_osl_memcpy(user_buf->data_buf,
 459                         &(ctlr->aen_queue[event_index]),
 460                         sizeof(struct tw_cl_event_packet));
 461
 462                 ctlr->aen_queue[event_index].retrieved = TW_CL_AEN_RETRIEVED;
 463
 464                 break;
 465
 466
 467         case TW_CL_IOCTL_GET_NEXT_EVENT:
 468                 tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(),
 469                         "Get Next Event");
 470
 471                 user_buf->driver_pkt.status = 0;
 472                 if (ctlr->aen_q_wrapped) {
 473                         tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(),
 474                                 "Get Next Event: wrapped");
 475                         if (ctlr->aen_q_overflow) {
 476                                 /*
 477                                  * The aen queue has wrapped, even before some
 478                                  * events have been retrieved.  Let the caller
 479                                  * know that he missed out on some AEN's.
 480                                  */
 481                                 tw_cli_dbg_printf(2, ctlr_handle,
 482                                         tw_osl_cur_func(),
 483                                         "Get Next Event: overflow");
 484                                 user_buf->driver_pkt.status =
 485                                         TW_CL_ERROR_AEN_OVERFLOW;
 486                                 ctlr->aen_q_overflow = TW_CL_FALSE;
 487                         }
 488                         start_index = ctlr->aen_head;
 489                 } else {
 490                         if (ctlr->aen_head == ctlr->aen_tail) {
 491                                 tw_cli_dbg_printf(3, ctlr_handle,
 492                                         tw_osl_cur_func(),
 493                                         "Get Next Event: empty queue");
 494                                 user_buf->driver_pkt.status =
 495                                         TW_CL_ERROR_AEN_NO_EVENTS;
 496                                 break;
 497                         }
 498                         start_index = ctlr->aen_tail;   /* = 0 */
 499                 }
 500                 tw_osl_memcpy(&event_buf, user_buf->data_buf,
 501                         sizeof(struct tw_cl_event_packet));
 502
 503                 event_index = (start_index + event_buf.sequence_id -
 504                         ctlr->aen_queue[start_index].sequence_id + 1) %
 505                         ctlr->max_aens_supported;
 506
 507                 tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(),
 508                         "Get Next Event: si = %x, ei = %x, ebsi = %x, "
 509                         "sisi = %x, eisi = %x",
 510                         start_index, event_index, event_buf.sequence_id,
 511                         ctlr->aen_queue[start_index].sequence_id,
 512                         ctlr->aen_queue[event_index].sequence_id);
 513
 514                 if (! (ctlr->aen_queue[event_index].sequence_id >
 515                         event_buf.sequence_id)) {
 516                         /*
 517                          * We don't have any event matching the criterion.  So,
 518                          * we have to report TW_CL_ERROR_NO_EVENTS.  If we also
 519                          * encountered an overflow condition above, we cannot
 520                          * report both conditions during this call.  We choose
 521                          * to report NO_EVENTS this time, and an overflow the
 522                          * next time we are called.
 523                          */
 524                         if (user_buf->driver_pkt.status ==
 525                                 TW_CL_ERROR_AEN_OVERFLOW) {
 526                                 /*
 527                                  * Make a note so we report the overflow
 528                                  * next time.
 529                                  */
 530                                 ctlr->aen_q_overflow = TW_CL_TRUE;
 531                         }
 532                         user_buf->driver_pkt.status = TW_CL_ERROR_AEN_NO_EVENTS;
 533                         break;
 534                 }
 535                 /* Copy the event -- even if there has been an overflow. */
 536                 tw_osl_memcpy(user_buf->data_buf,
 537                         &(ctlr->aen_queue[event_index]),
 538                         sizeof(struct tw_cl_event_packet));
 539
 540                 ctlr->aen_queue[event_index].retrieved = TW_CL_AEN_RETRIEVED;
 541
 542                 break;
 543
 544
 545         case TW_CL_IOCTL_GET_PREVIOUS_EVENT:
 546                 tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(),
 547                         "Get Previous Event");
 548
 549                 user_buf->driver_pkt.status = 0;
 550                 if (ctlr->aen_q_wrapped) {
 551                         if (ctlr->aen_q_overflow) {
 552                                 /*
 553                                  * The aen queue has wrapped, even before some
 554                                  * events have been retrieved.  Let the caller
 555                                  * know that he missed out on some AEN's.
 556                                  */
 557                                 user_buf->driver_pkt.status =
 558                                         TW_CL_ERROR_AEN_OVERFLOW;
 559                                 ctlr->aen_q_overflow = TW_CL_FALSE;
 560                         }
 561                         start_index = ctlr->aen_head;
 562                 } else {
 563                         if (ctlr->aen_head == ctlr->aen_tail) {
 564                                 user_buf->driver_pkt.status =
 565                                         TW_CL_ERROR_AEN_NO_EVENTS;
 566                                 break;
 567                         }
 568                         start_index = ctlr->aen_tail;   /* = 0 */
 569                 }
 570                 tw_osl_memcpy(&event_buf, user_buf->data_buf,
 571                         sizeof(struct tw_cl_event_packet));
 572
 573                 event_index = (start_index + event_buf.sequence_id -
 574                         ctlr->aen_queue[start_index].sequence_id - 1) %
 575                         ctlr->max_aens_supported;
 576
 577                 if (! (ctlr->aen_queue[event_index].sequence_id <
 578                         event_buf.sequence_id)) {
 579                         /*
 580                          * We don't have any event matching the criterion.  So,
 581                          * we have to report TW_CL_ERROR_NO_EVENTS.  If we also
 582                          * encountered an overflow condition above, we cannot
 583                          * report both conditions during this call.  We choose
 584                          * to report NO_EVENTS this time, and an overflow the
 585                          * next time we are called.
 586                          */
 587                         if (user_buf->driver_pkt.status ==
 588                                 TW_CL_ERROR_AEN_OVERFLOW) {
 589                                 /*
 590                                  * Make a note so we report the overflow
 591                                  * next time.
 592                                  */
 593                                 ctlr->aen_q_overflow = TW_CL_TRUE;
 594                         }
 595                         user_buf->driver_pkt.status = TW_CL_ERROR_AEN_NO_EVENTS;
 596                         break;
 597                 }
 598                 /* Copy the event -- even if there has been an overflow. */
 599                 tw_osl_memcpy(user_buf->data_buf,
 600                         &(ctlr->aen_queue[event_index]),
 601                         sizeof(struct tw_cl_event_packet));
 602
 603                 ctlr->aen_queue[event_index].retrieved = TW_CL_AEN_RETRIEVED;
 604
 605                 break;
 606
 607
 608         case TW_CL_IOCTL_GET_LOCK:
 609         {
 610                 struct tw_cl_lock_packet        lock_pkt;
 611                 TW_TIME                         cur_time;
 612
 613                 tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(),
 614                         "Get ioctl lock");
 615
 616                 cur_time = tw_osl_get_local_time();
 617                 tw_osl_memcpy(&lock_pkt, user_buf->data_buf,
 618                         sizeof(struct tw_cl_lock_packet));
 619
 620                 if ((ctlr->ioctl_lock.lock == TW_CLI_LOCK_FREE) ||
 621                         (lock_pkt.force_flag) ||
 622                         (cur_time >= ctlr->ioctl_lock.timeout)) {
 623                         tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(),
 624                                 "GET_LOCK: Getting lock!");
 625                         ctlr->ioctl_lock.lock = TW_CLI_LOCK_HELD;
 626                         ctlr->ioctl_lock.timeout =
 627                                 cur_time + (lock_pkt.timeout_msec / 1000);
 628                         lock_pkt.time_remaining_msec = lock_pkt.timeout_msec;
 629                         user_buf->driver_pkt.status = 0;
 630                 } else {
 631                         tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
 632                                 "GET_LOCK: Lock already held!");
 633                         lock_pkt.time_remaining_msec = (TW_UINT32)(
 634                                 (ctlr->ioctl_lock.timeout - cur_time) * 1000);
 635                         user_buf->driver_pkt.status =
 636                                 TW_CL_ERROR_IOCTL_LOCK_ALREADY_HELD;
 637                 }
 638                 tw_osl_memcpy(user_buf->data_buf, &lock_pkt,
 639                         sizeof(struct tw_cl_lock_packet));
 640                 break;
 641         }
 642
 643
 644         case TW_CL_IOCTL_RELEASE_LOCK:
 645                 tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(),
 646                         "Release ioctl lock");
 647
 648                 if (ctlr->ioctl_lock.lock == TW_CLI_LOCK_FREE) {
 649                         tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
 650                                 "twa_ioctl: RELEASE_LOCK: Lock not held!");
 651                         user_buf->driver_pkt.status =
 652                                 TW_CL_ERROR_IOCTL_LOCK_NOT_HELD;
 653                 } else {
 654                         tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(),
 655                                 "RELEASE_LOCK: Releasing lock!");
 656                         ctlr->ioctl_lock.lock = TW_CLI_LOCK_FREE;
 657                         user_buf->driver_pkt.status = 0;
 658                 }
 659                 break;
 660
 661
 662         case TW_CL_IOCTL_GET_COMPATIBILITY_INFO:
 663         {
 664                 struct tw_cl_compatibility_packet       comp_pkt;
 665
 666                 tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(),
 667                         "Get compatibility info");
 668
 669                 tw_osl_memcpy(comp_pkt.driver_version,
 670                         TW_OSL_DRIVER_VERSION_STRING,
 671                         sizeof(TW_OSL_DRIVER_VERSION_STRING));
 672                 comp_pkt.working_srl = ctlr->working_srl;
 673                 comp_pkt.working_branch = ctlr->working_branch;
 674                 comp_pkt.working_build = ctlr->working_build;
 675                 comp_pkt.driver_srl_high = TWA_CURRENT_FW_SRL;
 676                 comp_pkt.driver_branch_high =
 677                         TWA_CURRENT_FW_BRANCH(ctlr->arch_id);
 678                 comp_pkt.driver_build_high =
 679                         TWA_CURRENT_FW_BUILD(ctlr->arch_id);
 680                 comp_pkt.driver_srl_low = TWA_BASE_FW_SRL;
 681                 comp_pkt.driver_branch_low = TWA_BASE_FW_BRANCH;
 682                 comp_pkt.driver_build_low = TWA_BASE_FW_BUILD;
 683                 comp_pkt.fw_on_ctlr_srl = ctlr->fw_on_ctlr_srl;
 684                 comp_pkt.fw_on_ctlr_branch = ctlr->fw_on_ctlr_branch;
 685                 comp_pkt.fw_on_ctlr_build = ctlr->fw_on_ctlr_build;
 686                 user_buf->driver_pkt.status = 0;
 687
 688                 /* Copy compatibility information to user space. */
 689                 tw_osl_memcpy(user_buf->data_buf, &comp_pkt,
 690                         (sizeof(struct tw_cl_compatibility_packet) <
 691                         user_buf->driver_pkt.buffer_length) ?
 692                         sizeof(struct tw_cl_compatibility_packet) :
 693                         user_buf->driver_pkt.buffer_length);
 694                 break;
 695         }
 696
 697         default:
 698                 /* Unknown opcode. */
 699                 tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(),
 700                         "Unknown ioctl cmd 0x%x", cmd);
 701                 error = TW_OSL_ENOTTY;
 702         }
 703
 704         tw_osl_free_lock(ctlr_handle, ctlr->gen_lock);
 705         return(error);
 706 }
 707
 708
 709
 710 /*
 711  * Function name:       tw_cli_get_param
 712  * Description:         Get a firmware parameter.
 713  *
 714  * Input:               ctlr            -- ptr to per ctlr structure
 715  *                      table_id        -- parameter table #
 716  *                      param_id        -- index of the parameter in the table
 717  *                      param_size      -- size of the parameter in bytes
 718  *                      callback        -- ptr to function, if any, to be called
 719  *                                      back on completion; TW_CL_NULL if no callback.
 720  * Output:              param_data      -- param value
 721  * Return value:        0       -- success
 722  *                      non-zero-- failure
 723  */
 724 TW_INT32
 725 tw_cli_get_param(struct tw_cli_ctlr_context *ctlr, TW_INT32 table_id,
 726         TW_INT32 param_id, TW_VOID *param_data, TW_INT32 param_size,
 727         TW_VOID (* callback)(struct tw_cli_req_context *req))
 728 {
 729         struct tw_cli_req_context       *req;
 730         union tw_cl_command_7k          *cmd;
 731         struct tw_cl_param_9k           *param = TW_CL_NULL;
 732         TW_INT32                        error = TW_OSL_EBUSY;
 733
 734         tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
 735
 736         /* Get a request packet. */
 737         if ((req = tw_cli_get_request(ctlr
 738                 )) == TW_CL_NULL)
 739                 goto out;
 740
 741         /* Make sure this is the only CL internal request at this time. */
 742         if (ctlr->internal_req_busy) {
 743                 error = TW_OSL_EBUSY;
 744                 goto out;
 745         }
 746         ctlr->internal_req_busy = TW_CL_TRUE;
 747         req->data = ctlr->internal_req_data;
 748         req->data_phys = ctlr->internal_req_data_phys;
 749         req->length = TW_CLI_SECTOR_SIZE;
 750         req->flags |= TW_CLI_REQ_FLAGS_INTERNAL;
 751
 752         /* Initialize memory to read data into. */
 753         param = (struct tw_cl_param_9k *)(req->data);
 754         tw_osl_memzero(param, sizeof(struct tw_cl_param_9k) - 1 + param_size);
 755
 756         /* Build the cmd pkt. */
 757         cmd = &(req->cmd_pkt->command.cmd_pkt_7k);
 758
 759         req->cmd_pkt->cmd_hdr.header_desc.size_header = 128;
 760
 761         cmd->param.sgl_off__opcode =
 762                 BUILD_SGL_OFF__OPCODE(2, TWA_FW_CMD_GET_PARAM);
 763         cmd->param.request_id =
 764                 (TW_UINT8)(TW_CL_SWAP16(req->request_id));
 765         cmd->param.host_id__unit = BUILD_HOST_ID__UNIT(0, 0);
 766         cmd->param.param_count = TW_CL_SWAP16(1);
 767
 768         if (ctlr->flags & TW_CL_64BIT_ADDRESSES) {
 769                 ((struct tw_cl_sg_desc64 *)(cmd->param.sgl))[0].address =
 770                         TW_CL_SWAP64(req->data_phys);
 771                 ((struct tw_cl_sg_desc64 *)(cmd->param.sgl))[0].length =
 772                         TW_CL_SWAP32(req->length);
 773                 cmd->param.size = 2 + 3;
 774         } else {
 775                 ((struct tw_cl_sg_desc32 *)(cmd->param.sgl))[0].address =
 776                         TW_CL_SWAP32(req->data_phys);
 777                 ((struct tw_cl_sg_desc32 *)(cmd->param.sgl))[0].length =
 778                         TW_CL_SWAP32(req->length);
 779                 cmd->param.size = 2 + 2;
 780         }
 781
 782         /* Specify which parameter we need. */
 783         param->table_id = TW_CL_SWAP16(table_id | TWA_9K_PARAM_DESCRIPTOR);
 784         param->parameter_id = (TW_UINT8)(param_id);
 785         param->parameter_size_bytes = TW_CL_SWAP16(param_size);
 786
 787         /* Submit the command. */
 788         if (callback == TW_CL_NULL) {
 789                 /* There's no call back; wait till the command completes. */
 790                 error = tw_cli_submit_and_poll_request(req,
 791                                 TW_CLI_REQUEST_TIMEOUT_PERIOD);
 792                 if (error == TW_OSL_ETIMEDOUT)
 793                         /* Clean-up done by tw_cli_submit_and_poll_request. */
 794                         return(error);
 795                 if (error)
 796                         goto out;
 797                 if ((error = cmd->param.status)) {
 798                         tw_cli_create_ctlr_event(ctlr,
 799                                 TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
 800                                 &(req->cmd_pkt->cmd_hdr));
 801                         goto out;
 802                 }
 803                 tw_osl_memcpy(param_data, param->data, param_size);
 804                 ctlr->internal_req_busy = TW_CL_FALSE;
 805                 tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
 806         } else {
 807                 /* There's a call back.  Simply submit the command. */
 808                 req->tw_cli_callback = callback;
 809                 if ((error = tw_cli_submit_cmd(req)))
 810                         goto out;
 811         }
 812         return(0);
 813
 814 out:
 815         tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
 816                 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 817                 0x1101, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 818                 "get_param failed",
 819                 "error = %d", error);
 820         if (param)
 821                 ctlr->internal_req_busy = TW_CL_FALSE;
 822         if (req)
 823                 tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
 824         return(1);
 825 }
 826
 827
 828
 829 /*
 830  * Function name:       tw_cli_set_param
 831  * Description:         Set a firmware parameter.
 832  *
 833  * Input:               ctlr            -- ptr to per ctlr structure
 834  *                      table_id        -- parameter table #
 835  *                      param_id        -- index of the parameter in the table
 836  *                      param_size      -- size of the parameter in bytes
 837  *                      callback        -- ptr to function, if any, to be called
 838  *                                      back on completion; TW_CL_NULL if no callback.
 839  * Output:              None
 840  * Return value:        0       -- success
 841  *                      non-zero-- failure
 842  */
 843 TW_INT32
 844 tw_cli_set_param(struct tw_cli_ctlr_context *ctlr, TW_INT32 table_id,
 845         TW_INT32 param_id, TW_INT32 param_size, TW_VOID *data,
 846         TW_VOID (* callback)(struct tw_cli_req_context *req))
 847 {
 848         struct tw_cli_req_context       *req;
 849         union tw_cl_command_7k          *cmd;
 850         struct tw_cl_param_9k           *param = TW_CL_NULL;
 851         TW_INT32                        error = TW_OSL_EBUSY;
 852
 853         tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
 854
 855         /* Get a request packet. */
 856         if ((req = tw_cli_get_request(ctlr
 857                 )) == TW_CL_NULL)
 858                 goto out;
 859
 860         /* Make sure this is the only CL internal request at this time. */
 861         if (ctlr->internal_req_busy) {
 862                 error = TW_OSL_EBUSY;
 863                 goto out;
 864         }
 865         ctlr->internal_req_busy = TW_CL_TRUE;
 866         req->data = ctlr->internal_req_data;
 867         req->data_phys = ctlr->internal_req_data_phys;
 868         req->length = TW_CLI_SECTOR_SIZE;
 869         req->flags |= TW_CLI_REQ_FLAGS_INTERNAL;
 870
 871         /* Initialize memory to send data using. */
 872         param = (struct tw_cl_param_9k *)(req->data);
 873         tw_osl_memzero(param, sizeof(struct tw_cl_param_9k) - 1 + param_size);
 874
 875         /* Build the cmd pkt. */
 876         cmd = &(req->cmd_pkt->command.cmd_pkt_7k);
 877
 878         req->cmd_pkt->cmd_hdr.header_desc.size_header = 128;
 879
 880         cmd->param.sgl_off__opcode =
 881                 BUILD_SGL_OFF__OPCODE(2, TWA_FW_CMD_SET_PARAM);
 882         cmd->param.request_id = (TW_UINT8)(TW_CL_SWAP16(req->request_id));
 883         cmd->param.host_id__unit = BUILD_HOST_ID__UNIT(0, 0);
 884         cmd->param.param_count = TW_CL_SWAP16(1);
 885
 886         if (ctlr->flags & TW_CL_64BIT_ADDRESSES) {
 887                 ((struct tw_cl_sg_desc64 *)(cmd->param.sgl))[0].address =
 888                         TW_CL_SWAP64(req->data_phys);
 889                 ((struct tw_cl_sg_desc64 *)(cmd->param.sgl))[0].length =
 890                         TW_CL_SWAP32(req->length);
 891                 cmd->param.size = 2 + 3;
 892         } else {
 893                 ((struct tw_cl_sg_desc32 *)(cmd->param.sgl))[0].address =
 894                         TW_CL_SWAP32(req->data_phys);
 895                 ((struct tw_cl_sg_desc32 *)(cmd->param.sgl))[0].length =
 896                         TW_CL_SWAP32(req->length);
 897                 cmd->param.size = 2 + 2;
 898         }
 899
 900         /* Specify which parameter we want to set. */
 901         param->table_id = TW_CL_SWAP16(table_id | TWA_9K_PARAM_DESCRIPTOR);
 902         param->parameter_id = (TW_UINT8)(param_id);
 903         param->parameter_size_bytes = TW_CL_SWAP16(param_size);
 904         tw_osl_memcpy(param->data, data, param_size);
 905
 906         /* Submit the command. */
 907         if (callback == TW_CL_NULL) {
 908                 /* There's no call back;  wait till the command completes. */
 909                 error = tw_cli_submit_and_poll_request(req,
 910                         TW_CLI_REQUEST_TIMEOUT_PERIOD);
 911                 if (error == TW_OSL_ETIMEDOUT)
 912                         /* Clean-up done by tw_cli_submit_and_poll_request. */
 913                         return(error);
 914                 if (error)
 915                         goto out;
 916                 if ((error = cmd->param.status)) {
 917                         tw_cli_create_ctlr_event(ctlr,
 918                                 TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
 919                                 &(req->cmd_pkt->cmd_hdr));
 920                         goto out;
 921                 }
 922                 ctlr->internal_req_busy = TW_CL_FALSE;
 923                 tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
 924         } else {
 925                 /* There's a call back.  Simply submit the command. */
 926                 req->tw_cli_callback = callback;
 927                 if ((error = tw_cli_submit_cmd(req)))
 928                         goto out;
 929         }
 930         return(error);
 931
 932 out:
 933         tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
 934                 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 935                 0x1102, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 936                 "set_param failed",
 937                 "error = %d", error);
 938         if (param)
 939                 ctlr->internal_req_busy = TW_CL_FALSE;
 940         if (req)
 941                 tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
 942         return(error);
 943 }
 944
 945
 946
 947 /*
 948  * Function name:       tw_cli_submit_and_poll_request
 949  * Description:         Sends down a firmware cmd, and waits for the completion
 950  *                      in a tight loop.
 951  *
 952  * Input:               req     -- ptr to request pkt
 953  *                      timeout -- max # of seconds to wait before giving up
 954  * Output:              None
 955  * Return value:        0       -- success
 956  *                      non-zero-- failure
 957  */
 958 TW_INT32
 959 tw_cli_submit_and_poll_request(struct tw_cli_req_context *req,
 960         TW_UINT32 timeout)
 961 {
 962         struct tw_cli_ctlr_context      *ctlr = req->ctlr;
 963         TW_TIME                         end_time;
 964         TW_INT32                        error;
 965
 966         tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
 967
 968         /*
 969          * If the cmd queue is full, tw_cli_submit_cmd will queue this
 970          * request in the pending queue, since this is an internal request.
 971          */
 972         if ((error = tw_cli_submit_cmd(req))) {
 973                 tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
 974                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 975                         0x1103, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 976                         "Failed to start internal request",
 977                         "error = %d", error);
 978                 return(error);
 979         }
 980
 981         /*
 982          * Poll for the response until the command gets completed, or there's
 983          * a timeout.
 984          */
 985         end_time = tw_osl_get_local_time() + timeout;
 986         do {
 987                 if ((error = req->error_code))
 988                         /*
 989                          * This will take care of completion due to a reset,
 990                          * or a failure in tw_cli_submit_pending_queue.
 991                          * The caller should do the clean-up.
 992                          */
 993                         return(error);
 994
 995                 /* See if the command completed. */
 996                 tw_cli_process_resp_intr(ctlr);
 997
 998                 if ((req->state != TW_CLI_REQ_STATE_BUSY) &&
 999                         (req->state != TW_CLI_REQ_STATE_PENDING))
1000                         return(req->state != TW_CLI_REQ_STATE_COMPLETE);
1001         } while (tw_osl_get_local_time() <= end_time);
1002
1003         /* Time out! */
1004         tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
1005                 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
1006                 0x1104, 0x1, TW_CL_SEVERITY_ERROR_STRING,
1007                 "Internal request timed out",
1008                 "request = %p", req);
1009
1010         /*
1011          * We will reset the controller only if the request has already been
1012          * submitted, so as to not lose the request packet.  If a busy request
1013          * timed out, the reset will take care of freeing resources.  If a
1014          * pending request timed out, we will free resources for that request,
1015          * right here, thereby avoiding a reset.  So, the caller is expected
1016          * to NOT cleanup when TW_OSL_ETIMEDOUT is returned.
1017          */
1018
1019         /*
1020          * We have to make sure that this timed out request, if it were in the
1021          * pending queue, doesn't get submitted while we are here, from
1022          * tw_cli_submit_pending_queue.  There could be a race in that case.
1023          * Need to revisit.
1024          */
1025         if (req->state != TW_CLI_REQ_STATE_PENDING)
1026                 tw_cl_reset_ctlr(ctlr->ctlr_handle);
1027         else {
1028                 tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(),
1029                         "Removing request from pending queue");
1030                 /*
1031                  * Request was never submitted.  Clean up.  Note that we did
1032                  * not do a reset.  So, we have to remove the request ourselves
1033                  * from the pending queue (as against tw_cli_drain_pendinq_queue
1034                  * taking care of it).
1035                  */
1036                 tw_cli_req_q_remove_item(req, TW_CLI_PENDING_Q);
1037                 if ((TW_CL_Q_FIRST_ITEM(&(ctlr->req_q_head[TW_CLI_PENDING_Q]))) == TW_CL_NULL)
1038                         TW_CLI_WRITE_CONTROL_REGISTER(ctlr->ctlr_handle,
1039                                 TWA_CONTROL_MASK_COMMAND_INTERRUPT);
1040                 if (req->data)
1041                         ctlr->internal_req_busy = TW_CL_FALSE;
1042                 tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
1043         }
1044
1045         return(TW_OSL_ETIMEDOUT);
1046 }
1047
1048
1049
1050 /*
1051  * Function name:       tw_cl_reset_ctlr
1052  * Description:         Soft resets and then initializes the controller;
1053  *                      drains any incomplete requests.
1054  *
1055  * Input:               ctlr    -- ptr to per ctlr structure
1056  * Output:              None
1057  * Return value:        0       -- success
1058  *                      non-zero-- failure
1059  */
1060 TW_INT32
1061 tw_cl_reset_ctlr(struct tw_cl_ctlr_handle *ctlr_handle)
1062 {
1063         struct tw_cli_ctlr_context      *ctlr =
1064                 (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
1065         struct twa_softc                *sc = ctlr_handle->osl_ctlr_ctxt;
1066         TW_INT32                        reset_attempt = 1;
1067         TW_INT32                        error;
1068
1069         tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(), "entered");
1070
1071         ctlr->reset_in_progress = TW_CL_TRUE;
1072         xpt_freeze_simq(sc->sim, 1);
1073
1074         tw_cli_disable_interrupts(ctlr);
1075
1076         /*
1077          * Error back all requests in the complete, busy, and pending queues.
1078          * If any request is already on its way to getting submitted, it's in
1079          * none of these queues and so, will not be completed.  That request
1080          * will continue its course and get submitted to the controller after
1081          * the reset is done (and io_lock is released).
1082          */
1083         tw_cli_dbg_printf(2, ctlr_handle, tw_osl_cur_func(),
1084                 "Draining all queues following reset");
1085         tw_cli_drain_complete_queue(ctlr);
1086         tw_cli_drain_busy_queue(ctlr);
1087         tw_cli_drain_pending_queue(ctlr);
1088         ctlr->internal_req_busy = TW_CL_FALSE;
1089         ctlr->get_more_aens     = TW_CL_FALSE;
1090
1091         /* Soft reset the controller. */
1092 try_reset:
1093         if ((error = tw_cli_soft_reset(ctlr))) {
1094                 tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
1095                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
1096                         0x1105, 0x1, TW_CL_SEVERITY_ERROR_STRING,
1097                         "Controller reset failed",
1098                         "error = %d; attempt %d", error, reset_attempt++);
1099                 if (reset_attempt <= TW_CLI_MAX_RESET_ATTEMPTS)
1100                         goto try_reset;
1101                 else
1102                         goto out;
1103         }
1104
1105         /* Re-establish logical connection with the controller. */
1106         if ((error = tw_cli_init_connection(ctlr,
1107                         (TW_UINT16)(ctlr->max_simult_reqs),
1108                         0, 0, 0, 0, 0, TW_CL_NULL, TW_CL_NULL, TW_CL_NULL,
1109                         TW_CL_NULL, TW_CL_NULL))) {
1110                 tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
1111                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
1112                         0x1106, 0x1, TW_CL_SEVERITY_ERROR_STRING,
1113                         "Can't initialize connection after reset",
1114                         "error = %d", error);
1115                 goto out;
1116         }
1117
1118         tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
1119                 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
1120                 0x1107, 0x3, TW_CL_SEVERITY_INFO_STRING,
1121                 "Controller reset done!",
1122                 " ");
1123
1124 out:
1125         ctlr->reset_in_progress = TW_CL_FALSE;
1126         xpt_release_simq(sc->sim, 1);
1127
1128         /*
1129          * Enable interrupts, and also clear attention and response interrupts.
1130          */
1131         tw_cli_enable_interrupts(ctlr);
1132
1133         /* Request for a bus re-scan. */
1134         if (!error)
1135                 tw_osl_scan_bus(ctlr_handle);
1136         return(error);
1137 }
1138
1139
1140
1141 /*
1142  * Function name:       tw_cli_soft_reset
1143  * Description:         Does the actual soft reset.
1144  *
1145  * Input:               ctlr    -- ptr to per ctlr structure
1146  * Output:              None
1147  * Return value:        0       -- success
1148  *                      non-zero-- failure
1149  */
1150 TW_INT32
1151 tw_cli_soft_reset(struct tw_cli_ctlr_context *ctlr)
1152 {
1153         struct tw_cl_ctlr_handle        *ctlr_handle = ctlr->ctlr_handle;
1154         TW_UINT32                       status_reg;
1155         int                             found;
1156         int                             loop_count;
1157         TW_UINT32                       error;
1158
1159         tw_cli_dbg_printf(1, ctlr_handle, tw_osl_cur_func(), "entered");
1160
1161         tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
1162                 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
1163                 0x1108, 0x3, TW_CL_SEVERITY_INFO_STRING,
1164                 "Resetting controller...",
1165                 " ");
1166
1167         /* Don't let any new commands get submitted to the controller. */
1168         tw_osl_get_lock(ctlr_handle, ctlr->io_lock);
1169
1170         TW_CLI_SOFT_RESET(ctlr_handle);
1171
1172         if ((ctlr->device_id == TW_CL_DEVICE_ID_9K_X) ||
1173             (ctlr->device_id == TW_CL_DEVICE_ID_9K_E) ||
1174             (ctlr->device_id == TW_CL_DEVICE_ID_9K_SA)) {
1175                 /*
1176                  * There's a hardware bug in the G133 ASIC, which can lead to
1177                  * PCI parity errors and hangs, if the host accesses any
1178                  * registers when the firmware is resetting the hardware, as
1179                  * part of a hard/soft reset.  The window of time when the
1180                  * problem can occur is about 10 ms.  Here, we will handshake
1181                  * with the firmware to find out when the firmware is pulling
1182                  * down the hardware reset pin, and wait for about 500 ms to
1183                  * make sure we don't access any hardware registers (for
1184                  * polling) during that window.
1185                  */
1186                 ctlr->reset_phase1_in_progress = TW_CL_TRUE;
1187                 loop_count = 0;
1188                 do {
1189                         found = (tw_cli_find_response(ctlr, TWA_RESET_PHASE1_NOTIFICATION_RESPONSE) == TW_OSL_ESUCCESS);
1190                         tw_osl_delay(10);
1191                         loop_count++;
1192                         error = 0x7888;
1193                 } while (!found && (loop_count < 6000000)); /* Loop for no more than 60 seconds */
1194
1195                 if (!found) {
1196                         tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
1197                                 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
1198                                 0x1109, 0x1, TW_CL_SEVERITY_ERROR_STRING,
1199                                 "Missed firmware handshake after soft-reset",
1200                                 "error = %d", error);
1201                         tw_osl_free_lock(ctlr_handle, ctlr->io_lock);
1202                         return(error);
1203                 }
1204
1205                 tw_osl_delay(TWA_RESET_PHASE1_WAIT_TIME_MS * 1000);
1206                 ctlr->reset_phase1_in_progress = TW_CL_FALSE;
1207         }
1208
1209         if ((error = tw_cli_poll_status(ctlr,
1210                         TWA_STATUS_MICROCONTROLLER_READY |
1211                         TWA_STATUS_ATTENTION_INTERRUPT,
1212                         TW_CLI_RESET_TIMEOUT_PERIOD))) {
1213                 tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
1214                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
1215                         0x1109, 0x1, TW_CL_SEVERITY_ERROR_STRING,
1216                         "Micro-ctlr not ready/No attn intr after reset",
1217                         "error = %d", error);
1218                 tw_osl_free_lock(ctlr_handle, ctlr->io_lock);
1219                 return(error);
1220         }
1221
1222         TW_CLI_WRITE_CONTROL_REGISTER(ctlr_handle,
1223                 TWA_CONTROL_CLEAR_ATTENTION_INTERRUPT);
1224
1225         if ((error = tw_cli_drain_response_queue(ctlr))) {
1226                 tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
1227                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
1228                         0x110A, 0x1, TW_CL_SEVERITY_ERROR_STRING,
1229                         "Can't drain response queue after reset",
1230                         "error = %d", error);
1231                 tw_osl_free_lock(ctlr_handle, ctlr->io_lock);
1232                 return(error);
1233         }
1234
1235         tw_osl_free_lock(ctlr_handle, ctlr->io_lock);
1236
1237         if ((error = tw_cli_drain_aen_queue(ctlr))) {
1238                 tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
1239                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
1240                         0x110B, 0x1, TW_CL_SEVERITY_ERROR_STRING,
1241                         "Can't drain AEN queue after reset",
1242                         "error = %d", error);
1243                 return(error);
1244         }
1245
1246         if ((error = tw_cli_find_aen(ctlr, TWA_AEN_SOFT_RESET))) {
1247                 tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
1248                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
1249                         0x110C, 0x1, TW_CL_SEVERITY_ERROR_STRING,
1250                         "Reset not reported by controller",
1251                         "error = %d", error);
1252                 return(error);
1253         }
1254
1255         status_reg = TW_CLI_READ_STATUS_REGISTER(ctlr_handle);
1256
1257         if ((error = TW_CLI_STATUS_ERRORS(status_reg)) ||
1258                         (error = tw_cli_check_ctlr_state(ctlr, status_reg))) {
1259                 tw_cl_create_event(ctlr_handle, TW_CL_TRUE,
1260                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT,
1261                         0x110D, 0x1, TW_CL_SEVERITY_ERROR_STRING,
1262                         "Controller errors detected after reset",
1263                         "error = %d", error);
1264                 return(error);
1265         }
1266
1267         return(TW_OSL_ESUCCESS);
1268 }
1269
1270
1271
1272 /*
1273  * Function name:       tw_cli_send_scsi_cmd
1274  * Description:         Sends down a scsi cmd to fw.
1275  *
1276  * Input:               req     -- ptr to request pkt
1277  *                      cmd     -- opcode of scsi cmd to send
1278  * Output:              None
1279  * Return value:        0       -- success
1280  *                      non-zero-- failure
1281  */
1282 TW_INT32
1283 tw_cli_send_scsi_cmd(struct tw_cli_req_context *req, TW_INT32 cmd)
1284 {
1285         struct tw_cl_command_packet     *cmdpkt;
1286         struct tw_cl_command_9k         *cmd9k;
1287         struct tw_cli_ctlr_context      *ctlr;
1288         TW_INT32                        error;
1289
1290         ctlr = req->ctlr;
1291         tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
1292
1293         /* Make sure this is the only CL internal request at this time. */
1294         if (ctlr->internal_req_busy)
1295                 return(TW_OSL_EBUSY);
1296         ctlr->internal_req_busy = TW_CL_TRUE;
1297         req->data = ctlr->internal_req_data;
1298         req->data_phys = ctlr->internal_req_data_phys;
1299         tw_osl_memzero(req->data, TW_CLI_SECTOR_SIZE);
1300         req->length = TW_CLI_SECTOR_SIZE;
1301
1302         /* Build the cmd pkt. */
1303         cmdpkt = req->cmd_pkt;
1304
1305         cmdpkt->cmd_hdr.header_desc.size_header = 128;
1306
1307         cmd9k = &(cmdpkt->command.cmd_pkt_9k);
1308
1309         cmd9k->res__opcode =
1310                 BUILD_RES__OPCODE(0, TWA_FW_CMD_EXECUTE_SCSI);
1311         cmd9k->unit = 0;
1312         cmd9k->lun_l4__req_id = TW_CL_SWAP16(req->request_id);
1313         cmd9k->status = 0;
1314         cmd9k->sgl_offset = 16; /* offset from end of hdr = max cdb len */
1315         cmd9k->lun_h4__sgl_entries = TW_CL_SWAP16(1);
1316
1317         if (req->ctlr->flags & TW_CL_64BIT_ADDRESSES) {
1318                 ((struct tw_cl_sg_desc64 *)(cmd9k->sg_list))[0].address =
1319                         TW_CL_SWAP64(req->data_phys);
1320                 ((struct tw_cl_sg_desc64 *)(cmd9k->sg_list))[0].length =
1321                         TW_CL_SWAP32(req->length);
1322         } else {
1323                 ((struct tw_cl_sg_desc32 *)(cmd9k->sg_list))[0].address =
1324                         TW_CL_SWAP32(req->data_phys);
1325                 ((struct tw_cl_sg_desc32 *)(cmd9k->sg_list))[0].length =
1326                         TW_CL_SWAP32(req->length);
1327         }
1328
1329         cmd9k->cdb[0] = (TW_UINT8)cmd;
1330         cmd9k->cdb[4] = 128;
1331
1332         if ((error = tw_cli_submit_cmd(req)))
1333                 if (error != TW_OSL_EBUSY) {
1334                         tw_cli_dbg_printf(1, ctlr->ctlr_handle,
1335                                 tw_osl_cur_func(),
1336                                 "Failed to start SCSI command",
1337                                 "request = %p, error = %d", req, error);
1338                         return(TW_OSL_EIO);
1339                 }
1340         return(TW_OSL_ESUCCESS);
1341 }
1342
1343
1344
1345 /*
1346  * Function name:       tw_cli_get_aen
1347  * Description:         Sends down a Request Sense cmd to fw to fetch an AEN.
1348  *
1349  * Input:               ctlr    -- ptr to per ctlr structure
1350  * Output:              None
1351  * Return value:        0       -- success
1352  *                      non-zero-- failure
1353  */
1354 TW_INT32
1355 tw_cli_get_aen(struct tw_cli_ctlr_context *ctlr)
1356 {
1357         struct tw_cli_req_context       *req;
1358         TW_INT32                        error;
1359
1360         tw_cli_dbg_printf(4, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
1361
1362         if ((req = tw_cli_get_request(ctlr
1363                 )) == TW_CL_NULL)
1364                 return(TW_OSL_EBUSY);
1365
1366         req->flags |= TW_CLI_REQ_FLAGS_INTERNAL;
1367         req->flags |= TW_CLI_REQ_FLAGS_9K;
1368         req->tw_cli_callback = tw_cli_aen_callback;
1369         if ((error = tw_cli_send_scsi_cmd(req, 0x03 /* REQUEST_SENSE */))) {
1370                 tw_cli_dbg_printf(1, ctlr->ctlr_handle, tw_osl_cur_func(),
1371                         "Could not send SCSI command",
1372                         "request = %p, error = %d", req, error);
1373                 if (req->data)
1374                         ctlr->internal_req_busy = TW_CL_FALSE;
1375                 tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
1376         }
1377         return(error);
1378 }
1379
1380
1381
1382 /*
1383  * Function name:       tw_cli_fill_sg_list
1384  * Description:         Fills in the scatter/gather list.
1385  *
1386  * Input:               ctlr    -- ptr to per ctlr structure
1387  *                      sgl_src -- ptr to fill the sg list from
1388  *                      sgl_dest-- ptr to sg list
1389  *                      nsegments--# of segments
1390  * Output:              None
1391  * Return value:        None
1392  */
1393 TW_VOID
1394 tw_cli_fill_sg_list(struct tw_cli_ctlr_context *ctlr, TW_VOID *sgl_src,
1395         TW_VOID *sgl_dest, TW_INT32 num_sgl_entries)
1396 {
1397         TW_INT32        i;
1398
1399         tw_cli_dbg_printf(10, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
1400
1401         if (ctlr->flags & TW_CL_64BIT_ADDRESSES) {
1402                 struct tw_cl_sg_desc64 *sgl_s =
1403                         (struct tw_cl_sg_desc64 *)sgl_src;
1404                 struct tw_cl_sg_desc64 *sgl_d =
1405                         (struct tw_cl_sg_desc64 *)sgl_dest;
1406
1407                 tw_cli_dbg_printf(10, ctlr->ctlr_handle, tw_osl_cur_func(),
1408                         "64 bit addresses");
1409                 for (i = 0; i < num_sgl_entries; i++) {
1410                         sgl_d[i].address = TW_CL_SWAP64(sgl_s->address);
1411                         sgl_d[i].length = TW_CL_SWAP32(sgl_s->length);
1412                         sgl_s++;
1413                         if (ctlr->flags & TW_CL_64BIT_SG_LENGTH)
1414                                 sgl_s = (struct tw_cl_sg_desc64 *)
1415                                         (((TW_INT8 *)(sgl_s)) + 4);
1416                 }
1417         } else {
1418                 struct tw_cl_sg_desc32 *sgl_s =
1419                         (struct tw_cl_sg_desc32 *)sgl_src;
1420                 struct tw_cl_sg_desc32 *sgl_d =
1421                         (struct tw_cl_sg_desc32 *)sgl_dest;
1422
1423                 tw_cli_dbg_printf(10, ctlr->ctlr_handle, tw_osl_cur_func(),
1424                         "32 bit addresses");
1425                 for (i = 0; i < num_sgl_entries; i++) {
1426                         sgl_d[i].address = TW_CL_SWAP32(sgl_s[i].address);
1427                         sgl_d[i].length = TW_CL_SWAP32(sgl_s[i].length);
1428                 }
1429         }
1430 }