drivers/scsi/bfa/vfapi.c

   1 /*
   2  * Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
   3  * All rights reserved
   4  * www.brocade.com
   5  *
   6  * Linux driver for Brocade Fibre Channel Host Bus Adapter.
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License (GPL) Version 2 as
  10  * published by the Free Software Foundation
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  */
  17
  18 /**
  19  *  vfapi.c Fabric module implementation.
  20  */
  21
  22 #include "fcs_fabric.h"
  23 #include "fcs_trcmod.h"
  24
  25 BFA_TRC_FILE(FCS, VFAPI);
  26
  27 /**
  28  *  fcs_vf_api virtual fabrics API
  29  */
  30
  31 /**
  32  *              Enable VF mode.
  33  *
  34  * @param[in]           fcs             fcs module instance
  35  * @param[in]           vf_id           default vf_id of port, FC_VF_ID_NULL
  36  *                                      to use standard default vf_id of 1.
  37  *
  38  * @retval      BFA_STATUS_OK           vf mode is enabled
  39  * @retval      BFA_STATUS_BUSY         Port is active. Port must be disabled
  40  *                                      before VF mode can be enabled.
  41  */
  42 bfa_status_t
  43 bfa_fcs_vf_mode_enable(struct bfa_fcs_s *fcs, u16 vf_id)
  44 {
  45         return BFA_STATUS_OK;
  46 }
  47
  48 /**
  49  *              Disable VF mode.
  50  *
  51  * @param[in]           fcs             fcs module instance
  52  *
  53  * @retval      BFA_STATUS_OK           vf mode is disabled
  54  * @retval      BFA_STATUS_BUSY         VFs are present and being used. All
  55  *                                      VFs must be deleted before disabling
  56  *                                      VF mode.
  57  */
  58 bfa_status_t
  59 bfa_fcs_vf_mode_disable(struct bfa_fcs_s *fcs)
  60 {
  61         return BFA_STATUS_OK;
  62 }
  63
  64 /**
  65  *              Create a new VF instance.
  66  *
  67  *  A new VF is created using the given VF configuration. A VF is identified
  68  *  by VF id. No duplicate VF creation is allowed with the same VF id. Once
  69  *  a VF is created, VF is automatically started after link initialization
  70  *  and EVFP exchange is completed.
  71  *
  72  *      param[in] vf            -       FCS vf data structure. Memory is
  73  *                                      allocated by caller (driver)
  74  *      param[in] fcs           -       FCS module
  75  *      param[in] vf_cfg        -       VF configuration
  76  *      param[in] vf_drv        -       Opaque handle back to the driver's
  77  *                                      virtual vf structure
  78  *
  79  *      retval BFA_STATUS_OK VF creation is successful
  80  *      retval BFA_STATUS_FAILED VF creation failed
  81  *      retval BFA_STATUS_EEXIST A VF exists with the given vf_id
  82  */
  83 bfa_status_t
  84 bfa_fcs_vf_create(bfa_fcs_vf_t *vf, struct bfa_fcs_s *fcs, u16 vf_id,
  85                   struct bfa_port_cfg_s *port_cfg, struct bfad_vf_s *vf_drv)
  86 {
  87         bfa_trc(fcs, vf_id);
  88         return BFA_STATUS_OK;
  89 }
  90
  91 /**
  92  *      Use this function to delete a BFA VF object. VF object should
  93  *              be stopped before this function call.
  94  *
  95  *      param[in] vf - pointer to bfa_vf_t.
  96  *
  97  *      retval BFA_STATUS_OK    On vf deletion success
  98  *      retval BFA_STATUS_BUSY VF is not in a stopped state
  99  *      retval BFA_STATUS_INPROGRESS VF deletion in in progress
 100  */
 101 bfa_status_t
 102 bfa_fcs_vf_delete(bfa_fcs_vf_t *vf)
 103 {
 104         bfa_trc(vf->fcs, vf->vf_id);
 105         return BFA_STATUS_OK;
 106 }
 107
 108 /**
 109  *      Start participation in VF. This triggers login to the virtual fabric.
 110  *
 111  *      param[in] vf - pointer to bfa_vf_t.
 112  *
 113  *      return None
 114  */
 115 void
 116 bfa_fcs_vf_start(bfa_fcs_vf_t *vf)
 117 {
 118         bfa_trc(vf->fcs, vf->vf_id);
 119 }
 120
 121 /**
 122  *      Logout with the virtual fabric.
 123  *
 124  *      param[in] vf - pointer to bfa_vf_t.
 125  *
 126  *      retval BFA_STATUS_OK    On success.
 127  *      retval BFA_STATUS_INPROGRESS VF is being stopped.
 128  */
 129 bfa_status_t
 130 bfa_fcs_vf_stop(bfa_fcs_vf_t *vf)
 131 {
 132         bfa_trc(vf->fcs, vf->vf_id);
 133         return BFA_STATUS_OK;
 134 }
 135
 136 /**
 137  *      Returns attributes of the given VF.
 138  *
 139  *      param[in]       vf                      pointer to bfa_vf_t.
 140  *      param[out] vf_attr      vf attributes returned
 141  *
 142  *      return None
 143  */
 144 void
 145 bfa_fcs_vf_get_attr(bfa_fcs_vf_t *vf, struct bfa_vf_attr_s *vf_attr)
 146 {
 147         bfa_trc(vf->fcs, vf->vf_id);
 148 }
 149
 150 /**
 151  *              Return statistics associated with the given vf.
 152  *
 153  *      param[in]       vf                      pointer to bfa_vf_t.
 154  *      param[out] vf_stats     vf statistics returned
 155  *
 156  *  @return None
 157  */
 158 void
 159 bfa_fcs_vf_get_stats(bfa_fcs_vf_t *vf, struct bfa_vf_stats_s *vf_stats)
 160 {
 161         bfa_os_memcpy(vf_stats, &vf->stats, sizeof(struct bfa_vf_stats_s));
 162         return;
 163 }
 164
 165 void
 166 /**
 167  *              clear statistics associated with the given vf.
 168  *
 169  *      param[in]       vf                      pointer to bfa_vf_t.
 170  *
 171  *  @return None
 172  */
 173 bfa_fcs_vf_clear_stats(bfa_fcs_vf_t *vf)
 174 {
 175         bfa_os_memset(&vf->stats, 0, sizeof(struct bfa_vf_stats_s));
 176         return;
 177 }
 178
 179 /**
 180  *      Returns FCS vf structure for a given vf_id.
 181  *
 182  *      param[in]       vf_id           - VF_ID
 183  *
 184  *      return
 185  *              If lookup succeeds, retuns fcs vf object, otherwise returns NULL
 186  */
 187 bfa_fcs_vf_t   *
 188 bfa_fcs_vf_lookup(struct bfa_fcs_s *fcs, u16 vf_id)
 189 {
 190         bfa_trc(fcs, vf_id);
 191         if (vf_id == FC_VF_ID_NULL)
 192                 return &fcs->fabric;
 193
 194         /**
 195          * @todo vf support
 196          */
 197
 198         return NULL;
 199 }
 200
 201 /**
 202  *      Returns driver VF structure for a given FCS vf.
 203  *
 204  *      param[in]       vf              - pointer to bfa_vf_t
 205  *
 206  *      return Driver VF structure
 207  */
 208 struct bfad_vf_s      *
 209 bfa_fcs_vf_get_drv_vf(bfa_fcs_vf_t *vf)
 210 {
 211         bfa_assert(vf);
 212         bfa_trc(vf->fcs, vf->vf_id);
 213         return vf->vf_drv;
 214 }
 215
 216 /**
 217  *      Return the list of VFs configured.
 218  *
 219  *      param[in]       fcs     fcs module instance
 220  *      param[out]      vf_ids  returned list of vf_ids
 221  *      param[in,out]   nvfs    in:size of vf_ids array,
 222  *                              out:total elements present,
 223  *                              actual elements returned is limited by the size
 224  *
 225  *      return Driver VF structure
 226  */
 227 void
 228 bfa_fcs_vf_list(struct bfa_fcs_s *fcs, u16 *vf_ids, int *nvfs)
 229 {
 230         bfa_trc(fcs, *nvfs);
 231 }
 232
 233 /**
 234  *      Return the list of all VFs visible from fabric.
 235  *
 236  *      param[in]       fcs     fcs module instance
 237  *      param[out]      vf_ids  returned list of vf_ids
 238  *      param[in,out]   nvfs    in:size of vf_ids array,
 239  *                              out:total elements present,
 240  *                              actual elements returned is limited by the size
 241  *
 242  *      return Driver VF structure
 243  */
 244 void
 245 bfa_fcs_vf_list_all(struct bfa_fcs_s *fcs, u16 *vf_ids, int *nvfs)
 246 {
 247         bfa_trc(fcs, *nvfs);
 248 }
 249
 250 /**
 251  *              Return the list of local logical ports present in the given VF.
 252  *
 253  *      param[in]       vf      vf for which logical ports are returned
 254  *      param[out]      lpwwn   returned logical port wwn list
 255  *      param[in,out]   nlports in:size of lpwwn list;
 256  *                              out:total elements present,
 257  *                              actual elements returned is limited by the size
 258  *
 259  */
 260 void
 261 bfa_fcs_vf_get_ports(bfa_fcs_vf_t *vf, wwn_t lpwwn[], int *nlports)
 262 {
 263         struct list_head        *qe;
 264         struct bfa_fcs_vport_s *vport;
 265         int             i;
 266         struct bfa_fcs_s      *fcs;
 267
 268         if (vf == NULL || lpwwn == NULL || *nlports == 0)
 269                 return;
 270
 271         fcs = vf->fcs;
 272
 273         bfa_trc(fcs, vf->vf_id);
 274         bfa_trc(fcs, (u32) *nlports);
 275
 276         i = 0;
 277         lpwwn[i++] = vf->bport.port_cfg.pwwn;
 278
 279         list_for_each(qe, &vf->vport_q) {
 280                 if (i >= *nlports)
 281                         break;
 282
 283                 vport = (struct bfa_fcs_vport_s *) qe;
 284                 lpwwn[i++] = vport->lport.port_cfg.pwwn;
 285         }
 286
 287         bfa_trc(fcs, i);
 288         *nlports = i;
 289         return;
 290 }
 291
 292