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

Cache object: ec23bf79a944f6b3474b73f0daa0ea3b


[ 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.