?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 5.1.15
[linux/fpc-iii.git] / drivers / scsi / esas2r / esas2r_disc.c
blob1c079f4300a56a4d42ab3e5564dc9460b7704675
1 /*
2 * linux/drivers/scsi/esas2r/esas2r_disc.c
3 * esas2r device discovery routines
4 *
5 * Copyright (c) 2001-2013 ATTO Technology, Inc.
6 * (mailto:linuxdrivers@attotech.com)
7 */
8 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9 /*
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2 of the License.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * NO WARRANTY
20 * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
21 * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
22 * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
23 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
24 * solely responsible for determining the appropriateness of using and
25 * distributing the Program and assumes all risks associated with its
26 * exercise of rights under this Agreement, including but not limited to
27 * the risks and costs of program errors, damage to or loss of data,
28 * programs or equipment, and unavailability or interruption of operations.
29 *
30 * DISCLAIMER OF LIABILITY
31 * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
32 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
34 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
35 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
36 * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
37 * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
38 *
39 * You should have received a copy of the GNU General Public License
40 * along with this program; if not, write to the Free Software
41 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
42 */
43 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
44
45 #include "esas2r.h"
46
47 /* Miscellaneous internal discovery routines */
48 static void esas2r_disc_abort(struct esas2r_adapter *a,
49 struct esas2r_request *rq);
50 static bool esas2r_disc_continue(struct esas2r_adapter *a,
51 struct esas2r_request *rq);
52 static void esas2r_disc_fix_curr_requests(struct esas2r_adapter *a);
53 static u32 esas2r_disc_get_phys_addr(struct esas2r_sg_context *sgc, u64 *addr);
54 static bool esas2r_disc_start_request(struct esas2r_adapter *a,
55 struct esas2r_request *rq);
56
57 /* Internal discovery routines that process the states */
58 static bool esas2r_disc_block_dev_scan(struct esas2r_adapter *a,
59 struct esas2r_request *rq);
60 static void esas2r_disc_block_dev_scan_cb(struct esas2r_adapter *a,
61 struct esas2r_request *rq);
62 static bool esas2r_disc_dev_add(struct esas2r_adapter *a,
63 struct esas2r_request *rq);
64 static bool esas2r_disc_dev_remove(struct esas2r_adapter *a,
65 struct esas2r_request *rq);
66 static bool esas2r_disc_part_info(struct esas2r_adapter *a,
67 struct esas2r_request *rq);
68 static void esas2r_disc_part_info_cb(struct esas2r_adapter *a,
69 struct esas2r_request *rq);
70 static bool esas2r_disc_passthru_dev_info(struct esas2r_adapter *a,
71 struct esas2r_request *rq);
72 static void esas2r_disc_passthru_dev_info_cb(struct esas2r_adapter *a,
73 struct esas2r_request *rq);
74 static bool esas2r_disc_passthru_dev_addr(struct esas2r_adapter *a,
75 struct esas2r_request *rq);
76 static void esas2r_disc_passthru_dev_addr_cb(struct esas2r_adapter *a,
77 struct esas2r_request *rq);
78 static bool esas2r_disc_raid_grp_info(struct esas2r_adapter *a,
79 struct esas2r_request *rq);
80 static void esas2r_disc_raid_grp_info_cb(struct esas2r_adapter *a,
81 struct esas2r_request *rq);
82
83 void esas2r_disc_initialize(struct esas2r_adapter *a)
84 {
85 struct esas2r_sas_nvram *nvr = a->nvram;
86
87 esas2r_trace_enter();
88
89 clear_bit(AF_DISC_IN_PROG, &a->flags);
90 clear_bit(AF2_DEV_SCAN, &a->flags2);
91 clear_bit(AF2_DEV_CNT_OK, &a->flags2);
92
93 a->disc_start_time = jiffies_to_msecs(jiffies);
94 a->disc_wait_time = nvr->dev_wait_time * 1000;
95 a->disc_wait_cnt = nvr->dev_wait_count;
96
97 if (a->disc_wait_cnt > ESAS2R_MAX_TARGETS)
98 a->disc_wait_cnt = ESAS2R_MAX_TARGETS;
99
100 /*
101 * If we are doing chip reset or power management processing, always
102 * wait for devices. use the NVRAM device count if it is greater than
103 * previously discovered devices.
104 */
105
106 esas2r_hdebug("starting discovery...");
107
108 a->general_req.interrupt_cx = NULL;
109
110 if (test_bit(AF_CHPRST_DETECTED, &a->flags) ||
111 test_bit(AF_POWER_MGT, &a->flags)) {
112 if (a->prev_dev_cnt == 0) {
113 /* Don't bother waiting if there is nothing to wait
114 * for.
115 */
116 a->disc_wait_time = 0;
117 } else {
118 /*
119 * Set the device wait count to what was previously
120 * found. We don't care if the user only configured
121 * a time because we know the exact count to wait for.
122 * There is no need to honor the user's wishes to
123 * always wait the full time.
124 */
125 a->disc_wait_cnt = a->prev_dev_cnt;
126
127 /*
128 * bump the minimum wait time to 15 seconds since the
129 * default is 3 (system boot or the boot driver usually
130 * buys us more time).
131 */
132 if (a->disc_wait_time < 15000)
133 a->disc_wait_time = 15000;
134 }
135 }
136
137 esas2r_trace("disc wait count: %d", a->disc_wait_cnt);
138 esas2r_trace("disc wait time: %d", a->disc_wait_time);
139
140 if (a->disc_wait_time == 0)
141 esas2r_disc_check_complete(a);
142
143 esas2r_trace_exit();
144 }
145
146 void esas2r_disc_start_waiting(struct esas2r_adapter *a)
147 {
148 unsigned long flags;
149
150 spin_lock_irqsave(&a->mem_lock, flags);
151
152 if (a->disc_ctx.disc_evt)
153 esas2r_disc_start_port(a);
154
155 spin_unlock_irqrestore(&a->mem_lock, flags);
156 }
157
158 void esas2r_disc_check_for_work(struct esas2r_adapter *a)
159 {
160 struct esas2r_request *rq = &a->general_req;
161
162 /* service any pending interrupts first */
163
164 esas2r_polled_interrupt(a);
165
166 /*
167 * now, interrupt processing may have queued up a discovery event. go
168 * see if we have one to start. we couldn't start it in the ISR since
169 * polled discovery would cause a deadlock.
170 */
171
172 esas2r_disc_start_waiting(a);
173
174 if (rq->interrupt_cx == NULL)
175 return;
176
177 if (rq->req_stat == RS_STARTED
178 && rq->timeout <= RQ_MAX_TIMEOUT) {
179 /* wait for the current discovery request to complete. */
180 esas2r_wait_request(a, rq);
181
182 if (rq->req_stat == RS_TIMEOUT) {
183 esas2r_disc_abort(a, rq);
184 esas2r_local_reset_adapter(a);
185 return;
186 }
187 }
188
189 if (rq->req_stat == RS_PENDING
190 || rq->req_stat == RS_STARTED)
191 return;
192
193 esas2r_disc_continue(a, rq);
194 }
195
196 void esas2r_disc_check_complete(struct esas2r_adapter *a)
197 {
198 unsigned long flags;
199
200 esas2r_trace_enter();
201
202 /* check to see if we should be waiting for devices */
203 if (a->disc_wait_time) {
204 u32 currtime = jiffies_to_msecs(jiffies);
205 u32 time = currtime - a->disc_start_time;
206
207 /*
208 * Wait until the device wait time is exhausted or the device
209 * wait count is satisfied.
210 */
211 if (time < a->disc_wait_time
212 && (esas2r_targ_db_get_tgt_cnt(a) < a->disc_wait_cnt
213 || a->disc_wait_cnt == 0)) {
214 /* After three seconds of waiting, schedule a scan. */
215 if (time >= 3000
216 && !test_and_set_bit(AF2_DEV_SCAN, &a->flags2)) {
217 spin_lock_irqsave(&a->mem_lock, flags);
218 esas2r_disc_queue_event(a, DCDE_DEV_SCAN);
219 spin_unlock_irqrestore(&a->mem_lock, flags);
220 }
221
222 esas2r_trace_exit();
223 return;
224 }
225
226 /*
227 * We are done waiting...we think. Adjust the wait time to
228 * consume events after the count is met.
229 */
230 if (!test_and_set_bit(AF2_DEV_CNT_OK, &a->flags2))
231 a->disc_wait_time = time + 3000;
232
233 /* If we haven't done a full scan yet, do it now. */
234 if (!test_and_set_bit(AF2_DEV_SCAN, &a->flags2)) {
235 spin_lock_irqsave(&a->mem_lock, flags);
236 esas2r_disc_queue_event(a, DCDE_DEV_SCAN);
237 spin_unlock_irqrestore(&a->mem_lock, flags);
238 esas2r_trace_exit();
239 return;
240 }
241
242 /*
243 * Now, if there is still time left to consume events, continue
244 * waiting.
245 */
246 if (time < a->disc_wait_time) {
247 esas2r_trace_exit();
248 return;
249 }
250 } else {
251 if (!test_and_set_bit(AF2_DEV_SCAN, &a->flags2)) {
252 spin_lock_irqsave(&a->mem_lock, flags);
253 esas2r_disc_queue_event(a, DCDE_DEV_SCAN);
254 spin_unlock_irqrestore(&a->mem_lock, flags);
255 }
256 }
257
258 /* We want to stop waiting for devices. */
259 a->disc_wait_time = 0;
260
261 if (test_bit(AF_DISC_POLLED, &a->flags) &&
262 test_bit(AF_DISC_IN_PROG, &a->flags)) {
263 /*
264 * Polled discovery is still pending so continue the active
265 * discovery until it is done. At that point, we will stop
266 * polled discovery and transition to interrupt driven
267 * discovery.
268 */
269 } else {
270 /*
271 * Done waiting for devices. Note that we get here immediately
272 * after deferred waiting completes because that is interrupt
273 * driven; i.e. There is no transition.
274 */
275 esas2r_disc_fix_curr_requests(a);
276 clear_bit(AF_DISC_PENDING, &a->flags);
277
278 /*
279 * We have deferred target state changes until now because we
280 * don't want to report any removals (due to the first arrival)
281 * until the device wait time expires.
282 */
283 set_bit(AF_PORT_CHANGE, &a->flags);
284 }
285
286 esas2r_trace_exit();
287 }
288
289 void esas2r_disc_queue_event(struct esas2r_adapter *a, u8 disc_evt)
290 {
291 struct esas2r_disc_context *dc = &a->disc_ctx;
292
293 esas2r_trace_enter();
294
295 esas2r_trace("disc_event: %d", disc_evt);
296
297 /* Initialize the discovery context */
298 dc->disc_evt |= disc_evt;
299
300 /*
301 * Don't start discovery before or during polled discovery. if we did,
302 * we would have a deadlock if we are in the ISR already.
303 */
304 if (!test_bit(AF_CHPRST_PENDING, &a->flags) &&
305 !test_bit(AF_DISC_POLLED, &a->flags))
306 esas2r_disc_start_port(a);
307
308 esas2r_trace_exit();
309 }
310
311 bool esas2r_disc_start_port(struct esas2r_adapter *a)
312 {
313 struct esas2r_request *rq = &a->general_req;
314 struct esas2r_disc_context *dc = &a->disc_ctx;
315 bool ret;
316
317 esas2r_trace_enter();
318
319 if (test_bit(AF_DISC_IN_PROG, &a->flags)) {
320 esas2r_trace_exit();
321
322 return false;
323 }
324
325 /* If there is a discovery waiting, process it. */
326 if (dc->disc_evt) {
327 if (test_bit(AF_DISC_POLLED, &a->flags)
328 && a->disc_wait_time == 0) {
329 /*
330 * We are doing polled discovery, but we no longer want
331 * to wait for devices. Stop polled discovery and
332 * transition to interrupt driven discovery.
333 */
334
335 esas2r_trace_exit();
336
337 return false;
338 }
339 } else {
340 /* Discovery is complete. */
341
342 esas2r_hdebug("disc done");
343
344 set_bit(AF_PORT_CHANGE, &a->flags);
345
346 esas2r_trace_exit();
347
348 return false;
349 }
350
351 /* Handle the discovery context */
352 esas2r_trace("disc_evt: %d", dc->disc_evt);
353 set_bit(AF_DISC_IN_PROG, &a->flags);
354 dc->flags = 0;
355
356 if (test_bit(AF_DISC_POLLED, &a->flags))
357 dc->flags |= DCF_POLLED;
358
359 rq->interrupt_cx = dc;
360 rq->req_stat = RS_SUCCESS;
361
362 /* Decode the event code */
363 if (dc->disc_evt & DCDE_DEV_SCAN) {
364 dc->disc_evt &= ~DCDE_DEV_SCAN;
365
366 dc->flags |= DCF_DEV_SCAN;
367 dc->state = DCS_BLOCK_DEV_SCAN;
368 } else if (dc->disc_evt & DCDE_DEV_CHANGE) {
369 dc->disc_evt &= ~DCDE_DEV_CHANGE;
370
371 dc->flags |= DCF_DEV_CHANGE;
372 dc->state = DCS_DEV_RMV;
373 }
374
375 /* Continue interrupt driven discovery */
376 if (!test_bit(AF_DISC_POLLED, &a->flags))
377 ret = esas2r_disc_continue(a, rq);
378 else
379 ret = true;
380
381 esas2r_trace_exit();
382
383 return ret;
384 }
385
386 static bool esas2r_disc_continue(struct esas2r_adapter *a,
387 struct esas2r_request *rq)
388 {
389 struct esas2r_disc_context *dc =
390 (struct esas2r_disc_context *)rq->interrupt_cx;
391 bool rslt;
392
393 /* Device discovery/removal */
394 while (dc->flags & (DCF_DEV_CHANGE | DCF_DEV_SCAN)) {
395 rslt = false;
396
397 switch (dc->state) {
398 case DCS_DEV_RMV:
399
400 rslt = esas2r_disc_dev_remove(a, rq);
401 break;
402
403 case DCS_DEV_ADD:
404
405 rslt = esas2r_disc_dev_add(a, rq);
406 break;
407
408 case DCS_BLOCK_DEV_SCAN:
409
410 rslt = esas2r_disc_block_dev_scan(a, rq);
411 break;
412
413 case DCS_RAID_GRP_INFO:
414
415 rslt = esas2r_disc_raid_grp_info(a, rq);
416 break;
417
418 case DCS_PART_INFO:
419
420 rslt = esas2r_disc_part_info(a, rq);
421 break;
422
423 case DCS_PT_DEV_INFO:
424
425 rslt = esas2r_disc_passthru_dev_info(a, rq);
426 break;
427 case DCS_PT_DEV_ADDR:
428
429 rslt = esas2r_disc_passthru_dev_addr(a, rq);
430 break;
431 case DCS_DISC_DONE:
432
433 dc->flags &= ~(DCF_DEV_CHANGE | DCF_DEV_SCAN);
434 break;
435
436 default:
437
438 esas2r_bugon();
439 dc->state = DCS_DISC_DONE;
440 break;
441 }
442
443 if (rslt)
444 return true;
445 }
446
447 /* Discovery is done...for now. */
448 rq->interrupt_cx = NULL;
449
450 if (!test_bit(AF_DISC_PENDING, &a->flags))
451 esas2r_disc_fix_curr_requests(a);
452
453 clear_bit(AF_DISC_IN_PROG, &a->flags);
454
455 /* Start the next discovery. */
456 return esas2r_disc_start_port(a);
457 }
458
459 static bool esas2r_disc_start_request(struct esas2r_adapter *a,
460 struct esas2r_request *rq)
461 {
462 unsigned long flags;
463
464 /* Set the timeout to a minimum value. */
465 if (rq->timeout < ESAS2R_DEFAULT_TMO)
466 rq->timeout = ESAS2R_DEFAULT_TMO;
467
468 /*
469 * Override the request type to distinguish discovery requests. If we
470 * end up deferring the request, esas2r_disc_local_start_request()
471 * will be called to restart it.
472 */
473 rq->req_type = RT_DISC_REQ;
474
475 spin_lock_irqsave(&a->queue_lock, flags);
476
477 if (!test_bit(AF_CHPRST_PENDING, &a->flags) &&
478 !test_bit(AF_FLASHING, &a->flags))
479 esas2r_disc_local_start_request(a, rq);
480 else
481 list_add_tail(&rq->req_list, &a->defer_list);
482
483 spin_unlock_irqrestore(&a->queue_lock, flags);
484
485 return true;
486 }
487
488 void esas2r_disc_local_start_request(struct esas2r_adapter *a,
489 struct esas2r_request *rq)
490 {
491 esas2r_trace_enter();
492
493 list_add_tail(&rq->req_list, &a->active_list);
494
495 esas2r_start_vda_request(a, rq);
496
497 esas2r_trace_exit();
498
499 return;
500 }
501
502 static void esas2r_disc_abort(struct esas2r_adapter *a,
503 struct esas2r_request *rq)
504 {
505 struct esas2r_disc_context *dc =
506 (struct esas2r_disc_context *)rq->interrupt_cx;
507
508 esas2r_trace_enter();
509
510 /* abort the current discovery */
511
512 dc->state = DCS_DISC_DONE;
513
514 esas2r_trace_exit();
515 }
516
517 static bool esas2r_disc_block_dev_scan(struct esas2r_adapter *a,
518 struct esas2r_request *rq)
519 {
520 struct esas2r_disc_context *dc =
521 (struct esas2r_disc_context *)rq->interrupt_cx;
522 bool rslt;
523
524 esas2r_trace_enter();
525
526 esas2r_rq_init_request(rq, a);
527
528 esas2r_build_mgt_req(a,
529 rq,
530 VDAMGT_DEV_SCAN,
531 0,
532 0,
533 0,
534 NULL);
535
536 rq->comp_cb = esas2r_disc_block_dev_scan_cb;
537
538 rq->timeout = 30000;
539 rq->interrupt_cx = dc;
540
541 rslt = esas2r_disc_start_request(a, rq);
542
543 esas2r_trace_exit();
544
545 return rslt;
546 }
547
548 static void esas2r_disc_block_dev_scan_cb(struct esas2r_adapter *a,
549 struct esas2r_request *rq)
550 {
551 struct esas2r_disc_context *dc =
552 (struct esas2r_disc_context *)rq->interrupt_cx;
553 unsigned long flags;
554
555 esas2r_trace_enter();
556
557 spin_lock_irqsave(&a->mem_lock, flags);
558
559 if (rq->req_stat == RS_SUCCESS)
560 dc->scan_gen = rq->func_rsp.mgt_rsp.scan_generation;
561
562 dc->state = DCS_RAID_GRP_INFO;
563 dc->raid_grp_ix = 0;
564
565 esas2r_rq_destroy_request(rq, a);
566
567 /* continue discovery if it's interrupt driven */
568
569 if (!(dc->flags & DCF_POLLED))
570 esas2r_disc_continue(a, rq);
571
572 spin_unlock_irqrestore(&a->mem_lock, flags);
573
574 esas2r_trace_exit();
575 }
576
577 static bool esas2r_disc_raid_grp_info(struct esas2r_adapter *a,
578 struct esas2r_request *rq)
579 {
580 struct esas2r_disc_context *dc =
581 (struct esas2r_disc_context *)rq->interrupt_cx;
582 bool rslt;
583 struct atto_vda_grp_info *grpinfo;
584
585 esas2r_trace_enter();
586
587 esas2r_trace("raid_group_idx: %d", dc->raid_grp_ix);
588
589 if (dc->raid_grp_ix >= VDA_MAX_RAID_GROUPS) {
590 dc->state = DCS_DISC_DONE;
591
592 esas2r_trace_exit();
593
594 return false;
595 }
596
597 esas2r_rq_init_request(rq, a);
598
599 grpinfo = &rq->vda_rsp_data->mgt_data.data.grp_info;
600
601 memset(grpinfo, 0, sizeof(struct atto_vda_grp_info));
602
603 esas2r_build_mgt_req(a,
604 rq,
605 VDAMGT_GRP_INFO,
606 dc->scan_gen,
607 0,
608 sizeof(struct atto_vda_grp_info),
609 NULL);
610
611 grpinfo->grp_index = dc->raid_grp_ix;
612
613 rq->comp_cb = esas2r_disc_raid_grp_info_cb;
614
615 rq->interrupt_cx = dc;
616
617 rslt = esas2r_disc_start_request(a, rq);
618
619 esas2r_trace_exit();
620
621 return rslt;
622 }
623
624 static void esas2r_disc_raid_grp_info_cb(struct esas2r_adapter *a,
625 struct esas2r_request *rq)
626 {
627 struct esas2r_disc_context *dc =
628 (struct esas2r_disc_context *)rq->interrupt_cx;
629 unsigned long flags;
630 struct atto_vda_grp_info *grpinfo;
631
632 esas2r_trace_enter();
633
634 spin_lock_irqsave(&a->mem_lock, flags);
635
636 if (rq->req_stat == RS_SCAN_GEN) {
637 dc->scan_gen = rq->func_rsp.mgt_rsp.scan_generation;
638 dc->raid_grp_ix = 0;
639 goto done;
640 }
641
642 if (rq->req_stat == RS_SUCCESS) {
643 grpinfo = &rq->vda_rsp_data->mgt_data.data.grp_info;
644
645 if (grpinfo->status != VDA_GRP_STAT_ONLINE
646 && grpinfo->status != VDA_GRP_STAT_DEGRADED) {
647 /* go to the next group. */
648
649 dc->raid_grp_ix++;
650 } else {
651 memcpy(&dc->raid_grp_name[0],
652 &grpinfo->grp_name[0],
653 sizeof(grpinfo->grp_name));
654
655 dc->interleave = le32_to_cpu(grpinfo->interleave);
656 dc->block_size = le32_to_cpu(grpinfo->block_size);
657
658 dc->state = DCS_PART_INFO;
659 dc->part_num = 0;
660 }
661 } else {
662 if (!(rq->req_stat == RS_GRP_INVALID)) {
663 esas2r_log(ESAS2R_LOG_WARN,
664 "A request for RAID group info failed - "
665 "returned with %x",
666 rq->req_stat);
667 }
668
669 dc->dev_ix = 0;
670 dc->state = DCS_PT_DEV_INFO;
671 }
672
673 done:
674
675 esas2r_rq_destroy_request(rq, a);
676
677 /* continue discovery if it's interrupt driven */
678
679 if (!(dc->flags & DCF_POLLED))
680 esas2r_disc_continue(a, rq);
681
682 spin_unlock_irqrestore(&a->mem_lock, flags);
683
684 esas2r_trace_exit();
685 }
686
687 static bool esas2r_disc_part_info(struct esas2r_adapter *a,
688 struct esas2r_request *rq)
689 {
690 struct esas2r_disc_context *dc =
691 (struct esas2r_disc_context *)rq->interrupt_cx;
692 bool rslt;
693 struct atto_vdapart_info *partinfo;
694
695 esas2r_trace_enter();
696
697 esas2r_trace("part_num: %d", dc->part_num);
698
699 if (dc->part_num >= VDA_MAX_PARTITIONS) {
700 dc->state = DCS_RAID_GRP_INFO;
701 dc->raid_grp_ix++;
702
703 esas2r_trace_exit();
704
705 return false;
706 }
707
708 esas2r_rq_init_request(rq, a);
709
710 partinfo = &rq->vda_rsp_data->mgt_data.data.part_info;
711
712 memset(partinfo, 0, sizeof(struct atto_vdapart_info));
713
714 esas2r_build_mgt_req(a,
715 rq,
716 VDAMGT_PART_INFO,
717 dc->scan_gen,
718 0,
719 sizeof(struct atto_vdapart_info),
720 NULL);
721
722 partinfo->part_no = dc->part_num;
723
724 memcpy(&partinfo->grp_name[0],
725 &dc->raid_grp_name[0],
726 sizeof(partinfo->grp_name));
727
728 rq->comp_cb = esas2r_disc_part_info_cb;
729
730 rq->interrupt_cx = dc;
731
732 rslt = esas2r_disc_start_request(a, rq);
733
734 esas2r_trace_exit();
735
736 return rslt;
737 }
738
739 static void esas2r_disc_part_info_cb(struct esas2r_adapter *a,
740 struct esas2r_request *rq)
741 {
742 struct esas2r_disc_context *dc =
743 (struct esas2r_disc_context *)rq->interrupt_cx;
744 unsigned long flags;
745 struct atto_vdapart_info *partinfo;
746
747 esas2r_trace_enter();
748
749 spin_lock_irqsave(&a->mem_lock, flags);
750
751 if (rq->req_stat == RS_SCAN_GEN) {
752 dc->scan_gen = rq->func_rsp.mgt_rsp.scan_generation;
753 dc->raid_grp_ix = 0;
754 dc->state = DCS_RAID_GRP_INFO;
755 } else if (rq->req_stat == RS_SUCCESS) {
756 partinfo = &rq->vda_rsp_data->mgt_data.data.part_info;
757
758 dc->part_num = partinfo->part_no;
759
760 dc->curr_virt_id = le16_to_cpu(partinfo->target_id);
761
762 esas2r_targ_db_add_raid(a, dc);
763
764 dc->part_num++;
765 } else {
766 if (!(rq->req_stat == RS_PART_LAST)) {
767 esas2r_log(ESAS2R_LOG_WARN,
768 "A request for RAID group partition info "
769 "failed - status:%d", rq->req_stat);
770 }
771
772 dc->state = DCS_RAID_GRP_INFO;
773 dc->raid_grp_ix++;
774 }
775
776 esas2r_rq_destroy_request(rq, a);
777
778 /* continue discovery if it's interrupt driven */
779
780 if (!(dc->flags & DCF_POLLED))
781 esas2r_disc_continue(a, rq);
782
783 spin_unlock_irqrestore(&a->mem_lock, flags);
784
785 esas2r_trace_exit();
786 }
787
788 static bool esas2r_disc_passthru_dev_info(struct esas2r_adapter *a,
789 struct esas2r_request *rq)
790 {
791 struct esas2r_disc_context *dc =
792 (struct esas2r_disc_context *)rq->interrupt_cx;
793 bool rslt;
794 struct atto_vda_devinfo *devinfo;
795
796 esas2r_trace_enter();
797
798 esas2r_trace("dev_ix: %d", dc->dev_ix);
799
800 esas2r_rq_init_request(rq, a);
801
802 devinfo = &rq->vda_rsp_data->mgt_data.data.dev_info;
803
804 memset(devinfo, 0, sizeof(struct atto_vda_devinfo));
805
806 esas2r_build_mgt_req(a,
807 rq,
808 VDAMGT_DEV_PT_INFO,
809 dc->scan_gen,
810 dc->dev_ix,
811 sizeof(struct atto_vda_devinfo),
812 NULL);
813
814 rq->comp_cb = esas2r_disc_passthru_dev_info_cb;
815
816 rq->interrupt_cx = dc;
817
818 rslt = esas2r_disc_start_request(a, rq);
819
820 esas2r_trace_exit();
821
822 return rslt;
823 }
824
825 static void esas2r_disc_passthru_dev_info_cb(struct esas2r_adapter *a,
826 struct esas2r_request *rq)
827 {
828 struct esas2r_disc_context *dc =
829 (struct esas2r_disc_context *)rq->interrupt_cx;
830 unsigned long flags;
831 struct atto_vda_devinfo *devinfo;
832
833 esas2r_trace_enter();
834
835 spin_lock_irqsave(&a->mem_lock, flags);
836
837 if (rq->req_stat == RS_SCAN_GEN) {
838 dc->scan_gen = rq->func_rsp.mgt_rsp.scan_generation;
839 dc->dev_ix = 0;
840 dc->state = DCS_PT_DEV_INFO;
841 } else if (rq->req_stat == RS_SUCCESS) {
842 devinfo = &rq->vda_rsp_data->mgt_data.data.dev_info;
843
844 dc->dev_ix = le16_to_cpu(rq->func_rsp.mgt_rsp.dev_index);
845
846 dc->curr_virt_id = le16_to_cpu(devinfo->target_id);
847
848 if (le16_to_cpu(devinfo->features) & VDADEVFEAT_PHYS_ID) {
849 dc->curr_phys_id =
850 le16_to_cpu(devinfo->phys_target_id);
851 dc->dev_addr_type = ATTO_GDA_AT_PORT;
852 dc->state = DCS_PT_DEV_ADDR;
853
854 esas2r_trace("curr_virt_id: %d", dc->curr_virt_id);
855 esas2r_trace("curr_phys_id: %d", dc->curr_phys_id);
856 } else {
857 dc->dev_ix++;
858 }
859 } else {
860 if (!(rq->req_stat == RS_DEV_INVALID)) {
861 esas2r_log(ESAS2R_LOG_WARN,
862 "A request for device information failed - "
863 "status:%d", rq->req_stat);
864 }
865
866 dc->state = DCS_DISC_DONE;
867 }
868
869 esas2r_rq_destroy_request(rq, a);
870
871 /* continue discovery if it's interrupt driven */
872
873 if (!(dc->flags & DCF_POLLED))
874 esas2r_disc_continue(a, rq);
875
876 spin_unlock_irqrestore(&a->mem_lock, flags);
877
878 esas2r_trace_exit();
879 }
880
881 static bool esas2r_disc_passthru_dev_addr(struct esas2r_adapter *a,
882 struct esas2r_request *rq)
883 {
884 struct esas2r_disc_context *dc =
885 (struct esas2r_disc_context *)rq->interrupt_cx;
886 bool rslt;
887 struct atto_ioctl *hi;
888 struct esas2r_sg_context sgc;
889
890 esas2r_trace_enter();
891
892 esas2r_rq_init_request(rq, a);
893
894 /* format the request. */
895
896 sgc.cur_offset = NULL;
897 sgc.get_phys_addr = (PGETPHYSADDR)esas2r_disc_get_phys_addr;
898 sgc.length = offsetof(struct atto_ioctl, data)
899 + sizeof(struct atto_hba_get_device_address);
900
901 esas2r_sgc_init(&sgc, a, rq, rq->vrq->ioctl.sge);
902
903 esas2r_build_ioctl_req(a, rq, sgc.length, VDA_IOCTL_HBA);
904
905 if (!esas2r_build_sg_list(a, rq, &sgc)) {
906 esas2r_rq_destroy_request(rq, a);
907
908 esas2r_trace_exit();
909
910 return false;
911 }
912
913 rq->comp_cb = esas2r_disc_passthru_dev_addr_cb;
914
915 rq->interrupt_cx = dc;
916
917 /* format the IOCTL data. */
918
919 hi = (struct atto_ioctl *)a->disc_buffer;
920
921 memset(a->disc_buffer, 0, ESAS2R_DISC_BUF_LEN);
922
923 hi->version = ATTO_VER_GET_DEV_ADDR0;
924 hi->function = ATTO_FUNC_GET_DEV_ADDR;
925 hi->flags = HBAF_TUNNEL;
926
927 hi->data.get_dev_addr.target_id = le32_to_cpu(dc->curr_phys_id);
928 hi->data.get_dev_addr.addr_type = dc->dev_addr_type;
929
930 /* start it up. */
931
932 rslt = esas2r_disc_start_request(a, rq);
933
934 esas2r_trace_exit();
935
936 return rslt;
937 }
938
939 static void esas2r_disc_passthru_dev_addr_cb(struct esas2r_adapter *a,
940 struct esas2r_request *rq)
941 {
942 struct esas2r_disc_context *dc =
943 (struct esas2r_disc_context *)rq->interrupt_cx;
944 struct esas2r_target *t = NULL;
945 unsigned long flags;
946 struct atto_ioctl *hi;
947 u16 addrlen;
948
949 esas2r_trace_enter();
950
951 spin_lock_irqsave(&a->mem_lock, flags);
952
953 hi = (struct atto_ioctl *)a->disc_buffer;
954
955 if (rq->req_stat == RS_SUCCESS
956 && hi->status == ATTO_STS_SUCCESS) {
957 addrlen = le16_to_cpu(hi->data.get_dev_addr.addr_len);
958
959 if (dc->dev_addr_type == ATTO_GDA_AT_PORT) {
960 if (addrlen == sizeof(u64))
961 memcpy(&dc->sas_addr,
962 &hi->data.get_dev_addr.address[0],
963 addrlen);
964 else
965 memset(&dc->sas_addr, 0, sizeof(dc->sas_addr));
966
967 /* Get the unique identifier. */
968 dc->dev_addr_type = ATTO_GDA_AT_UNIQUE;
969
970 goto next_dev_addr;
971 } else {
972 /* Add the pass through target. */
973 if (HIBYTE(addrlen) == 0) {
974 t = esas2r_targ_db_add_pthru(a,
975 dc,
976 &hi->data.
977 get_dev_addr.
978 address[0],
979 (u8)hi->data.
980 get_dev_addr.
981 addr_len);
982
983 if (t)
984 memcpy(&t->sas_addr, &dc->sas_addr,
985 sizeof(t->sas_addr));
986 } else {
987 /* getting the back end data failed */
988
989 esas2r_log(ESAS2R_LOG_WARN,
990 "an error occurred retrieving the "
991 "back end data (%s:%d)",
992 __func__,
993 __LINE__);
994 }
995 }
996 } else {
997 /* getting the back end data failed */
998
999 esas2r_log(ESAS2R_LOG_WARN,
1000 "an error occurred retrieving the back end data - "
1001 "rq->req_stat:%d hi->status:%d",
1002 rq->req_stat, hi->status);
1003 }
1004
1005 /* proceed to the next device. */
1006
1007 if (dc->flags & DCF_DEV_SCAN) {
1008 dc->dev_ix++;
1009 dc->state = DCS_PT_DEV_INFO;
1010 } else if (dc->flags & DCF_DEV_CHANGE) {
1011 dc->curr_targ++;
1012 dc->state = DCS_DEV_ADD;
1013 } else {
1014 esas2r_bugon();
1015 }
1016
1017 next_dev_addr:
1018 esas2r_rq_destroy_request(rq, a);
1019
1020 /* continue discovery if it's interrupt driven */
1021
1022 if (!(dc->flags & DCF_POLLED))
1023 esas2r_disc_continue(a, rq);
1024
1025 spin_unlock_irqrestore(&a->mem_lock, flags);
1026
1027 esas2r_trace_exit();
1028 }
1029
1030 static u32 esas2r_disc_get_phys_addr(struct esas2r_sg_context *sgc, u64 *addr)
1031 {
1032 struct esas2r_adapter *a = sgc->adapter;
1033
1034 if (sgc->length > ESAS2R_DISC_BUF_LEN)
1035 esas2r_bugon();
1036
1037 *addr = a->uncached_phys
1038 + (u64)((u8 *)a->disc_buffer - a->uncached);
1039
1040 return sgc->length;
1041 }
1042
1043 static bool esas2r_disc_dev_remove(struct esas2r_adapter *a,
1044 struct esas2r_request *rq)
1045 {
1046 struct esas2r_disc_context *dc =
1047 (struct esas2r_disc_context *)rq->interrupt_cx;
1048 struct esas2r_target *t;
1049 struct esas2r_target *t2;
1050
1051 esas2r_trace_enter();
1052
1053 /* process removals. */
1054
1055 for (t = a->targetdb; t < a->targetdb_end; t++) {
1056 if (t->new_target_state != TS_NOT_PRESENT)
1057 continue;
1058
1059 t->new_target_state = TS_INVALID;
1060
1061 /* remove the right target! */
1062
1063 t2 =
1064 esas2r_targ_db_find_by_virt_id(a,
1065 esas2r_targ_get_id(t,
1066 a));
1067
1068 if (t2)
1069 esas2r_targ_db_remove(a, t2);
1070 }
1071
1072 /* removals complete. process arrivals. */
1073
1074 dc->state = DCS_DEV_ADD;
1075 dc->curr_targ = a->targetdb;
1076
1077 esas2r_trace_exit();
1078
1079 return false;
1080 }
1081
1082 static bool esas2r_disc_dev_add(struct esas2r_adapter *a,
1083 struct esas2r_request *rq)
1084 {
1085 struct esas2r_disc_context *dc =
1086 (struct esas2r_disc_context *)rq->interrupt_cx;
1087 struct esas2r_target *t = dc->curr_targ;
1088
1089 if (t >= a->targetdb_end) {
1090 /* done processing state changes. */
1091
1092 dc->state = DCS_DISC_DONE;
1093 } else if (t->new_target_state == TS_PRESENT) {
1094 struct atto_vda_ae_lu *luevt = &t->lu_event;
1095
1096 esas2r_trace_enter();
1097
1098 /* clear this now in case more events come in. */
1099
1100 t->new_target_state = TS_INVALID;
1101
1102 /* setup the discovery context for adding this device. */
1103
1104 dc->curr_virt_id = esas2r_targ_get_id(t, a);
1105
1106 if ((luevt->hdr.bylength >= offsetof(struct atto_vda_ae_lu, id)
1107 + sizeof(struct atto_vda_ae_lu_tgt_lun_raid))
1108 && !(luevt->dwevent & VDAAE_LU_PASSTHROUGH)) {
1109 dc->block_size = luevt->id.tgtlun_raid.dwblock_size;
1110 dc->interleave = luevt->id.tgtlun_raid.dwinterleave;
1111 } else {
1112 dc->block_size = 0;
1113 dc->interleave = 0;
1114 }
1115
1116 /* determine the device type being added. */
1117
1118 if (luevt->dwevent & VDAAE_LU_PASSTHROUGH) {
1119 if (luevt->dwevent & VDAAE_LU_PHYS_ID) {
1120 dc->state = DCS_PT_DEV_ADDR;
1121 dc->dev_addr_type = ATTO_GDA_AT_PORT;
1122 dc->curr_phys_id = luevt->wphys_target_id;
1123 } else {
1124 esas2r_log(ESAS2R_LOG_WARN,
1125 "luevt->dwevent does not have the "
1126 "VDAAE_LU_PHYS_ID bit set (%s:%d)",
1127 __func__, __LINE__);
1128 }
1129 } else {
1130 dc->raid_grp_name[0] = 0;
1131
1132 esas2r_targ_db_add_raid(a, dc);
1133 }
1134
1135 esas2r_trace("curr_virt_id: %d", dc->curr_virt_id);
1136 esas2r_trace("curr_phys_id: %d", dc->curr_phys_id);
1137 esas2r_trace("dwevent: %d", luevt->dwevent);
1138
1139 esas2r_trace_exit();
1140 }
1141
1142 if (dc->state == DCS_DEV_ADD) {
1143 /* go to the next device. */
1144
1145 dc->curr_targ++;
1146 }
1147
1148 return false;
1149 }
1150
1151 /*
1152 * When discovery is done, find all requests on defer queue and
1153 * test if they need to be modified. If a target is no longer present
1154 * then complete the request with RS_SEL. Otherwise, update the
1155 * target_id since after a hibernate it can be a different value.
1156 * VDA does not make passthrough target IDs persistent.
1157 */
1158 static void esas2r_disc_fix_curr_requests(struct esas2r_adapter *a)
1159 {
1160 unsigned long flags;
1161 struct esas2r_target *t;
1162 struct esas2r_request *rq;
1163 struct list_head *element;
1164
1165 /* update virt_targ_id in any outstanding esas2r_requests */
1166
1167 spin_lock_irqsave(&a->queue_lock, flags);
1168
1169 list_for_each(element, &a->defer_list) {
1170 rq = list_entry(element, struct esas2r_request, req_list);
1171 if (rq->vrq->scsi.function == VDA_FUNC_SCSI) {
1172 t = a->targetdb + rq->target_id;
1173
1174 if (t->target_state == TS_PRESENT)
1175 rq->vrq->scsi.target_id = le16_to_cpu(
1176 t->virt_targ_id);
1177 else
1178 rq->req_stat = RS_SEL;
1179 }
1180
1181 }
1182
1183 spin_unlock_irqrestore(&a->queue_lock, flags);
1184 }
Linux with added FPC-III support