sys/dev/raid/twa/tw_cl_init.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_init.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 initialization 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
  53 /*
  54  * Function name:       tw_cl_ctlr_supported
  55  * Description:         Determines if a controller is supported.
  56  *
  57  * Input:               vendor_id -- vendor id of the controller
  58  *                      device_id -- device id of the controller
  59  * Output:              None
  60  * Return value:        TW_CL_TRUE-- controller supported
  61  *                      TW_CL_FALSE-- controller not supported
  62  */
  63 TW_INT32
  64 tw_cl_ctlr_supported(TW_INT32 vendor_id, TW_INT32 device_id)
  65 {
  66         if ((vendor_id == TW_CL_VENDOR_ID) &&
  67                 ((device_id == TW_CL_DEVICE_ID_9K) ||
  68                  (device_id == TW_CL_DEVICE_ID_9K_X) ||
  69                  (device_id == TW_CL_DEVICE_ID_9K_E) ||
  70                  (device_id == TW_CL_DEVICE_ID_9K_SA)))
  71                 return(TW_CL_TRUE);
  72         return(TW_CL_FALSE);
  73 }
  74
  75
  76
  77 /*
  78  * Function name:       tw_cl_get_pci_bar_info
  79  * Description:         Returns PCI BAR info.
  80  *
  81  * Input:               device_id -- device id of the controller
  82  *                      bar_type -- type of PCI BAR in question
  83  * Output:              bar_num -- PCI BAR number corresponding to bar_type
  84  *                      bar0_offset -- byte offset from BAR 0 (0x10 in
  85  *                                      PCI config space)
  86  *                      bar_size -- size, in bytes, of the BAR in question
  87  * Return value:        0 -- success
  88  *                      non-zero -- failure
  89  */
  90 TW_INT32
  91 tw_cl_get_pci_bar_info(TW_INT32 device_id, TW_INT32 bar_type,
  92         TW_INT32 *bar_num, TW_INT32 *bar0_offset, TW_INT32 *bar_size)
  93 {
  94         TW_INT32        error = TW_OSL_ESUCCESS;
  95
  96         switch(device_id) {
  97         case TW_CL_DEVICE_ID_9K:
  98                 switch(bar_type) {
  99                 case TW_CL_BAR_TYPE_IO:
 100                         *bar_num = 0;
 101                         *bar0_offset = 0;
 102                         *bar_size = 4;
 103                         break;
 104
 105                 case TW_CL_BAR_TYPE_MEM:
 106                         *bar_num = 1;
 107                         *bar0_offset = 0x4;
 108                         *bar_size = 8;
 109                         break;
 110
 111                 case TW_CL_BAR_TYPE_SBUF:
 112                         *bar_num = 2;
 113                         *bar0_offset = 0xC;
 114                         *bar_size = 8;
 115                         break;
 116                 }
 117                 break;
 118
 119         case TW_CL_DEVICE_ID_9K_X:
 120         case TW_CL_DEVICE_ID_9K_E:
 121         case TW_CL_DEVICE_ID_9K_SA:
 122                 switch(bar_type) {
 123                 case TW_CL_BAR_TYPE_IO:
 124                         *bar_num = 2;
 125                         *bar0_offset = 0x10;
 126                         *bar_size = 4;
 127                         break;
 128
 129                 case TW_CL_BAR_TYPE_MEM:
 130                         *bar_num = 1;
 131                         *bar0_offset = 0x8;
 132                         *bar_size = 8;
 133                         break;
 134
 135                 case TW_CL_BAR_TYPE_SBUF:
 136                         *bar_num = 0;
 137                         *bar0_offset = 0;
 138                         *bar_size = 8;
 139                         break;
 140                 }
 141                 break;
 142
 143         default:
 144                 error = TW_OSL_ENOTTY;
 145                 break;
 146         }
 147
 148         return(error);
 149 }
 150
 151
 152
 153 /*
 154  * Function name:       tw_cl_get_mem_requirements
 155  * Description:         Provides info about Common Layer requirements for a
 156  *                      controller, given the controller type (in 'flags').
 157  * Input:               ctlr_handle -- controller handle
 158  *                      flags -- more info passed by the OS Layer
 159  *                      device_id -- device id of the controller
 160  *                      max_simult_reqs -- maximum # of simultaneous
 161  *                                      requests that the OS Layer expects
 162  *                                      the Common Layer to support
 163  *                      max_aens -- maximun # of AEN's needed to be supported
 164  * Output:              alignment -- alignment needed for all DMA'able
 165  *                                      buffers
 166  *                      sg_size_factor -- every SG element should have a size
 167  *                                      that's a multiple of this number
 168  *                      non_dma_mem_size -- # of bytes of memory needed for
 169  *                                      non-DMA purposes
 170  *                      dma_mem_size -- # of bytes of DMA'able memory needed
 171  *                      per_req_dma_mem_size -- # of bytes of DMA'able memory
 172  *                                      needed per request, if applicable
 173  *                      per_req_non_dma_mem_size -- # of bytes of memory needed
 174  *                                      per request for non-DMA purposes,
 175  *                                      if applicable
 176  * Output:              None
 177  * Return value:        0       -- success
 178  *                      non-zero-- failure
 179  */
 180 TW_INT32
 181 tw_cl_get_mem_requirements(struct tw_cl_ctlr_handle *ctlr_handle,
 182         TW_UINT32 flags, TW_INT32 device_id, TW_INT32 max_simult_reqs,
 183         TW_INT32 max_aens, TW_UINT32 *alignment, TW_UINT32 *sg_size_factor,
 184         TW_UINT32 *non_dma_mem_size, TW_UINT32 *dma_mem_size
 185         )
 186 {
 187         if (device_id == 0)
 188                 device_id = TW_CL_DEVICE_ID_9K;
 189
 190         if (max_simult_reqs > TW_CL_MAX_SIMULTANEOUS_REQUESTS) {
 191                 tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 192                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 193                         0x1000, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 194                         "Too many simultaneous requests to support!",
 195                         "requested = %d, supported = %d, error = %d\n",
 196                         max_simult_reqs, TW_CL_MAX_SIMULTANEOUS_REQUESTS,
 197                         TW_OSL_EBIG);
 198                 return(TW_OSL_EBIG);
 199         }
 200
 201         *alignment = TWA_ALIGNMENT(device_id);
 202         *sg_size_factor = TWA_SG_ELEMENT_SIZE_FACTOR(device_id);
 203
 204         /*
 205          * Total non-DMA memory needed is the sum total of memory needed for
 206          * the controller context, request packets (including the 1 needed for
 207          * CL internal requests), and event packets.
 208          */
 209
 210         *non_dma_mem_size = sizeof(struct tw_cli_ctlr_context) +
 211                 (sizeof(struct tw_cli_req_context) * max_simult_reqs) +
 212                 (sizeof(struct tw_cl_event_packet) * max_aens);
 213
 214
 215         /*
 216          * Total DMA'able memory needed is the sum total of memory needed for
 217          * all command packets (including the 1 needed for CL internal
 218          * requests), and memory needed to hold the payload for internal
 219          * requests.
 220          */
 221
 222         *dma_mem_size = (sizeof(struct tw_cl_command_packet) *
 223                 (max_simult_reqs)) + (TW_CLI_SECTOR_SIZE);
 224
 225         return(0);
 226 }
 227
 228
 229
 230 /*
 231  * Function name:       tw_cl_init_ctlr
 232  * Description:         Initializes driver data structures for the controller.
 233  *
 234  * Input:               ctlr_handle -- controller handle
 235  *                      flags -- more info passed by the OS Layer
 236  *                      device_id -- device id of the controller
 237  *                      max_simult_reqs -- maximum # of simultaneous requests
 238  *                                      that the OS Layer expects the Common
 239  *                                      Layer to support
 240  *                      max_aens -- maximun # of AEN's needed to be supported
 241  *                      non_dma_mem -- ptr to allocated non-DMA memory
 242  *                      dma_mem -- ptr to allocated DMA'able memory
 243  *                      dma_mem_phys -- physical address of dma_mem
 244  * Output:              None
 245  * Return value:        0       -- success
 246  *                      non-zero-- failure
 247  */
 248 TW_INT32
 249 tw_cl_init_ctlr(struct tw_cl_ctlr_handle *ctlr_handle, TW_UINT32 flags,
 250         TW_INT32 device_id, TW_INT32 max_simult_reqs, TW_INT32 max_aens,
 251         TW_VOID *non_dma_mem, TW_VOID *dma_mem, TW_UINT64 dma_mem_phys
 252         )
 253 {
 254         struct tw_cli_ctlr_context      *ctlr;
 255         struct tw_cli_req_context       *req;
 256         TW_UINT8                        *free_non_dma_mem;
 257         TW_INT32                        error = TW_OSL_ESUCCESS;
 258         TW_INT32                        i;
 259
 260         tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(), "entered");
 261
 262         if (flags & TW_CL_START_CTLR_ONLY) {
 263                 ctlr = (struct tw_cli_ctlr_context *)
 264                         (ctlr_handle->cl_ctlr_ctxt);
 265                 goto start_ctlr;
 266         }
 267
 268         if (max_simult_reqs > TW_CL_MAX_SIMULTANEOUS_REQUESTS) {
 269                 tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 270                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 271                         0x1000, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 272                         "Too many simultaneous requests to support!",
 273                         "requested = %d, supported = %d, error = %d\n",
 274                         max_simult_reqs, TW_CL_MAX_SIMULTANEOUS_REQUESTS,
 275                         TW_OSL_EBIG);
 276                 return(TW_OSL_EBIG);
 277         }
 278
 279         if ((non_dma_mem == TW_CL_NULL) || (dma_mem == TW_CL_NULL)
 280                 ) {
 281                 tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 282                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 283                         0x1001, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 284                         "Insufficient memory for Common Layer's internal usage",
 285                         "error = %d\n", TW_OSL_ENOMEM);
 286                 return(TW_OSL_ENOMEM);
 287         }
 288
 289         tw_osl_memzero(non_dma_mem, sizeof(struct tw_cli_ctlr_context) +
 290                 (sizeof(struct tw_cli_req_context) * max_simult_reqs) +
 291                 (sizeof(struct tw_cl_event_packet) * max_aens));
 292
 293         tw_osl_memzero(dma_mem,
 294                 (sizeof(struct tw_cl_command_packet) *
 295                 max_simult_reqs) +
 296                 TW_CLI_SECTOR_SIZE);
 297
 298         free_non_dma_mem = (TW_UINT8 *)non_dma_mem;
 299
 300         ctlr = (struct tw_cli_ctlr_context *)free_non_dma_mem;
 301         free_non_dma_mem += sizeof(struct tw_cli_ctlr_context);
 302
 303         ctlr_handle->cl_ctlr_ctxt = ctlr;
 304         ctlr->ctlr_handle = ctlr_handle;
 305
 306         ctlr->device_id = (TW_UINT32)device_id;
 307         ctlr->arch_id = TWA_ARCH_ID(device_id);
 308         ctlr->flags = flags;
 309         ctlr->sg_size_factor = TWA_SG_ELEMENT_SIZE_FACTOR(device_id);
 310         ctlr->max_simult_reqs = max_simult_reqs;
 311         ctlr->max_aens_supported = max_aens;
 312
 313         /* Initialize queues of CL internal request context packets. */
 314         tw_cli_req_q_init(ctlr, TW_CLI_FREE_Q);
 315         tw_cli_req_q_init(ctlr, TW_CLI_BUSY_Q);
 316         tw_cli_req_q_init(ctlr, TW_CLI_PENDING_Q);
 317         tw_cli_req_q_init(ctlr, TW_CLI_COMPLETE_Q);
 318
 319         /* Initialize all locks used by CL. */
 320         ctlr->gen_lock = &(ctlr->gen_lock_handle);
 321         tw_osl_init_lock(ctlr_handle, "tw_cl_gen_lock", ctlr->gen_lock);
 322         ctlr->io_lock = &(ctlr->io_lock_handle);
 323         tw_osl_init_lock(ctlr_handle, "tw_cl_io_lock", ctlr->io_lock);
 324
 325         /* Initialize CL internal request context packets. */
 326         ctlr->req_ctxt_buf = (struct tw_cli_req_context *)free_non_dma_mem;
 327         free_non_dma_mem += (sizeof(struct tw_cli_req_context) *
 328                 max_simult_reqs);
 329
 330         ctlr->cmd_pkt_buf = (struct tw_cl_command_packet *)dma_mem;
 331         ctlr->cmd_pkt_phys = dma_mem_phys;
 332
 333         ctlr->internal_req_data = (TW_UINT8 *)
 334                 (ctlr->cmd_pkt_buf +
 335                 max_simult_reqs);
 336         ctlr->internal_req_data_phys = ctlr->cmd_pkt_phys +
 337                 (sizeof(struct tw_cl_command_packet) *
 338                 max_simult_reqs);
 339
 340         for (i = 0; i < max_simult_reqs; i++) {
 341                 req = &(ctlr->req_ctxt_buf[i]);
 342
 343                 req->cmd_pkt = &(ctlr->cmd_pkt_buf[i]);
 344                 req->cmd_pkt_phys = ctlr->cmd_pkt_phys +
 345                         (i * sizeof(struct tw_cl_command_packet));
 346
 347                 req->request_id = i;
 348                 req->ctlr = ctlr;
 349
 350                 /* Insert request into the free queue. */
 351                 tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
 352         }
 353
 354         /* Initialize the AEN queue. */
 355         ctlr->aen_queue = (struct tw_cl_event_packet *)free_non_dma_mem;
 356
 357
 358 start_ctlr:
 359         /*
 360          * Disable interrupts.  Interrupts will be enabled in tw_cli_start_ctlr
 361          * (only) if initialization succeeded.
 362          */
 363         tw_cli_disable_interrupts(ctlr);
 364
 365         /* Initialize the controller. */
 366         if ((error = tw_cli_start_ctlr(ctlr))) {
 367                 /* Soft reset the controller, and try one more time. */
 368                 tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 369                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 370                         0x1002, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 371                         "Controller initialization failed. Retrying...",
 372                         "error = %d\n", error);
 373                 if ((error = tw_cli_soft_reset(ctlr))) {
 374                         tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 375                                 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 376                                 0x1003, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 377                                 "Controller soft reset failed",
 378                                 "error = %d\n", error);
 379                         return(error);
 380                 } else if ((error = tw_cli_start_ctlr(ctlr))) {
 381                         tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 382                                 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 383                                 0x1004, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 384                                 "Controller initialization retry failed",
 385                                 "error = %d\n", error);
 386                         return(error);
 387                 }
 388         }
 389         /* Notify some info about the controller to the OSL. */
 390         tw_cli_notify_ctlr_info(ctlr);
 391
 392         /* Mark the controller active. */
 393         ctlr->active = TW_CL_TRUE;
 394         return(error);
 395 }
 396
 397 /*
 398  * Function name:       tw_cli_start_ctlr
 399  * Description:         Establishes a logical connection with the controller.
 400  *                      Determines whether or not the driver is compatible
 401  *                      with the firmware on the controller, before proceeding
 402  *                      to work with it.
 403  *
 404  * Input:               ctlr    -- ptr to per ctlr structure
 405  * Output:              None
 406  * Return value:        0       -- success
 407  *                      non-zero-- failure
 408  */
 409 TW_INT32
 410 tw_cli_start_ctlr(struct tw_cli_ctlr_context *ctlr)
 411 {
 412         TW_UINT16       fw_on_ctlr_srl = 0;
 413         TW_UINT16       fw_on_ctlr_arch_id = 0;
 414         TW_UINT16       fw_on_ctlr_branch = 0;
 415         TW_UINT16       fw_on_ctlr_build = 0;
 416         TW_UINT32       init_connect_result = 0;
 417         TW_INT32        error = TW_OSL_ESUCCESS;
 418
 419         tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
 420
 421         /* Wait for the controller to become ready. */
 422         if ((error = tw_cli_poll_status(ctlr,
 423                         TWA_STATUS_MICROCONTROLLER_READY,
 424                         TW_CLI_REQUEST_TIMEOUT_PERIOD))) {
 425                 tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
 426                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 427                         0x1009, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 428                         "Microcontroller not ready",
 429                         "error = %d", error);
 430                 return(error);
 431         }
 432         /* Drain the response queue. */
 433         if ((error = tw_cli_drain_response_queue(ctlr))) {
 434                 tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
 435                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 436                         0x100A, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 437                         "Can't drain response queue",
 438                         "error = %d", error);
 439                 return(error);
 440         }
 441         /* Establish a logical connection with the controller. */
 442         if ((error = tw_cli_init_connection(ctlr,
 443                         (TW_UINT16)(ctlr->max_simult_reqs),
 444                         TWA_EXTENDED_INIT_CONNECT, TWA_CURRENT_FW_SRL,
 445                         (TW_UINT16)(ctlr->arch_id),
 446                         TWA_CURRENT_FW_BRANCH(ctlr->arch_id),
 447                         TWA_CURRENT_FW_BUILD(ctlr->arch_id),
 448                         &fw_on_ctlr_srl, &fw_on_ctlr_arch_id,
 449                         &fw_on_ctlr_branch, &fw_on_ctlr_build,
 450                         &init_connect_result))) {
 451                 tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
 452                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 453                         0x100B, 0x2, TW_CL_SEVERITY_WARNING_STRING,
 454                         "Can't initialize connection in current mode",
 455                         "error = %d", error);
 456                 return(error);
 457         }
 458         {
 459                  /* See if we can at least work with the firmware on the
 460                  * controller in the current mode.
 461                  */
 462                 if (init_connect_result & TWA_CTLR_FW_COMPATIBLE) {
 463                         /* Yes, we can.  Make note of the operating mode. */
 464                         if (init_connect_result & TWA_CTLR_FW_SAME_OR_NEWER) {
 465                                 ctlr->working_srl = TWA_CURRENT_FW_SRL;
 466                                 ctlr->working_branch =
 467                                         TWA_CURRENT_FW_BRANCH(ctlr->arch_id);
 468                                 ctlr->working_build =
 469                                         TWA_CURRENT_FW_BUILD(ctlr->arch_id);
 470                         } else {
 471                                 ctlr->working_srl = fw_on_ctlr_srl;
 472                                 ctlr->working_branch = fw_on_ctlr_branch;
 473                                 ctlr->working_build = fw_on_ctlr_build;
 474                         }
 475                 } else {
 476                         /*
 477                          * No, we can't.  See if we can at least work with
 478                          * it in the base mode.
 479                          */
 480                         tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
 481                                 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 482                                 0x1010, 0x2, TW_CL_SEVERITY_WARNING_STRING,
 483                                 "Driver/Firmware mismatch. "
 484                                 "Negotiating for base level...",
 485                                 " ");
 486                         if ((error = tw_cli_init_connection(ctlr,
 487                                         (TW_UINT16)(ctlr->max_simult_reqs),
 488                                         TWA_EXTENDED_INIT_CONNECT,
 489                                         TWA_BASE_FW_SRL,
 490                                         (TW_UINT16)(ctlr->arch_id),
 491                                         TWA_BASE_FW_BRANCH, TWA_BASE_FW_BUILD,
 492                                         &fw_on_ctlr_srl, &fw_on_ctlr_arch_id,
 493                                         &fw_on_ctlr_branch, &fw_on_ctlr_build,
 494                                         &init_connect_result))) {
 495                                 tw_cl_create_event(ctlr->ctlr_handle,
 496                                         TW_CL_FALSE,
 497                                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 498                                         0x1011, 0x1,
 499                                         TW_CL_SEVERITY_ERROR_STRING,
 500                                         "Can't initialize connection in "
 501                                         "base mode",
 502                                         " ");
 503                                 return(error);
 504                         }
 505                         if (!(init_connect_result & TWA_CTLR_FW_COMPATIBLE)) {
 506                                 /*
 507                                  * The firmware on the controller is not even
 508                                  * compatible with our base mode.  We cannot
 509                                  * work with it.  Bail...
 510                                  */
 511                                 return(1);
 512                         }
 513                         /*
 514                          * We can work with this firmware, but only in
 515                          * base mode.
 516                          */
 517                         ctlr->working_srl = TWA_BASE_FW_SRL;
 518                         ctlr->working_branch = TWA_BASE_FW_BRANCH;
 519                         ctlr->working_build = TWA_BASE_FW_BUILD;
 520                         ctlr->operating_mode = TWA_BASE_MODE;
 521                 }
 522                 ctlr->fw_on_ctlr_srl = fw_on_ctlr_srl;
 523                 ctlr->fw_on_ctlr_branch = fw_on_ctlr_branch;
 524                 ctlr->fw_on_ctlr_build = fw_on_ctlr_build;
 525         }
 526
 527         /* Drain the AEN queue */
 528         if ((error = tw_cli_drain_aen_queue(ctlr)))
 529                 /*
 530                  * We will just print that we couldn't drain the AEN queue.
 531                  * There's no need to bail out.
 532                  */
 533                 tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
 534                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 535                         0x1014, 0x2, TW_CL_SEVERITY_WARNING_STRING,
 536                         "Can't drain AEN queue",
 537                         "error = %d", error);
 538
 539         /* Enable interrupts. */
 540         tw_cli_enable_interrupts(ctlr);
 541
 542         return(TW_OSL_ESUCCESS);
 543 }
 544
 545
 546 /*
 547  * Function name:       tw_cl_shutdown_ctlr
 548  * Description:         Closes logical connection with the controller.
 549  *
 550  * Input:               ctlr    -- ptr to per ctlr structure
 551  *                      flags   -- more info passed by the OS Layer
 552  * Output:              None
 553  * Return value:        0       -- success
 554  *                      non-zero-- failure
 555  */
 556 TW_INT32
 557 tw_cl_shutdown_ctlr(struct tw_cl_ctlr_handle *ctlr_handle, TW_UINT32 flags)
 558 {
 559         struct tw_cli_ctlr_context      *ctlr =
 560                 (struct tw_cli_ctlr_context *)(ctlr_handle->cl_ctlr_ctxt);
 561         TW_INT32                        error;
 562
 563         tw_cli_dbg_printf(3, ctlr_handle, tw_osl_cur_func(), "entered");
 564         /*
 565          * Mark the controller as inactive, disable any further interrupts,
 566          * and notify the controller that we are going down.
 567          */
 568         ctlr->active = TW_CL_FALSE;
 569
 570         tw_cli_disable_interrupts(ctlr);
 571
 572         /* Let the controller know that we are going down. */
 573         if ((error = tw_cli_init_connection(ctlr, TWA_SHUTDOWN_MESSAGE_CREDITS,
 574                         0, 0, 0, 0, 0, TW_CL_NULL, TW_CL_NULL, TW_CL_NULL,
 575                         TW_CL_NULL, TW_CL_NULL)))
 576                 tw_cl_create_event(ctlr_handle, TW_CL_FALSE,
 577                         TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 578                         0x1015, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 579                         "Can't close connection with controller",
 580                         "error = %d", error);
 581
 582         if (flags & TW_CL_STOP_CTLR_ONLY)
 583                 goto ret;
 584
 585         /* Destroy all locks used by CL. */
 586         tw_osl_destroy_lock(ctlr_handle, ctlr->gen_lock);
 587         tw_osl_destroy_lock(ctlr_handle, ctlr->io_lock);
 588
 589 ret:
 590         return(error);
 591 }
 592
 593
 594
 595 /*
 596  * Function name:       tw_cli_init_connection
 597  * Description:         Sends init_connection cmd to firmware
 598  *
 599  * Input:               ctlr            -- ptr to per ctlr structure
 600  *                      message_credits -- max # of requests that we might send
 601  *                                       down simultaneously.  This will be
 602  *                                       typically set to 256 at init-time or
 603  *                                      after a reset, and to 1 at shutdown-time
 604  *                      set_features    -- indicates if we intend to use 64-bit
 605  *                                      sg, also indicates if we want to do a
 606  *                                      basic or an extended init_connection;
 607  *
 608  * Note: The following input/output parameters are valid, only in case of an
 609  *              extended init_connection:
 610  *
 611  *                      current_fw_srl          -- srl of fw we are bundled
 612  *                                              with, if any; 0 otherwise
 613  *                      current_fw_arch_id      -- arch_id of fw we are bundled
 614  *                                              with, if any; 0 otherwise
 615  *                      current_fw_branch       -- branch # of fw we are bundled
 616  *                                              with, if any; 0 otherwise
 617  *                      current_fw_build        -- build # of fw we are bundled
 618  *                                              with, if any; 0 otherwise
 619  * Output:              fw_on_ctlr_srl          -- srl of fw on ctlr
 620  *                      fw_on_ctlr_arch_id      -- arch_id of fw on ctlr
 621  *                      fw_on_ctlr_branch       -- branch # of fw on ctlr
 622  *                      fw_on_ctlr_build        -- build # of fw on ctlr
 623  *                      init_connect_result     -- result bitmap of fw response
 624  * Return value:        0       -- success
 625  *                      non-zero-- failure
 626  */
 627 TW_INT32
 628 tw_cli_init_connection(struct tw_cli_ctlr_context *ctlr,
 629         TW_UINT16 message_credits, TW_UINT32 set_features,
 630         TW_UINT16 current_fw_srl, TW_UINT16 current_fw_arch_id,
 631         TW_UINT16 current_fw_branch, TW_UINT16 current_fw_build,
 632         TW_UINT16 *fw_on_ctlr_srl, TW_UINT16 *fw_on_ctlr_arch_id,
 633         TW_UINT16 *fw_on_ctlr_branch, TW_UINT16 *fw_on_ctlr_build,
 634         TW_UINT32 *init_connect_result)
 635 {
 636         struct tw_cli_req_context               *req;
 637         struct tw_cl_command_init_connect       *init_connect;
 638         TW_INT32                                error = TW_OSL_EBUSY;
 639
 640         tw_cli_dbg_printf(3, ctlr->ctlr_handle, tw_osl_cur_func(), "entered");
 641
 642         /* Get a request packet. */
 643         if ((req = tw_cli_get_request(ctlr
 644                 )) == TW_CL_NULL)
 645                 goto out;
 646
 647         req->flags |= TW_CLI_REQ_FLAGS_INTERNAL;
 648
 649         /* Build the cmd pkt. */
 650         init_connect = &(req->cmd_pkt->command.cmd_pkt_7k.init_connect);
 651
 652         req->cmd_pkt->cmd_hdr.header_desc.size_header = 128;
 653
 654         init_connect->res1__opcode =
 655                 BUILD_RES__OPCODE(0, TWA_FW_CMD_INIT_CONNECTION);
 656         init_connect->request_id =
 657                 (TW_UINT8)(TW_CL_SWAP16(req->request_id));
 658         init_connect->message_credits = TW_CL_SWAP16(message_credits);
 659         init_connect->features = TW_CL_SWAP32(set_features);
 660         if (ctlr->flags & TW_CL_64BIT_ADDRESSES)
 661                 init_connect->features |= TW_CL_SWAP32(TWA_64BIT_SG_ADDRESSES);
 662         if (set_features & TWA_EXTENDED_INIT_CONNECT) {
 663                 /*
 664                  * Fill in the extra fields needed for an extended
 665                  * init_connect.
 666                  */
 667                 init_connect->size = 6;
 668                 init_connect->fw_srl = TW_CL_SWAP16(current_fw_srl);
 669                 init_connect->fw_arch_id = TW_CL_SWAP16(current_fw_arch_id);
 670                 init_connect->fw_branch = TW_CL_SWAP16(current_fw_branch);
 671                 init_connect->fw_build = TW_CL_SWAP16(current_fw_build);
 672         } else
 673                 init_connect->size = 3;
 674
 675         /* Submit the command, and wait for it to complete. */
 676         error = tw_cli_submit_and_poll_request(req,
 677                 TW_CLI_REQUEST_TIMEOUT_PERIOD);
 678         if (error == TW_OSL_ETIMEDOUT)
 679                 /* Clean-up done by tw_cli_submit_and_poll_request. */
 680                 return(error);
 681         if (error)
 682                 goto out;
 683         if ((error = init_connect->status)) {
 684                 tw_cli_create_ctlr_event(ctlr,
 685                         TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR,
 686                         &(req->cmd_pkt->cmd_hdr));
 687                 goto out;
 688         }
 689         if (set_features & TWA_EXTENDED_INIT_CONNECT) {
 690                 *fw_on_ctlr_srl = TW_CL_SWAP16(init_connect->fw_srl);
 691                 *fw_on_ctlr_arch_id = TW_CL_SWAP16(init_connect->fw_arch_id);
 692                 *fw_on_ctlr_branch = TW_CL_SWAP16(init_connect->fw_branch);
 693                 *fw_on_ctlr_build = TW_CL_SWAP16(init_connect->fw_build);
 694                 *init_connect_result = TW_CL_SWAP32(init_connect->result);
 695         }
 696         tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
 697         return(error);
 698
 699 out:
 700         tw_cl_create_event(ctlr->ctlr_handle, TW_CL_FALSE,
 701                 TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR,
 702                 0x1016, 0x1, TW_CL_SEVERITY_ERROR_STRING,
 703                 "init_connection failed",
 704                 "error = %d", error);
 705         if (req)
 706                 tw_cli_req_q_insert_tail(req, TW_CLI_FREE_Q);
 707         return(error);
 708 }