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 
1038 	*addr = a->uncached_phys
1039 		+ (u64)((u8 *)a->disc_buffer - a->uncached);
1040 
1041 	return sgc->length;
1042 }
1043 
1044 static bool esas2r_disc_dev_remove(struct esas2r_adapter *a,
1045 				   struct esas2r_request *rq)
1046 {
1047 	struct esas2r_disc_context *dc =
1048 		(struct esas2r_disc_context *)rq->interrupt_cx;
1049 	struct esas2r_target *t;
1050 	struct esas2r_target *t2;
1051 
1052 	esas2r_trace_enter();
1053 
1054 	/* process removals. */
1055 
1056 	for (t = a->targetdb; t < a->targetdb_end; t++) {
1057 		if (t->new_target_state != TS_NOT_PRESENT)
1058 			continue;
1059 
1060 		t->new_target_state = TS_INVALID;
1061 
1062 		/* remove the right target! */
1063 
1064 		t2 =
1065 			esas2r_targ_db_find_by_virt_id(a,
1066 						       esas2r_targ_get_id(t,
1067 									  a));
1068 
1069 		if (t2)
1070 			esas2r_targ_db_remove(a, t2);
1071 	}
1072 
1073 	/* removals complete.  process arrivals. */
1074 
1075 	dc->state = DCS_DEV_ADD;
1076 	dc->curr_targ = a->targetdb;
1077 
1078 	esas2r_trace_exit();
1079 
1080 	return false;
1081 }
1082 
1083 static bool esas2r_disc_dev_add(struct esas2r_adapter *a,
1084 				struct esas2r_request *rq)
1085 {
1086 	struct esas2r_disc_context *dc =
1087 		(struct esas2r_disc_context *)rq->interrupt_cx;
1088 	struct esas2r_target *t = dc->curr_targ;
1089 
1090 	if (t >= a->targetdb_end) {
1091 		/* done processing state changes. */
1092 
1093 		dc->state = DCS_DISC_DONE;
1094 	} else if (t->new_target_state == TS_PRESENT) {
1095 		struct atto_vda_ae_lu *luevt = &t->lu_event;
1096 
1097 		esas2r_trace_enter();
1098 
1099 		/* clear this now in case more events come in. */
1100 
1101 		t->new_target_state = TS_INVALID;
1102 
1103 		/* setup the discovery context for adding this device. */
1104 
1105 		dc->curr_virt_id = esas2r_targ_get_id(t, a);
1106 
1107 		if ((luevt->hdr.bylength >= offsetof(struct atto_vda_ae_lu, id)
1108 		     + sizeof(struct atto_vda_ae_lu_tgt_lun_raid))
1109 		    && !(luevt->dwevent & VDAAE_LU_PASSTHROUGH)) {
1110 			dc->block_size = luevt->id.tgtlun_raid.dwblock_size;
1111 			dc->interleave = luevt->id.tgtlun_raid.dwinterleave;
1112 		} else {
1113 			dc->block_size = 0;
1114 			dc->interleave = 0;
1115 		}
1116 
1117 		/* determine the device type being added. */
1118 
1119 		if (luevt->dwevent & VDAAE_LU_PASSTHROUGH) {
1120 			if (luevt->dwevent & VDAAE_LU_PHYS_ID) {
1121 				dc->state = DCS_PT_DEV_ADDR;
1122 				dc->dev_addr_type = ATTO_GDA_AT_PORT;
1123 				dc->curr_phys_id = luevt->wphys_target_id;
1124 			} else {
1125 				esas2r_log(ESAS2R_LOG_WARN,
1126 					   "luevt->dwevent does not have the "
1127 					   "VDAAE_LU_PHYS_ID bit set (%s:%d)",
1128 					   __func__, __LINE__);
1129 			}
1130 		} else {
1131 			dc->raid_grp_name[0] = 0;
1132 
1133 			esas2r_targ_db_add_raid(a, dc);
1134 		}
1135 
1136 		esas2r_trace("curr_virt_id: %d", dc->curr_virt_id);
1137 		esas2r_trace("curr_phys_id: %d", dc->curr_phys_id);
1138 		esas2r_trace("dwevent: %d", luevt->dwevent);
1139 
1140 		esas2r_trace_exit();
1141 	}
1142 
1143 	if (dc->state == DCS_DEV_ADD) {
1144 		/* go to the next device. */
1145 
1146 		dc->curr_targ++;
1147 	}
1148 
1149 	return false;
1150 }
1151 
1152 /*
1153  * When discovery is done, find all requests on defer queue and
1154  * test if they need to be modified. If a target is no longer present
1155  * then complete the request with RS_SEL. Otherwise, update the
1156  * target_id since after a hibernate it can be a different value.
1157  * VDA does not make passthrough target IDs persistent.
1158  */
1159 static void esas2r_disc_fix_curr_requests(struct esas2r_adapter *a)
1160 {
1161 	unsigned long flags;
1162 	struct esas2r_target *t;
1163 	struct esas2r_request *rq;
1164 	struct list_head *element;
1165 
1166 	/* update virt_targ_id in any outstanding esas2r_requests  */
1167 
1168 	spin_lock_irqsave(&a->queue_lock, flags);
1169 
1170 	list_for_each(element, &a->defer_list) {
1171 		rq = list_entry(element, struct esas2r_request, req_list);
1172 		if (rq->vrq->scsi.function == VDA_FUNC_SCSI) {
1173 			t = a->targetdb + rq->target_id;
1174 
1175 			if (t->target_state == TS_PRESENT)
1176 				rq->vrq->scsi.target_id = le16_to_cpu(
1177 					t->virt_targ_id);
1178 			else
1179 				rq->req_stat = RS_SEL;
1180 		}
1181 
1182 	}
1183 
1184 	spin_unlock_irqrestore(&a->queue_lock, flags);
1185 }
1186