1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2005-2014 Brocade Communications Systems, Inc.
4 * Copyright (c) 2014- QLogic Corporation.
5 * All rights reserved
6 * www.qlogic.com
7 *
8 * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter.
9 */
10
11 /*
12 * bfad_im.c Linux driver IM module.
13 */
14
15 #include <linux/export.h>
16
17 #include "bfad_drv.h"
18 #include "bfad_im.h"
19 #include "bfa_fcs.h"
20
21 BFA_TRC_FILE(LDRV, IM);
22
23 DEFINE_IDR(bfad_im_port_index);
24 struct scsi_transport_template *bfad_im_scsi_transport_template;
25 struct scsi_transport_template *bfad_im_scsi_vport_transport_template;
26 static void bfad_im_itnim_work_handler(struct work_struct *work);
27 static enum scsi_qc_status bfad_im_queuecommand(struct Scsi_Host *h,
28 struct scsi_cmnd *cmnd);
29 static int bfad_im_sdev_init(struct scsi_device *sdev);
30 static void bfad_im_fc_rport_add(struct bfad_im_port_s *im_port,
31 struct bfad_itnim_s *itnim);
32
33 void
bfa_cb_ioim_done(void * drv,struct bfad_ioim_s * dio,enum bfi_ioim_status io_status,u8 scsi_status,int sns_len,u8 * sns_info,s32 residue)34 bfa_cb_ioim_done(void *drv, struct bfad_ioim_s *dio,
35 enum bfi_ioim_status io_status, u8 scsi_status,
36 int sns_len, u8 *sns_info, s32 residue)
37 {
38 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio;
39 struct bfad_s *bfad = drv;
40 struct bfad_itnim_data_s *itnim_data;
41 struct bfad_itnim_s *itnim;
42 u8 host_status = DID_OK;
43
44 switch (io_status) {
45 case BFI_IOIM_STS_OK:
46 bfa_trc(bfad, scsi_status);
47 scsi_set_resid(cmnd, 0);
48
49 if (sns_len > 0) {
50 bfa_trc(bfad, sns_len);
51 if (sns_len > SCSI_SENSE_BUFFERSIZE)
52 sns_len = SCSI_SENSE_BUFFERSIZE;
53 memcpy(cmnd->sense_buffer, sns_info, sns_len);
54 }
55
56 if (residue > 0) {
57 bfa_trc(bfad, residue);
58 scsi_set_resid(cmnd, residue);
59 if (!sns_len && (scsi_status == SAM_STAT_GOOD) &&
60 (scsi_bufflen(cmnd) - residue) <
61 cmnd->underflow) {
62 bfa_trc(bfad, 0);
63 host_status = DID_ERROR;
64 }
65 }
66 cmnd->result = host_status << 16 | scsi_status;
67
68 break;
69
70 case BFI_IOIM_STS_TIMEDOUT:
71 cmnd->result = DID_TIME_OUT << 16;
72 break;
73 case BFI_IOIM_STS_PATHTOV:
74 cmnd->result = DID_TRANSPORT_DISRUPTED << 16;
75 break;
76 default:
77 cmnd->result = DID_ERROR << 16;
78 }
79
80 /* Unmap DMA, if host is NULL, it means a scsi passthru cmd */
81 if (cmnd->device->host != NULL)
82 scsi_dma_unmap(cmnd);
83
84 cmnd->host_scribble = NULL;
85 bfa_trc(bfad, cmnd->result);
86
87 itnim_data = cmnd->device->hostdata;
88 if (itnim_data) {
89 itnim = itnim_data->itnim;
90 if (!cmnd->result && itnim &&
91 (bfa_lun_queue_depth > cmnd->device->queue_depth)) {
92 /* Queue depth adjustment for good status completion */
93 bfad_ramp_up_qdepth(itnim, cmnd->device);
94 } else if (cmnd->result == SAM_STAT_TASK_SET_FULL && itnim) {
95 /* qfull handling */
96 bfad_handle_qfull(itnim, cmnd->device);
97 }
98 }
99
100 scsi_done(cmnd);
101 }
102
103 void
bfa_cb_ioim_good_comp(void * drv,struct bfad_ioim_s * dio)104 bfa_cb_ioim_good_comp(void *drv, struct bfad_ioim_s *dio)
105 {
106 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio;
107 struct bfad_itnim_data_s *itnim_data;
108 struct bfad_itnim_s *itnim;
109
110 cmnd->result = DID_OK << 16 | SAM_STAT_GOOD;
111
112 /* Unmap DMA, if host is NULL, it means a scsi passthru cmd */
113 if (cmnd->device->host != NULL)
114 scsi_dma_unmap(cmnd);
115
116 cmnd->host_scribble = NULL;
117
118 /* Queue depth adjustment */
119 if (bfa_lun_queue_depth > cmnd->device->queue_depth) {
120 itnim_data = cmnd->device->hostdata;
121 if (itnim_data) {
122 itnim = itnim_data->itnim;
123 if (itnim)
124 bfad_ramp_up_qdepth(itnim, cmnd->device);
125 }
126 }
127
128 scsi_done(cmnd);
129 }
130
131 void
bfa_cb_ioim_abort(void * drv,struct bfad_ioim_s * dio)132 bfa_cb_ioim_abort(void *drv, struct bfad_ioim_s *dio)
133 {
134 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio;
135 struct bfad_s *bfad = drv;
136
137 cmnd->result = DID_ERROR << 16;
138
139 /* Unmap DMA, if host is NULL, it means a scsi passthru cmd */
140 if (cmnd->device->host != NULL)
141 scsi_dma_unmap(cmnd);
142
143 bfa_trc(bfad, cmnd->result);
144 cmnd->host_scribble = NULL;
145 }
146
147 void
bfa_cb_tskim_done(void * bfad,struct bfad_tskim_s * dtsk,enum bfi_tskim_status tsk_status)148 bfa_cb_tskim_done(void *bfad, struct bfad_tskim_s *dtsk,
149 enum bfi_tskim_status tsk_status)
150 {
151 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dtsk;
152 wait_queue_head_t *wq;
153
154 bfad_priv(cmnd)->status |= tsk_status << 1;
155 set_bit(IO_DONE_BIT, &bfad_priv(cmnd)->status);
156 wq = bfad_priv(cmnd)->wq;
157 bfad_priv(cmnd)->wq = NULL;
158
159 if (wq)
160 wake_up(wq);
161 }
162
163 /*
164 * Scsi_Host_template SCSI host template
165 */
166 /*
167 * Scsi_Host template entry, returns BFAD PCI info.
168 */
169 static const char *
bfad_im_info(struct Scsi_Host * shost)170 bfad_im_info(struct Scsi_Host *shost)
171 {
172 static char bfa_buf[256];
173 struct bfad_im_port_s *im_port =
174 (struct bfad_im_port_s *) shost->hostdata[0];
175 struct bfad_s *bfad = im_port->bfad;
176
177 memset(bfa_buf, 0, sizeof(bfa_buf));
178 snprintf(bfa_buf, sizeof(bfa_buf),
179 "QLogic BR-series FC/FCOE Adapter, hwpath: %s driver: %s",
180 bfad->pci_name, BFAD_DRIVER_VERSION);
181
182 return bfa_buf;
183 }
184
185 /*
186 * Scsi_Host template entry, aborts the specified SCSI command.
187 *
188 * Returns: SUCCESS or FAILED.
189 */
190 static int
bfad_im_abort_handler(struct scsi_cmnd * cmnd)191 bfad_im_abort_handler(struct scsi_cmnd *cmnd)
192 {
193 struct Scsi_Host *shost = cmnd->device->host;
194 struct bfad_im_port_s *im_port =
195 (struct bfad_im_port_s *) shost->hostdata[0];
196 struct bfad_s *bfad = im_port->bfad;
197 struct bfa_ioim_s *hal_io;
198 unsigned long flags;
199 u32 timeout;
200 int rc = FAILED;
201
202 spin_lock_irqsave(&bfad->bfad_lock, flags);
203 hal_io = (struct bfa_ioim_s *) cmnd->host_scribble;
204 if (!hal_io) {
205 /* IO has been completed, return success */
206 rc = SUCCESS;
207 goto out;
208 }
209 if (hal_io->dio != (struct bfad_ioim_s *) cmnd) {
210 rc = FAILED;
211 goto out;
212 }
213
214 bfa_trc(bfad, hal_io->iotag);
215 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
216 "scsi%d: abort cmnd %p iotag %x\n",
217 im_port->shost->host_no, cmnd, hal_io->iotag);
218 (void) bfa_ioim_abort(hal_io);
219 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
220
221 /* Need to wait until the command get aborted */
222 timeout = 10;
223 while ((struct bfa_ioim_s *) cmnd->host_scribble == hal_io) {
224 set_current_state(TASK_UNINTERRUPTIBLE);
225 schedule_timeout(timeout);
226 if (timeout < 4 * HZ)
227 timeout *= 2;
228 }
229
230 scsi_done(cmnd);
231 bfa_trc(bfad, hal_io->iotag);
232 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
233 "scsi%d: complete abort 0x%p iotag 0x%x\n",
234 im_port->shost->host_no, cmnd, hal_io->iotag);
235 return SUCCESS;
236 out:
237 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
238 return rc;
239 }
240
241 static bfa_status_t
bfad_im_target_reset_send(struct bfad_s * bfad,struct scsi_cmnd * cmnd,struct bfad_itnim_s * itnim)242 bfad_im_target_reset_send(struct bfad_s *bfad, struct scsi_cmnd *cmnd,
243 struct bfad_itnim_s *itnim)
244 {
245 struct bfa_tskim_s *tskim;
246 struct bfa_itnim_s *bfa_itnim;
247 bfa_status_t rc = BFA_STATUS_OK;
248 struct scsi_lun scsilun;
249
250 tskim = bfa_tskim_alloc(&bfad->bfa, (struct bfad_tskim_s *) cmnd);
251 if (!tskim) {
252 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
253 "target reset, fail to allocate tskim\n");
254 rc = BFA_STATUS_FAILED;
255 goto out;
256 }
257
258 /*
259 * Set host_scribble to NULL to avoid aborting a task command if
260 * happens.
261 */
262 cmnd->host_scribble = NULL;
263 bfad_priv(cmnd)->status = 0;
264 bfa_itnim = bfa_fcs_itnim_get_halitn(&itnim->fcs_itnim);
265 /*
266 * bfa_itnim can be NULL if the port gets disconnected and the bfa
267 * and fcs layers have cleaned up their nexus with the targets and
268 * the same has not been cleaned up by the shim
269 */
270 if (bfa_itnim == NULL) {
271 bfa_tskim_free(tskim);
272 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
273 "target reset, bfa_itnim is NULL\n");
274 rc = BFA_STATUS_FAILED;
275 goto out;
276 }
277
278 memset(&scsilun, 0, sizeof(scsilun));
279 bfa_tskim_start(tskim, bfa_itnim, scsilun,
280 FCP_TM_TARGET_RESET, BFAD_TARGET_RESET_TMO);
281 out:
282 return rc;
283 }
284
285 /*
286 * Scsi_Host template entry, resets a LUN and abort its all commands.
287 *
288 * Returns: SUCCESS or FAILED.
289 *
290 */
291 static int
bfad_im_reset_lun_handler(struct scsi_cmnd * cmnd)292 bfad_im_reset_lun_handler(struct scsi_cmnd *cmnd)
293 {
294 struct Scsi_Host *shost = cmnd->device->host;
295 struct bfad_im_port_s *im_port =
296 (struct bfad_im_port_s *) shost->hostdata[0];
297 struct bfad_itnim_data_s *itnim_data = cmnd->device->hostdata;
298 struct bfad_s *bfad = im_port->bfad;
299 struct bfa_tskim_s *tskim;
300 struct bfad_itnim_s *itnim;
301 struct bfa_itnim_s *bfa_itnim;
302 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
303 int rc = SUCCESS;
304 unsigned long flags;
305 enum bfi_tskim_status task_status;
306 struct scsi_lun scsilun;
307
308 spin_lock_irqsave(&bfad->bfad_lock, flags);
309 itnim = itnim_data->itnim;
310 if (!itnim) {
311 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
312 rc = FAILED;
313 goto out;
314 }
315
316 tskim = bfa_tskim_alloc(&bfad->bfa, (struct bfad_tskim_s *) cmnd);
317 if (!tskim) {
318 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
319 "LUN reset, fail to allocate tskim");
320 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
321 rc = FAILED;
322 goto out;
323 }
324
325 /*
326 * Set host_scribble to NULL to avoid aborting a task command
327 * if happens.
328 */
329 cmnd->host_scribble = NULL;
330 bfad_priv(cmnd)->wq = &wq;
331 bfad_priv(cmnd)->status = 0;
332 bfa_itnim = bfa_fcs_itnim_get_halitn(&itnim->fcs_itnim);
333 /*
334 * bfa_itnim can be NULL if the port gets disconnected and the bfa
335 * and fcs layers have cleaned up their nexus with the targets and
336 * the same has not been cleaned up by the shim
337 */
338 if (bfa_itnim == NULL) {
339 bfa_tskim_free(tskim);
340 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
341 "lun reset, bfa_itnim is NULL\n");
342 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
343 rc = FAILED;
344 goto out;
345 }
346 int_to_scsilun(cmnd->device->lun, &scsilun);
347 bfa_tskim_start(tskim, bfa_itnim, scsilun,
348 FCP_TM_LUN_RESET, BFAD_LUN_RESET_TMO);
349 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
350
351 wait_event(wq, test_bit(IO_DONE_BIT, &bfad_priv(cmnd)->status));
352
353 task_status = bfad_priv(cmnd)->status >> 1;
354 if (task_status != BFI_TSKIM_STS_OK) {
355 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
356 "LUN reset failure, status: %d\n", task_status);
357 rc = FAILED;
358 }
359
360 out:
361 return rc;
362 }
363
364 /*
365 * Scsi_Host template entry, resets the target and abort all commands.
366 */
367 static int
bfad_im_reset_target_handler(struct scsi_cmnd * cmnd)368 bfad_im_reset_target_handler(struct scsi_cmnd *cmnd)
369 {
370 struct Scsi_Host *shost = cmnd->device->host;
371 struct scsi_target *starget = scsi_target(cmnd->device);
372 struct bfad_im_port_s *im_port =
373 (struct bfad_im_port_s *) shost->hostdata[0];
374 struct bfad_s *bfad = im_port->bfad;
375 struct bfad_itnim_s *itnim;
376 unsigned long flags;
377 u32 rc, rtn = FAILED;
378 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
379 enum bfi_tskim_status task_status;
380
381 spin_lock_irqsave(&bfad->bfad_lock, flags);
382 itnim = bfad_get_itnim(im_port, starget->id);
383 if (itnim) {
384 bfad_priv(cmnd)->wq = &wq;
385 rc = bfad_im_target_reset_send(bfad, cmnd, itnim);
386 if (rc == BFA_STATUS_OK) {
387 /* wait target reset to complete */
388 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
389 wait_event(wq, test_bit(IO_DONE_BIT,
390 &bfad_priv(cmnd)->status));
391 spin_lock_irqsave(&bfad->bfad_lock, flags);
392
393 task_status = bfad_priv(cmnd)->status >> 1;
394 if (task_status != BFI_TSKIM_STS_OK)
395 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
396 "target reset failure,"
397 " status: %d\n", task_status);
398 else
399 rtn = SUCCESS;
400 }
401 }
402 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
403
404 return rtn;
405 }
406
407 /*
408 * Scsi_Host template entry sdev_destroy.
409 */
410 static void
bfad_im_sdev_destroy(struct scsi_device * sdev)411 bfad_im_sdev_destroy(struct scsi_device *sdev)
412 {
413 sdev->hostdata = NULL;
414 return;
415 }
416
417 /*
418 * BFA FCS itnim callbacks
419 */
420
421 /*
422 * BFA FCS itnim alloc callback, after successful PRLI
423 * Context: Interrupt
424 */
425 int
bfa_fcb_itnim_alloc(struct bfad_s * bfad,struct bfa_fcs_itnim_s ** itnim,struct bfad_itnim_s ** itnim_drv)426 bfa_fcb_itnim_alloc(struct bfad_s *bfad, struct bfa_fcs_itnim_s **itnim,
427 struct bfad_itnim_s **itnim_drv)
428 {
429 *itnim_drv = kzalloc_obj(struct bfad_itnim_s, GFP_ATOMIC);
430 if (*itnim_drv == NULL)
431 return -ENOMEM;
432
433 (*itnim_drv)->im = bfad->im;
434 *itnim = &(*itnim_drv)->fcs_itnim;
435 (*itnim_drv)->state = ITNIM_STATE_NONE;
436
437 /*
438 * Initiaze the itnim_work
439 */
440 INIT_WORK(&(*itnim_drv)->itnim_work, bfad_im_itnim_work_handler);
441 bfad->bfad_flags |= BFAD_RPORT_ONLINE;
442 return 0;
443 }
444
445 /*
446 * BFA FCS itnim free callback.
447 * Context: Interrupt. bfad_lock is held
448 */
449 void
bfa_fcb_itnim_free(struct bfad_s * bfad,struct bfad_itnim_s * itnim_drv)450 bfa_fcb_itnim_free(struct bfad_s *bfad, struct bfad_itnim_s *itnim_drv)
451 {
452 struct bfad_port_s *port;
453 wwn_t wwpn;
454 u32 fcid;
455 char wwpn_str[32], fcid_str[16];
456 struct bfad_im_s *im = itnim_drv->im;
457
458 /* online to free state transtion should not happen */
459 WARN_ON(itnim_drv->state == ITNIM_STATE_ONLINE);
460
461 itnim_drv->queue_work = 1;
462 /* offline request is not yet done, use the same request to free */
463 if (itnim_drv->state == ITNIM_STATE_OFFLINE_PENDING)
464 itnim_drv->queue_work = 0;
465
466 itnim_drv->state = ITNIM_STATE_FREE;
467 port = bfa_fcs_itnim_get_drvport(&itnim_drv->fcs_itnim);
468 itnim_drv->im_port = port->im_port;
469 wwpn = bfa_fcs_itnim_get_pwwn(&itnim_drv->fcs_itnim);
470 fcid = bfa_fcs_itnim_get_fcid(&itnim_drv->fcs_itnim);
471 wwn2str(wwpn_str, wwpn);
472 fcid2str(fcid_str, fcid);
473 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
474 "ITNIM FREE scsi%d: FCID: %s WWPN: %s\n",
475 port->im_port->shost->host_no,
476 fcid_str, wwpn_str);
477
478 /* ITNIM processing */
479 if (itnim_drv->queue_work)
480 queue_work(im->drv_workq, &itnim_drv->itnim_work);
481 }
482
483 /*
484 * BFA FCS itnim online callback.
485 * Context: Interrupt. bfad_lock is held
486 */
487 void
bfa_fcb_itnim_online(struct bfad_itnim_s * itnim_drv)488 bfa_fcb_itnim_online(struct bfad_itnim_s *itnim_drv)
489 {
490 struct bfad_port_s *port;
491 struct bfad_im_s *im = itnim_drv->im;
492
493 itnim_drv->bfa_itnim = bfa_fcs_itnim_get_halitn(&itnim_drv->fcs_itnim);
494 port = bfa_fcs_itnim_get_drvport(&itnim_drv->fcs_itnim);
495 itnim_drv->state = ITNIM_STATE_ONLINE;
496 itnim_drv->queue_work = 1;
497 itnim_drv->im_port = port->im_port;
498
499 /* ITNIM processing */
500 if (itnim_drv->queue_work)
501 queue_work(im->drv_workq, &itnim_drv->itnim_work);
502 }
503
504 /*
505 * BFA FCS itnim offline callback.
506 * Context: Interrupt. bfad_lock is held
507 */
508 void
bfa_fcb_itnim_offline(struct bfad_itnim_s * itnim_drv)509 bfa_fcb_itnim_offline(struct bfad_itnim_s *itnim_drv)
510 {
511 struct bfad_port_s *port;
512 struct bfad_s *bfad;
513 struct bfad_im_s *im = itnim_drv->im;
514
515 port = bfa_fcs_itnim_get_drvport(&itnim_drv->fcs_itnim);
516 bfad = port->bfad;
517 if ((bfad->pport.flags & BFAD_PORT_DELETE) ||
518 (port->flags & BFAD_PORT_DELETE)) {
519 itnim_drv->state = ITNIM_STATE_OFFLINE;
520 return;
521 }
522 itnim_drv->im_port = port->im_port;
523 itnim_drv->state = ITNIM_STATE_OFFLINE_PENDING;
524 itnim_drv->queue_work = 1;
525
526 /* ITNIM processing */
527 if (itnim_drv->queue_work)
528 queue_work(im->drv_workq, &itnim_drv->itnim_work);
529 }
530
531 /*
532 * Allocate a Scsi_Host for a port.
533 */
534 int
bfad_im_scsi_host_alloc(struct bfad_s * bfad,struct bfad_im_port_s * im_port,struct device * dev)535 bfad_im_scsi_host_alloc(struct bfad_s *bfad, struct bfad_im_port_s *im_port,
536 struct device *dev)
537 {
538 struct bfad_im_port_pointer *im_portp;
539 int error;
540
541 mutex_lock(&bfad_mutex);
542 error = idr_alloc(&bfad_im_port_index, im_port, 0, 0, GFP_KERNEL);
543 if (error < 0) {
544 mutex_unlock(&bfad_mutex);
545 printk(KERN_WARNING "idr_alloc failure\n");
546 goto out;
547 }
548 im_port->idr_id = error;
549 mutex_unlock(&bfad_mutex);
550
551 im_port->shost = bfad_scsi_host_alloc(im_port, bfad);
552 if (!im_port->shost) {
553 error = 1;
554 goto out_free_idr;
555 }
556
557 im_portp = shost_priv(im_port->shost);
558 im_portp->p = im_port;
559 im_port->shost->unique_id = im_port->idr_id;
560 im_port->shost->this_id = -1;
561 im_port->shost->max_id = MAX_FCP_TARGET;
562 im_port->shost->max_lun = MAX_FCP_LUN;
563 im_port->shost->max_cmd_len = 16;
564 im_port->shost->can_queue = bfad->cfg_data.ioc_queue_depth;
565 if (im_port->port->pvb_type == BFAD_PORT_PHYS_BASE)
566 im_port->shost->transportt = bfad_im_scsi_transport_template;
567 else
568 im_port->shost->transportt =
569 bfad_im_scsi_vport_transport_template;
570
571 error = scsi_add_host_with_dma(im_port->shost, dev, &bfad->pcidev->dev);
572 if (error) {
573 printk(KERN_WARNING "scsi_add_host failure %d\n", error);
574 goto out_fc_rel;
575 }
576
577 return 0;
578
579 out_fc_rel:
580 scsi_host_put(im_port->shost);
581 im_port->shost = NULL;
582 out_free_idr:
583 mutex_lock(&bfad_mutex);
584 idr_remove(&bfad_im_port_index, im_port->idr_id);
585 mutex_unlock(&bfad_mutex);
586 out:
587 return error;
588 }
589
590 void
bfad_im_scsi_host_free(struct bfad_s * bfad,struct bfad_im_port_s * im_port)591 bfad_im_scsi_host_free(struct bfad_s *bfad, struct bfad_im_port_s *im_port)
592 {
593 bfa_trc(bfad, bfad->inst_no);
594 BFA_LOG(KERN_INFO, bfad, bfa_log_level, "Free scsi%d\n",
595 im_port->shost->host_no);
596
597 fc_remove_host(im_port->shost);
598
599 scsi_remove_host(im_port->shost);
600 scsi_host_put(im_port->shost);
601
602 mutex_lock(&bfad_mutex);
603 idr_remove(&bfad_im_port_index, im_port->idr_id);
604 mutex_unlock(&bfad_mutex);
605 }
606
607 static void
bfad_im_port_delete_handler(struct work_struct * work)608 bfad_im_port_delete_handler(struct work_struct *work)
609 {
610 struct bfad_im_port_s *im_port =
611 container_of(work, struct bfad_im_port_s, port_delete_work);
612
613 if (im_port->port->pvb_type != BFAD_PORT_PHYS_BASE) {
614 im_port->flags |= BFAD_PORT_DELETE;
615 fc_vport_terminate(im_port->fc_vport);
616 }
617 }
618
619 bfa_status_t
bfad_im_port_new(struct bfad_s * bfad,struct bfad_port_s * port)620 bfad_im_port_new(struct bfad_s *bfad, struct bfad_port_s *port)
621 {
622 int rc = BFA_STATUS_OK;
623 struct bfad_im_port_s *im_port;
624
625 im_port = kzalloc_obj(struct bfad_im_port_s, GFP_ATOMIC);
626 if (im_port == NULL) {
627 rc = BFA_STATUS_ENOMEM;
628 goto ext;
629 }
630 port->im_port = im_port;
631 im_port->port = port;
632 im_port->bfad = bfad;
633
634 INIT_WORK(&im_port->port_delete_work, bfad_im_port_delete_handler);
635 INIT_LIST_HEAD(&im_port->itnim_mapped_list);
636 INIT_LIST_HEAD(&im_port->binding_list);
637
638 ext:
639 return rc;
640 }
641
642 void
bfad_im_port_delete(struct bfad_s * bfad,struct bfad_port_s * port)643 bfad_im_port_delete(struct bfad_s *bfad, struct bfad_port_s *port)
644 {
645 struct bfad_im_port_s *im_port = port->im_port;
646
647 queue_work(bfad->im->drv_workq,
648 &im_port->port_delete_work);
649 }
650
651 void
bfad_im_port_clean(struct bfad_im_port_s * im_port)652 bfad_im_port_clean(struct bfad_im_port_s *im_port)
653 {
654 struct bfad_fcp_binding *bp, *bp_new;
655 unsigned long flags;
656 struct bfad_s *bfad = im_port->bfad;
657
658 spin_lock_irqsave(&bfad->bfad_lock, flags);
659 list_for_each_entry_safe(bp, bp_new, &im_port->binding_list,
660 list_entry) {
661 list_del(&bp->list_entry);
662 kfree(bp);
663 }
664
665 /* the itnim_mapped_list must be empty at this time */
666 WARN_ON(!list_empty(&im_port->itnim_mapped_list));
667
668 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
669 }
670
bfad_aen_im_notify_handler(struct work_struct * work)671 static void bfad_aen_im_notify_handler(struct work_struct *work)
672 {
673 struct bfad_im_s *im =
674 container_of(work, struct bfad_im_s, aen_im_notify_work);
675 struct bfa_aen_entry_s *aen_entry;
676 struct bfad_s *bfad = im->bfad;
677 struct Scsi_Host *shost = bfad->pport.im_port->shost;
678 void *event_data;
679 unsigned long flags;
680
681 while (!list_empty(&bfad->active_aen_q)) {
682 spin_lock_irqsave(&bfad->bfad_aen_spinlock, flags);
683 bfa_q_deq(&bfad->active_aen_q, &aen_entry);
684 spin_unlock_irqrestore(&bfad->bfad_aen_spinlock, flags);
685 event_data = (char *)aen_entry + sizeof(struct list_head);
686 fc_host_post_vendor_event(shost, fc_get_event_number(),
687 sizeof(struct bfa_aen_entry_s) -
688 sizeof(struct list_head),
689 (char *)event_data, BFAD_NL_VENDOR_ID);
690 spin_lock_irqsave(&bfad->bfad_aen_spinlock, flags);
691 list_add_tail(&aen_entry->qe, &bfad->free_aen_q);
692 spin_unlock_irqrestore(&bfad->bfad_aen_spinlock, flags);
693 }
694 }
695
696 bfa_status_t
bfad_im_probe(struct bfad_s * bfad)697 bfad_im_probe(struct bfad_s *bfad)
698 {
699 struct bfad_im_s *im;
700
701 im = kzalloc_obj(struct bfad_im_s);
702 if (im == NULL)
703 return BFA_STATUS_ENOMEM;
704
705 bfad->im = im;
706 im->bfad = bfad;
707
708 if (bfad_thread_workq(bfad) != BFA_STATUS_OK) {
709 kfree(im);
710 bfad->im = NULL;
711 return BFA_STATUS_FAILED;
712 }
713
714 INIT_WORK(&im->aen_im_notify_work, bfad_aen_im_notify_handler);
715 return BFA_STATUS_OK;
716 }
717
718 void
bfad_im_probe_undo(struct bfad_s * bfad)719 bfad_im_probe_undo(struct bfad_s *bfad)
720 {
721 if (bfad->im) {
722 bfad_destroy_workq(bfad->im);
723 kfree(bfad->im);
724 bfad->im = NULL;
725 }
726 }
727
728 struct Scsi_Host *
bfad_scsi_host_alloc(struct bfad_im_port_s * im_port,struct bfad_s * bfad)729 bfad_scsi_host_alloc(struct bfad_im_port_s *im_port, struct bfad_s *bfad)
730 {
731 struct scsi_host_template *sht;
732
733 if (im_port->port->pvb_type == BFAD_PORT_PHYS_BASE)
734 sht = &bfad_im_scsi_host_template;
735 else
736 sht = &bfad_im_vport_template;
737
738 if (max_xfer_size != BFAD_MAX_SECTORS >> 1)
739 sht->max_sectors = max_xfer_size << 1;
740
741 sht->sg_tablesize = bfad->cfg_data.io_max_sge;
742
743 return scsi_host_alloc(sht, sizeof(struct bfad_im_port_pointer));
744 }
745
746 void
bfad_scsi_host_free(struct bfad_s * bfad,struct bfad_im_port_s * im_port)747 bfad_scsi_host_free(struct bfad_s *bfad, struct bfad_im_port_s *im_port)
748 {
749 if (!(im_port->flags & BFAD_PORT_DELETE))
750 flush_workqueue(bfad->im->drv_workq);
751 bfad_im_scsi_host_free(im_port->bfad, im_port);
752 bfad_im_port_clean(im_port);
753 kfree(im_port);
754 }
755
756 void
bfad_destroy_workq(struct bfad_im_s * im)757 bfad_destroy_workq(struct bfad_im_s *im)
758 {
759 if (im && im->drv_workq) {
760 destroy_workqueue(im->drv_workq);
761 im->drv_workq = NULL;
762 }
763 }
764
765 bfa_status_t
bfad_thread_workq(struct bfad_s * bfad)766 bfad_thread_workq(struct bfad_s *bfad)
767 {
768 struct bfad_im_s *im = bfad->im;
769
770 bfa_trc(bfad, 0);
771 im->drv_workq = alloc_ordered_workqueue("bfad_wq_%d", WQ_MEM_RECLAIM,
772 bfad->inst_no);
773 if (!im->drv_workq)
774 return BFA_STATUS_FAILED;
775
776 return BFA_STATUS_OK;
777 }
778
779 /*
780 * Scsi_Host template entry.
781 *
782 * Description:
783 * OS entry point to adjust the queue_depths on a per-device basis.
784 * Called once per device during the bus scan.
785 * Return non-zero if fails.
786 */
787 static int
bfad_im_sdev_configure(struct scsi_device * sdev,struct queue_limits * lim)788 bfad_im_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)
789 {
790 scsi_change_queue_depth(sdev, bfa_lun_queue_depth);
791 return 0;
792 }
793
794 struct scsi_host_template bfad_im_scsi_host_template = {
795 .module = THIS_MODULE,
796 .name = BFAD_DRIVER_NAME,
797 .info = bfad_im_info,
798 .queuecommand = bfad_im_queuecommand,
799 .cmd_size = sizeof(struct bfad_cmd_priv),
800 .eh_timed_out = fc_eh_timed_out,
801 .eh_abort_handler = bfad_im_abort_handler,
802 .eh_device_reset_handler = bfad_im_reset_lun_handler,
803 .eh_target_reset_handler = bfad_im_reset_target_handler,
804
805 .sdev_init = bfad_im_sdev_init,
806 .sdev_configure = bfad_im_sdev_configure,
807 .sdev_destroy = bfad_im_sdev_destroy,
808
809 .this_id = -1,
810 .sg_tablesize = BFAD_IO_MAX_SGE,
811 .cmd_per_lun = 3,
812 .shost_groups = bfad_im_host_groups,
813 .max_sectors = BFAD_MAX_SECTORS,
814 .vendor_id = BFA_PCI_VENDOR_ID_BROCADE,
815 };
816
817 struct scsi_host_template bfad_im_vport_template = {
818 .module = THIS_MODULE,
819 .name = BFAD_DRIVER_NAME,
820 .info = bfad_im_info,
821 .queuecommand = bfad_im_queuecommand,
822 .cmd_size = sizeof(struct bfad_cmd_priv),
823 .eh_timed_out = fc_eh_timed_out,
824 .eh_abort_handler = bfad_im_abort_handler,
825 .eh_device_reset_handler = bfad_im_reset_lun_handler,
826 .eh_target_reset_handler = bfad_im_reset_target_handler,
827
828 .sdev_init = bfad_im_sdev_init,
829 .sdev_configure = bfad_im_sdev_configure,
830 .sdev_destroy = bfad_im_sdev_destroy,
831
832 .this_id = -1,
833 .sg_tablesize = BFAD_IO_MAX_SGE,
834 .cmd_per_lun = 3,
835 .shost_groups = bfad_im_vport_groups,
836 .max_sectors = BFAD_MAX_SECTORS,
837 };
838
839 bfa_status_t
bfad_im_module_init(void)840 bfad_im_module_init(void)
841 {
842 bfad_im_scsi_transport_template =
843 fc_attach_transport(&bfad_im_fc_function_template);
844 if (!bfad_im_scsi_transport_template)
845 return BFA_STATUS_ENOMEM;
846
847 bfad_im_scsi_vport_transport_template =
848 fc_attach_transport(&bfad_im_vport_fc_function_template);
849 if (!bfad_im_scsi_vport_transport_template) {
850 fc_release_transport(bfad_im_scsi_transport_template);
851 return BFA_STATUS_ENOMEM;
852 }
853
854 return BFA_STATUS_OK;
855 }
856
857 void
bfad_im_module_exit(void)858 bfad_im_module_exit(void)
859 {
860 if (bfad_im_scsi_transport_template)
861 fc_release_transport(bfad_im_scsi_transport_template);
862
863 if (bfad_im_scsi_vport_transport_template)
864 fc_release_transport(bfad_im_scsi_vport_transport_template);
865
866 idr_destroy(&bfad_im_port_index);
867 }
868
869 void
bfad_ramp_up_qdepth(struct bfad_itnim_s * itnim,struct scsi_device * sdev)870 bfad_ramp_up_qdepth(struct bfad_itnim_s *itnim, struct scsi_device *sdev)
871 {
872 struct scsi_device *tmp_sdev;
873
874 if (((jiffies - itnim->last_ramp_up_time) >
875 BFA_QUEUE_FULL_RAMP_UP_TIME * HZ) &&
876 ((jiffies - itnim->last_queue_full_time) >
877 BFA_QUEUE_FULL_RAMP_UP_TIME * HZ)) {
878 shost_for_each_device(tmp_sdev, sdev->host) {
879 if (bfa_lun_queue_depth > tmp_sdev->queue_depth) {
880 if (tmp_sdev->id != sdev->id)
881 continue;
882 scsi_change_queue_depth(tmp_sdev,
883 tmp_sdev->queue_depth + 1);
884
885 itnim->last_ramp_up_time = jiffies;
886 }
887 }
888 }
889 }
890
891 void
bfad_handle_qfull(struct bfad_itnim_s * itnim,struct scsi_device * sdev)892 bfad_handle_qfull(struct bfad_itnim_s *itnim, struct scsi_device *sdev)
893 {
894 struct scsi_device *tmp_sdev;
895
896 itnim->last_queue_full_time = jiffies;
897
898 shost_for_each_device(tmp_sdev, sdev->host) {
899 if (tmp_sdev->id != sdev->id)
900 continue;
901 scsi_track_queue_full(tmp_sdev, tmp_sdev->queue_depth - 1);
902 }
903 }
904
905 struct bfad_itnim_s *
bfad_get_itnim(struct bfad_im_port_s * im_port,int id)906 bfad_get_itnim(struct bfad_im_port_s *im_port, int id)
907 {
908 struct bfad_itnim_s *itnim = NULL;
909
910 /* Search the mapped list for this target ID */
911 list_for_each_entry(itnim, &im_port->itnim_mapped_list, list_entry) {
912 if (id == itnim->scsi_tgt_id)
913 return itnim;
914 }
915
916 return NULL;
917 }
918
919 /*
920 * Function is invoked from the SCSI Host Template sdev_init() entry point.
921 * Has the logic to query the LUN Mask database to check if this LUN needs to
922 * be made visible to the SCSI mid-layer or not.
923 *
924 * Returns BFA_STATUS_OK if this LUN needs to be added to the OS stack.
925 * Returns -ENXIO to notify SCSI mid-layer to not add this LUN to the OS stack.
926 */
927 static int
bfad_im_check_if_make_lun_visible(struct scsi_device * sdev,struct fc_rport * rport)928 bfad_im_check_if_make_lun_visible(struct scsi_device *sdev,
929 struct fc_rport *rport)
930 {
931 struct bfad_itnim_data_s *itnim_data =
932 (struct bfad_itnim_data_s *) rport->dd_data;
933 struct bfa_s *bfa = itnim_data->itnim->bfa_itnim->bfa;
934 struct bfa_rport_s *bfa_rport = itnim_data->itnim->bfa_itnim->rport;
935 struct bfa_lun_mask_s *lun_list = bfa_get_lun_mask_list(bfa);
936 int i = 0, ret = -ENXIO;
937
938 for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
939 if (lun_list[i].state == BFA_IOIM_LUN_MASK_ACTIVE &&
940 scsilun_to_int(&lun_list[i].lun) == sdev->lun &&
941 lun_list[i].rp_tag == bfa_rport->rport_tag &&
942 lun_list[i].lp_tag == (u8)bfa_rport->rport_info.lp_tag) {
943 ret = BFA_STATUS_OK;
944 break;
945 }
946 }
947 return ret;
948 }
949
950 /*
951 * Scsi_Host template entry sdev_init
952 */
953 static int
bfad_im_sdev_init(struct scsi_device * sdev)954 bfad_im_sdev_init(struct scsi_device *sdev)
955 {
956 struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
957 struct bfad_itnim_data_s *itnim_data;
958 struct bfa_s *bfa;
959
960 if (!rport || fc_remote_port_chkready(rport))
961 return -ENXIO;
962
963 itnim_data = (struct bfad_itnim_data_s *) rport->dd_data;
964 bfa = itnim_data->itnim->bfa_itnim->bfa;
965
966 if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_ENABLED) {
967 /*
968 * We should not mask LUN 0 - since this will translate
969 * to no LUN / TARGET for SCSI ml resulting no scan.
970 */
971 if (sdev->lun == 0) {
972 sdev->sdev_bflags |= BLIST_NOREPORTLUN |
973 BLIST_SPARSELUN;
974 goto done;
975 }
976
977 /*
978 * Query LUN Mask configuration - to expose this LUN
979 * to the SCSI mid-layer or to mask it.
980 */
981 if (bfad_im_check_if_make_lun_visible(sdev, rport) !=
982 BFA_STATUS_OK)
983 return -ENXIO;
984 }
985 done:
986 sdev->hostdata = rport->dd_data;
987
988 return 0;
989 }
990
991 u32
bfad_im_supported_speeds(struct bfa_s * bfa)992 bfad_im_supported_speeds(struct bfa_s *bfa)
993 {
994 struct bfa_ioc_attr_s *ioc_attr;
995 u32 supported_speed = 0;
996
997 ioc_attr = kzalloc_obj(struct bfa_ioc_attr_s);
998 if (!ioc_attr)
999 return 0;
1000
1001 bfa_ioc_get_attr(&bfa->ioc, ioc_attr);
1002 if (ioc_attr->adapter_attr.max_speed == BFA_PORT_SPEED_16GBPS)
1003 supported_speed |= FC_PORTSPEED_16GBIT | FC_PORTSPEED_8GBIT |
1004 FC_PORTSPEED_4GBIT | FC_PORTSPEED_2GBIT;
1005 else if (ioc_attr->adapter_attr.max_speed == BFA_PORT_SPEED_8GBPS) {
1006 if (ioc_attr->adapter_attr.is_mezz) {
1007 supported_speed |= FC_PORTSPEED_8GBIT |
1008 FC_PORTSPEED_4GBIT |
1009 FC_PORTSPEED_2GBIT | FC_PORTSPEED_1GBIT;
1010 } else {
1011 supported_speed |= FC_PORTSPEED_8GBIT |
1012 FC_PORTSPEED_4GBIT |
1013 FC_PORTSPEED_2GBIT;
1014 }
1015 } else if (ioc_attr->adapter_attr.max_speed == BFA_PORT_SPEED_4GBPS) {
1016 supported_speed |= FC_PORTSPEED_4GBIT | FC_PORTSPEED_2GBIT |
1017 FC_PORTSPEED_1GBIT;
1018 } else if (ioc_attr->adapter_attr.max_speed == BFA_PORT_SPEED_10GBPS) {
1019 supported_speed |= FC_PORTSPEED_10GBIT;
1020 }
1021 kfree(ioc_attr);
1022 return supported_speed;
1023 }
1024
1025 void
bfad_fc_host_init(struct bfad_im_port_s * im_port)1026 bfad_fc_host_init(struct bfad_im_port_s *im_port)
1027 {
1028 struct Scsi_Host *host = im_port->shost;
1029 struct bfad_s *bfad = im_port->bfad;
1030 struct bfad_port_s *port = im_port->port;
1031 char symname[BFA_SYMNAME_MAXLEN];
1032 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
1033
1034 fc_host_node_name(host) =
1035 cpu_to_be64((bfa_fcs_lport_get_nwwn(port->fcs_port)));
1036 fc_host_port_name(host) =
1037 cpu_to_be64((bfa_fcs_lport_get_pwwn(port->fcs_port)));
1038 fc_host_max_npiv_vports(host) = bfa_lps_get_max_vport(&bfad->bfa);
1039
1040 fc_host_supported_classes(host) = FC_COS_CLASS3;
1041
1042 memset(fc_host_supported_fc4s(host), 0,
1043 sizeof(fc_host_supported_fc4s(host)));
1044 if (supported_fc4s & BFA_LPORT_ROLE_FCP_IM)
1045 /* For FCP type 0x08 */
1046 fc_host_supported_fc4s(host)[2] = 1;
1047 /* For fibre channel services type 0x20 */
1048 fc_host_supported_fc4s(host)[7] = 1;
1049
1050 strscpy(symname, bfad->bfa_fcs.fabric.bport.port_cfg.sym_name.symname,
1051 BFA_SYMNAME_MAXLEN);
1052 sprintf(fc_host_symbolic_name(host), "%s", symname);
1053
1054 fc_host_supported_speeds(host) = bfad_im_supported_speeds(&bfad->bfa);
1055 fc_host_maxframe_size(host) = fcport->cfg.maxfrsize;
1056 }
1057
1058 static void
bfad_im_fc_rport_add(struct bfad_im_port_s * im_port,struct bfad_itnim_s * itnim)1059 bfad_im_fc_rport_add(struct bfad_im_port_s *im_port, struct bfad_itnim_s *itnim)
1060 {
1061 struct fc_rport_identifiers rport_ids;
1062 struct fc_rport *fc_rport;
1063 struct bfad_itnim_data_s *itnim_data;
1064
1065 rport_ids.node_name =
1066 cpu_to_be64(bfa_fcs_itnim_get_nwwn(&itnim->fcs_itnim));
1067 rport_ids.port_name =
1068 cpu_to_be64(bfa_fcs_itnim_get_pwwn(&itnim->fcs_itnim));
1069 rport_ids.port_id =
1070 bfa_hton3b(bfa_fcs_itnim_get_fcid(&itnim->fcs_itnim));
1071 rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
1072
1073 itnim->fc_rport = fc_rport =
1074 fc_remote_port_add(im_port->shost, 0, &rport_ids);
1075
1076 if (!fc_rport)
1077 return;
1078
1079 fc_rport->maxframe_size =
1080 bfa_fcs_itnim_get_maxfrsize(&itnim->fcs_itnim);
1081 fc_rport->supported_classes = bfa_fcs_itnim_get_cos(&itnim->fcs_itnim);
1082
1083 itnim_data = fc_rport->dd_data;
1084 itnim_data->itnim = itnim;
1085
1086 rport_ids.roles |= FC_RPORT_ROLE_FCP_TARGET;
1087
1088 if (rport_ids.roles != FC_RPORT_ROLE_UNKNOWN)
1089 fc_remote_port_rolechg(fc_rport, rport_ids.roles);
1090
1091 if ((fc_rport->scsi_target_id != -1)
1092 && (fc_rport->scsi_target_id < MAX_FCP_TARGET))
1093 itnim->scsi_tgt_id = fc_rport->scsi_target_id;
1094
1095 itnim->channel = fc_rport->channel;
1096
1097 return;
1098 }
1099
1100 /*
1101 * Work queue handler using FC transport service
1102 * Context: kernel
1103 */
1104 static void
bfad_im_itnim_work_handler(struct work_struct * work)1105 bfad_im_itnim_work_handler(struct work_struct *work)
1106 {
1107 struct bfad_itnim_s *itnim = container_of(work, struct bfad_itnim_s,
1108 itnim_work);
1109 struct bfad_im_s *im = itnim->im;
1110 struct bfad_s *bfad = im->bfad;
1111 struct bfad_im_port_s *im_port;
1112 unsigned long flags;
1113 struct fc_rport *fc_rport;
1114 wwn_t wwpn;
1115 u32 fcid;
1116 char wwpn_str[32], fcid_str[16];
1117
1118 spin_lock_irqsave(&bfad->bfad_lock, flags);
1119 im_port = itnim->im_port;
1120 bfa_trc(bfad, itnim->state);
1121 switch (itnim->state) {
1122 case ITNIM_STATE_ONLINE:
1123 if (!itnim->fc_rport) {
1124 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1125 bfad_im_fc_rport_add(im_port, itnim);
1126 spin_lock_irqsave(&bfad->bfad_lock, flags);
1127 wwpn = bfa_fcs_itnim_get_pwwn(&itnim->fcs_itnim);
1128 fcid = bfa_fcs_itnim_get_fcid(&itnim->fcs_itnim);
1129 wwn2str(wwpn_str, wwpn);
1130 fcid2str(fcid_str, fcid);
1131 list_add_tail(&itnim->list_entry,
1132 &im_port->itnim_mapped_list);
1133 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
1134 "ITNIM ONLINE Target: %d:0:%d "
1135 "FCID: %s WWPN: %s\n",
1136 im_port->shost->host_no,
1137 itnim->scsi_tgt_id,
1138 fcid_str, wwpn_str);
1139 } else {
1140 printk(KERN_WARNING
1141 "%s: itnim %llx is already in online state\n",
1142 __func__,
1143 bfa_fcs_itnim_get_pwwn(&itnim->fcs_itnim));
1144 }
1145
1146 break;
1147 case ITNIM_STATE_OFFLINE_PENDING:
1148 itnim->state = ITNIM_STATE_OFFLINE;
1149 if (itnim->fc_rport) {
1150 fc_rport = itnim->fc_rport;
1151 ((struct bfad_itnim_data_s *)
1152 fc_rport->dd_data)->itnim = NULL;
1153 itnim->fc_rport = NULL;
1154 if (!(im_port->port->flags & BFAD_PORT_DELETE)) {
1155 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1156 fc_rport->dev_loss_tmo =
1157 bfa_fcpim_path_tov_get(&bfad->bfa) + 1;
1158 fc_remote_port_delete(fc_rport);
1159 spin_lock_irqsave(&bfad->bfad_lock, flags);
1160 }
1161 wwpn = bfa_fcs_itnim_get_pwwn(&itnim->fcs_itnim);
1162 fcid = bfa_fcs_itnim_get_fcid(&itnim->fcs_itnim);
1163 wwn2str(wwpn_str, wwpn);
1164 fcid2str(fcid_str, fcid);
1165 list_del(&itnim->list_entry);
1166 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
1167 "ITNIM OFFLINE Target: %d:0:%d "
1168 "FCID: %s WWPN: %s\n",
1169 im_port->shost->host_no,
1170 itnim->scsi_tgt_id,
1171 fcid_str, wwpn_str);
1172 }
1173 break;
1174 case ITNIM_STATE_FREE:
1175 if (itnim->fc_rport) {
1176 fc_rport = itnim->fc_rport;
1177 ((struct bfad_itnim_data_s *)
1178 fc_rport->dd_data)->itnim = NULL;
1179 itnim->fc_rport = NULL;
1180 if (!(im_port->port->flags & BFAD_PORT_DELETE)) {
1181 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1182 fc_rport->dev_loss_tmo =
1183 bfa_fcpim_path_tov_get(&bfad->bfa) + 1;
1184 fc_remote_port_delete(fc_rport);
1185 spin_lock_irqsave(&bfad->bfad_lock, flags);
1186 }
1187 list_del(&itnim->list_entry);
1188 }
1189
1190 kfree(itnim);
1191 break;
1192 default:
1193 WARN_ON(1);
1194 break;
1195 }
1196
1197 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1198 }
1199
1200 /*
1201 * Scsi_Host template entry, queue a SCSI command to the BFAD.
1202 */
bfad_im_queuecommand_lck(struct scsi_cmnd * cmnd)1203 static enum scsi_qc_status bfad_im_queuecommand_lck(struct scsi_cmnd *cmnd)
1204 {
1205 void (*done)(struct scsi_cmnd *) = scsi_done;
1206 struct bfad_im_port_s *im_port =
1207 (struct bfad_im_port_s *) cmnd->device->host->hostdata[0];
1208 struct bfad_s *bfad = im_port->bfad;
1209 struct bfad_itnim_data_s *itnim_data = cmnd->device->hostdata;
1210 struct bfad_itnim_s *itnim;
1211 struct bfa_ioim_s *hal_io;
1212 unsigned long flags;
1213 int rc;
1214 int sg_cnt = 0;
1215 struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
1216
1217 rc = fc_remote_port_chkready(rport);
1218 if (rc) {
1219 cmnd->result = rc;
1220 done(cmnd);
1221 return 0;
1222 }
1223
1224 if (bfad->bfad_flags & BFAD_EEH_BUSY) {
1225 if (bfad->bfad_flags & BFAD_EEH_PCI_CHANNEL_IO_PERM_FAILURE)
1226 cmnd->result = DID_NO_CONNECT << 16;
1227 else
1228 cmnd->result = DID_REQUEUE << 16;
1229 done(cmnd);
1230 return 0;
1231 }
1232
1233 sg_cnt = scsi_dma_map(cmnd);
1234 if (sg_cnt < 0)
1235 return SCSI_MLQUEUE_HOST_BUSY;
1236
1237 spin_lock_irqsave(&bfad->bfad_lock, flags);
1238 if (!(bfad->bfad_flags & BFAD_HAL_START_DONE)) {
1239 printk(KERN_WARNING
1240 "bfad%d, queuecommand %p %x failed, BFA stopped\n",
1241 bfad->inst_no, cmnd, cmnd->cmnd[0]);
1242 cmnd->result = DID_NO_CONNECT << 16;
1243 goto out_fail_cmd;
1244 }
1245
1246
1247 itnim = itnim_data->itnim;
1248 if (!itnim) {
1249 cmnd->result = DID_IMM_RETRY << 16;
1250 goto out_fail_cmd;
1251 }
1252
1253 hal_io = bfa_ioim_alloc(&bfad->bfa, (struct bfad_ioim_s *) cmnd,
1254 itnim->bfa_itnim, sg_cnt);
1255 if (!hal_io) {
1256 printk(KERN_WARNING "hal_io failure\n");
1257 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1258 scsi_dma_unmap(cmnd);
1259 return SCSI_MLQUEUE_HOST_BUSY;
1260 }
1261
1262 cmnd->host_scribble = (char *)hal_io;
1263 bfa_ioim_start(hal_io);
1264 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1265
1266 return 0;
1267
1268 out_fail_cmd:
1269 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
1270 scsi_dma_unmap(cmnd);
1271 if (done)
1272 done(cmnd);
1273
1274 return 0;
1275 }
1276
DEF_SCSI_QCMD(bfad_im_queuecommand)1277 static DEF_SCSI_QCMD(bfad_im_queuecommand)
1278
1279 void
1280 bfad_rport_online_wait(struct bfad_s *bfad)
1281 {
1282 int i;
1283 int rport_delay = 10;
1284
1285 for (i = 0; !(bfad->bfad_flags & BFAD_PORT_ONLINE)
1286 && i < bfa_linkup_delay; i++) {
1287 set_current_state(TASK_UNINTERRUPTIBLE);
1288 schedule_timeout(HZ);
1289 }
1290
1291 if (bfad->bfad_flags & BFAD_PORT_ONLINE) {
1292 rport_delay = rport_delay < bfa_linkup_delay ?
1293 rport_delay : bfa_linkup_delay;
1294 for (i = 0; !(bfad->bfad_flags & BFAD_RPORT_ONLINE)
1295 && i < rport_delay; i++) {
1296 set_current_state(TASK_UNINTERRUPTIBLE);
1297 schedule_timeout(HZ);
1298 }
1299
1300 if (rport_delay > 0 && (bfad->bfad_flags & BFAD_RPORT_ONLINE)) {
1301 set_current_state(TASK_UNINTERRUPTIBLE);
1302 schedule_timeout(rport_delay * HZ);
1303 }
1304 }
1305 }
1306
1307 int
bfad_get_linkup_delay(struct bfad_s * bfad)1308 bfad_get_linkup_delay(struct bfad_s *bfad)
1309 {
1310 u8 nwwns = 0;
1311 wwn_t wwns[BFA_PREBOOT_BOOTLUN_MAX];
1312 int linkup_delay;
1313
1314 /*
1315 * Querying for the boot target port wwns
1316 * -- read from boot information in flash.
1317 * If nwwns > 0 => boot over SAN and set linkup_delay = 30
1318 * else => local boot machine set linkup_delay = 0
1319 */
1320
1321 bfa_iocfc_get_bootwwns(&bfad->bfa, &nwwns, wwns);
1322
1323 if (nwwns > 0)
1324 /* If Boot over SAN set linkup_delay = 30sec */
1325 linkup_delay = 30;
1326 else
1327 /* If local boot; no linkup_delay */
1328 linkup_delay = 0;
1329
1330 return linkup_delay;
1331 }
1332