SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/scsi/qla2xxx/qla_mid.c

   1 /*
   2  * QLogic Fibre Channel HBA Driver
   3  * Copyright (c)  2003-2008 QLogic Corporation
   4  *
   5  * See LICENSE.qla2xxx for copyright and licensing details.
   6  */
   7 #include "qla_def.h"
   8
   9 #include <linux/moduleparam.h>
  10 #include <linux/vmalloc.h>
  11 #include <linux/smp_lock.h>
  12 #include <linux/list.h>
  13
  14 #include <scsi/scsi_tcq.h>
  15 #include <scsi/scsicam.h>
  16 #include <linux/delay.h>
  17
  18 void
  19 qla2x00_vp_stop_timer(scsi_qla_host_t *vha)
  20 {
  21         if (vha->parent && vha->timer_active) {
  22                 del_timer_sync(&vha->timer);
  23                 vha->timer_active = 0;
  24         }
  25 }
  26
  27 static uint32_t
  28 qla24xx_allocate_vp_id(scsi_qla_host_t *vha)
  29 {
  30         uint32_t vp_id;
  31         scsi_qla_host_t *ha = vha->parent;
  32
  33         /* Find an empty slot and assign an vp_id */
  34         mutex_lock(&ha->vport_lock);
  35         vp_id = find_first_zero_bit(ha->vp_idx_map, ha->max_npiv_vports + 1);
  36         if (vp_id > ha->max_npiv_vports) {
  37                 DEBUG15(printk ("vp_id %d is bigger than max-supported %d.\n",
  38                     vp_id, ha->max_npiv_vports));
  39                 mutex_unlock(&ha->vport_lock);
  40                 return vp_id;
  41         }
  42
  43         set_bit(vp_id, ha->vp_idx_map);
  44         ha->num_vhosts++;
  45         ha->cur_vport_count++;
  46         vha->vp_idx = vp_id;
  47         list_add_tail(&vha->vp_list, &ha->vp_list);
  48         mutex_unlock(&ha->vport_lock);
  49         return vp_id;
  50 }
  51
  52 void
  53 qla24xx_deallocate_vp_id(scsi_qla_host_t *vha)
  54 {
  55         uint16_t vp_id;
  56         scsi_qla_host_t *ha = vha->parent;
  57
  58         mutex_lock(&ha->vport_lock);
  59         vp_id = vha->vp_idx;
  60         ha->num_vhosts--;
  61         ha->cur_vport_count--;
  62         clear_bit(vp_id, ha->vp_idx_map);
  63         list_del(&vha->vp_list);
  64         mutex_unlock(&ha->vport_lock);
  65 }
  66
  67 static scsi_qla_host_t *
  68 qla24xx_find_vhost_by_name(scsi_qla_host_t *ha, uint8_t *port_name)
  69 {
  70         scsi_qla_host_t *vha;
  71
  72         /* Locate matching device in database. */
  73         list_for_each_entry(vha, &ha->vp_list, vp_list) {
  74                 if (!memcmp(port_name, vha->port_name, WWN_SIZE))
  75                         return vha;
  76         }
  77         return NULL;
  78 }
  79
  80 /*
  81  * qla2x00_mark_vp_devices_dead
  82  *      Updates fcport state when device goes offline.
  83  *
  84  * Input:
  85  *      ha = adapter block pointer.
  86  *      fcport = port structure pointer.
  87  *
  88  * Return:
  89  *      None.
  90  *
  91  * Context:
  92  */
  93 static void
  94 qla2x00_mark_vp_devices_dead(scsi_qla_host_t *vha)
  95 {
  96         fc_port_t *fcport;
  97         scsi_qla_host_t *pha = to_qla_parent(vha);
  98
  99         list_for_each_entry(fcport, &pha->fcports, list) {
 100                 if (fcport->vp_idx != vha->vp_idx)
 101                         continue;
 102
 103                 DEBUG15(printk("scsi(%ld): Marking port dead, "
 104                     "loop_id=0x%04x :%x\n",
 105                     vha->host_no, fcport->loop_id, fcport->vp_idx));
 106
 107                 qla2x00_mark_device_lost(vha, fcport, 0, 0);
 108                 atomic_set(&fcport->state, FCS_UNCONFIGURED);
 109         }
 110 }
 111
 112 int
 113 qla24xx_disable_vp(scsi_qla_host_t *vha)
 114 {
 115         int ret;
 116
 117         ret = qla24xx_control_vp(vha, VCE_COMMAND_DISABLE_VPS_LOGO_ALL);
 118         atomic_set(&vha->loop_state, LOOP_DOWN);
 119         atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
 120
 121         /* Delete all vp's fcports from parent's list */
 122         qla2x00_mark_vp_devices_dead(vha);
 123         atomic_set(&vha->vp_state, VP_FAILED);
 124         vha->flags.management_server_logged_in = 0;
 125         if (ret == QLA_SUCCESS) {
 126                 fc_vport_set_state(vha->fc_vport, FC_VPORT_DISABLED);
 127         } else {
 128                 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
 129                 return -1;
 130         }
 131         return 0;
 132 }
 133
 134 int
 135 qla24xx_enable_vp(scsi_qla_host_t *vha)
 136 {
 137         int ret;
 138         scsi_qla_host_t *ha = vha->parent;
 139
 140         /* Check if physical ha port is Up */
 141         if (atomic_read(&ha->loop_state) == LOOP_DOWN  ||
 142                 atomic_read(&ha->loop_state) == LOOP_DEAD ) {
 143                 vha->vp_err_state =  VP_ERR_PORTDWN;
 144                 fc_vport_set_state(vha->fc_vport, FC_VPORT_LINKDOWN);
 145                 goto enable_failed;
 146         }
 147
 148         /* Initialize the new vport unless it is a persistent port */
 149         mutex_lock(&ha->vport_lock);
 150         ret = qla24xx_modify_vp_config(vha);
 151         mutex_unlock(&ha->vport_lock);
 152
 153         if (ret != QLA_SUCCESS) {
 154                 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
 155                 goto enable_failed;
 156         }
 157
 158         DEBUG15(qla_printk(KERN_INFO, ha,
 159             "Virtual port with id: %d - Enabled\n", vha->vp_idx));
 160         return 0;
 161
 162 enable_failed:
 163         DEBUG15(qla_printk(KERN_INFO, ha,
 164             "Virtual port with id: %d - Disabled\n", vha->vp_idx));
 165         return 1;
 166 }
 167
 168 static void
 169 qla24xx_configure_vp(scsi_qla_host_t *vha)
 170 {
 171         struct fc_vport *fc_vport;
 172         int ret;
 173
 174         fc_vport = vha->fc_vport;
 175
 176         DEBUG15(printk("scsi(%ld): %s: change request #3 for this host.\n",
 177             vha->host_no, __func__));
 178         ret = qla2x00_send_change_request(vha, 0x3, vha->vp_idx);
 179         if (ret != QLA_SUCCESS) {
 180                 DEBUG15(qla_printk(KERN_ERR, vha, "Failed to enable receiving"
 181                     " of RSCN requests: 0x%x\n", ret));
 182                 return;
 183         } else {
 184                 /* Corresponds to SCR enabled */
 185                 clear_bit(VP_SCR_NEEDED, &vha->vp_flags);
 186         }
 187
 188         vha->flags.online = 1;
 189         if (qla24xx_configure_vhba(vha))
 190                 return;
 191
 192         atomic_set(&vha->vp_state, VP_ACTIVE);
 193         fc_vport_set_state(fc_vport, FC_VPORT_ACTIVE);
 194 }
 195
 196 void
 197 qla2x00_alert_all_vps(scsi_qla_host_t *ha, uint16_t *mb)
 198 {
 199         int i, vp_idx_matched;
 200         scsi_qla_host_t *vha;
 201
 202         if (ha->parent)
 203                 return;
 204
 205         for_each_mapped_vp_idx(ha, i) {
 206                 vp_idx_matched = 0;
 207
 208                 list_for_each_entry(vha, &ha->vp_list, vp_list) {
 209                         if (i == vha->vp_idx) {
 210                                 vp_idx_matched = 1;
 211                                 break;
 212                         }
 213                 }
 214
 215                 if (vp_idx_matched) {
 216                         switch (mb[0]) {
 217                         case MBA_LIP_OCCURRED:
 218                         case MBA_LOOP_UP:
 219                         case MBA_LOOP_DOWN:
 220                         case MBA_LIP_RESET:
 221                         case MBA_POINT_TO_POINT:
 222                         case MBA_CHG_IN_CONNECTION:
 223                         case MBA_PORT_UPDATE:
 224                         case MBA_RSCN_UPDATE:
 225                                 DEBUG15(printk("scsi(%ld)%s: Async_event for"
 226                                     " VP[%d], mb = 0x%x, vha=%p\n",
 227                                     vha->host_no, __func__,i, *mb, vha));
 228                                 qla2x00_async_event(vha, mb);
 229                                 break;
 230                         }
 231                 }
 232         }
 233 }
 234
 235 void
 236 qla2x00_vp_abort_isp(scsi_qla_host_t *vha)
 237 {
 238         /*
 239          * Physical port will do most of the abort and recovery work. We can
 240          * just treat it as a loop down
 241          */
 242         if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
 243                 atomic_set(&vha->loop_state, LOOP_DOWN);
 244                 qla2x00_mark_all_devices_lost(vha, 0);
 245         } else {
 246                 if (!atomic_read(&vha->loop_down_timer))
 247                         atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
 248         }
 249
 250         DEBUG15(printk("scsi(%ld): Scheduling enable of Vport %d...\n",
 251             vha->host_no, vha->vp_idx));
 252         qla24xx_enable_vp(vha);
 253 }
 254
 255 static int
 256 qla2x00_do_dpc_vp(scsi_qla_host_t *vha)
 257 {
 258         scsi_qla_host_t *ha = vha->parent;
 259
 260         if (test_and_clear_bit(VP_IDX_ACQUIRED, &vha->vp_flags)) {
 261                 /* VP acquired. complete port configuration */
 262                 if (atomic_read(&ha->loop_state) == LOOP_READY) {
 263                         qla24xx_configure_vp(vha);
 264                 } else {
 265                         set_bit(VP_IDX_ACQUIRED, &vha->vp_flags);
 266                         set_bit(VP_DPC_NEEDED, &ha->dpc_flags);
 267                 }
 268
 269                 return 0;
 270         }
 271
 272         if (test_and_clear_bit(ISP_ABORT_NEEDED, &vha->dpc_flags))
 273                 qla2x00_vp_abort_isp(vha);
 274
 275         if (test_and_clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags) &&
 276             (!(test_and_set_bit(RESET_ACTIVE, &vha->dpc_flags)))) {
 277                 clear_bit(RESET_ACTIVE, &vha->dpc_flags);
 278         }
 279
 280         if (atomic_read(&vha->vp_state) == VP_ACTIVE &&
 281             test_and_clear_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) {
 282                 if (!(test_and_set_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags))) {
 283                         qla2x00_loop_resync(vha);
 284                         clear_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags);
 285                 }
 286         }
 287
 288         return 0;
 289 }
 290
 291 void
 292 qla2x00_do_dpc_all_vps(scsi_qla_host_t *ha)
 293 {
 294         int ret;
 295         int i, vp_idx_matched;
 296         scsi_qla_host_t *vha;
 297
 298         if (ha->parent)
 299                 return;
 300         if (list_empty(&ha->vp_list))
 301                 return;
 302
 303         clear_bit(VP_DPC_NEEDED, &ha->dpc_flags);
 304
 305         for_each_mapped_vp_idx(ha, i) {
 306                 vp_idx_matched = 0;
 307
 308                 list_for_each_entry(vha, &ha->vp_list, vp_list) {
 309                         if (i == vha->vp_idx) {
 310                                 vp_idx_matched = 1;
 311                                 break;
 312                         }
 313                 }
 314
 315                 if (vp_idx_matched)
 316                         ret = qla2x00_do_dpc_vp(vha);
 317         }
 318 }
 319
 320 int
 321 qla24xx_vport_create_req_sanity_check(struct fc_vport *fc_vport)
 322 {
 323         scsi_qla_host_t *ha = shost_priv(fc_vport->shost);
 324         scsi_qla_host_t *vha;
 325         uint8_t port_name[WWN_SIZE];
 326
 327         if (fc_vport->roles != FC_PORT_ROLE_FCP_INITIATOR)
 328                 return VPCERR_UNSUPPORTED;
 329
 330         /* Check up the F/W and H/W support NPIV */
 331         if (!ha->flags.npiv_supported)
 332                 return VPCERR_UNSUPPORTED;
 333
 334         /* Check up whether npiv supported switch presented */
 335         if (!(ha->switch_cap & FLOGI_MID_SUPPORT))
 336                 return VPCERR_NO_FABRIC_SUPP;
 337
 338         /* Check up unique WWPN */
 339         u64_to_wwn(fc_vport->port_name, port_name);
 340         if (!memcmp(port_name, ha->port_name, WWN_SIZE))
 341                 return VPCERR_BAD_WWN;
 342         vha = qla24xx_find_vhost_by_name(ha, port_name);
 343         if (vha)
 344                 return VPCERR_BAD_WWN;
 345
 346         /* Check up max-npiv-supports */
 347         if (ha->num_vhosts > ha->max_npiv_vports) {
 348                 DEBUG15(printk("scsi(%ld): num_vhosts %ud is bigger than "
 349                     "max_npv_vports %ud.\n", ha->host_no,
 350                     ha->num_vhosts, ha->max_npiv_vports));
 351                 return VPCERR_UNSUPPORTED;
 352         }
 353         return 0;
 354 }
 355
 356 scsi_qla_host_t *
 357 qla24xx_create_vhost(struct fc_vport *fc_vport)
 358 {
 359         scsi_qla_host_t *ha = shost_priv(fc_vport->shost);
 360         scsi_qla_host_t *vha;
 361         struct Scsi_Host *host;
 362
 363         host = scsi_host_alloc(&qla24xx_driver_template,
 364             sizeof(scsi_qla_host_t));
 365         if (!host) {
 366                 printk(KERN_WARNING
 367                     "qla2xxx: scsi_host_alloc() failed for vport\n");
 368                 return(NULL);
 369         }
 370
 371         vha = shost_priv(host);
 372
 373         /* clone the parent hba */
 374         memcpy(vha, ha, sizeof (scsi_qla_host_t));
 375
 376         fc_vport->dd_data = vha;
 377
 378         vha->node_name = kmalloc(WWN_SIZE * sizeof(char), GFP_KERNEL);
 379         if (!vha->node_name)
 380                 goto create_vhost_failed_1;
 381
 382         vha->port_name = kmalloc(WWN_SIZE * sizeof(char), GFP_KERNEL);
 383         if (!vha->port_name)
 384                 goto create_vhost_failed_2;
 385
 386         /* New host info */
 387         u64_to_wwn(fc_vport->node_name, vha->node_name);
 388         u64_to_wwn(fc_vport->port_name, vha->port_name);
 389
 390         vha->host = host;
 391         vha->host_no = host->host_no;
 392         vha->parent = ha;
 393         vha->fc_vport = fc_vport;
 394         vha->device_flags = 0;
 395         vha->vp_idx = qla24xx_allocate_vp_id(vha);
 396         if (vha->vp_idx > ha->max_npiv_vports) {
 397                 DEBUG15(printk("scsi(%ld): Couldn't allocate vp_id.\n",
 398                         vha->host_no));
 399                 goto create_vhost_failed_3;
 400         }
 401         vha->mgmt_svr_loop_id = 10 + vha->vp_idx;
 402
 403         init_completion(&vha->mbx_cmd_comp);
 404         complete(&vha->mbx_cmd_comp);
 405         init_completion(&vha->mbx_intr_comp);
 406
 407         INIT_LIST_HEAD(&vha->list);
 408         INIT_LIST_HEAD(&vha->fcports);
 409         INIT_LIST_HEAD(&vha->vp_fcports);
 410         INIT_LIST_HEAD(&vha->work_list);
 411
 412         vha->dpc_flags = 0L;
 413         set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
 414         set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
 415
 416         /*
 417          * To fix the issue of processing a parent's RSCN for the vport before
 418          * its SCR is complete.
 419          */
 420         set_bit(VP_SCR_NEEDED, &vha->vp_flags);
 421         atomic_set(&vha->loop_state, LOOP_DOWN);
 422         atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
 423
 424         qla2x00_start_timer(vha, qla2x00_timer, WATCH_INTERVAL);
 425
 426         host->can_queue = vha->request_q_length + 128;
 427         host->this_id = 255;
 428         host->cmd_per_lun = 3;
 429         host->max_cmd_len = MAX_CMDSZ;
 430         host->max_channel = MAX_BUSES - 1;
 431         host->max_lun = MAX_LUNS;
 432         host->unique_id = host->host_no;
 433         host->max_id = MAX_TARGETS_2200;
 434         host->transportt = qla2xxx_transport_vport_template;
 435
 436         DEBUG15(printk("DEBUG: detect vport hba %ld at address = %p\n",
 437             vha->host_no, vha));
 438
 439         vha->flags.init_done = 1;
 440
 441         return vha;
 442
 443 create_vhost_failed_3:
 444         kfree(vha->port_name);
 445
 446 create_vhost_failed_2:
 447         kfree(vha->node_name);
 448
 449 create_vhost_failed_1:
 450         return NULL;
 451 }