The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/twa/tw_cl_init.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

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

Cache object: 19e670753f2d3a48f604d4720be25d33


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.