Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
qla_bsg.c
Go to the documentation of this file.
1 /*
2  * QLogic Fibre Channel HBA Driver
3  * Copyright (c) 2003-2012 QLogic Corporation
4  *
5  * See LICENSE.qla2xxx for copyright and licensing details.
6  */
7 #include "qla_def.h"
8 
9 #include <linux/kthread.h>
10 #include <linux/vmalloc.h>
11 #include <linux/delay.h>
12 
13 /* BSG support for ELS/CT pass through */
14 void
15 qla2x00_bsg_job_done(void *data, void *ptr, int res)
16 {
17  srb_t *sp = (srb_t *)ptr;
18  struct scsi_qla_host *vha = (scsi_qla_host_t *)data;
19  struct fc_bsg_job *bsg_job = sp->u.bsg_job;
20 
21  bsg_job->reply->result = res;
22  bsg_job->job_done(bsg_job);
23  sp->free(vha, sp);
24 }
25 
26 void
27 qla2x00_bsg_sp_free(void *data, void *ptr)
28 {
29  srb_t *sp = (srb_t *)ptr;
30  struct scsi_qla_host *vha = (scsi_qla_host_t *)data;
31  struct fc_bsg_job *bsg_job = sp->u.bsg_job;
32  struct qla_hw_data *ha = vha->hw;
33 
34  dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
35  bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
36 
37  dma_unmap_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
38  bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
39 
40  if (sp->type == SRB_CT_CMD ||
41  sp->type == SRB_ELS_CMD_HST)
42  kfree(sp->fcport);
43  mempool_free(sp, vha->hw->srb_mempool);
44 }
45 
46 int
47 qla24xx_fcp_prio_cfg_valid(scsi_qla_host_t *vha,
48  struct qla_fcp_prio_cfg *pri_cfg, uint8_t flag)
49 {
50  int i, ret, num_valid;
51  uint8_t *bcode;
52  struct qla_fcp_prio_entry *pri_entry;
53  uint32_t *bcode_val_ptr, bcode_val;
54 
55  ret = 1;
56  num_valid = 0;
57  bcode = (uint8_t *)pri_cfg;
58  bcode_val_ptr = (uint32_t *)pri_cfg;
59  bcode_val = (uint32_t)(*bcode_val_ptr);
60 
61  if (bcode_val == 0xFFFFFFFF) {
62  /* No FCP Priority config data in flash */
63  ql_dbg(ql_dbg_user, vha, 0x7051,
64  "No FCP Priority config data.\n");
65  return 0;
66  }
67 
68  if (bcode[0] != 'H' || bcode[1] != 'Q' || bcode[2] != 'O' ||
69  bcode[3] != 'S') {
70  /* Invalid FCP priority data header*/
71  ql_dbg(ql_dbg_user, vha, 0x7052,
72  "Invalid FCP Priority data header. bcode=0x%x.\n",
73  bcode_val);
74  return 0;
75  }
76  if (flag != 1)
77  return ret;
78 
79  pri_entry = &pri_cfg->entry[0];
80  for (i = 0; i < pri_cfg->num_entries; i++) {
81  if (pri_entry->flags & FCP_PRIO_ENTRY_TAG_VALID)
82  num_valid++;
83  pri_entry++;
84  }
85 
86  if (num_valid == 0) {
87  /* No valid FCP priority data entries */
88  ql_dbg(ql_dbg_user, vha, 0x7053,
89  "No valid FCP Priority data entries.\n");
90  ret = 0;
91  } else {
92  /* FCP priority data is valid */
93  ql_dbg(ql_dbg_user, vha, 0x7054,
94  "Valid FCP priority data. num entries = %d.\n",
95  num_valid);
96  }
97 
98  return ret;
99 }
100 
101 static int
102 qla24xx_proc_fcp_prio_cfg_cmd(struct fc_bsg_job *bsg_job)
103 {
104  struct Scsi_Host *host = bsg_job->shost;
105  scsi_qla_host_t *vha = shost_priv(host);
106  struct qla_hw_data *ha = vha->hw;
107  int ret = 0;
108  uint32_t len;
109  uint32_t oper;
110 
111  if (!(IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha) || IS_QLA82XX(ha))) {
112  ret = -EINVAL;
113  goto exit_fcp_prio_cfg;
114  }
115 
116  /* Get the sub command */
117  oper = bsg_job->request->rqst_data.h_vendor.vendor_cmd[1];
118 
119  /* Only set config is allowed if config memory is not allocated */
120  if (!ha->fcp_prio_cfg && (oper != QLFC_FCP_PRIO_SET_CONFIG)) {
121  ret = -EINVAL;
122  goto exit_fcp_prio_cfg;
123  }
124  switch (oper) {
125  case QLFC_FCP_PRIO_DISABLE:
126  if (ha->flags.fcp_prio_enabled) {
127  ha->flags.fcp_prio_enabled = 0;
128  ha->fcp_prio_cfg->attributes &=
129  ~FCP_PRIO_ATTR_ENABLE;
130  qla24xx_update_all_fcp_prio(vha);
131  bsg_job->reply->result = DID_OK;
132  } else {
133  ret = -EINVAL;
134  bsg_job->reply->result = (DID_ERROR << 16);
135  goto exit_fcp_prio_cfg;
136  }
137  break;
138 
139  case QLFC_FCP_PRIO_ENABLE:
140  if (!ha->flags.fcp_prio_enabled) {
141  if (ha->fcp_prio_cfg) {
142  ha->flags.fcp_prio_enabled = 1;
143  ha->fcp_prio_cfg->attributes |=
144  FCP_PRIO_ATTR_ENABLE;
145  qla24xx_update_all_fcp_prio(vha);
146  bsg_job->reply->result = DID_OK;
147  } else {
148  ret = -EINVAL;
149  bsg_job->reply->result = (DID_ERROR << 16);
150  goto exit_fcp_prio_cfg;
151  }
152  }
153  break;
154 
155  case QLFC_FCP_PRIO_GET_CONFIG:
156  len = bsg_job->reply_payload.payload_len;
157  if (!len || len > FCP_PRIO_CFG_SIZE) {
158  ret = -EINVAL;
159  bsg_job->reply->result = (DID_ERROR << 16);
160  goto exit_fcp_prio_cfg;
161  }
162 
163  bsg_job->reply->result = DID_OK;
164  bsg_job->reply->reply_payload_rcv_len =
165  sg_copy_from_buffer(
166  bsg_job->reply_payload.sg_list,
167  bsg_job->reply_payload.sg_cnt, ha->fcp_prio_cfg,
168  len);
169 
170  break;
171 
172  case QLFC_FCP_PRIO_SET_CONFIG:
173  len = bsg_job->request_payload.payload_len;
174  if (!len || len > FCP_PRIO_CFG_SIZE) {
175  bsg_job->reply->result = (DID_ERROR << 16);
176  ret = -EINVAL;
177  goto exit_fcp_prio_cfg;
178  }
179 
180  if (!ha->fcp_prio_cfg) {
181  ha->fcp_prio_cfg = vmalloc(FCP_PRIO_CFG_SIZE);
182  if (!ha->fcp_prio_cfg) {
183  ql_log(ql_log_warn, vha, 0x7050,
184  "Unable to allocate memory for fcp prio "
185  "config data (%x).\n", FCP_PRIO_CFG_SIZE);
186  bsg_job->reply->result = (DID_ERROR << 16);
187  ret = -ENOMEM;
188  goto exit_fcp_prio_cfg;
189  }
190  }
191 
192  memset(ha->fcp_prio_cfg, 0, FCP_PRIO_CFG_SIZE);
193  sg_copy_to_buffer(bsg_job->request_payload.sg_list,
194  bsg_job->request_payload.sg_cnt, ha->fcp_prio_cfg,
195  FCP_PRIO_CFG_SIZE);
196 
197  /* validate fcp priority data */
198 
199  if (!qla24xx_fcp_prio_cfg_valid(vha,
200  (struct qla_fcp_prio_cfg *) ha->fcp_prio_cfg, 1)) {
201  bsg_job->reply->result = (DID_ERROR << 16);
202  ret = -EINVAL;
203  /* If buffer was invalidatic int
204  * fcp_prio_cfg is of no use
205  */
206  vfree(ha->fcp_prio_cfg);
207  ha->fcp_prio_cfg = NULL;
208  goto exit_fcp_prio_cfg;
209  }
210 
211  ha->flags.fcp_prio_enabled = 0;
212  if (ha->fcp_prio_cfg->attributes & FCP_PRIO_ATTR_ENABLE)
213  ha->flags.fcp_prio_enabled = 1;
214  qla24xx_update_all_fcp_prio(vha);
215  bsg_job->reply->result = DID_OK;
216  break;
217  default:
218  ret = -EINVAL;
219  break;
220  }
221 exit_fcp_prio_cfg:
222  bsg_job->job_done(bsg_job);
223  return ret;
224 }
225 
226 static int
227 qla2x00_process_els(struct fc_bsg_job *bsg_job)
228 {
229  struct fc_rport *rport;
230  fc_port_t *fcport = NULL;
231  struct Scsi_Host *host;
232  scsi_qla_host_t *vha;
233  struct qla_hw_data *ha;
234  srb_t *sp;
235  const char *type;
236  int req_sg_cnt, rsp_sg_cnt;
237  int rval = (DRIVER_ERROR << 16);
238  uint16_t nextlid = 0;
239 
240  if (bsg_job->request->msgcode == FC_BSG_RPT_ELS) {
241  rport = bsg_job->rport;
242  fcport = *(fc_port_t **) rport->dd_data;
243  host = rport_to_shost(rport);
244  vha = shost_priv(host);
245  ha = vha->hw;
246  type = "FC_BSG_RPT_ELS";
247  } else {
248  host = bsg_job->shost;
249  vha = shost_priv(host);
250  ha = vha->hw;
251  type = "FC_BSG_HST_ELS_NOLOGIN";
252  }
253 
254  /* pass through is supported only for ISP 4Gb or higher */
255  if (!IS_FWI2_CAPABLE(ha)) {
256  ql_dbg(ql_dbg_user, vha, 0x7001,
257  "ELS passthru not supported for ISP23xx based adapters.\n");
258  rval = -EPERM;
259  goto done;
260  }
261 
262  /* Multiple SG's are not supported for ELS requests */
263  if (bsg_job->request_payload.sg_cnt > 1 ||
264  bsg_job->reply_payload.sg_cnt > 1) {
265  ql_dbg(ql_dbg_user, vha, 0x7002,
266  "Multiple SG's are not suppored for ELS requests, "
267  "request_sg_cnt=%x reply_sg_cnt=%x.\n",
268  bsg_job->request_payload.sg_cnt,
269  bsg_job->reply_payload.sg_cnt);
270  rval = -EPERM;
271  goto done;
272  }
273 
274  /* ELS request for rport */
275  if (bsg_job->request->msgcode == FC_BSG_RPT_ELS) {
276  /* make sure the rport is logged in,
277  * if not perform fabric login
278  */
279  if (qla2x00_fabric_login(vha, fcport, &nextlid)) {
280  ql_dbg(ql_dbg_user, vha, 0x7003,
281  "Failed to login port %06X for ELS passthru.\n",
282  fcport->d_id.b24);
283  rval = -EIO;
284  goto done;
285  }
286  } else {
287  /* Allocate a dummy fcport structure, since functions
288  * preparing the IOCB and mailbox command retrieves port
289  * specific information from fcport structure. For Host based
290  * ELS commands there will be no fcport structure allocated
291  */
292  fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
293  if (!fcport) {
294  rval = -ENOMEM;
295  goto done;
296  }
297 
298  /* Initialize all required fields of fcport */
299  fcport->vha = vha;
300  fcport->d_id.b.al_pa =
301  bsg_job->request->rqst_data.h_els.port_id[0];
302  fcport->d_id.b.area =
303  bsg_job->request->rqst_data.h_els.port_id[1];
304  fcport->d_id.b.domain =
305  bsg_job->request->rqst_data.h_els.port_id[2];
306  fcport->loop_id =
307  (fcport->d_id.b.al_pa == 0xFD) ?
308  NPH_FABRIC_CONTROLLER : NPH_F_PORT;
309  }
310 
311  if (!vha->flags.online) {
312  ql_log(ql_log_warn, vha, 0x7005, "Host not online.\n");
313  rval = -EIO;
314  goto done;
315  }
316 
317  req_sg_cnt =
318  dma_map_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
319  bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
320  if (!req_sg_cnt) {
321  rval = -ENOMEM;
322  goto done_free_fcport;
323  }
324 
325  rsp_sg_cnt = dma_map_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
326  bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
327  if (!rsp_sg_cnt) {
328  rval = -ENOMEM;
329  goto done_free_fcport;
330  }
331 
332  if ((req_sg_cnt != bsg_job->request_payload.sg_cnt) ||
333  (rsp_sg_cnt != bsg_job->reply_payload.sg_cnt)) {
334  ql_log(ql_log_warn, vha, 0x7008,
335  "dma mapping resulted in different sg counts, "
336  "request_sg_cnt: %x dma_request_sg_cnt:%x reply_sg_cnt:%x "
337  "dma_reply_sg_cnt:%x.\n", bsg_job->request_payload.sg_cnt,
338  req_sg_cnt, bsg_job->reply_payload.sg_cnt, rsp_sg_cnt);
339  rval = -EAGAIN;
340  goto done_unmap_sg;
341  }
342 
343  /* Alloc SRB structure */
344  sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
345  if (!sp) {
346  rval = -ENOMEM;
347  goto done_unmap_sg;
348  }
349 
350  sp->type =
351  (bsg_job->request->msgcode == FC_BSG_RPT_ELS ?
352  SRB_ELS_CMD_RPT : SRB_ELS_CMD_HST);
353  sp->name =
354  (bsg_job->request->msgcode == FC_BSG_RPT_ELS ?
355  "bsg_els_rpt" : "bsg_els_hst");
356  sp->u.bsg_job = bsg_job;
357  sp->free = qla2x00_bsg_sp_free;
358  sp->done = qla2x00_bsg_job_done;
359 
360  ql_dbg(ql_dbg_user, vha, 0x700a,
361  "bsg rqst type: %s els type: %x - loop-id=%x "
362  "portid=%-2x%02x%02x.\n", type,
363  bsg_job->request->rqst_data.h_els.command_code, fcport->loop_id,
364  fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa);
365 
366  rval = qla2x00_start_sp(sp);
367  if (rval != QLA_SUCCESS) {
368  ql_log(ql_log_warn, vha, 0x700e,
369  "qla2x00_start_sp failed = %d\n", rval);
370  mempool_free(sp, ha->srb_mempool);
371  rval = -EIO;
372  goto done_unmap_sg;
373  }
374  return rval;
375 
376 done_unmap_sg:
377  dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
378  bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
379  dma_unmap_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
380  bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
381  goto done_free_fcport;
382 
383 done_free_fcport:
384  if (bsg_job->request->msgcode == FC_BSG_HST_ELS_NOLOGIN)
385  kfree(fcport);
386 done:
387  return rval;
388 }
389 
390 inline uint16_t
391 qla24xx_calc_ct_iocbs(uint16_t dsds)
392 {
393  uint16_t iocbs;
394 
395  iocbs = 1;
396  if (dsds > 2) {
397  iocbs += (dsds - 2) / 5;
398  if ((dsds - 2) % 5)
399  iocbs++;
400  }
401  return iocbs;
402 }
403 
404 static int
405 qla2x00_process_ct(struct fc_bsg_job *bsg_job)
406 {
407  srb_t *sp;
408  struct Scsi_Host *host = bsg_job->shost;
409  scsi_qla_host_t *vha = shost_priv(host);
410  struct qla_hw_data *ha = vha->hw;
411  int rval = (DRIVER_ERROR << 16);
412  int req_sg_cnt, rsp_sg_cnt;
413  uint16_t loop_id;
414  struct fc_port *fcport;
415  char *type = "FC_BSG_HST_CT";
416 
417  req_sg_cnt =
418  dma_map_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
419  bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
420  if (!req_sg_cnt) {
421  ql_log(ql_log_warn, vha, 0x700f,
422  "dma_map_sg return %d for request\n", req_sg_cnt);
423  rval = -ENOMEM;
424  goto done;
425  }
426 
427  rsp_sg_cnt = dma_map_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
428  bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
429  if (!rsp_sg_cnt) {
430  ql_log(ql_log_warn, vha, 0x7010,
431  "dma_map_sg return %d for reply\n", rsp_sg_cnt);
432  rval = -ENOMEM;
433  goto done;
434  }
435 
436  if ((req_sg_cnt != bsg_job->request_payload.sg_cnt) ||
437  (rsp_sg_cnt != bsg_job->reply_payload.sg_cnt)) {
438  ql_log(ql_log_warn, vha, 0x7011,
439  "request_sg_cnt: %x dma_request_sg_cnt: %x reply_sg_cnt:%x "
440  "dma_reply_sg_cnt: %x\n", bsg_job->request_payload.sg_cnt,
441  req_sg_cnt, bsg_job->reply_payload.sg_cnt, rsp_sg_cnt);
442  rval = -EAGAIN;
443  goto done_unmap_sg;
444  }
445 
446  if (!vha->flags.online) {
447  ql_log(ql_log_warn, vha, 0x7012,
448  "Host is not online.\n");
449  rval = -EIO;
450  goto done_unmap_sg;
451  }
452 
453  loop_id =
454  (bsg_job->request->rqst_data.h_ct.preamble_word1 & 0xFF000000)
455  >> 24;
456  switch (loop_id) {
457  case 0xFC:
458  loop_id = cpu_to_le16(NPH_SNS);
459  break;
460  case 0xFA:
461  loop_id = vha->mgmt_svr_loop_id;
462  break;
463  default:
464  ql_dbg(ql_dbg_user, vha, 0x7013,
465  "Unknown loop id: %x.\n", loop_id);
466  rval = -EINVAL;
467  goto done_unmap_sg;
468  }
469 
470  /* Allocate a dummy fcport structure, since functions preparing the
471  * IOCB and mailbox command retrieves port specific information
472  * from fcport structure. For Host based ELS commands there will be
473  * no fcport structure allocated
474  */
475  fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
476  if (!fcport) {
477  ql_log(ql_log_warn, vha, 0x7014,
478  "Failed to allocate fcport.\n");
479  rval = -ENOMEM;
480  goto done_unmap_sg;
481  }
482 
483  /* Initialize all required fields of fcport */
484  fcport->vha = vha;
485  fcport->d_id.b.al_pa = bsg_job->request->rqst_data.h_ct.port_id[0];
486  fcport->d_id.b.area = bsg_job->request->rqst_data.h_ct.port_id[1];
487  fcport->d_id.b.domain = bsg_job->request->rqst_data.h_ct.port_id[2];
488  fcport->loop_id = loop_id;
489 
490  /* Alloc SRB structure */
491  sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
492  if (!sp) {
493  ql_log(ql_log_warn, vha, 0x7015,
494  "qla2x00_get_sp failed.\n");
495  rval = -ENOMEM;
496  goto done_free_fcport;
497  }
498 
499  sp->type = SRB_CT_CMD;
500  sp->name = "bsg_ct";
501  sp->iocbs = qla24xx_calc_ct_iocbs(req_sg_cnt + rsp_sg_cnt);
502  sp->u.bsg_job = bsg_job;
503  sp->free = qla2x00_bsg_sp_free;
504  sp->done = qla2x00_bsg_job_done;
505 
506  ql_dbg(ql_dbg_user, vha, 0x7016,
507  "bsg rqst type: %s else type: %x - "
508  "loop-id=%x portid=%02x%02x%02x.\n", type,
509  (bsg_job->request->rqst_data.h_ct.preamble_word2 >> 16),
510  fcport->loop_id, fcport->d_id.b.domain, fcport->d_id.b.area,
511  fcport->d_id.b.al_pa);
512 
513  rval = qla2x00_start_sp(sp);
514  if (rval != QLA_SUCCESS) {
515  ql_log(ql_log_warn, vha, 0x7017,
516  "qla2x00_start_sp failed=%d.\n", rval);
517  mempool_free(sp, ha->srb_mempool);
518  rval = -EIO;
519  goto done_free_fcport;
520  }
521  return rval;
522 
523 done_free_fcport:
524  kfree(fcport);
525 done_unmap_sg:
526  dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
527  bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
528  dma_unmap_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
529  bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
530 done:
531  return rval;
532 }
533 /*
534  * Set the port configuration to enable the internal or external loopback
535  * depending on the loopback mode.
536  */
537 static inline int
538 qla81xx_set_loopback_mode(scsi_qla_host_t *vha, uint16_t *config,
539  uint16_t *new_config, uint16_t mode)
540 {
541  int ret = 0;
542  int rval = 0;
543  struct qla_hw_data *ha = vha->hw;
544 
545  if (!IS_QLA81XX(ha) && !IS_QLA8031(ha))
546  goto done_set_internal;
547 
548  if (mode == INTERNAL_LOOPBACK)
549  new_config[0] = config[0] | (ENABLE_INTERNAL_LOOPBACK << 1);
550  else if (mode == EXTERNAL_LOOPBACK)
551  new_config[0] = config[0] | (ENABLE_EXTERNAL_LOOPBACK << 1);
552  ql_dbg(ql_dbg_user, vha, 0x70be,
553  "new_config[0]=%02x\n", (new_config[0] & INTERNAL_LOOPBACK_MASK));
554 
555  memcpy(&new_config[1], &config[1], sizeof(uint16_t) * 3);
556 
557  ha->notify_dcbx_comp = 1;
558  ret = qla81xx_set_port_config(vha, new_config);
559  if (ret != QLA_SUCCESS) {
560  ql_log(ql_log_warn, vha, 0x7021,
561  "set port config failed.\n");
562  ha->notify_dcbx_comp = 0;
563  rval = -EINVAL;
564  goto done_set_internal;
565  }
566 
567  /* Wait for DCBX complete event */
568  if (!wait_for_completion_timeout(&ha->dcbx_comp, (20 * HZ))) {
569  ql_dbg(ql_dbg_user, vha, 0x7022,
570  "State change notification not received.\n");
571  rval = -EINVAL;
572  } else {
573  if (ha->flags.idc_compl_status) {
574  ql_dbg(ql_dbg_user, vha, 0x70c3,
575  "Bad status in IDC Completion AEN\n");
576  rval = -EINVAL;
577  ha->flags.idc_compl_status = 0;
578  } else
579  ql_dbg(ql_dbg_user, vha, 0x7023,
580  "State change received.\n");
581  }
582 
583  ha->notify_dcbx_comp = 0;
584 
585 done_set_internal:
586  return rval;
587 }
588 
589 /* Disable loopback mode */
590 static inline int
591 qla81xx_reset_loopback_mode(scsi_qla_host_t *vha, uint16_t *config,
592  int wait)
593 {
594  int ret = 0;
595  int rval = 0;
596  uint16_t new_config[4];
597  struct qla_hw_data *ha = vha->hw;
598 
599  if (!IS_QLA81XX(ha) && !IS_QLA8031(ha))
600  goto done_reset_internal;
601 
602  memset(new_config, 0 , sizeof(new_config));
603  if ((config[0] & INTERNAL_LOOPBACK_MASK) >> 1 ==
604  ENABLE_INTERNAL_LOOPBACK ||
605  (config[0] & INTERNAL_LOOPBACK_MASK) >> 1 ==
606  ENABLE_EXTERNAL_LOOPBACK) {
607  new_config[0] = config[0] & ~INTERNAL_LOOPBACK_MASK;
608  ql_dbg(ql_dbg_user, vha, 0x70bf, "new_config[0]=%02x\n",
609  (new_config[0] & INTERNAL_LOOPBACK_MASK));
610  memcpy(&new_config[1], &config[1], sizeof(uint16_t) * 3) ;
611 
612  ha->notify_dcbx_comp = wait;
613  ret = qla81xx_set_port_config(vha, new_config);
614  if (ret != QLA_SUCCESS) {
615  ql_log(ql_log_warn, vha, 0x7025,
616  "Set port config failed.\n");
617  ha->notify_dcbx_comp = 0;
618  rval = -EINVAL;
619  goto done_reset_internal;
620  }
621 
622  /* Wait for DCBX complete event */
623  if (wait && !wait_for_completion_timeout(&ha->dcbx_comp,
624  (20 * HZ))) {
625  ql_dbg(ql_dbg_user, vha, 0x7026,
626  "State change notification not received.\n");
627  ha->notify_dcbx_comp = 0;
628  rval = -EINVAL;
629  goto done_reset_internal;
630  } else
631  ql_dbg(ql_dbg_user, vha, 0x7027,
632  "State change received.\n");
633 
634  ha->notify_dcbx_comp = 0;
635  }
636 done_reset_internal:
637  return rval;
638 }
639 
640 static int
641 qla2x00_process_loopback(struct fc_bsg_job *bsg_job)
642 {
643  struct Scsi_Host *host = bsg_job->shost;
644  scsi_qla_host_t *vha = shost_priv(host);
645  struct qla_hw_data *ha = vha->hw;
646  int rval;
647  uint8_t command_sent;
648  char *type;
649  struct msg_echo_lb elreq;
650  uint16_t response[MAILBOX_REGISTER_COUNT];
651  uint16_t config[4], new_config[4];
652  uint8_t *fw_sts_ptr;
653  uint8_t *req_data = NULL;
654  dma_addr_t req_data_dma;
655  uint32_t req_data_len;
656  uint8_t *rsp_data = NULL;
657  dma_addr_t rsp_data_dma;
658  uint32_t rsp_data_len;
659 
660  if (!vha->flags.online) {
661  ql_log(ql_log_warn, vha, 0x7019, "Host is not online.\n");
662  return -EIO;
663  }
664 
665  elreq.req_sg_cnt = dma_map_sg(&ha->pdev->dev,
666  bsg_job->request_payload.sg_list, bsg_job->request_payload.sg_cnt,
667  DMA_TO_DEVICE);
668 
669  if (!elreq.req_sg_cnt) {
670  ql_log(ql_log_warn, vha, 0x701a,
671  "dma_map_sg returned %d for request.\n", elreq.req_sg_cnt);
672  return -ENOMEM;
673  }
674 
675  elreq.rsp_sg_cnt = dma_map_sg(&ha->pdev->dev,
676  bsg_job->reply_payload.sg_list, bsg_job->reply_payload.sg_cnt,
677  DMA_FROM_DEVICE);
678 
679  if (!elreq.rsp_sg_cnt) {
680  ql_log(ql_log_warn, vha, 0x701b,
681  "dma_map_sg returned %d for reply.\n", elreq.rsp_sg_cnt);
682  rval = -ENOMEM;
683  goto done_unmap_req_sg;
684  }
685 
686  if ((elreq.req_sg_cnt != bsg_job->request_payload.sg_cnt) ||
687  (elreq.rsp_sg_cnt != bsg_job->reply_payload.sg_cnt)) {
688  ql_log(ql_log_warn, vha, 0x701c,
689  "dma mapping resulted in different sg counts, "
690  "request_sg_cnt: %x dma_request_sg_cnt: %x "
691  "reply_sg_cnt: %x dma_reply_sg_cnt: %x.\n",
692  bsg_job->request_payload.sg_cnt, elreq.req_sg_cnt,
693  bsg_job->reply_payload.sg_cnt, elreq.rsp_sg_cnt);
694  rval = -EAGAIN;
695  goto done_unmap_sg;
696  }
697  req_data_len = rsp_data_len = bsg_job->request_payload.payload_len;
698  req_data = dma_alloc_coherent(&ha->pdev->dev, req_data_len,
699  &req_data_dma, GFP_KERNEL);
700  if (!req_data) {
701  ql_log(ql_log_warn, vha, 0x701d,
702  "dma alloc failed for req_data.\n");
703  rval = -ENOMEM;
704  goto done_unmap_sg;
705  }
706 
707  rsp_data = dma_alloc_coherent(&ha->pdev->dev, rsp_data_len,
708  &rsp_data_dma, GFP_KERNEL);
709  if (!rsp_data) {
710  ql_log(ql_log_warn, vha, 0x7004,
711  "dma alloc failed for rsp_data.\n");
712  rval = -ENOMEM;
713  goto done_free_dma_req;
714  }
715 
716  /* Copy the request buffer in req_data now */
717  sg_copy_to_buffer(bsg_job->request_payload.sg_list,
718  bsg_job->request_payload.sg_cnt, req_data, req_data_len);
719 
720  elreq.send_dma = req_data_dma;
721  elreq.rcv_dma = rsp_data_dma;
722  elreq.transfer_size = req_data_len;
723 
724  elreq.options = bsg_job->request->rqst_data.h_vendor.vendor_cmd[1];
725 
726  if (atomic_read(&vha->loop_state) == LOOP_READY &&
727  (ha->current_topology == ISP_CFG_F ||
728  ((IS_QLA81XX(ha) || IS_QLA8031(ha)) &&
729  le32_to_cpu(*(uint32_t *)req_data) == ELS_OPCODE_BYTE
730  && req_data_len == MAX_ELS_FRAME_PAYLOAD)) &&
731  elreq.options == EXTERNAL_LOOPBACK) {
732  type = "FC_BSG_HST_VENDOR_ECHO_DIAG";
733  ql_dbg(ql_dbg_user, vha, 0x701e,
734  "BSG request type: %s.\n", type);
735  command_sent = INT_DEF_LB_ECHO_CMD;
736  rval = qla2x00_echo_test(vha, &elreq, response);
737  } else {
738  if (IS_QLA81XX(ha) || IS_QLA8031(ha)) {
739  memset(config, 0, sizeof(config));
740  memset(new_config, 0, sizeof(new_config));
741  if (qla81xx_get_port_config(vha, config)) {
742  ql_log(ql_log_warn, vha, 0x701f,
743  "Get port config failed.\n");
744  bsg_job->reply->result = (DID_ERROR << 16);
745  rval = -EPERM;
746  goto done_free_dma_req;
747  }
748 
749  ql_dbg(ql_dbg_user, vha, 0x70c0,
750  "elreq.options=%04x\n", elreq.options);
751 
752  if (elreq.options == EXTERNAL_LOOPBACK)
753  if (IS_QLA8031(ha))
754  rval = qla81xx_set_loopback_mode(vha,
755  config, new_config, elreq.options);
756  else
757  rval = qla81xx_reset_loopback_mode(vha,
758  config, 1);
759  else
760  rval = qla81xx_set_loopback_mode(vha, config,
761  new_config, elreq.options);
762 
763  if (rval) {
764  bsg_job->reply->result = (DID_ERROR << 16);
765  rval = -EPERM;
766  goto done_free_dma_req;
767  }
768 
769  type = "FC_BSG_HST_VENDOR_LOOPBACK";
770  ql_dbg(ql_dbg_user, vha, 0x7028,
771  "BSG request type: %s.\n", type);
772 
773  command_sent = INT_DEF_LB_LOOPBACK_CMD;
774  rval = qla2x00_loopback_test(vha, &elreq, response);
775 
776  if (new_config[0]) {
777  /* Revert back to original port config
778  * Also clear internal loopback
779  */
780  qla81xx_reset_loopback_mode(vha,
781  new_config, 0);
782  }
783 
784  if (response[0] == MBS_COMMAND_ERROR &&
785  response[1] == MBS_LB_RESET) {
786  ql_log(ql_log_warn, vha, 0x7029,
787  "MBX command error, Aborting ISP.\n");
788  set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
789  qla2xxx_wake_dpc(vha);
790  qla2x00_wait_for_chip_reset(vha);
791  /* Also reset the MPI */
792  if (qla81xx_restart_mpi_firmware(vha) !=
793  QLA_SUCCESS) {
794  ql_log(ql_log_warn, vha, 0x702a,
795  "MPI reset failed.\n");
796  }
797 
798  bsg_job->reply->result = (DID_ERROR << 16);
799  rval = -EIO;
800  goto done_free_dma_req;
801  }
802  } else {
803  type = "FC_BSG_HST_VENDOR_LOOPBACK";
804  ql_dbg(ql_dbg_user, vha, 0x702b,
805  "BSG request type: %s.\n", type);
806  command_sent = INT_DEF_LB_LOOPBACK_CMD;
807  rval = qla2x00_loopback_test(vha, &elreq, response);
808  }
809  }
810 
811  if (rval) {
812  ql_log(ql_log_warn, vha, 0x702c,
813  "Vendor request %s failed.\n", type);
814 
815  fw_sts_ptr = ((uint8_t *)bsg_job->req->sense) +
816  sizeof(struct fc_bsg_reply);
817 
818  memcpy(fw_sts_ptr, response, sizeof(response));
819  fw_sts_ptr += sizeof(response);
820  *fw_sts_ptr = command_sent;
821  rval = 0;
822  bsg_job->reply->result = (DID_ERROR << 16);
823  } else {
824  ql_dbg(ql_dbg_user, vha, 0x702d,
825  "Vendor request %s completed.\n", type);
826 
827  bsg_job->reply_len = sizeof(struct fc_bsg_reply) +
828  sizeof(response) + sizeof(uint8_t);
829  bsg_job->reply->reply_payload_rcv_len =
830  bsg_job->reply_payload.payload_len;
831  fw_sts_ptr = ((uint8_t *)bsg_job->req->sense) +
832  sizeof(struct fc_bsg_reply);
833  memcpy(fw_sts_ptr, response, sizeof(response));
834  fw_sts_ptr += sizeof(response);
835  *fw_sts_ptr = command_sent;
836  bsg_job->reply->result = DID_OK;
837  sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
838  bsg_job->reply_payload.sg_cnt, rsp_data,
839  rsp_data_len);
840  }
841  bsg_job->job_done(bsg_job);
842 
843  dma_free_coherent(&ha->pdev->dev, rsp_data_len,
844  rsp_data, rsp_data_dma);
845 done_free_dma_req:
846  dma_free_coherent(&ha->pdev->dev, req_data_len,
847  req_data, req_data_dma);
848 done_unmap_sg:
849  dma_unmap_sg(&ha->pdev->dev,
850  bsg_job->reply_payload.sg_list,
851  bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
852 done_unmap_req_sg:
853  dma_unmap_sg(&ha->pdev->dev,
854  bsg_job->request_payload.sg_list,
855  bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
856  return rval;
857 }
858 
859 static int
860 qla84xx_reset(struct fc_bsg_job *bsg_job)
861 {
862  struct Scsi_Host *host = bsg_job->shost;
863  scsi_qla_host_t *vha = shost_priv(host);
864  struct qla_hw_data *ha = vha->hw;
865  int rval = 0;
866  uint32_t flag;
867 
868  if (!IS_QLA84XX(ha)) {
869  ql_dbg(ql_dbg_user, vha, 0x702f, "Not 84xx, exiting.\n");
870  return -EINVAL;
871  }
872 
873  flag = bsg_job->request->rqst_data.h_vendor.vendor_cmd[1];
874 
875  rval = qla84xx_reset_chip(vha, flag == A84_ISSUE_RESET_DIAG_FW);
876 
877  if (rval) {
878  ql_log(ql_log_warn, vha, 0x7030,
879  "Vendor request 84xx reset failed.\n");
880  rval = 0;
881  bsg_job->reply->result = (DID_ERROR << 16);
882 
883  } else {
884  ql_dbg(ql_dbg_user, vha, 0x7031,
885  "Vendor request 84xx reset completed.\n");
886  bsg_job->reply->result = DID_OK;
887  }
888 
889  bsg_job->job_done(bsg_job);
890  return rval;
891 }
892 
893 static int
894 qla84xx_updatefw(struct fc_bsg_job *bsg_job)
895 {
896  struct Scsi_Host *host = bsg_job->shost;
897  scsi_qla_host_t *vha = shost_priv(host);
898  struct qla_hw_data *ha = vha->hw;
899  struct verify_chip_entry_84xx *mn = NULL;
900  dma_addr_t mn_dma, fw_dma;
901  void *fw_buf = NULL;
902  int rval = 0;
903  uint32_t sg_cnt;
904  uint32_t data_len;
905  uint16_t options;
906  uint32_t flag;
907  uint32_t fw_ver;
908 
909  if (!IS_QLA84XX(ha)) {
910  ql_dbg(ql_dbg_user, vha, 0x7032,
911  "Not 84xx, exiting.\n");
912  return -EINVAL;
913  }
914 
915  sg_cnt = dma_map_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
916  bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
917  if (!sg_cnt) {
918  ql_log(ql_log_warn, vha, 0x7033,
919  "dma_map_sg returned %d for request.\n", sg_cnt);
920  return -ENOMEM;
921  }
922 
923  if (sg_cnt != bsg_job->request_payload.sg_cnt) {
924  ql_log(ql_log_warn, vha, 0x7034,
925  "DMA mapping resulted in different sg counts, "
926  "request_sg_cnt: %x dma_request_sg_cnt: %x.\n",
927  bsg_job->request_payload.sg_cnt, sg_cnt);
928  rval = -EAGAIN;
929  goto done_unmap_sg;
930  }
931 
932  data_len = bsg_job->request_payload.payload_len;
933  fw_buf = dma_alloc_coherent(&ha->pdev->dev, data_len,
934  &fw_dma, GFP_KERNEL);
935  if (!fw_buf) {
936  ql_log(ql_log_warn, vha, 0x7035,
937  "DMA alloc failed for fw_buf.\n");
938  rval = -ENOMEM;
939  goto done_unmap_sg;
940  }
941 
942  sg_copy_to_buffer(bsg_job->request_payload.sg_list,
943  bsg_job->request_payload.sg_cnt, fw_buf, data_len);
944 
945  mn = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &mn_dma);
946  if (!mn) {
947  ql_log(ql_log_warn, vha, 0x7036,
948  "DMA alloc failed for fw buffer.\n");
949  rval = -ENOMEM;
950  goto done_free_fw_buf;
951  }
952 
953  flag = bsg_job->request->rqst_data.h_vendor.vendor_cmd[1];
954  fw_ver = le32_to_cpu(*((uint32_t *)((uint32_t *)fw_buf + 2)));
955 
956  memset(mn, 0, sizeof(struct access_chip_84xx));
957  mn->entry_type = VERIFY_CHIP_IOCB_TYPE;
958  mn->entry_count = 1;
959 
960  options = VCO_FORCE_UPDATE | VCO_END_OF_DATA;
961  if (flag == A84_ISSUE_UPDATE_DIAGFW_CMD)
962  options |= VCO_DIAG_FW;
963 
964  mn->options = cpu_to_le16(options);
965  mn->fw_ver = cpu_to_le32(fw_ver);
966  mn->fw_size = cpu_to_le32(data_len);
967  mn->fw_seq_size = cpu_to_le32(data_len);
968  mn->dseg_address[0] = cpu_to_le32(LSD(fw_dma));
969  mn->dseg_address[1] = cpu_to_le32(MSD(fw_dma));
970  mn->dseg_length = cpu_to_le32(data_len);
971  mn->data_seg_cnt = cpu_to_le16(1);
972 
973  rval = qla2x00_issue_iocb_timeout(vha, mn, mn_dma, 0, 120);
974 
975  if (rval) {
976  ql_log(ql_log_warn, vha, 0x7037,
977  "Vendor request 84xx updatefw failed.\n");
978 
979  rval = 0;
980  bsg_job->reply->result = (DID_ERROR << 16);
981  } else {
982  ql_dbg(ql_dbg_user, vha, 0x7038,
983  "Vendor request 84xx updatefw completed.\n");
984 
985  bsg_job->reply_len = sizeof(struct fc_bsg_reply);
986  bsg_job->reply->result = DID_OK;
987  }
988 
989  bsg_job->job_done(bsg_job);
990  dma_pool_free(ha->s_dma_pool, mn, mn_dma);
991 
992 done_free_fw_buf:
993  dma_free_coherent(&ha->pdev->dev, data_len, fw_buf, fw_dma);
994 
995 done_unmap_sg:
996  dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
997  bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
998 
999  return rval;
1000 }
1001 
1002 static int
1003 qla84xx_mgmt_cmd(struct fc_bsg_job *bsg_job)
1004 {
1005  struct Scsi_Host *host = bsg_job->shost;
1006  scsi_qla_host_t *vha = shost_priv(host);
1007  struct qla_hw_data *ha = vha->hw;
1008  struct access_chip_84xx *mn = NULL;
1009  dma_addr_t mn_dma, mgmt_dma;
1010  void *mgmt_b = NULL;
1011  int rval = 0;
1012  struct qla_bsg_a84_mgmt *ql84_mgmt;
1013  uint32_t sg_cnt;
1014  uint32_t data_len = 0;
1015  uint32_t dma_direction = DMA_NONE;
1016 
1017  if (!IS_QLA84XX(ha)) {
1018  ql_log(ql_log_warn, vha, 0x703a,
1019  "Not 84xx, exiting.\n");
1020  return -EINVAL;
1021  }
1022 
1023  ql84_mgmt = (struct qla_bsg_a84_mgmt *)((char *)bsg_job->request +
1024  sizeof(struct fc_bsg_request));
1025  if (!ql84_mgmt) {
1026  ql_log(ql_log_warn, vha, 0x703b,
1027  "MGMT header not provided, exiting.\n");
1028  return -EINVAL;
1029  }
1030 
1031  mn = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &mn_dma);
1032  if (!mn) {
1033  ql_log(ql_log_warn, vha, 0x703c,
1034  "DMA alloc failed for fw buffer.\n");
1035  return -ENOMEM;
1036  }
1037 
1038  memset(mn, 0, sizeof(struct access_chip_84xx));
1039  mn->entry_type = ACCESS_CHIP_IOCB_TYPE;
1040  mn->entry_count = 1;
1041 
1042  switch (ql84_mgmt->mgmt.cmd) {
1043  case QLA84_MGMT_READ_MEM:
1044  case QLA84_MGMT_GET_INFO:
1045  sg_cnt = dma_map_sg(&ha->pdev->dev,
1046  bsg_job->reply_payload.sg_list,
1047  bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
1048  if (!sg_cnt) {
1049  ql_log(ql_log_warn, vha, 0x703d,
1050  "dma_map_sg returned %d for reply.\n", sg_cnt);
1051  rval = -ENOMEM;
1052  goto exit_mgmt;
1053  }
1054 
1055  dma_direction = DMA_FROM_DEVICE;
1056 
1057  if (sg_cnt != bsg_job->reply_payload.sg_cnt) {
1058  ql_log(ql_log_warn, vha, 0x703e,
1059  "DMA mapping resulted in different sg counts, "
1060  "reply_sg_cnt: %x dma_reply_sg_cnt: %x.\n",
1061  bsg_job->reply_payload.sg_cnt, sg_cnt);
1062  rval = -EAGAIN;
1063  goto done_unmap_sg;
1064  }
1065 
1066  data_len = bsg_job->reply_payload.payload_len;
1067 
1068  mgmt_b = dma_alloc_coherent(&ha->pdev->dev, data_len,
1069  &mgmt_dma, GFP_KERNEL);
1070  if (!mgmt_b) {
1071  ql_log(ql_log_warn, vha, 0x703f,
1072  "DMA alloc failed for mgmt_b.\n");
1073  rval = -ENOMEM;
1074  goto done_unmap_sg;
1075  }
1076 
1077  if (ql84_mgmt->mgmt.cmd == QLA84_MGMT_READ_MEM) {
1078  mn->options = cpu_to_le16(ACO_DUMP_MEMORY);
1079  mn->parameter1 =
1080  cpu_to_le32(
1081  ql84_mgmt->mgmt.mgmtp.u.mem.start_addr);
1082 
1083  } else if (ql84_mgmt->mgmt.cmd == QLA84_MGMT_GET_INFO) {
1084  mn->options = cpu_to_le16(ACO_REQUEST_INFO);
1085  mn->parameter1 =
1086  cpu_to_le32(ql84_mgmt->mgmt.mgmtp.u.info.type);
1087 
1088  mn->parameter2 =
1089  cpu_to_le32(
1090  ql84_mgmt->mgmt.mgmtp.u.info.context);
1091  }
1092  break;
1093 
1094  case QLA84_MGMT_WRITE_MEM:
1095  sg_cnt = dma_map_sg(&ha->pdev->dev,
1096  bsg_job->request_payload.sg_list,
1097  bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
1098 
1099  if (!sg_cnt) {
1100  ql_log(ql_log_warn, vha, 0x7040,
1101  "dma_map_sg returned %d.\n", sg_cnt);
1102  rval = -ENOMEM;
1103  goto exit_mgmt;
1104  }
1105 
1106  dma_direction = DMA_TO_DEVICE;
1107 
1108  if (sg_cnt != bsg_job->request_payload.sg_cnt) {
1109  ql_log(ql_log_warn, vha, 0x7041,
1110  "DMA mapping resulted in different sg counts, "
1111  "request_sg_cnt: %x dma_request_sg_cnt: %x.\n",
1112  bsg_job->request_payload.sg_cnt, sg_cnt);
1113  rval = -EAGAIN;
1114  goto done_unmap_sg;
1115  }
1116 
1117  data_len = bsg_job->request_payload.payload_len;
1118  mgmt_b = dma_alloc_coherent(&ha->pdev->dev, data_len,
1119  &mgmt_dma, GFP_KERNEL);
1120  if (!mgmt_b) {
1121  ql_log(ql_log_warn, vha, 0x7042,
1122  "DMA alloc failed for mgmt_b.\n");
1123  rval = -ENOMEM;
1124  goto done_unmap_sg;
1125  }
1126 
1127  sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1128  bsg_job->request_payload.sg_cnt, mgmt_b, data_len);
1129 
1130  mn->options = cpu_to_le16(ACO_LOAD_MEMORY);
1131  mn->parameter1 =
1132  cpu_to_le32(ql84_mgmt->mgmt.mgmtp.u.mem.start_addr);
1133  break;
1134 
1135  case QLA84_MGMT_CHNG_CONFIG:
1136  mn->options = cpu_to_le16(ACO_CHANGE_CONFIG_PARAM);
1137  mn->parameter1 =
1138  cpu_to_le32(ql84_mgmt->mgmt.mgmtp.u.config.id);
1139 
1140  mn->parameter2 =
1141  cpu_to_le32(ql84_mgmt->mgmt.mgmtp.u.config.param0);
1142 
1143  mn->parameter3 =
1144  cpu_to_le32(ql84_mgmt->mgmt.mgmtp.u.config.param1);
1145  break;
1146 
1147  default:
1148  rval = -EIO;
1149  goto exit_mgmt;
1150  }
1151 
1152  if (ql84_mgmt->mgmt.cmd != QLA84_MGMT_CHNG_CONFIG) {
1153  mn->total_byte_cnt = cpu_to_le32(ql84_mgmt->mgmt.len);
1154  mn->dseg_count = cpu_to_le16(1);
1155  mn->dseg_address[0] = cpu_to_le32(LSD(mgmt_dma));
1156  mn->dseg_address[1] = cpu_to_le32(MSD(mgmt_dma));
1157  mn->dseg_length = cpu_to_le32(ql84_mgmt->mgmt.len);
1158  }
1159 
1160  rval = qla2x00_issue_iocb(vha, mn, mn_dma, 0);
1161 
1162  if (rval) {
1163  ql_log(ql_log_warn, vha, 0x7043,
1164  "Vendor request 84xx mgmt failed.\n");
1165 
1166  rval = 0;
1167  bsg_job->reply->result = (DID_ERROR << 16);
1168 
1169  } else {
1170  ql_dbg(ql_dbg_user, vha, 0x7044,
1171  "Vendor request 84xx mgmt completed.\n");
1172 
1173  bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1174  bsg_job->reply->result = DID_OK;
1175 
1176  if ((ql84_mgmt->mgmt.cmd == QLA84_MGMT_READ_MEM) ||
1177  (ql84_mgmt->mgmt.cmd == QLA84_MGMT_GET_INFO)) {
1178  bsg_job->reply->reply_payload_rcv_len =
1179  bsg_job->reply_payload.payload_len;
1180 
1181  sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
1182  bsg_job->reply_payload.sg_cnt, mgmt_b,
1183  data_len);
1184  }
1185  }
1186 
1187  bsg_job->job_done(bsg_job);
1188 
1189 done_unmap_sg:
1190  if (mgmt_b)
1191  dma_free_coherent(&ha->pdev->dev, data_len, mgmt_b, mgmt_dma);
1192 
1193  if (dma_direction == DMA_TO_DEVICE)
1194  dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
1195  bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
1196  else if (dma_direction == DMA_FROM_DEVICE)
1197  dma_unmap_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
1198  bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
1199 
1200 exit_mgmt:
1201  dma_pool_free(ha->s_dma_pool, mn, mn_dma);
1202 
1203  return rval;
1204 }
1205 
1206 static int
1207 qla24xx_iidma(struct fc_bsg_job *bsg_job)
1208 {
1209  struct Scsi_Host *host = bsg_job->shost;
1210  scsi_qla_host_t *vha = shost_priv(host);
1211  int rval = 0;
1212  struct qla_port_param *port_param = NULL;
1213  fc_port_t *fcport = NULL;
1214  uint16_t mb[MAILBOX_REGISTER_COUNT];
1215  uint8_t *rsp_ptr = NULL;
1216 
1217  if (!IS_IIDMA_CAPABLE(vha->hw)) {
1218  ql_log(ql_log_info, vha, 0x7046, "iiDMA not supported.\n");
1219  return -EINVAL;
1220  }
1221 
1222  port_param = (struct qla_port_param *)((char *)bsg_job->request +
1223  sizeof(struct fc_bsg_request));
1224  if (!port_param) {
1225  ql_log(ql_log_warn, vha, 0x7047,
1226  "port_param header not provided.\n");
1227  return -EINVAL;
1228  }
1229 
1230  if (port_param->fc_scsi_addr.dest_type != EXT_DEF_TYPE_WWPN) {
1231  ql_log(ql_log_warn, vha, 0x7048,
1232  "Invalid destination type.\n");
1233  return -EINVAL;
1234  }
1235 
1236  list_for_each_entry(fcport, &vha->vp_fcports, list) {
1237  if (fcport->port_type != FCT_TARGET)
1238  continue;
1239 
1240  if (memcmp(port_param->fc_scsi_addr.dest_addr.wwpn,
1241  fcport->port_name, sizeof(fcport->port_name)))
1242  continue;
1243  break;
1244  }
1245 
1246  if (!fcport) {
1247  ql_log(ql_log_warn, vha, 0x7049,
1248  "Failed to find port.\n");
1249  return -EINVAL;
1250  }
1251 
1252  if (atomic_read(&fcport->state) != FCS_ONLINE) {
1253  ql_log(ql_log_warn, vha, 0x704a,
1254  "Port is not online.\n");
1255  return -EINVAL;
1256  }
1257 
1258  if (fcport->flags & FCF_LOGIN_NEEDED) {
1259  ql_log(ql_log_warn, vha, 0x704b,
1260  "Remote port not logged in flags = 0x%x.\n", fcport->flags);
1261  return -EINVAL;
1262  }
1263 
1264  if (port_param->mode)
1265  rval = qla2x00_set_idma_speed(vha, fcport->loop_id,
1266  port_param->speed, mb);
1267  else
1268  rval = qla2x00_get_idma_speed(vha, fcport->loop_id,
1269  &port_param->speed, mb);
1270 
1271  if (rval) {
1272  ql_log(ql_log_warn, vha, 0x704c,
1273  "iIDMA cmd failed for %02x%02x%02x%02x%02x%02x%02x%02x -- "
1274  "%04x %x %04x %04x.\n", fcport->port_name[0],
1275  fcport->port_name[1], fcport->port_name[2],
1276  fcport->port_name[3], fcport->port_name[4],
1277  fcport->port_name[5], fcport->port_name[6],
1278  fcport->port_name[7], rval, fcport->fp_speed, mb[0], mb[1]);
1279  rval = 0;
1280  bsg_job->reply->result = (DID_ERROR << 16);
1281 
1282  } else {
1283  if (!port_param->mode) {
1284  bsg_job->reply_len = sizeof(struct fc_bsg_reply) +
1285  sizeof(struct qla_port_param);
1286 
1287  rsp_ptr = ((uint8_t *)bsg_job->reply) +
1288  sizeof(struct fc_bsg_reply);
1289 
1290  memcpy(rsp_ptr, port_param,
1291  sizeof(struct qla_port_param));
1292  }
1293 
1294  bsg_job->reply->result = DID_OK;
1295  }
1296 
1297  bsg_job->job_done(bsg_job);
1298  return rval;
1299 }
1300 
1301 static int
1302 qla2x00_optrom_setup(struct fc_bsg_job *bsg_job, scsi_qla_host_t *vha,
1303  uint8_t is_update)
1304 {
1305  uint32_t start = 0;
1306  int valid = 0;
1307  struct qla_hw_data *ha = vha->hw;
1308 
1309  if (unlikely(pci_channel_offline(ha->pdev)))
1310  return -EINVAL;
1311 
1312  start = bsg_job->request->rqst_data.h_vendor.vendor_cmd[1];
1313  if (start > ha->optrom_size) {
1314  ql_log(ql_log_warn, vha, 0x7055,
1315  "start %d > optrom_size %d.\n", start, ha->optrom_size);
1316  return -EINVAL;
1317  }
1318 
1319  if (ha->optrom_state != QLA_SWAITING) {
1320  ql_log(ql_log_info, vha, 0x7056,
1321  "optrom_state %d.\n", ha->optrom_state);
1322  return -EBUSY;
1323  }
1324 
1325  ha->optrom_region_start = start;
1326  ql_dbg(ql_dbg_user, vha, 0x7057, "is_update=%d.\n", is_update);
1327  if (is_update) {
1328  if (ha->optrom_size == OPTROM_SIZE_2300 && start == 0)
1329  valid = 1;
1330  else if (start == (ha->flt_region_boot * 4) ||
1331  start == (ha->flt_region_fw * 4))
1332  valid = 1;
1333  else if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha) ||
1334  IS_CNA_CAPABLE(ha) || IS_QLA2031(ha))
1335  valid = 1;
1336  if (!valid) {
1337  ql_log(ql_log_warn, vha, 0x7058,
1338  "Invalid start region 0x%x/0x%x.\n", start,
1339  bsg_job->request_payload.payload_len);
1340  return -EINVAL;
1341  }
1342 
1343  ha->optrom_region_size = start +
1344  bsg_job->request_payload.payload_len > ha->optrom_size ?
1345  ha->optrom_size - start :
1346  bsg_job->request_payload.payload_len;
1347  ha->optrom_state = QLA_SWRITING;
1348  } else {
1349  ha->optrom_region_size = start +
1350  bsg_job->reply_payload.payload_len > ha->optrom_size ?
1351  ha->optrom_size - start :
1352  bsg_job->reply_payload.payload_len;
1353  ha->optrom_state = QLA_SREADING;
1354  }
1355 
1356  ha->optrom_buffer = vmalloc(ha->optrom_region_size);
1357  if (!ha->optrom_buffer) {
1358  ql_log(ql_log_warn, vha, 0x7059,
1359  "Read: Unable to allocate memory for optrom retrieval "
1360  "(%x)\n", ha->optrom_region_size);
1361 
1362  ha->optrom_state = QLA_SWAITING;
1363  return -ENOMEM;
1364  }
1365 
1366  memset(ha->optrom_buffer, 0, ha->optrom_region_size);
1367  return 0;
1368 }
1369 
1370 static int
1371 qla2x00_read_optrom(struct fc_bsg_job *bsg_job)
1372 {
1373  struct Scsi_Host *host = bsg_job->shost;
1374  scsi_qla_host_t *vha = shost_priv(host);
1375  struct qla_hw_data *ha = vha->hw;
1376  int rval = 0;
1377 
1378  if (ha->flags.nic_core_reset_hdlr_active)
1379  return -EBUSY;
1380 
1381  rval = qla2x00_optrom_setup(bsg_job, vha, 0);
1382  if (rval)
1383  return rval;
1384 
1385  ha->isp_ops->read_optrom(vha, ha->optrom_buffer,
1386  ha->optrom_region_start, ha->optrom_region_size);
1387 
1388  sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
1389  bsg_job->reply_payload.sg_cnt, ha->optrom_buffer,
1390  ha->optrom_region_size);
1391 
1392  bsg_job->reply->reply_payload_rcv_len = ha->optrom_region_size;
1393  bsg_job->reply->result = DID_OK;
1394  vfree(ha->optrom_buffer);
1395  ha->optrom_buffer = NULL;
1396  ha->optrom_state = QLA_SWAITING;
1397  bsg_job->job_done(bsg_job);
1398  return rval;
1399 }
1400 
1401 static int
1402 qla2x00_update_optrom(struct fc_bsg_job *bsg_job)
1403 {
1404  struct Scsi_Host *host = bsg_job->shost;
1405  scsi_qla_host_t *vha = shost_priv(host);
1406  struct qla_hw_data *ha = vha->hw;
1407  int rval = 0;
1408 
1409  rval = qla2x00_optrom_setup(bsg_job, vha, 1);
1410  if (rval)
1411  return rval;
1412 
1413  /* Set the isp82xx_no_md_cap not to capture minidump */
1414  ha->flags.isp82xx_no_md_cap = 1;
1415 
1416  sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1417  bsg_job->request_payload.sg_cnt, ha->optrom_buffer,
1418  ha->optrom_region_size);
1419 
1420  ha->isp_ops->write_optrom(vha, ha->optrom_buffer,
1421  ha->optrom_region_start, ha->optrom_region_size);
1422 
1423  bsg_job->reply->result = DID_OK;
1424  vfree(ha->optrom_buffer);
1425  ha->optrom_buffer = NULL;
1426  ha->optrom_state = QLA_SWAITING;
1427  bsg_job->job_done(bsg_job);
1428  return rval;
1429 }
1430 
1431 static int
1432 qla2x00_update_fru_versions(struct fc_bsg_job *bsg_job)
1433 {
1434  struct Scsi_Host *host = bsg_job->shost;
1435  scsi_qla_host_t *vha = shost_priv(host);
1436  struct qla_hw_data *ha = vha->hw;
1437  int rval = 0;
1438  uint8_t bsg[DMA_POOL_SIZE];
1439  struct qla_image_version_list *list = (void *)bsg;
1440  struct qla_image_version *image;
1441  uint32_t count;
1442  dma_addr_t sfp_dma;
1443  void *sfp = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &sfp_dma);
1444  if (!sfp) {
1445  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1446  EXT_STATUS_NO_MEMORY;
1447  goto done;
1448  }
1449 
1450  sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1451  bsg_job->request_payload.sg_cnt, list, sizeof(bsg));
1452 
1453  image = list->version;
1454  count = list->count;
1455  while (count--) {
1456  memcpy(sfp, &image->field_info, sizeof(image->field_info));
1457  rval = qla2x00_write_sfp(vha, sfp_dma, sfp,
1458  image->field_address.device, image->field_address.offset,
1459  sizeof(image->field_info), image->field_address.option);
1460  if (rval) {
1461  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1462  EXT_STATUS_MAILBOX;
1463  goto dealloc;
1464  }
1465  image++;
1466  }
1467 
1468  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] = 0;
1469 
1470 dealloc:
1471  dma_pool_free(ha->s_dma_pool, sfp, sfp_dma);
1472 
1473 done:
1474  bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1475  bsg_job->reply->result = DID_OK << 16;
1476  bsg_job->job_done(bsg_job);
1477 
1478  return 0;
1479 }
1480 
1481 static int
1482 qla2x00_read_fru_status(struct fc_bsg_job *bsg_job)
1483 {
1484  struct Scsi_Host *host = bsg_job->shost;
1485  scsi_qla_host_t *vha = shost_priv(host);
1486  struct qla_hw_data *ha = vha->hw;
1487  int rval = 0;
1488  uint8_t bsg[DMA_POOL_SIZE];
1489  struct qla_status_reg *sr = (void *)bsg;
1490  dma_addr_t sfp_dma;
1491  uint8_t *sfp = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &sfp_dma);
1492  if (!sfp) {
1493  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1494  EXT_STATUS_NO_MEMORY;
1495  goto done;
1496  }
1497 
1498  sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1499  bsg_job->request_payload.sg_cnt, sr, sizeof(*sr));
1500 
1501  rval = qla2x00_read_sfp(vha, sfp_dma, sfp,
1502  sr->field_address.device, sr->field_address.offset,
1503  sizeof(sr->status_reg), sr->field_address.option);
1504  sr->status_reg = *sfp;
1505 
1506  if (rval) {
1507  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1508  EXT_STATUS_MAILBOX;
1509  goto dealloc;
1510  }
1511 
1512  sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
1513  bsg_job->reply_payload.sg_cnt, sr, sizeof(*sr));
1514 
1515  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] = 0;
1516 
1517 dealloc:
1518  dma_pool_free(ha->s_dma_pool, sfp, sfp_dma);
1519 
1520 done:
1521  bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1522  bsg_job->reply->reply_payload_rcv_len = sizeof(*sr);
1523  bsg_job->reply->result = DID_OK << 16;
1524  bsg_job->job_done(bsg_job);
1525 
1526  return 0;
1527 }
1528 
1529 static int
1530 qla2x00_write_fru_status(struct fc_bsg_job *bsg_job)
1531 {
1532  struct Scsi_Host *host = bsg_job->shost;
1533  scsi_qla_host_t *vha = shost_priv(host);
1534  struct qla_hw_data *ha = vha->hw;
1535  int rval = 0;
1536  uint8_t bsg[DMA_POOL_SIZE];
1537  struct qla_status_reg *sr = (void *)bsg;
1538  dma_addr_t sfp_dma;
1539  uint8_t *sfp = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &sfp_dma);
1540  if (!sfp) {
1541  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1542  EXT_STATUS_NO_MEMORY;
1543  goto done;
1544  }
1545 
1546  sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1547  bsg_job->request_payload.sg_cnt, sr, sizeof(*sr));
1548 
1549  *sfp = sr->status_reg;
1550  rval = qla2x00_write_sfp(vha, sfp_dma, sfp,
1551  sr->field_address.device, sr->field_address.offset,
1552  sizeof(sr->status_reg), sr->field_address.option);
1553 
1554  if (rval) {
1555  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1556  EXT_STATUS_MAILBOX;
1557  goto dealloc;
1558  }
1559 
1560  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] = 0;
1561 
1562 dealloc:
1563  dma_pool_free(ha->s_dma_pool, sfp, sfp_dma);
1564 
1565 done:
1566  bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1567  bsg_job->reply->result = DID_OK << 16;
1568  bsg_job->job_done(bsg_job);
1569 
1570  return 0;
1571 }
1572 
1573 static int
1574 qla2x00_write_i2c(struct fc_bsg_job *bsg_job)
1575 {
1576  struct Scsi_Host *host = bsg_job->shost;
1577  scsi_qla_host_t *vha = shost_priv(host);
1578  struct qla_hw_data *ha = vha->hw;
1579  int rval = 0;
1580  uint8_t bsg[DMA_POOL_SIZE];
1581  struct qla_i2c_access *i2c = (void *)bsg;
1582  dma_addr_t sfp_dma;
1583  uint8_t *sfp = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &sfp_dma);
1584  if (!sfp) {
1585  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1586  EXT_STATUS_NO_MEMORY;
1587  goto done;
1588  }
1589 
1590  sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1591  bsg_job->request_payload.sg_cnt, i2c, sizeof(*i2c));
1592 
1593  memcpy(sfp, i2c->buffer, i2c->length);
1594  rval = qla2x00_write_sfp(vha, sfp_dma, sfp,
1595  i2c->device, i2c->offset, i2c->length, i2c->option);
1596 
1597  if (rval) {
1598  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1599  EXT_STATUS_MAILBOX;
1600  goto dealloc;
1601  }
1602 
1603  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] = 0;
1604 
1605 dealloc:
1606  dma_pool_free(ha->s_dma_pool, sfp, sfp_dma);
1607 
1608 done:
1609  bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1610  bsg_job->reply->result = DID_OK << 16;
1611  bsg_job->job_done(bsg_job);
1612 
1613  return 0;
1614 }
1615 
1616 static int
1617 qla2x00_read_i2c(struct fc_bsg_job *bsg_job)
1618 {
1619  struct Scsi_Host *host = bsg_job->shost;
1620  scsi_qla_host_t *vha = shost_priv(host);
1621  struct qla_hw_data *ha = vha->hw;
1622  int rval = 0;
1623  uint8_t bsg[DMA_POOL_SIZE];
1624  struct qla_i2c_access *i2c = (void *)bsg;
1625  dma_addr_t sfp_dma;
1626  uint8_t *sfp = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &sfp_dma);
1627  if (!sfp) {
1628  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1629  EXT_STATUS_NO_MEMORY;
1630  goto done;
1631  }
1632 
1633  sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1634  bsg_job->request_payload.sg_cnt, i2c, sizeof(*i2c));
1635 
1636  rval = qla2x00_read_sfp(vha, sfp_dma, sfp,
1637  i2c->device, i2c->offset, i2c->length, i2c->option);
1638 
1639  if (rval) {
1640  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1641  EXT_STATUS_MAILBOX;
1642  goto dealloc;
1643  }
1644 
1645  memcpy(i2c->buffer, sfp, i2c->length);
1646  sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
1647  bsg_job->reply_payload.sg_cnt, i2c, sizeof(*i2c));
1648 
1649  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] = 0;
1650 
1651 dealloc:
1652  dma_pool_free(ha->s_dma_pool, sfp, sfp_dma);
1653 
1654 done:
1655  bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1656  bsg_job->reply->reply_payload_rcv_len = sizeof(*i2c);
1657  bsg_job->reply->result = DID_OK << 16;
1658  bsg_job->job_done(bsg_job);
1659 
1660  return 0;
1661 }
1662 
1663 static int
1664 qla24xx_process_bidir_cmd(struct fc_bsg_job *bsg_job)
1665 {
1666  struct Scsi_Host *host = bsg_job->shost;
1667  scsi_qla_host_t *vha = shost_priv(host);
1668  struct qla_hw_data *ha = vha->hw;
1669  uint16_t thread_id;
1670  uint32_t rval = EXT_STATUS_OK;
1671  uint16_t req_sg_cnt = 0;
1672  uint16_t rsp_sg_cnt = 0;
1673  uint16_t nextlid = 0;
1674  uint32_t tot_dsds;
1675  srb_t *sp = NULL;
1676  uint32_t req_data_len = 0;
1677  uint32_t rsp_data_len = 0;
1678 
1679  /* Check the type of the adapter */
1680  if (!IS_BIDI_CAPABLE(ha)) {
1681  ql_log(ql_log_warn, vha, 0x70a0,
1682  "This adapter is not supported\n");
1683  rval = EXT_STATUS_NOT_SUPPORTED;
1684  goto done;
1685  }
1686 
1687  if (test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) ||
1688  test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) ||
1689  test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
1690  rval = EXT_STATUS_BUSY;
1691  goto done;
1692  }
1693 
1694  /* Check if host is online */
1695  if (!vha->flags.online) {
1696  ql_log(ql_log_warn, vha, 0x70a1,
1697  "Host is not online\n");
1698  rval = EXT_STATUS_DEVICE_OFFLINE;
1699  goto done;
1700  }
1701 
1702  /* Check if cable is plugged in or not */
1703  if (vha->device_flags & DFLG_NO_CABLE) {
1704  ql_log(ql_log_warn, vha, 0x70a2,
1705  "Cable is unplugged...\n");
1706  rval = EXT_STATUS_INVALID_CFG;
1707  goto done;
1708  }
1709 
1710  /* Check if the switch is connected or not */
1711  if (ha->current_topology != ISP_CFG_F) {
1712  ql_log(ql_log_warn, vha, 0x70a3,
1713  "Host is not connected to the switch\n");
1714  rval = EXT_STATUS_INVALID_CFG;
1715  goto done;
1716  }
1717 
1718  /* Check if operating mode is P2P */
1719  if (ha->operating_mode != P2P) {
1720  ql_log(ql_log_warn, vha, 0x70a4,
1721  "Host is operating mode is not P2p\n");
1722  rval = EXT_STATUS_INVALID_CFG;
1723  goto done;
1724  }
1725 
1726  thread_id = bsg_job->request->rqst_data.h_vendor.vendor_cmd[1];
1727 
1728  mutex_lock(&ha->selflogin_lock);
1729  if (vha->self_login_loop_id == 0) {
1730  /* Initialize all required fields of fcport */
1731  vha->bidir_fcport.vha = vha;
1732  vha->bidir_fcport.d_id.b.al_pa = vha->d_id.b.al_pa;
1733  vha->bidir_fcport.d_id.b.area = vha->d_id.b.area;
1734  vha->bidir_fcport.d_id.b.domain = vha->d_id.b.domain;
1735  vha->bidir_fcport.loop_id = vha->loop_id;
1736 
1737  if (qla2x00_fabric_login(vha, &(vha->bidir_fcport), &nextlid)) {
1738  ql_log(ql_log_warn, vha, 0x70a7,
1739  "Failed to login port %06X for bidirectional IOCB\n",
1740  vha->bidir_fcport.d_id.b24);
1741  mutex_unlock(&ha->selflogin_lock);
1742  rval = EXT_STATUS_MAILBOX;
1743  goto done;
1744  }
1745  vha->self_login_loop_id = nextlid - 1;
1746 
1747  }
1748  /* Assign the self login loop id to fcport */
1749  mutex_unlock(&ha->selflogin_lock);
1750 
1751  vha->bidir_fcport.loop_id = vha->self_login_loop_id;
1752 
1753  req_sg_cnt = dma_map_sg(&ha->pdev->dev,
1754  bsg_job->request_payload.sg_list,
1755  bsg_job->request_payload.sg_cnt,
1756  DMA_TO_DEVICE);
1757 
1758  if (!req_sg_cnt) {
1759  rval = EXT_STATUS_NO_MEMORY;
1760  goto done;
1761  }
1762 
1763  rsp_sg_cnt = dma_map_sg(&ha->pdev->dev,
1764  bsg_job->reply_payload.sg_list, bsg_job->reply_payload.sg_cnt,
1765  DMA_FROM_DEVICE);
1766 
1767  if (!rsp_sg_cnt) {
1768  rval = EXT_STATUS_NO_MEMORY;
1769  goto done_unmap_req_sg;
1770  }
1771 
1772  if ((req_sg_cnt != bsg_job->request_payload.sg_cnt) ||
1773  (rsp_sg_cnt != bsg_job->reply_payload.sg_cnt)) {
1774  ql_dbg(ql_dbg_user, vha, 0x70a9,
1775  "Dma mapping resulted in different sg counts "
1776  "[request_sg_cnt: %x dma_request_sg_cnt: %x reply_sg_cnt: "
1777  "%x dma_reply_sg_cnt: %x]\n",
1778  bsg_job->request_payload.sg_cnt, req_sg_cnt,
1779  bsg_job->reply_payload.sg_cnt, rsp_sg_cnt);
1780  rval = EXT_STATUS_NO_MEMORY;
1781  goto done_unmap_sg;
1782  }
1783 
1784  if (req_data_len != rsp_data_len) {
1785  rval = EXT_STATUS_BUSY;
1786  ql_log(ql_log_warn, vha, 0x70aa,
1787  "req_data_len != rsp_data_len\n");
1788  goto done_unmap_sg;
1789  }
1790 
1791  req_data_len = bsg_job->request_payload.payload_len;
1792  rsp_data_len = bsg_job->reply_payload.payload_len;
1793 
1794 
1795  /* Alloc SRB structure */
1796  sp = qla2x00_get_sp(vha, &(vha->bidir_fcport), GFP_KERNEL);
1797  if (!sp) {
1798  ql_dbg(ql_dbg_user, vha, 0x70ac,
1799  "Alloc SRB structure failed\n");
1800  rval = EXT_STATUS_NO_MEMORY;
1801  goto done_unmap_sg;
1802  }
1803 
1804  /*Populate srb->ctx with bidir ctx*/
1805  sp->u.bsg_job = bsg_job;
1806  sp->free = qla2x00_bsg_sp_free;
1807  sp->type = SRB_BIDI_CMD;
1808  sp->done = qla2x00_bsg_job_done;
1809 
1810  /* Add the read and write sg count */
1811  tot_dsds = rsp_sg_cnt + req_sg_cnt;
1812 
1813  rval = qla2x00_start_bidir(sp, vha, tot_dsds);
1814  if (rval != EXT_STATUS_OK)
1815  goto done_free_srb;
1816  /* the bsg request will be completed in the interrupt handler */
1817  return rval;
1818 
1819 done_free_srb:
1820  mempool_free(sp, ha->srb_mempool);
1821 done_unmap_sg:
1822  dma_unmap_sg(&ha->pdev->dev,
1823  bsg_job->reply_payload.sg_list,
1824  bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
1825 done_unmap_req_sg:
1826  dma_unmap_sg(&ha->pdev->dev,
1827  bsg_job->request_payload.sg_list,
1828  bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
1829 done:
1830 
1831  /* Return an error vendor specific response
1832  * and complete the bsg request
1833  */
1834  bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] = rval;
1835  bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1836  bsg_job->reply->reply_payload_rcv_len = 0;
1837  bsg_job->reply->result = (DID_OK) << 16;
1838  bsg_job->job_done(bsg_job);
1839  /* Always retrun success, vendor rsp carries correct status */
1840  return 0;
1841 }
1842 
1843 static int
1844 qla2x00_process_vendor_specific(struct fc_bsg_job *bsg_job)
1845 {
1846  switch (bsg_job->request->rqst_data.h_vendor.vendor_cmd[0]) {
1847  case QL_VND_LOOPBACK:
1848  return qla2x00_process_loopback(bsg_job);
1849 
1850  case QL_VND_A84_RESET:
1851  return qla84xx_reset(bsg_job);
1852 
1853  case QL_VND_A84_UPDATE_FW:
1854  return qla84xx_updatefw(bsg_job);
1855 
1856  case QL_VND_A84_MGMT_CMD:
1857  return qla84xx_mgmt_cmd(bsg_job);
1858 
1859  case QL_VND_IIDMA:
1860  return qla24xx_iidma(bsg_job);
1861 
1862  case QL_VND_FCP_PRIO_CFG_CMD:
1863  return qla24xx_proc_fcp_prio_cfg_cmd(bsg_job);
1864 
1865  case QL_VND_READ_FLASH:
1866  return qla2x00_read_optrom(bsg_job);
1867 
1868  case QL_VND_UPDATE_FLASH:
1869  return qla2x00_update_optrom(bsg_job);
1870 
1871  case QL_VND_SET_FRU_VERSION:
1872  return qla2x00_update_fru_versions(bsg_job);
1873 
1874  case QL_VND_READ_FRU_STATUS:
1875  return qla2x00_read_fru_status(bsg_job);
1876 
1877  case QL_VND_WRITE_FRU_STATUS:
1878  return qla2x00_write_fru_status(bsg_job);
1879 
1880  case QL_VND_WRITE_I2C:
1881  return qla2x00_write_i2c(bsg_job);
1882 
1883  case QL_VND_READ_I2C:
1884  return qla2x00_read_i2c(bsg_job);
1885 
1886  case QL_VND_DIAG_IO_CMD:
1887  return qla24xx_process_bidir_cmd(bsg_job);
1888 
1889  default:
1890  bsg_job->reply->result = (DID_ERROR << 16);
1891  bsg_job->job_done(bsg_job);
1892  return -ENOSYS;
1893  }
1894 }
1895 
1896 int
1897 qla24xx_bsg_request(struct fc_bsg_job *bsg_job)
1898 {
1899  int ret = -EINVAL;
1900  struct fc_rport *rport;
1901  fc_port_t *fcport = NULL;
1902  struct Scsi_Host *host;
1903  scsi_qla_host_t *vha;
1904 
1905  /* In case no data transferred. */
1906  bsg_job->reply->reply_payload_rcv_len = 0;
1907 
1908  if (bsg_job->request->msgcode == FC_BSG_RPT_ELS) {
1909  rport = bsg_job->rport;
1910  fcport = *(fc_port_t **) rport->dd_data;
1911  host = rport_to_shost(rport);
1912  vha = shost_priv(host);
1913  } else {
1914  host = bsg_job->shost;
1915  vha = shost_priv(host);
1916  }
1917 
1918  if (qla2x00_reset_active(vha)) {
1919  ql_dbg(ql_dbg_user, vha, 0x709f,
1920  "BSG: ISP abort active/needed -- cmd=%d.\n",
1921  bsg_job->request->msgcode);
1922  bsg_job->reply->result = (DID_ERROR << 16);
1923  bsg_job->job_done(bsg_job);
1924  return -EBUSY;
1925  }
1926 
1927  ql_dbg(ql_dbg_user, vha, 0x7000,
1928  "Entered %s msgcode=0x%x.\n", __func__, bsg_job->request->msgcode);
1929 
1930  switch (bsg_job->request->msgcode) {
1931  case FC_BSG_RPT_ELS:
1932  case FC_BSG_HST_ELS_NOLOGIN:
1933  ret = qla2x00_process_els(bsg_job);
1934  break;
1935  case FC_BSG_HST_CT:
1936  ret = qla2x00_process_ct(bsg_job);
1937  break;
1938  case FC_BSG_HST_VENDOR:
1939  ret = qla2x00_process_vendor_specific(bsg_job);
1940  break;
1941  case FC_BSG_HST_ADD_RPORT:
1942  case FC_BSG_HST_DEL_RPORT:
1943  case FC_BSG_RPT_CT:
1944  default:
1945  ql_log(ql_log_warn, vha, 0x705a, "Unsupported BSG request.\n");
1946  bsg_job->reply->result = ret;
1947  break;
1948  }
1949  return ret;
1950 }
1951 
1952 int
1953 qla24xx_bsg_timeout(struct fc_bsg_job *bsg_job)
1954 {
1955  scsi_qla_host_t *vha = shost_priv(bsg_job->shost);
1956  struct qla_hw_data *ha = vha->hw;
1957  srb_t *sp;
1958  int cnt, que;
1959  unsigned long flags;
1960  struct req_que *req;
1961 
1962  /* find the bsg job from the active list of commands */
1963  spin_lock_irqsave(&ha->hardware_lock, flags);
1964  for (que = 0; que < ha->max_req_queues; que++) {
1965  req = ha->req_q_map[que];
1966  if (!req)
1967  continue;
1968 
1969  for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
1970  sp = req->outstanding_cmds[cnt];
1971  if (sp) {
1972  if (((sp->type == SRB_CT_CMD) ||
1973  (sp->type == SRB_ELS_CMD_HST))
1974  && (sp->u.bsg_job == bsg_job)) {
1975  spin_unlock_irqrestore(&ha->hardware_lock, flags);
1976  if (ha->isp_ops->abort_command(sp)) {
1977  ql_log(ql_log_warn, vha, 0x7089,
1978  "mbx abort_command "
1979  "failed.\n");
1980  bsg_job->req->errors =
1981  bsg_job->reply->result = -EIO;
1982  } else {
1983  ql_dbg(ql_dbg_user, vha, 0x708a,
1984  "mbx abort_command "
1985  "success.\n");
1986  bsg_job->req->errors =
1987  bsg_job->reply->result = 0;
1988  }
1989  spin_lock_irqsave(&ha->hardware_lock, flags);
1990  goto done;
1991  }
1992  }
1993  }
1994  }
1995  spin_unlock_irqrestore(&ha->hardware_lock, flags);
1996  ql_log(ql_log_info, vha, 0x708b, "SRB not found to abort.\n");
1997  bsg_job->req->errors = bsg_job->reply->result = -ENXIO;
1998  return 0;
1999 
2000 done:
2001  spin_unlock_irqrestore(&ha->hardware_lock, flags);
2002  if (bsg_job->request->msgcode == FC_BSG_HST_CT)
2003  kfree(sp->fcport);
2004  mempool_free(sp, ha->srb_mempool);
2005  return 0;
2006 }
Generated on Thu Jan 10 2013 14:23:31 for Linux Kernel by   doxygen 1.8.2