projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[libata] build fix after cdb_len move
[deliverable/linux.git] / drivers / scsi / qla2xxx / qla_rscn.c
1 /*
2 * QLogic Fibre Channel HBA Driver
3 * Copyright (c) 2003-2005 QLogic Corporation
4 *
5 * See LICENSE.qla2xxx for copyright and licensing details.
6 */
7 #include "qla_def.h"
8
9 #include <scsi/scsi_transport_fc.h>
10
11 /**
12 * IO descriptor handle definitions.
13 *
14 * Signature form:
15 *
16 * |31------28|27-------------------12|11-------0|
17 * | Type | Rolling Signature | Index |
18 * |----------|-----------------------|----------|
19 *
20 **/
21
22 #define HDL_TYPE_SCSI 0
23 #define HDL_TYPE_ASYNC_IOCB 0x0A
24
25 #define HDL_INDEX_BITS 12
26 #define HDL_ITER_BITS 16
27 #define HDL_TYPE_BITS 4
28
29 #define HDL_INDEX_MASK ((1UL << HDL_INDEX_BITS) - 1)
30 #define HDL_ITER_MASK ((1UL << HDL_ITER_BITS) - 1)
31 #define HDL_TYPE_MASK ((1UL << HDL_TYPE_BITS) - 1)
32
33 #define HDL_INDEX_SHIFT 0
34 #define HDL_ITER_SHIFT (HDL_INDEX_SHIFT + HDL_INDEX_BITS)
35 #define HDL_TYPE_SHIFT (HDL_ITER_SHIFT + HDL_ITER_BITS)
36
37 /* Local Prototypes. */
38 static inline uint32_t qla2x00_to_handle(uint16_t, uint16_t, uint16_t);
39 static inline uint16_t qla2x00_handle_to_idx(uint32_t);
40 static inline uint32_t qla2x00_iodesc_to_handle(struct io_descriptor *);
41 static inline struct io_descriptor *qla2x00_handle_to_iodesc(scsi_qla_host_t *,
42 uint32_t);
43
44 static inline struct io_descriptor *qla2x00_alloc_iodesc(scsi_qla_host_t *);
45 static inline void qla2x00_free_iodesc(struct io_descriptor *);
46 static inline void qla2x00_init_io_descriptors(scsi_qla_host_t *);
47
48 static void qla2x00_iodesc_timeout(unsigned long);
49 static inline void qla2x00_add_iodesc_timer(struct io_descriptor *);
50 static inline void qla2x00_remove_iodesc_timer(struct io_descriptor *);
51
52 static inline void qla2x00_update_login_fcport(scsi_qla_host_t *,
53 struct mbx_entry *, fc_port_t *);
54
55 static int qla2x00_send_abort_iocb(scsi_qla_host_t *, struct io_descriptor *,
56 uint32_t, int);
57 static int qla2x00_send_abort_iocb_cb(scsi_qla_host_t *, struct io_descriptor *,
58 struct mbx_entry *);
59
60 static int qla2x00_send_adisc_iocb(scsi_qla_host_t *, struct io_descriptor *,
61 int);
62 static int qla2x00_send_adisc_iocb_cb(scsi_qla_host_t *, struct io_descriptor *,
63 struct mbx_entry *);
64
65 static int qla2x00_send_logout_iocb(scsi_qla_host_t *, struct io_descriptor *,
66 int);
67 static int qla2x00_send_logout_iocb_cb(scsi_qla_host_t *,
68 struct io_descriptor *, struct mbx_entry *);
69
70 static int qla2x00_send_login_iocb(scsi_qla_host_t *, struct io_descriptor *,
71 port_id_t *, int);
72 static int qla2x00_send_login_iocb_cb(scsi_qla_host_t *, struct io_descriptor *,
73 struct mbx_entry *);
74
75 /**
76 * Mailbox IOCB callback array.
77 **/
78 static int (*iocb_function_cb_list[LAST_IOCB_CB])
79 (scsi_qla_host_t *, struct io_descriptor *, struct mbx_entry *) = {
80
81 qla2x00_send_abort_iocb_cb,
82 qla2x00_send_adisc_iocb_cb,
83 qla2x00_send_logout_iocb_cb,
84 qla2x00_send_login_iocb_cb,
85 };
86
87
88 /**
89 * Generic IO descriptor handle routines.
90 **/
91
92 /**
93 * qla2x00_to_handle() - Create a descriptor handle.
94 * @type: descriptor type
95 * @iter: descriptor rolling signature
96 * @idx: index to the descriptor array
97 *
98 * Returns a composite handle based in the @type, @iter, and @idx.
99 */
100 static inline uint32_t
101 qla2x00_to_handle(uint16_t type, uint16_t iter, uint16_t idx)
102 {
103 return ((uint32_t)(((uint32_t)type << HDL_TYPE_SHIFT) |
104 ((uint32_t)iter << HDL_ITER_SHIFT) |
105 ((uint32_t)idx << HDL_INDEX_SHIFT)));
106 }
107
108 /**
109 * qla2x00_handle_to_idx() - Retrive the index for a given handle.
110 * @handle: descriptor handle
111 *
112 * Returns the index specified by the @handle.
113 */
114 static inline uint16_t
115 qla2x00_handle_to_idx(uint32_t handle)
116 {
117 return ((uint16_t)(((handle) >> HDL_INDEX_SHIFT) & HDL_INDEX_MASK));
118 }
119
120 /**
121 * qla2x00_iodesc_to_handle() - Convert an IO descriptor to a unique handle.
122 * @iodesc: io descriptor
123 *
124 * Returns a unique handle for @iodesc.
125 */
126 static inline uint32_t
127 qla2x00_iodesc_to_handle(struct io_descriptor *iodesc)
128 {
129 uint32_t handle;
130
131 handle = qla2x00_to_handle(HDL_TYPE_ASYNC_IOCB,
132 ++iodesc->ha->iodesc_signature, iodesc->idx);
133 iodesc->signature = handle;
134
135 return (handle);
136 }
137
138 /**
139 * qla2x00_handle_to_iodesc() - Retrieve an IO descriptor given a unique handle.
140 * @ha: HA context
141 * @handle: handle to io descriptor
142 *
143 * Returns a pointer to the io descriptor, or NULL, if the io descriptor does
144 * not exist or the io descriptors signature does not @handle.
145 */
146 static inline struct io_descriptor *
147 qla2x00_handle_to_iodesc(scsi_qla_host_t *ha, uint32_t handle)
148 {
149 uint16_t idx;
150 struct io_descriptor *iodesc;
151
152 idx = qla2x00_handle_to_idx(handle);
153 iodesc = &ha->io_descriptors[idx];
154 if (iodesc)
155 if (iodesc->signature != handle)
156 iodesc = NULL;
157
158 return (iodesc);
159 }
160
161
162 /**
163 * IO descriptor allocation routines.
164 **/
165
166 /**
167 * qla2x00_alloc_iodesc() - Allocate an IO descriptor from the pool.
168 * @ha: HA context
169 *
170 * Returns a pointer to the allocated io descriptor, or NULL, if none available.
171 */
172 static inline struct io_descriptor *
173 qla2x00_alloc_iodesc(scsi_qla_host_t *ha)
174 {
175 uint16_t iter;
176 struct io_descriptor *iodesc;
177
178 iodesc = NULL;
179 for (iter = 0; iter < MAX_IO_DESCRIPTORS; iter++) {
180 if (ha->io_descriptors[iter].used)
181 continue;
182
183 iodesc = &ha->io_descriptors[iter];
184 iodesc->used = 1;
185 iodesc->idx = iter;
186 init_timer(&iodesc->timer);
187 iodesc->ha = ha;
188 iodesc->signature = qla2x00_iodesc_to_handle(iodesc);
189 break;
190 }
191
192 return (iodesc);
193 }
194
195 /**
196 * qla2x00_free_iodesc() - Free an IO descriptor.
197 * @iodesc: io descriptor
198 *
199 * NOTE: The io descriptors timer *must* be stopped before it can be free'd.
200 */
201 static inline void
202 qla2x00_free_iodesc(struct io_descriptor *iodesc)
203 {
204 iodesc->used = 0;
205 iodesc->signature = 0;
206 }
207
208 /**
209 * qla2x00_remove_iodesc_timer() - Remove an active timer from an IO descriptor.
210 * @iodesc: io descriptor
211 */
212 static inline void
213 qla2x00_remove_iodesc_timer(struct io_descriptor *iodesc)
214 {
215 if (iodesc->timer.function != NULL) {
216 del_timer_sync(&iodesc->timer);
217 iodesc->timer.data = (unsigned long) NULL;
218 iodesc->timer.function = NULL;
219 }
220 }
221
222 /**
223 * qla2x00_init_io_descriptors() - Initialize the pool of IO descriptors.
224 * @ha: HA context
225 */
226 static inline void
227 qla2x00_init_io_descriptors(scsi_qla_host_t *ha)
228 {
229 uint16_t iter;
230
231 for (iter = 0; iter < MAX_IO_DESCRIPTORS; iter++) {
232 if (!ha->io_descriptors[iter].used)
233 continue;
234
235 qla2x00_remove_iodesc_timer(&ha->io_descriptors[iter]);
236 qla2x00_free_iodesc(&ha->io_descriptors[iter]);
237 }
238 }
239
240
241 /**
242 * IO descriptor timer routines.
243 **/
244
245 /**
246 * qla2x00_iodesc_timeout() - Timeout IO descriptor handler.
247 * @data: io descriptor
248 */
249 static void
250 qla2x00_iodesc_timeout(unsigned long data)
251 {
252 struct io_descriptor *iodesc;
253
254 iodesc = (struct io_descriptor *) data;
255
256 DEBUG14(printk("scsi(%ld): IO descriptor timeout, index=%x "
257 "signature=%08x, scheduling ISP abort.\n", iodesc->ha->host_no,
258 iodesc->idx, iodesc->signature));
259
260 qla2x00_free_iodesc(iodesc);
261
262 qla_printk(KERN_WARNING, iodesc->ha,
263 "IO descriptor timeout. Scheduling ISP abort.\n");
264 set_bit(ISP_ABORT_NEEDED, &iodesc->ha->dpc_flags);
265 }
266
267 /**
268 * qla2x00_add_iodesc_timer() - Add and start a timer for an IO descriptor.
269 * @iodesc: io descriptor
270 *
271 * NOTE:
272 * The firmware shall timeout an outstanding mailbox IOCB in 2 * R_A_TOV (in
273 * tenths of a second) after it hits the wire. But, if there are any request
274 * resource contraints (i.e. during heavy I/O), exchanges can be held off for
275 * at most R_A_TOV. Therefore, the driver will wait 4 * R_A_TOV before
276 * scheduling a recovery (big hammer).
277 */
278 static inline void
279 qla2x00_add_iodesc_timer(struct io_descriptor *iodesc)
280 {
281 unsigned long timeout;
282
283 timeout = (iodesc->ha->r_a_tov * 4) / 10;
284 init_timer(&iodesc->timer);
285 iodesc->timer.data = (unsigned long) iodesc;
286 iodesc->timer.expires = jiffies + (timeout * HZ);
287 iodesc->timer.function =
288 (void (*) (unsigned long)) qla2x00_iodesc_timeout;
289 add_timer(&iodesc->timer);
290 }
291
292 /**
293 * IO descriptor support routines.
294 **/
295
296 /**
297 * qla2x00_update_login_fcport() - Update fcport data after login processing.
298 * @ha: HA context
299 * @mbxstat: Mailbox command status IOCB
300 * @fcport: port to update
301 */
302 static inline void
303 qla2x00_update_login_fcport(scsi_qla_host_t *ha, struct mbx_entry *mbxstat,
304 fc_port_t *fcport)
305 {
306 if (le16_to_cpu(mbxstat->mb1) & BIT_0) {
307 fcport->port_type = FCT_INITIATOR;
308 } else {
309 fcport->port_type = FCT_TARGET;
310 if (le16_to_cpu(mbxstat->mb1) & BIT_1) {
311 fcport->flags |= FCF_TAPE_PRESENT;
312 }
313 }
314 fcport->login_retry = 0;
315 fcport->port_login_retry_count = ha->port_down_retry_count *
316 PORT_RETRY_TIME;
317 atomic_set(&fcport->port_down_timer, ha->port_down_retry_count *
318 PORT_RETRY_TIME);
319 fcport->flags |= FCF_FABRIC_DEVICE;
320 fcport->flags &= ~FCF_FAILOVER_NEEDED;
321 fcport->iodesc_idx_sent = IODESC_INVALID_INDEX;
322 atomic_set(&fcport->state, FCS_ONLINE);
323 schedule_work(&fcport->rport_add_work);
324 }
325
326
327 /**
328 * Mailbox IOCB commands.
329 **/
330
331 /**
332 * qla2x00_get_mbx_iocb_entry() - Retrieve an IOCB from the request queue.
333 * @ha: HA context
334 * @handle: handle to io descriptor
335 *
336 * Returns a pointer to the reqest entry, or NULL, if none were available.
337 */
338 static inline struct mbx_entry *
339 qla2x00_get_mbx_iocb_entry(scsi_qla_host_t *ha, uint32_t handle)
340 {
341 uint16_t cnt;
342 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
343 struct mbx_entry *mbxentry;
344
345 mbxentry = NULL;
346
347 if (ha->req_q_cnt < 3) {
348 cnt = qla2x00_debounce_register(ISP_REQ_Q_OUT(ha, reg));
349 if (ha->req_ring_index < cnt)
350 ha->req_q_cnt = cnt - ha->req_ring_index;
351 else
352 ha->req_q_cnt = ha->request_q_length -
353 (ha->req_ring_index - cnt);
354 }
355 if (ha->req_q_cnt >= 3) {
356 mbxentry = (struct mbx_entry *)ha->request_ring_ptr;
357
358 memset(mbxentry, 0, sizeof(struct mbx_entry));
359 mbxentry->entry_type = MBX_IOCB_TYPE;
360 mbxentry->entry_count = 1;
361 mbxentry->sys_define1 = SOURCE_ASYNC_IOCB;
362 mbxentry->handle = handle;
363 }
364 return (mbxentry);
365 }
366
367 /**
368 * qla2x00_send_abort_iocb() - Issue an abort IOCB to the firmware.
369 * @ha: HA context
370 * @iodesc: io descriptor
371 * @handle_to_abort: firmware handle to abort
372 * @ha_locked: is function called with the hardware lock
373 *
374 * Returns QLA_SUCCESS if the IOCB was issued.
375 */
376 static int
377 qla2x00_send_abort_iocb(scsi_qla_host_t *ha, struct io_descriptor *iodesc,
378 uint32_t handle_to_abort, int ha_locked)
379 {
380 unsigned long flags = 0;
381 struct mbx_entry *mbxentry;
382
383 /* Send marker if required. */
384 if (qla2x00_issue_marker(ha, ha_locked) != QLA_SUCCESS)
385 return (QLA_FUNCTION_FAILED);
386
387 if (!ha_locked)
388 spin_lock_irqsave(&ha->hardware_lock, flags);
389
390 /* Build abort mailbox IOCB. */
391 mbxentry = qla2x00_get_mbx_iocb_entry(ha, iodesc->signature);
392 if (mbxentry == NULL) {
393 if (!ha_locked)
394 spin_unlock_irqrestore(&ha->hardware_lock, flags);
395
396 return (QLA_FUNCTION_FAILED);
397 }
398 mbxentry->mb0 = __constant_cpu_to_le16(MBC_ABORT_COMMAND);
399 mbxentry->mb1 = mbxentry->loop_id.extended =
400 cpu_to_le16(iodesc->remote_fcport->loop_id);
401 mbxentry->mb2 = LSW(handle_to_abort);
402 mbxentry->mb3 = MSW(handle_to_abort);
403 wmb();
404
405 qla2x00_add_iodesc_timer(iodesc);
406
407 /* Issue command to ISP. */
408 qla2x00_isp_cmd(ha);
409
410 if (!ha_locked)
411 spin_unlock_irqrestore(&ha->hardware_lock, flags);
412
413 DEBUG14(printk("scsi(%ld): Sending Abort IOCB (%08x) to [%x], aborting "
414 "%08x.\n", ha->host_no, iodesc->signature,
415 iodesc->remote_fcport->loop_id, handle_to_abort));
416
417 return (QLA_SUCCESS);
418 }
419
420 /**
421 * qla2x00_send_abort_iocb_cb() - Abort IOCB callback.
422 * @ha: HA context
423 * @iodesc: io descriptor
424 * @mbxstat: mailbox status IOCB
425 *
426 * Returns QLA_SUCCESS if @iodesc can be freed by the caller, else, @iodesc
427 * will be used for a retry.
428 */
429 static int
430 qla2x00_send_abort_iocb_cb(scsi_qla_host_t *ha, struct io_descriptor *iodesc,
431 struct mbx_entry *mbxstat)
432 {
433 DEBUG14(printk("scsi(%ld): Abort IOCB -- sent to [%x/%02x%02x%02x], "
434 "status=%x mb0=%x.\n", ha->host_no, iodesc->remote_fcport->loop_id,
435 iodesc->d_id.b.domain, iodesc->d_id.b.area, iodesc->d_id.b.al_pa,
436 le16_to_cpu(mbxstat->status), le16_to_cpu(mbxstat->mb0)));
437
438 return (QLA_SUCCESS);
439 }
440
441
442 /**
443 * qla2x00_send_adisc_iocb() - Issue a Get Port Database IOCB to the firmware.
444 * @ha: HA context
445 * @iodesc: io descriptor
446 * @ha_locked: is function called with the hardware lock
447 *
448 * Returns QLA_SUCCESS if the IOCB was issued.
449 */
450 static int
451 qla2x00_send_adisc_iocb(scsi_qla_host_t *ha, struct io_descriptor *iodesc,
452 int ha_locked)
453 {
454 unsigned long flags = 0;
455 struct mbx_entry *mbxentry;
456
457 /* Send marker if required. */
458 if (qla2x00_issue_marker(ha, ha_locked) != QLA_SUCCESS)
459 return (QLA_FUNCTION_FAILED);
460
461 if (!ha_locked)
462 spin_lock_irqsave(&ha->hardware_lock, flags);
463
464 /* Build Get Port Database IOCB. */
465 mbxentry = qla2x00_get_mbx_iocb_entry(ha, iodesc->signature);
466 if (mbxentry == NULL) {
467 if (!ha_locked)
468 spin_unlock_irqrestore(&ha->hardware_lock, flags);
469
470 return (QLA_FUNCTION_FAILED);
471 }
472 mbxentry->mb0 = __constant_cpu_to_le16(MBC_GET_PORT_DATABASE);
473 mbxentry->mb1 = mbxentry->loop_id.extended =
474 cpu_to_le16(iodesc->remote_fcport->loop_id);
475 mbxentry->mb2 = cpu_to_le16(MSW(LSD(ha->iodesc_pd_dma)));
476 mbxentry->mb3 = cpu_to_le16(LSW(LSD(ha->iodesc_pd_dma)));
477 mbxentry->mb6 = cpu_to_le16(MSW(MSD(ha->iodesc_pd_dma)));
478 mbxentry->mb7 = cpu_to_le16(LSW(MSD(ha->iodesc_pd_dma)));
479 mbxentry->mb10 = __constant_cpu_to_le16(BIT_0);
480 wmb();
481
482 qla2x00_add_iodesc_timer(iodesc);
483
484 /* Issue command to ISP. */
485 qla2x00_isp_cmd(ha);
486
487 if (!ha_locked)
488 spin_unlock_irqrestore(&ha->hardware_lock, flags);
489
490 DEBUG14(printk("scsi(%ld): Sending Adisc IOCB (%08x) to [%x].\n",
491 ha->host_no, iodesc->signature, iodesc->remote_fcport->loop_id));
492
493 return (QLA_SUCCESS);
494 }
495
496 /**
497 * qla2x00_send_adisc_iocb_cb() - Get Port Database IOCB callback.
498 * @ha: HA context
499 * @iodesc: io descriptor
500 * @mbxstat: mailbox status IOCB
501 *
502 * Returns QLA_SUCCESS if @iodesc can be freed by the caller, else, @iodesc
503 * will be used for a retry.
504 */
505 static int
506 qla2x00_send_adisc_iocb_cb(scsi_qla_host_t *ha, struct io_descriptor *iodesc,
507 struct mbx_entry *mbxstat)
508 {
509 fc_port_t *remote_fcport;
510
511 remote_fcport = iodesc->remote_fcport;
512
513 /* Ensure the port IDs are consistent. */
514 if (remote_fcport->d_id.b24 != iodesc->d_id.b24) {
515 DEBUG14(printk("scsi(%ld): Adisc IOCB -- ignoring, remote port "
516 "id changed from [%02x%02x%02x] to [%02x%02x%02x].\n",
517 ha->host_no, remote_fcport->d_id.b.domain,
518 remote_fcport->d_id.b.area, remote_fcport->d_id.b.al_pa,
519 iodesc->d_id.b.domain, iodesc->d_id.b.area,
520 iodesc->d_id.b.al_pa));
521
522 return (QLA_SUCCESS);
523 }
524
525 /* Only process the last command. */
526 if (remote_fcport->iodesc_idx_sent != iodesc->idx) {
527 DEBUG14(printk("scsi(%ld): Adisc IOCB -- ignoring, sent to "
528 "[%02x%02x%02x], expected %x, received %x.\n", ha->host_no,
529 iodesc->d_id.b.domain, iodesc->d_id.b.area,
530 iodesc->d_id.b.al_pa, remote_fcport->iodesc_idx_sent,
531 iodesc->idx));
532
533 return (QLA_SUCCESS);
534 }
535
536 if (le16_to_cpu(mbxstat->status) == CS_COMPLETE) {
537 DEBUG14(printk("scsi(%ld): Adisc IOCB -- marking "
538 "[%x/%02x%02x%02x] online.\n", ha->host_no,
539 remote_fcport->loop_id, remote_fcport->d_id.b.domain,
540 remote_fcport->d_id.b.area, remote_fcport->d_id.b.al_pa));
541
542 atomic_set(&remote_fcport->state, FCS_ONLINE);
543 } else {
544 DEBUG14(printk("scsi(%ld): Adisc IOCB -- marking "
545 "[%x/%02x%02x%02x] lost, status=%x mb0=%x.\n", ha->host_no,
546 remote_fcport->loop_id, remote_fcport->d_id.b.domain,
547 remote_fcport->d_id.b.area, remote_fcport->d_id.b.al_pa,
548 le16_to_cpu(mbxstat->status), le16_to_cpu(mbxstat->mb0)));
549
550 if (atomic_read(&remote_fcport->state) != FCS_DEVICE_DEAD)
551 atomic_set(&remote_fcport->state, FCS_DEVICE_LOST);
552 }
553 remote_fcport->iodesc_idx_sent = IODESC_INVALID_INDEX;
554
555 return (QLA_SUCCESS);
556 }
557
558
559 /**
560 * qla2x00_send_logout_iocb() - Issue a fabric port logout IOCB to the firmware.
561 * @ha: HA context
562 * @iodesc: io descriptor
563 * @ha_locked: is function called with the hardware lock
564 *
565 * Returns QLA_SUCCESS if the IOCB was issued.
566 */
567 static int
568 qla2x00_send_logout_iocb(scsi_qla_host_t *ha, struct io_descriptor *iodesc,
569 int ha_locked)
570 {
571 unsigned long flags = 0;
572 struct mbx_entry *mbxentry;
573
574 /* Send marker if required. */
575 if (qla2x00_issue_marker(ha, ha_locked) != QLA_SUCCESS)
576 return (QLA_FUNCTION_FAILED);
577
578 if (!ha_locked)
579 spin_lock_irqsave(&ha->hardware_lock, flags);
580
581 /* Build fabric port logout mailbox IOCB. */
582 mbxentry = qla2x00_get_mbx_iocb_entry(ha, iodesc->signature);
583 if (mbxentry == NULL) {
584 if (!ha_locked)
585 spin_unlock_irqrestore(&ha->hardware_lock, flags);
586
587 return (QLA_FUNCTION_FAILED);
588 }
589 mbxentry->mb0 = __constant_cpu_to_le16(MBC_LOGOUT_FABRIC_PORT);
590 mbxentry->mb1 = mbxentry->loop_id.extended =
591 cpu_to_le16(iodesc->remote_fcport->loop_id);
592 wmb();
593
594 qla2x00_add_iodesc_timer(iodesc);
595
596 /* Issue command to ISP. */
597 qla2x00_isp_cmd(ha);
598
599 if (!ha_locked)
600 spin_unlock_irqrestore(&ha->hardware_lock, flags);
601
602 DEBUG14(printk("scsi(%ld): Sending Logout IOCB (%08x) to [%x].\n",
603 ha->host_no, iodesc->signature, iodesc->remote_fcport->loop_id));
604
605 return (QLA_SUCCESS);
606 }
607
608 /**
609 * qla2x00_send_logout_iocb_cb() - Fabric port logout IOCB callback.
610 * @ha: HA context
611 * @iodesc: io descriptor
612 * @mbxstat: mailbox status IOCB
613 *
614 * Returns QLA_SUCCESS if @iodesc can be freed by the caller, else, @iodesc
615 * will be used for a retry.
616 */
617 static int
618 qla2x00_send_logout_iocb_cb(scsi_qla_host_t *ha, struct io_descriptor *iodesc,
619 struct mbx_entry *mbxstat)
620 {
621 DEBUG14(printk("scsi(%ld): Logout IOCB -- sent to [%x/%02x%02x%02x], "
622 "status=%x mb0=%x mb1=%x.\n", ha->host_no,
623 iodesc->remote_fcport->loop_id,
624 iodesc->remote_fcport->d_id.b.domain,
625 iodesc->remote_fcport->d_id.b.area,
626 iodesc->remote_fcport->d_id.b.al_pa, le16_to_cpu(mbxstat->status),
627 le16_to_cpu(mbxstat->mb0), le16_to_cpu(mbxstat->mb1)));
628
629 return (QLA_SUCCESS);
630 }
631
632
633 /**
634 * qla2x00_send_login_iocb() - Issue a fabric port login IOCB to the firmware.
635 * @ha: HA context
636 * @iodesc: io descriptor
637 * @d_id: port id for device
638 * @ha_locked: is function called with the hardware lock
639 *
640 * Returns QLA_SUCCESS if the IOCB was issued.
641 */
642 static int
643 qla2x00_send_login_iocb(scsi_qla_host_t *ha, struct io_descriptor *iodesc,
644 port_id_t *d_id, int ha_locked)
645 {
646 unsigned long flags = 0;
647 struct mbx_entry *mbxentry;
648
649 /* Send marker if required. */
650 if (qla2x00_issue_marker(ha, ha_locked) != QLA_SUCCESS)
651 return (QLA_FUNCTION_FAILED);
652
653 if (!ha_locked)
654 spin_lock_irqsave(&ha->hardware_lock, flags);
655
656 /* Build fabric port login mailbox IOCB. */
657 mbxentry = qla2x00_get_mbx_iocb_entry(ha, iodesc->signature);
658 if (mbxentry == NULL) {
659 if (!ha_locked)
660 spin_unlock_irqrestore(&ha->hardware_lock, flags);
661
662 return (QLA_FUNCTION_FAILED);
663 }
664 mbxentry->mb0 = __constant_cpu_to_le16(MBC_LOGIN_FABRIC_PORT);
665 mbxentry->mb1 = mbxentry->loop_id.extended =
666 cpu_to_le16(iodesc->remote_fcport->loop_id);
667 mbxentry->mb2 = cpu_to_le16(d_id->b.domain);
668 mbxentry->mb3 = cpu_to_le16(d_id->b.area << 8 | d_id->b.al_pa);
669 mbxentry->mb10 = __constant_cpu_to_le16(BIT_0);
670 wmb();
671
672 qla2x00_add_iodesc_timer(iodesc);
673
674 /* Issue command to ISP. */
675 qla2x00_isp_cmd(ha);
676
677 if (!ha_locked)
678 spin_unlock_irqrestore(&ha->hardware_lock, flags);
679
680 DEBUG14(printk("scsi(%ld): Sending Login IOCB (%08x) to "
681 "[%x/%02x%02x%02x].\n", ha->host_no, iodesc->signature,
682 iodesc->remote_fcport->loop_id, d_id->b.domain, d_id->b.area,
683 d_id->b.al_pa));
684
685 return (QLA_SUCCESS);
686 }
687
688 /**
689 * qla2x00_send_login_iocb_cb() - Fabric port logout IOCB callback.
690 * @ha: HA context
691 * @iodesc: io descriptor
692 * @mbxstat: mailbox status IOCB
693 *
694 * Returns QLA_SUCCESS if @iodesc can be freed by the caller, else, @iodesc
695 * will be used for a retry.
696 */
697 static int
698 qla2x00_send_login_iocb_cb(scsi_qla_host_t *ha, struct io_descriptor *iodesc,
699 struct mbx_entry *mbxstat)
700 {
701 int rval;
702 fc_port_t *fcport, *remote_fcport, *exist_fcport;
703 struct io_descriptor *abort_iodesc, *login_iodesc;
704 uint16_t status, mb[8];
705 uint16_t reuse;
706 uint16_t remote_loopid;
707 port_id_t remote_did, inuse_did;
708
709 remote_fcport = iodesc->remote_fcport;
710
711 /* Only process the last command. */
712 if (remote_fcport->iodesc_idx_sent != iodesc->idx) {
713 DEBUG14(printk("scsi(%ld): Login IOCB -- ignoring, sent to "
714 "[%02x%02x%02x], expected %x, received %x.\n",
715 ha->host_no, iodesc->d_id.b.domain, iodesc->d_id.b.area,
716 iodesc->d_id.b.al_pa, remote_fcport->iodesc_idx_sent,
717 iodesc->idx));
718
719 /* Free RSCN fcport resources. */
720 if (remote_fcport->port_type == FCT_RSCN) {
721 DEBUG14(printk("scsi(%ld): Login IOCB -- Freeing RSCN "
722 "fcport %p [%x/%02x%02x%02x] given ignored Login "
723 "IOCB.\n", ha->host_no, remote_fcport,
724 remote_fcport->loop_id,
725 remote_fcport->d_id.b.domain,
726 remote_fcport->d_id.b.area,
727 remote_fcport->d_id.b.al_pa));
728
729 list_del(&remote_fcport->list);
730 kfree(remote_fcport);
731 }
732 return (QLA_SUCCESS);
733 }
734
735 status = le16_to_cpu(mbxstat->status);
736 mb[0] = le16_to_cpu(mbxstat->mb0);
737 mb[1] = le16_to_cpu(mbxstat->mb1);
738 mb[2] = le16_to_cpu(mbxstat->mb2);
739 mb[6] = le16_to_cpu(mbxstat->mb6);
740 mb[7] = le16_to_cpu(mbxstat->mb7);
741
742 /* Good status? */
743 if ((status == CS_COMPLETE || status == CS_COMPLETE_CHKCOND) &&
744 mb[0] == MBS_COMMAND_COMPLETE) {
745
746 DEBUG14(printk("scsi(%ld): Login IOCB -- status=%x mb1=%x pn="
747 "%02x%02x%02x%02x%02x%02x%02x%02x.\n", ha->host_no, status,
748 mb[1], mbxstat->port_name[0], mbxstat->port_name[1],
749 mbxstat->port_name[2], mbxstat->port_name[3],
750 mbxstat->port_name[4], mbxstat->port_name[5],
751 mbxstat->port_name[6], mbxstat->port_name[7]));
752
753 memcpy(remote_fcport->node_name, mbxstat->node_name, WWN_SIZE);
754 memcpy(remote_fcport->port_name, mbxstat->port_name, WWN_SIZE);
755
756 /* Is the device already in our fcports list? */
757 if (remote_fcport->port_type != FCT_RSCN) {
758 DEBUG14(printk("scsi(%ld): Login IOCB -- marking "
759 "[%x/%02x%02x%02x] online.\n", ha->host_no,
760 remote_fcport->loop_id,
761 remote_fcport->d_id.b.domain,
762 remote_fcport->d_id.b.area,
763 remote_fcport->d_id.b.al_pa));
764
765 qla2x00_update_login_fcport(ha, mbxstat, remote_fcport);
766
767 return (QLA_SUCCESS);
768 }
769
770 /* Does the RSCN portname already exist in our fcports list? */
771 exist_fcport = NULL;
772 list_for_each_entry(fcport, &ha->fcports, list) {
773 if (memcmp(remote_fcport->port_name, fcport->port_name,
774 WWN_SIZE) == 0) {
775 exist_fcport = fcport;
776 break;
777 }
778 }
779 if (exist_fcport != NULL) {
780 DEBUG14(printk("scsi(%ld): Login IOCB -- found RSCN "
781 "fcport in fcports list [%p].\n", ha->host_no,
782 exist_fcport));
783
784 /* Abort any ADISC that could have been sent. */
785 if (exist_fcport->iodesc_idx_sent != iodesc->idx &&
786 exist_fcport->iodesc_idx_sent <
787 MAX_IO_DESCRIPTORS &&
788 ha->io_descriptors[exist_fcport->iodesc_idx_sent].
789 cb_idx == ADISC_PORT_IOCB_CB) {
790
791 abort_iodesc = qla2x00_alloc_iodesc(ha);
792 if (abort_iodesc) {
793 DEBUG14(printk("scsi(%ld): Login IOCB "
794 "-- issuing abort to outstanding "
795 "Adisc [%x/%02x%02x%02x].\n",
796 ha->host_no, remote_fcport->loop_id,
797 exist_fcport->d_id.b.domain,
798 exist_fcport->d_id.b.area,
799 exist_fcport->d_id.b.al_pa));
800
801 abort_iodesc->cb_idx = ABORT_IOCB_CB;
802 abort_iodesc->d_id.b24 =
803 exist_fcport->d_id.b24;
804 abort_iodesc->remote_fcport =
805 exist_fcport;
806 exist_fcport->iodesc_idx_sent =
807 abort_iodesc->idx;
808 qla2x00_send_abort_iocb(ha,
809 abort_iodesc, ha->io_descriptors[
810 exist_fcport->iodesc_idx_sent].
811 signature, 1);
812 } else {
813 DEBUG14(printk("scsi(%ld): Login IOCB "
814 "-- unable to abort outstanding "
815 "Adisc [%x/%02x%02x%02x].\n",
816 ha->host_no, remote_fcport->loop_id,
817 exist_fcport->d_id.b.domain,
818 exist_fcport->d_id.b.area,
819 exist_fcport->d_id.b.al_pa));
820 }
821 }
822
823 /*
824 * If the existing fcport is waiting to send an ADISC
825 * or LOGIN, then reuse remote fcport (RSCN) to
826 * continue waiting.
827 */
828 reuse = 0;
829 remote_loopid = remote_fcport->loop_id;
830 remote_did.b24 = remote_fcport->d_id.b24;
831 if (exist_fcport->iodesc_idx_sent ==
832 IODESC_ADISC_NEEDED ||
833 exist_fcport->iodesc_idx_sent ==
834 IODESC_LOGIN_NEEDED) {
835 DEBUG14(printk("scsi(%ld): Login IOCB -- "
836 "existing fcport [%x/%02x%02x%02x] "
837 "waiting for IO descriptor, reuse RSCN "
838 "fcport.\n", ha->host_no,
839 exist_fcport->loop_id,
840 exist_fcport->d_id.b.domain,
841 exist_fcport->d_id.b.area,
842 exist_fcport->d_id.b.al_pa));
843
844 reuse++;
845 remote_fcport->iodesc_idx_sent =
846 exist_fcport->iodesc_idx_sent;
847 exist_fcport->iodesc_idx_sent =
848 IODESC_INVALID_INDEX;
849 remote_fcport->loop_id = exist_fcport->loop_id;
850 remote_fcport->d_id.b24 =
851 exist_fcport->d_id.b24;
852 }
853
854 /* Logout the old loopid. */
855 if (!reuse &&
856 exist_fcport->loop_id != remote_fcport->loop_id &&
857 exist_fcport->loop_id != FC_NO_LOOP_ID) {
858 login_iodesc = qla2x00_alloc_iodesc(ha);
859 if (login_iodesc) {
860 DEBUG14(printk("scsi(%ld): Login IOCB "
861 "-- issuing logout to free old "
862 "loop id [%x/%02x%02x%02x].\n",
863 ha->host_no, exist_fcport->loop_id,
864 exist_fcport->d_id.b.domain,
865 exist_fcport->d_id.b.area,
866 exist_fcport->d_id.b.al_pa));
867
868 login_iodesc->cb_idx =
869 LOGOUT_PORT_IOCB_CB;
870 login_iodesc->d_id.b24 =
871 exist_fcport->d_id.b24;
872 login_iodesc->remote_fcport =
873 exist_fcport;
874 exist_fcport->iodesc_idx_sent =
875 login_iodesc->idx;
876 qla2x00_send_logout_iocb(ha,
877 login_iodesc, 1);
878 } else {
879 /* Ran out of IO descriptiors. */
880 DEBUG14(printk("scsi(%ld): Login IOCB "
881 "-- unable to logout to free old "
882 "loop id [%x/%02x%02x%02x].\n",
883 ha->host_no, exist_fcport->loop_id,
884 exist_fcport->d_id.b.domain,
885 exist_fcport->d_id.b.area,
886 exist_fcport->d_id.b.al_pa));
887
888 exist_fcport->iodesc_idx_sent =
889 IODESC_INVALID_INDEX;
890 }
891
892 }
893
894 /* Update existing fcport with remote fcport info. */
895 DEBUG14(printk("scsi(%ld): Login IOCB -- marking "
896 "existing fcport [%x/%02x%02x%02x] online.\n",
897 ha->host_no, remote_loopid, remote_did.b.domain,
898 remote_did.b.area, remote_did.b.al_pa));
899
900 memcpy(exist_fcport->node_name,
901 remote_fcport->node_name, WWN_SIZE);
902 exist_fcport->loop_id = remote_loopid;
903 exist_fcport->d_id.b24 = remote_did.b24;
904 qla2x00_update_login_fcport(ha, mbxstat, exist_fcport);
905
906 /* Finally, free the remote (RSCN) fcport. */
907 if (!reuse) {
908 DEBUG14(printk("scsi(%ld): Login IOCB -- "
909 "Freeing RSCN fcport %p "
910 "[%x/%02x%02x%02x].\n", ha->host_no,
911 remote_fcport, remote_fcport->loop_id,
912 remote_fcport->d_id.b.domain,
913 remote_fcport->d_id.b.area,
914 remote_fcport->d_id.b.al_pa));
915
916 list_del(&remote_fcport->list);
917 kfree(remote_fcport);
918 }
919
920 return (QLA_SUCCESS);
921 }
922
923 /*
924 * A new device has been added, move the RSCN fcport to our
925 * fcports list.
926 */
927 DEBUG14(printk("scsi(%ld): Login IOCB -- adding RSCN fcport "
928 "[%x/%02x%02x%02x] to fcports list.\n", ha->host_no,
929 remote_fcport->loop_id, remote_fcport->d_id.b.domain,
930 remote_fcport->d_id.b.area, remote_fcport->d_id.b.al_pa));
931
932 list_del(&remote_fcport->list);
933 remote_fcport->flags = (FCF_RLC_SUPPORT | FCF_RESCAN_NEEDED);
934 qla2x00_update_login_fcport(ha, mbxstat, remote_fcport);
935 list_add_tail(&remote_fcport->list, &ha->fcports);
936 set_bit(FCPORT_RESCAN_NEEDED, &ha->dpc_flags);
937 } else {
938 /* Handle login failure. */
939 if (remote_fcport->login_retry != 0) {
940 if (mb[0] == MBS_LOOP_ID_USED) {
941 inuse_did.b.domain = LSB(mb[1]);
942 inuse_did.b.area = MSB(mb[2]);
943 inuse_did.b.al_pa = LSB(mb[2]);
944
945 DEBUG14(printk("scsi(%ld): Login IOCB -- loop "
946 "id [%x] used by port id [%02x%02x%02x].\n",
947 ha->host_no, remote_fcport->loop_id,
948 inuse_did.b.domain, inuse_did.b.area,
949 inuse_did.b.al_pa));
950
951 if (remote_fcport->d_id.b24 ==
952 INVALID_PORT_ID) {
953 /*
954 * Invalid port id means we are trying
955 * to login to a remote port with just
956 * a loop id without knowing about the
957 * port id. Copy the port id and try
958 * again.
959 */
960 remote_fcport->d_id.b24 = inuse_did.b24;
961 iodesc->d_id.b24 = inuse_did.b24;
962 } else {
963 remote_fcport->loop_id++;
964 rval = qla2x00_find_new_loop_id(ha,
965 remote_fcport);
966 if (rval == QLA_FUNCTION_FAILED) {
967 /* No more loop ids. */
968 return (QLA_SUCCESS);
969 }
970 }
971 } else if (mb[0] == MBS_PORT_ID_USED) {
972 /*
973 * Device has another loop ID. The firmware
974 * group recommends the driver perform an
975 * implicit login with the specified ID.
976 */
977 DEBUG14(printk("scsi(%ld): Login IOCB -- port "
978 "id [%02x%02x%02x] already assigned to "
979 "loop id [%x].\n", ha->host_no,
980 iodesc->d_id.b.domain, iodesc->d_id.b.area,
981 iodesc->d_id.b.al_pa, mb[1]));
982
983 remote_fcport->loop_id = mb[1];
984
985 } else {
986 /* Unable to perform login, try again. */
987 DEBUG14(printk("scsi(%ld): Login IOCB -- "
988 "failed login [%x/%02x%02x%02x], status=%x "
989 "mb0=%x mb1=%x mb2=%x mb6=%x mb7=%x.\n",
990 ha->host_no, remote_fcport->loop_id,
991 iodesc->d_id.b.domain, iodesc->d_id.b.area,
992 iodesc->d_id.b.al_pa, status, mb[0], mb[1],
993 mb[2], mb[6], mb[7]));
994 }
995
996 /* Reissue Login with the same IO descriptor. */
997 iodesc->signature =
998 qla2x00_iodesc_to_handle(iodesc);
999 iodesc->cb_idx = LOGIN_PORT_IOCB_CB;
1000 iodesc->d_id.b24 = remote_fcport->d_id.b24;
1001 remote_fcport->iodesc_idx_sent = iodesc->idx;
1002 remote_fcport->login_retry--;
1003
1004 DEBUG14(printk("scsi(%ld): Login IOCB -- retrying "
1005 "login to [%x/%02x%02x%02x] (%d).\n", ha->host_no,
1006 remote_fcport->loop_id,
1007 remote_fcport->d_id.b.domain,
1008 remote_fcport->d_id.b.area,
1009 remote_fcport->d_id.b.al_pa,
1010 remote_fcport->login_retry));
1011
1012 qla2x00_send_login_iocb(ha, iodesc,
1013 &remote_fcport->d_id, 1);
1014
1015 return (QLA_FUNCTION_FAILED);
1016 } else {
1017 /* No more logins, mark device dead. */
1018 DEBUG14(printk("scsi(%ld): Login IOCB -- failed "
1019 "login [%x/%02x%02x%02x] after retries, status=%x "
1020 "mb0=%x mb1=%x mb2=%x mb6=%x mb7=%x.\n",
1021 ha->host_no, remote_fcport->loop_id,
1022 iodesc->d_id.b.domain, iodesc->d_id.b.area,
1023 iodesc->d_id.b.al_pa, status, mb[0], mb[1],
1024 mb[2], mb[6], mb[7]));
1025
1026 atomic_set(&remote_fcport->state, FCS_DEVICE_DEAD);
1027 if (remote_fcport->port_type == FCT_RSCN) {
1028 DEBUG14(printk("scsi(%ld): Login IOCB -- "
1029 "Freeing dead RSCN fcport %p "
1030 "[%x/%02x%02x%02x].\n", ha->host_no,
1031 remote_fcport, remote_fcport->loop_id,
1032 remote_fcport->d_id.b.domain,
1033 remote_fcport->d_id.b.area,
1034 remote_fcport->d_id.b.al_pa));
1035
1036 list_del(&remote_fcport->list);
1037 kfree(remote_fcport);
1038 }
1039 }
1040 }
1041
1042 return (QLA_SUCCESS);
1043 }
1044
1045
1046 /**
1047 * IO descriptor processing routines.
1048 **/
1049
1050 /**
1051 * qla2x00_alloc_rscn_fcport() - Allocate an RSCN type fcport.
1052 * @ha: HA context
1053 * @flags: allocation flags
1054 *
1055 * Returns a pointer to the allocated RSCN fcport, or NULL, if none available.
1056 */
1057 fc_port_t *
1058 qla2x00_alloc_rscn_fcport(scsi_qla_host_t *ha, gfp_t flags)
1059 {
1060 fc_port_t *fcport;
1061
1062 fcport = qla2x00_alloc_fcport(ha, flags);
1063 if (fcport == NULL)
1064 return (fcport);
1065
1066 /* Setup RSCN fcport structure. */
1067 fcport->port_type = FCT_RSCN;
1068
1069 return (fcport);
1070 }
1071
1072 /**
1073 * qla2x00_handle_port_rscn() - Handle port RSCN.
1074 * @ha: HA context
1075 * @rscn_entry: RSCN entry
1076 * @fcport: fcport entry to updated
1077 *
1078 * Returns QLA_SUCCESS if the port RSCN was handled.
1079 */
1080 int
1081 qla2x00_handle_port_rscn(scsi_qla_host_t *ha, uint32_t rscn_entry,
1082 fc_port_t *known_fcport, int ha_locked)
1083 {
1084 int rval;
1085 port_id_t rscn_pid;
1086 fc_port_t *fcport, *remote_fcport, *rscn_fcport;
1087 struct io_descriptor *iodesc;
1088
1089 remote_fcport = NULL;
1090 rscn_fcport = NULL;
1091
1092 /* Prepare port id based on incoming entries. */
1093 if (known_fcport) {
1094 rscn_pid.b24 = known_fcport->d_id.b24;
1095 remote_fcport = known_fcport;
1096
1097 DEBUG14(printk("scsi(%ld): Handle RSCN -- process RSCN for "
1098 "fcport [%02x%02x%02x].\n", ha->host_no,
1099 remote_fcport->d_id.b.domain, remote_fcport->d_id.b.area,
1100 remote_fcport->d_id.b.al_pa));
1101 } else {
1102 rscn_pid.b.domain = LSB(MSW(rscn_entry));
1103 rscn_pid.b.area = MSB(LSW(rscn_entry));
1104 rscn_pid.b.al_pa = LSB(LSW(rscn_entry));
1105
1106 DEBUG14(printk("scsi(%ld): Handle RSCN -- process RSCN for "
1107 "port id [%02x%02x%02x].\n", ha->host_no,
1108 rscn_pid.b.domain, rscn_pid.b.area, rscn_pid.b.al_pa));
1109
1110 /*
1111 * Search fcport lists for a known entry at the specified port
1112 * ID.
1113 */
1114 list_for_each_entry(fcport, &ha->fcports, list) {
1115 if (rscn_pid.b24 == fcport->d_id.b24) {
1116 remote_fcport = fcport;
1117 break;
1118 }
1119 }
1120 list_for_each_entry(fcport, &ha->rscn_fcports, list) {
1121 if (rscn_pid.b24 == fcport->d_id.b24) {
1122 rscn_fcport = fcport;
1123 break;
1124 }
1125 }
1126 if (remote_fcport == NULL)
1127 remote_fcport = rscn_fcport;
1128 }
1129
1130 /*
1131 * If the port is already in our fcport list and online, send an ADISC
1132 * to see if it's still alive. Issue login if a new fcport or the known
1133 * fcport is currently offline.
1134 */
1135 if (remote_fcport) {
1136 /*
1137 * No need to send request if the remote fcport is currently
1138 * waiting for an available io descriptor.
1139 */
1140 if (known_fcport == NULL &&
1141 (remote_fcport->iodesc_idx_sent == IODESC_ADISC_NEEDED ||
1142 remote_fcport->iodesc_idx_sent == IODESC_LOGIN_NEEDED)) {
1143 /*
1144 * If previous waiting io descriptor is an ADISC, then
1145 * the new RSCN may come from a new remote fcport being
1146 * plugged into the same location.
1147 */
1148 if (remote_fcport->port_type == FCT_RSCN) {
1149 remote_fcport->iodesc_idx_sent =
1150 IODESC_LOGIN_NEEDED;
1151 } else if (remote_fcport->iodesc_idx_sent ==
1152 IODESC_ADISC_NEEDED) {
1153 fc_port_t *new_fcport;
1154
1155 remote_fcport->iodesc_idx_sent =
1156 IODESC_INVALID_INDEX;
1157
1158 /* Create new fcport for later login. */
1159 new_fcport = qla2x00_alloc_rscn_fcport(ha,
1160 ha_locked ? GFP_ATOMIC: GFP_KERNEL);
1161 if (new_fcport) {
1162 DEBUG14(printk("scsi(%ld): Handle RSCN "
1163 "-- creating RSCN fcport %p for "
1164 "future login.\n", ha->host_no,
1165 new_fcport));
1166
1167 new_fcport->d_id.b24 =
1168 remote_fcport->d_id.b24;
1169 new_fcport->iodesc_idx_sent =
1170 IODESC_LOGIN_NEEDED;
1171
1172 list_add_tail(&new_fcport->list,
1173 &ha->rscn_fcports);
1174 set_bit(IODESC_PROCESS_NEEDED,
1175 &ha->dpc_flags);
1176 } else {
1177 DEBUG14(printk("scsi(%ld): Handle RSCN "
1178 "-- unable to allocate RSCN fcport "
1179 "for future login.\n",
1180 ha->host_no));
1181 }
1182 }
1183 return (QLA_SUCCESS);
1184 }
1185
1186 /* Send ADISC if the fcport is online */
1187 if (atomic_read(&remote_fcport->state) == FCS_ONLINE ||
1188 remote_fcport->iodesc_idx_sent == IODESC_ADISC_NEEDED) {
1189
1190 atomic_set(&remote_fcport->state, FCS_DEVICE_LOST);
1191
1192 iodesc = qla2x00_alloc_iodesc(ha);
1193 if (iodesc == NULL) {
1194 /* Mark fcport for later adisc processing */
1195 DEBUG14(printk("scsi(%ld): Handle RSCN -- not "
1196 "enough IO descriptors for Adisc, flag "
1197 "for later processing.\n", ha->host_no));
1198
1199 remote_fcport->iodesc_idx_sent =
1200 IODESC_ADISC_NEEDED;
1201 set_bit(IODESC_PROCESS_NEEDED, &ha->dpc_flags);
1202
1203 return (QLA_SUCCESS);
1204 }
1205
1206 iodesc->cb_idx = ADISC_PORT_IOCB_CB;
1207 iodesc->d_id.b24 = rscn_pid.b24;
1208 iodesc->remote_fcport = remote_fcport;
1209 remote_fcport->iodesc_idx_sent = iodesc->idx;
1210 qla2x00_send_adisc_iocb(ha, iodesc, ha_locked);
1211
1212 return (QLA_SUCCESS);
1213 } else if (remote_fcport->iodesc_idx_sent <
1214 MAX_IO_DESCRIPTORS &&
1215 ha->io_descriptors[remote_fcport->iodesc_idx_sent].cb_idx ==
1216 ADISC_PORT_IOCB_CB) {
1217 /*
1218 * Receiving another RSCN while an ADISC is pending,
1219 * abort the IOCB. Use the same descriptor for the
1220 * abort.
1221 */
1222 uint32_t handle_to_abort;
1223
1224 iodesc = &ha->io_descriptors[
1225 remote_fcport->iodesc_idx_sent];
1226 qla2x00_remove_iodesc_timer(iodesc);
1227 handle_to_abort = iodesc->signature;
1228 iodesc->signature = qla2x00_iodesc_to_handle(iodesc);
1229 iodesc->cb_idx = ABORT_IOCB_CB;
1230 iodesc->d_id.b24 = remote_fcport->d_id.b24;
1231 iodesc->remote_fcport = remote_fcport;
1232 remote_fcport->iodesc_idx_sent = iodesc->idx;
1233
1234 DEBUG14(printk("scsi(%ld): Handle RSCN -- issuing "
1235 "abort to outstanding Adisc [%x/%02x%02x%02x].\n",
1236 ha->host_no, remote_fcport->loop_id,
1237 iodesc->d_id.b.domain, iodesc->d_id.b.area,
1238 iodesc->d_id.b.al_pa));
1239
1240 qla2x00_send_abort_iocb(ha, iodesc, handle_to_abort,
1241 ha_locked);
1242 }
1243 }
1244
1245 /* We need to login to the remote port, find it. */
1246 if (known_fcport) {
1247 remote_fcport = known_fcport;
1248 } else if (rscn_fcport && rscn_fcport->d_id.b24 != INVALID_PORT_ID &&
1249 rscn_fcport->iodesc_idx_sent < MAX_IO_DESCRIPTORS &&
1250 ha->io_descriptors[rscn_fcport->iodesc_idx_sent].cb_idx ==
1251 LOGIN_PORT_IOCB_CB) {
1252 /*
1253 * Ignore duplicate RSCN on fcport which has already
1254 * initiated a login IOCB.
1255 */
1256 DEBUG14(printk("scsi(%ld): Handle RSCN -- ignoring, login "
1257 "already sent to [%02x%02x%02x].\n", ha->host_no,
1258 rscn_fcport->d_id.b.domain, rscn_fcport->d_id.b.area,
1259 rscn_fcport->d_id.b.al_pa));
1260
1261 return (QLA_SUCCESS);
1262 } else if (rscn_fcport && rscn_fcport->d_id.b24 != INVALID_PORT_ID &&
1263 rscn_fcport != remote_fcport) {
1264 /* Reuse same rscn fcport. */
1265 DEBUG14(printk("scsi(%ld): Handle RSCN -- reusing RSCN fcport "
1266 "[%02x%02x%02x].\n", ha->host_no,
1267 rscn_fcport->d_id.b.domain, rscn_fcport->d_id.b.area,
1268 rscn_fcport->d_id.b.al_pa));
1269
1270 remote_fcport = rscn_fcport;
1271 } else {
1272 /* Create new fcport for later login. */
1273 remote_fcport = qla2x00_alloc_rscn_fcport(ha,
1274 ha_locked ? GFP_ATOMIC: GFP_KERNEL);
1275 list_add_tail(&remote_fcport->list, &ha->rscn_fcports);
1276 }
1277 if (remote_fcport == NULL)
1278 return (QLA_SUCCESS);
1279
1280 /* Prepare fcport for login. */
1281 atomic_set(&remote_fcport->state, FCS_DEVICE_LOST);
1282 remote_fcport->login_retry = 3; /* ha->login_retry_count; */
1283 remote_fcport->d_id.b24 = rscn_pid.b24;
1284
1285 iodesc = qla2x00_alloc_iodesc(ha);
1286 if (iodesc == NULL) {
1287 /* Mark fcport for later adisc processing. */
1288 DEBUG14(printk("scsi(%ld): Handle RSCN -- not enough IO "
1289 "descriptors for Login, flag for later processing.\n",
1290 ha->host_no));
1291
1292 remote_fcport->iodesc_idx_sent = IODESC_LOGIN_NEEDED;
1293 set_bit(IODESC_PROCESS_NEEDED, &ha->dpc_flags);
1294
1295 return (QLA_SUCCESS);
1296 }
1297
1298 if (known_fcport == NULL || rscn_pid.b24 != INVALID_PORT_ID) {
1299 remote_fcport->loop_id = ha->min_external_loopid;
1300
1301 rval = qla2x00_find_new_loop_id(ha, remote_fcport);
1302 if (rval == QLA_FUNCTION_FAILED) {
1303 /* No more loop ids, failed. */
1304 DEBUG14(printk("scsi(%ld): Handle RSCN -- no available "
1305 "loop id to perform Login, failed.\n",
1306 ha->host_no));
1307
1308 return (rval);
1309 }
1310 }
1311
1312 iodesc->cb_idx = LOGIN_PORT_IOCB_CB;
1313 iodesc->d_id.b24 = rscn_pid.b24;
1314 iodesc->remote_fcport = remote_fcport;
1315 remote_fcport->iodesc_idx_sent = iodesc->idx;
1316
1317 DEBUG14(printk("scsi(%ld): Handle RSCN -- attempting login to "
1318 "[%x/%02x%02x%02x].\n", ha->host_no, remote_fcport->loop_id,
1319 iodesc->d_id.b.domain, iodesc->d_id.b.area, iodesc->d_id.b.al_pa));
1320
1321 qla2x00_send_login_iocb(ha, iodesc, &rscn_pid, ha_locked);
1322
1323 return (QLA_SUCCESS);
1324 }
1325
1326 /**
1327 * qla2x00_process_iodesc() - Complete IO descriptor processing.
1328 * @ha: HA context
1329 * @mbxstat: Mailbox IOCB status
1330 */
1331 void
1332 qla2x00_process_iodesc(scsi_qla_host_t *ha, struct mbx_entry *mbxstat)
1333 {
1334 int rval;
1335 uint32_t signature;
1336 fc_port_t *fcport;
1337 struct io_descriptor *iodesc;
1338
1339 signature = mbxstat->handle;
1340
1341 DEBUG14(printk("scsi(%ld): Process IODesc -- processing %08x.\n",
1342 ha->host_no, signature));
1343
1344 /* Retrieve proper IO descriptor. */
1345 iodesc = qla2x00_handle_to_iodesc(ha, signature);
1346 if (iodesc == NULL) {
1347 DEBUG14(printk("scsi(%ld): Process IODesc -- ignoring, "
1348 "incorrect signature %08x.\n", ha->host_no, signature));
1349
1350 return;
1351 }
1352
1353 /* Stop IO descriptor timer. */
1354 qla2x00_remove_iodesc_timer(iodesc);
1355
1356 /* Verify signature match. */
1357 if (iodesc->signature != signature) {
1358 DEBUG14(printk("scsi(%ld): Process IODesc -- ignoring, "
1359 "signature mismatch, sent %08x, received %08x.\n",
1360 ha->host_no, iodesc->signature, signature));
1361
1362 return;
1363 }
1364
1365 /* Go with IOCB callback. */
1366 rval = iocb_function_cb_list[iodesc->cb_idx](ha, iodesc, mbxstat);
1367 if (rval != QLA_SUCCESS) {
1368 /* IO descriptor reused by callback. */
1369 return;
1370 }
1371
1372 qla2x00_free_iodesc(iodesc);
1373
1374 if (test_bit(IODESC_PROCESS_NEEDED, &ha->dpc_flags)) {
1375 /* Scan our fcports list for any RSCN requests. */
1376 list_for_each_entry(fcport, &ha->fcports, list) {
1377 if (fcport->iodesc_idx_sent == IODESC_ADISC_NEEDED ||
1378 fcport->iodesc_idx_sent == IODESC_LOGIN_NEEDED) {
1379 qla2x00_handle_port_rscn(ha, 0, fcport, 1);
1380 return;
1381 }
1382 }
1383
1384 /* Scan our RSCN fcports list for any RSCN requests. */
1385 list_for_each_entry(fcport, &ha->rscn_fcports, list) {
1386 if (fcport->iodesc_idx_sent == IODESC_ADISC_NEEDED ||
1387 fcport->iodesc_idx_sent == IODESC_LOGIN_NEEDED) {
1388 qla2x00_handle_port_rscn(ha, 0, fcport, 1);
1389 return;
1390 }
1391 }
1392 }
1393 clear_bit(IODESC_PROCESS_NEEDED, &ha->dpc_flags);
1394 }
1395
1396 /**
1397 * qla2x00_cancel_io_descriptors() - Cancel all outstanding io descriptors.
1398 * @ha: HA context
1399 *
1400 * This routine will also delete any RSCN entries related to the outstanding
1401 * IO descriptors.
1402 */
1403 void
1404 qla2x00_cancel_io_descriptors(scsi_qla_host_t *ha)
1405 {
1406 fc_port_t *fcport, *fcptemp;
1407
1408 clear_bit(IODESC_PROCESS_NEEDED, &ha->dpc_flags);
1409
1410 /* Abort all IO descriptors. */
1411 qla2x00_init_io_descriptors(ha);
1412
1413 /* Reset all pending IO descriptors in fcports list. */
1414 list_for_each_entry(fcport, &ha->fcports, list) {
1415 fcport->iodesc_idx_sent = IODESC_INVALID_INDEX;
1416 }
1417
1418 /* Reset all pending IO descriptors in rscn fcports list. */
1419 list_for_each_entry_safe(fcport, fcptemp, &ha->rscn_fcports, list) {
1420 DEBUG14(printk("scsi(%ld): Cancel IOs -- Freeing RSCN fcport "
1421 "%p [%x/%02x%02x%02x].\n", ha->host_no, fcport,
1422 fcport->loop_id, fcport->d_id.b.domain, fcport->d_id.b.area,
1423 fcport->d_id.b.al_pa));
1424
1425 list_del(&fcport->list);
1426 kfree(fcport);
1427 }
1428 }
Linux kernel - Deliverables
This page took 0.122454 seconds and 5 git commands to generate.