1 | /* |
2 | * linux/drivers/scsi/esas2r/esas2r_io.c |
3 | * For use with ATTO ExpressSAS R6xx SAS/SATA RAID controllers |
4 | * |
5 | * Copyright (c) 2001-2013 ATTO Technology, Inc. |
6 | * (mailto:linuxdrivers@attotech.com)mpt3sas/mpt3sas_trigger_diag. |
7 | * |
8 | * This program is free software; you can redistribute it and/or |
9 | * modify it under the terms of the GNU General Public License |
10 | * as published by the Free Software Foundation; either version 2 |
11 | * of the License, or (at your option) any later version. |
12 | * |
13 | * This program is distributed in the hope that it will be useful, |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
16 | * GNU General Public License for more details. |
17 | * |
18 | * NO WARRANTY |
19 | * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR |
20 | * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT |
21 | * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, |
22 | * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is |
23 | * solely responsible for determining the appropriateness of using and |
24 | * distributing the Program and assumes all risks associated with its |
25 | * exercise of rights under this Agreement, including but not limited to |
26 | * the risks and costs of program errors, damage to or loss of data, |
27 | * programs or equipment, and unavailability or interruption of operations. |
28 | * |
29 | * DISCLAIMER OF LIABILITY |
30 | * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY |
31 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
32 | * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND |
33 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR |
34 | * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE |
35 | * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED |
36 | * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES |
37 | * |
38 | * You should have received a copy of the GNU General Public License |
39 | * along with this program; if not, write to the Free Software |
40 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, |
41 | * USA. |
42 | */ |
43 | |
44 | #include "esas2r.h" |
45 | |
46 | void esas2r_start_request(struct esas2r_adapter *a, struct esas2r_request *rq) |
47 | { |
48 | struct esas2r_target *t = NULL; |
49 | struct esas2r_request *startrq = rq; |
50 | unsigned long flags; |
51 | |
52 | if (unlikely(test_bit(AF_DEGRADED_MODE, &a->flags) || |
53 | test_bit(AF_POWER_DOWN, &a->flags))) { |
54 | if (rq->vrq->scsi.function == VDA_FUNC_SCSI) |
55 | rq->req_stat = RS_SEL2; |
56 | else |
57 | rq->req_stat = RS_DEGRADED; |
58 | } else if (likely(rq->vrq->scsi.function == VDA_FUNC_SCSI)) { |
59 | t = a->targetdb + rq->target_id; |
60 | |
61 | if (unlikely(t >= a->targetdb_end |
62 | || !(t->flags & TF_USED))) { |
63 | rq->req_stat = RS_SEL; |
64 | } else { |
65 | /* copy in the target ID. */ |
66 | rq->vrq->scsi.target_id = cpu_to_le16(t->virt_targ_id); |
67 | |
68 | /* |
69 | * Test if we want to report RS_SEL for missing target. |
70 | * Note that if AF_DISC_PENDING is set than this will |
71 | * go on the defer queue. |
72 | */ |
73 | if (unlikely(t->target_state != TS_PRESENT && |
74 | !test_bit(AF_DISC_PENDING, &a->flags))) |
75 | rq->req_stat = RS_SEL; |
76 | } |
77 | } |
78 | |
79 | if (unlikely(rq->req_stat != RS_PENDING)) { |
80 | esas2r_complete_request(a, rq); |
81 | return; |
82 | } |
83 | |
84 | esas2r_trace("rq=%p" , rq); |
85 | esas2r_trace("rq->vrq->scsi.handle=%x" , rq->vrq->scsi.handle); |
86 | |
87 | if (rq->vrq->scsi.function == VDA_FUNC_SCSI) { |
88 | esas2r_trace("rq->target_id=%d" , rq->target_id); |
89 | esas2r_trace("rq->vrq->scsi.flags=%x" , rq->vrq->scsi.flags); |
90 | } |
91 | |
92 | spin_lock_irqsave(&a->queue_lock, flags); |
93 | |
94 | if (likely(list_empty(&a->defer_list) && |
95 | !test_bit(AF_CHPRST_PENDING, &a->flags) && |
96 | !test_bit(AF_FLASHING, &a->flags) && |
97 | !test_bit(AF_DISC_PENDING, &a->flags))) |
98 | esas2r_local_start_request(a, rq: startrq); |
99 | else |
100 | list_add_tail(new: &startrq->req_list, head: &a->defer_list); |
101 | |
102 | spin_unlock_irqrestore(lock: &a->queue_lock, flags); |
103 | } |
104 | |
105 | /* |
106 | * Starts the specified request. all requests have RS_PENDING set when this |
107 | * routine is called. The caller is usually esas2r_start_request, but |
108 | * esas2r_do_deferred_processes will start request that are deferred. |
109 | * |
110 | * The caller must ensure that requests can be started. |
111 | * |
112 | * esas2r_start_request will defer a request if there are already requests |
113 | * waiting or there is a chip reset pending. once the reset condition clears, |
114 | * esas2r_do_deferred_processes will call this function to start the request. |
115 | * |
116 | * When a request is started, it is placed on the active list and queued to |
117 | * the controller. |
118 | */ |
119 | void esas2r_local_start_request(struct esas2r_adapter *a, |
120 | struct esas2r_request *rq) |
121 | { |
122 | esas2r_trace_enter(); |
123 | esas2r_trace("rq=%p" , rq); |
124 | esas2r_trace("rq->vrq:%p" , rq->vrq); |
125 | esas2r_trace("rq->vrq_md->phys_addr:%x" , rq->vrq_md->phys_addr); |
126 | |
127 | if (unlikely(rq->vrq->scsi.function == VDA_FUNC_FLASH |
128 | && rq->vrq->flash.sub_func == VDA_FLASH_COMMIT)) |
129 | set_bit(AF_FLASHING, addr: &a->flags); |
130 | |
131 | list_add_tail(new: &rq->req_list, head: &a->active_list); |
132 | esas2r_start_vda_request(a, rq); |
133 | esas2r_trace_exit(); |
134 | return; |
135 | } |
136 | |
137 | void esas2r_start_vda_request(struct esas2r_adapter *a, |
138 | struct esas2r_request *rq) |
139 | { |
140 | struct esas2r_inbound_list_source_entry *element; |
141 | u32 dw; |
142 | |
143 | rq->req_stat = RS_STARTED; |
144 | /* |
145 | * Calculate the inbound list entry location and the current state of |
146 | * toggle bit. |
147 | */ |
148 | a->last_write++; |
149 | if (a->last_write >= a->list_size) { |
150 | a->last_write = 0; |
151 | /* update the toggle bit */ |
152 | if (test_bit(AF_COMM_LIST_TOGGLE, &a->flags)) |
153 | clear_bit(AF_COMM_LIST_TOGGLE, addr: &a->flags); |
154 | else |
155 | set_bit(AF_COMM_LIST_TOGGLE, addr: &a->flags); |
156 | } |
157 | |
158 | element = |
159 | (struct esas2r_inbound_list_source_entry *)a->inbound_list_md. |
160 | virt_addr |
161 | + a->last_write; |
162 | |
163 | /* Set the VDA request size if it was never modified */ |
164 | if (rq->vda_req_sz == RQ_SIZE_DEFAULT) |
165 | rq->vda_req_sz = (u16)(a->max_vdareq_size / sizeof(u32)); |
166 | |
167 | element->address = cpu_to_le64(rq->vrq_md->phys_addr); |
168 | element->length = cpu_to_le32(rq->vda_req_sz); |
169 | |
170 | /* Update the write pointer */ |
171 | dw = a->last_write; |
172 | |
173 | if (test_bit(AF_COMM_LIST_TOGGLE, &a->flags)) |
174 | dw |= MU_ILW_TOGGLE; |
175 | |
176 | esas2r_trace("rq->vrq->scsi.handle:%x" , rq->vrq->scsi.handle); |
177 | esas2r_trace("dw:%x" , dw); |
178 | esas2r_trace("rq->vda_req_sz:%x" , rq->vda_req_sz); |
179 | esas2r_write_register_dword(a, MU_IN_LIST_WRITE, dw); |
180 | } |
181 | |
182 | /* |
183 | * Build the scatter/gather list for an I/O request according to the |
184 | * specifications placed in the s/g context. The caller must initialize |
185 | * context prior to the initial call by calling esas2r_sgc_init(). |
186 | */ |
187 | bool esas2r_build_sg_list_sge(struct esas2r_adapter *a, |
188 | struct esas2r_sg_context *sgc) |
189 | { |
190 | struct esas2r_request *rq = sgc->first_req; |
191 | union atto_vda_req *vrq = rq->vrq; |
192 | |
193 | while (sgc->length) { |
194 | u32 rem = 0; |
195 | u64 addr; |
196 | u32 len; |
197 | |
198 | len = (*sgc->get_phys_addr)(sgc, &addr); |
199 | |
200 | if (unlikely(len == 0)) |
201 | return false; |
202 | |
203 | /* if current length is more than what's left, stop there */ |
204 | if (unlikely(len > sgc->length)) |
205 | len = sgc->length; |
206 | |
207 | another_entry: |
208 | /* limit to a round number less than the maximum length */ |
209 | if (len > SGE_LEN_MAX) { |
210 | /* |
211 | * Save the remainder of the split. Whenever we limit |
212 | * an entry we come back around to build entries out |
213 | * of the leftover. We do this to prevent multiple |
214 | * calls to the get_phys_addr() function for an SGE |
215 | * that is too large. |
216 | */ |
217 | rem = len - SGE_LEN_MAX; |
218 | len = SGE_LEN_MAX; |
219 | } |
220 | |
221 | /* See if we need to allocate a new SGL */ |
222 | if (unlikely(sgc->sge.a64.curr > sgc->sge.a64.limit)) { |
223 | u8 sgelen; |
224 | struct esas2r_mem_desc *sgl; |
225 | |
226 | /* |
227 | * If no SGls are available, return failure. The |
228 | * caller can call us later with the current context |
229 | * to pick up here. |
230 | */ |
231 | sgl = esas2r_alloc_sgl(a); |
232 | |
233 | if (unlikely(sgl == NULL)) |
234 | return false; |
235 | |
236 | /* Calculate the length of the last SGE filled in */ |
237 | sgelen = (u8)((u8 *)sgc->sge.a64.curr |
238 | - (u8 *)sgc->sge.a64.last); |
239 | |
240 | /* |
241 | * Copy the last SGE filled in to the first entry of |
242 | * the new SGL to make room for the chain entry. |
243 | */ |
244 | memcpy(sgl->virt_addr, sgc->sge.a64.last, sgelen); |
245 | |
246 | /* Figure out the new curr pointer in the new segment */ |
247 | sgc->sge.a64.curr = |
248 | (struct atto_vda_sge *)((u8 *)sgl->virt_addr + |
249 | sgelen); |
250 | |
251 | /* Set the limit pointer and build the chain entry */ |
252 | sgc->sge.a64.limit = |
253 | (struct atto_vda_sge *)((u8 *)sgl->virt_addr |
254 | + sgl_page_size |
255 | - sizeof(struct |
256 | atto_vda_sge)); |
257 | sgc->sge.a64.last->length = cpu_to_le32( |
258 | SGE_CHAIN | SGE_ADDR_64); |
259 | sgc->sge.a64.last->address = |
260 | cpu_to_le64(sgl->phys_addr); |
261 | |
262 | /* |
263 | * Now, if there was a previous chain entry, then |
264 | * update it to contain the length of this segment |
265 | * and size of this chain. otherwise this is the |
266 | * first SGL, so set the chain_offset in the request. |
267 | */ |
268 | if (sgc->sge.a64.chain) { |
269 | sgc->sge.a64.chain->length |= |
270 | cpu_to_le32( |
271 | ((u8 *)(sgc->sge.a64. |
272 | last + 1) |
273 | - (u8 *)rq->sg_table-> |
274 | virt_addr) |
275 | + sizeof(struct atto_vda_sge) * |
276 | LOBIT(SGE_CHAIN_SZ)); |
277 | } else { |
278 | vrq->scsi.chain_offset = (u8) |
279 | ((u8 *)sgc-> |
280 | sge.a64.last - |
281 | (u8 *)vrq); |
282 | |
283 | /* |
284 | * This is the first SGL, so set the |
285 | * chain_offset and the VDA request size in |
286 | * the request. |
287 | */ |
288 | rq->vda_req_sz = |
289 | (vrq->scsi.chain_offset + |
290 | sizeof(struct atto_vda_sge) + |
291 | 3) |
292 | / sizeof(u32); |
293 | } |
294 | |
295 | /* |
296 | * Remember this so when we get a new SGL filled in we |
297 | * can update the length of this chain entry. |
298 | */ |
299 | sgc->sge.a64.chain = sgc->sge.a64.last; |
300 | |
301 | /* Now link the new SGL onto the primary request. */ |
302 | list_add(new: &sgl->next_desc, head: &rq->sg_table_head); |
303 | } |
304 | |
305 | /* Update last one filled in */ |
306 | sgc->sge.a64.last = sgc->sge.a64.curr; |
307 | |
308 | /* Build the new SGE and update the S/G context */ |
309 | sgc->sge.a64.curr->length = cpu_to_le32(SGE_ADDR_64 | len); |
310 | sgc->sge.a64.curr->address = cpu_to_le32(addr); |
311 | sgc->sge.a64.curr++; |
312 | sgc->cur_offset += len; |
313 | sgc->length -= len; |
314 | |
315 | /* |
316 | * Check if we previously split an entry. If so we have to |
317 | * pick up where we left off. |
318 | */ |
319 | if (rem) { |
320 | addr += len; |
321 | len = rem; |
322 | rem = 0; |
323 | goto another_entry; |
324 | } |
325 | } |
326 | |
327 | /* Mark the end of the SGL */ |
328 | sgc->sge.a64.last->length |= cpu_to_le32(SGE_LAST); |
329 | |
330 | /* |
331 | * If there was a previous chain entry, update the length to indicate |
332 | * the length of this last segment. |
333 | */ |
334 | if (sgc->sge.a64.chain) { |
335 | sgc->sge.a64.chain->length |= cpu_to_le32( |
336 | ((u8 *)(sgc->sge.a64.curr) - |
337 | (u8 *)rq->sg_table->virt_addr)); |
338 | } else { |
339 | u16 reqsize; |
340 | |
341 | /* |
342 | * The entire VDA request was not used so lets |
343 | * set the size of the VDA request to be DMA'd |
344 | */ |
345 | reqsize = |
346 | ((u16)((u8 *)sgc->sge.a64.last - (u8 *)vrq) |
347 | + sizeof(struct atto_vda_sge) + 3) / sizeof(u32); |
348 | |
349 | /* |
350 | * Only update the request size if it is bigger than what is |
351 | * already there. We can come in here twice for some management |
352 | * commands. |
353 | */ |
354 | if (reqsize > rq->vda_req_sz) |
355 | rq->vda_req_sz = reqsize; |
356 | } |
357 | return true; |
358 | } |
359 | |
360 | |
361 | /* |
362 | * Create PRD list for each I-block consumed by the command. This routine |
363 | * determines how much data is required from each I-block being consumed |
364 | * by the command. The first and last I-blocks can be partials and all of |
365 | * the I-blocks in between are for a full I-block of data. |
366 | * |
367 | * The interleave size is used to determine the number of bytes in the 1st |
368 | * I-block and the remaining I-blocks are what remeains. |
369 | */ |
370 | static bool esas2r_build_prd_iblk(struct esas2r_adapter *a, |
371 | struct esas2r_sg_context *sgc) |
372 | { |
373 | struct esas2r_request *rq = sgc->first_req; |
374 | u64 addr; |
375 | u32 len; |
376 | struct esas2r_mem_desc *sgl; |
377 | u32 numchain = 1; |
378 | u32 rem = 0; |
379 | |
380 | while (sgc->length) { |
381 | /* Get the next address/length pair */ |
382 | |
383 | len = (*sgc->get_phys_addr)(sgc, &addr); |
384 | |
385 | if (unlikely(len == 0)) |
386 | return false; |
387 | |
388 | /* If current length is more than what's left, stop there */ |
389 | |
390 | if (unlikely(len > sgc->length)) |
391 | len = sgc->length; |
392 | |
393 | another_entry: |
394 | /* Limit to a round number less than the maximum length */ |
395 | |
396 | if (len > PRD_LEN_MAX) { |
397 | /* |
398 | * Save the remainder of the split. whenever we limit |
399 | * an entry we come back around to build entries out |
400 | * of the leftover. We do this to prevent multiple |
401 | * calls to the get_phys_addr() function for an SGE |
402 | * that is too large. |
403 | */ |
404 | rem = len - PRD_LEN_MAX; |
405 | len = PRD_LEN_MAX; |
406 | } |
407 | |
408 | /* See if we need to allocate a new SGL */ |
409 | if (sgc->sge.prd.sge_cnt == 0) { |
410 | if (len == sgc->length) { |
411 | /* |
412 | * We only have 1 PRD entry left. |
413 | * It can be placed where the chain |
414 | * entry would have gone |
415 | */ |
416 | |
417 | /* Build the simple SGE */ |
418 | sgc->sge.prd.curr->ctl_len = cpu_to_le32( |
419 | PRD_DATA | len); |
420 | sgc->sge.prd.curr->address = cpu_to_le64(addr); |
421 | |
422 | /* Adjust length related fields */ |
423 | sgc->cur_offset += len; |
424 | sgc->length -= len; |
425 | |
426 | /* We use the reserved chain entry for data */ |
427 | numchain = 0; |
428 | |
429 | break; |
430 | } |
431 | |
432 | if (sgc->sge.prd.chain) { |
433 | /* |
434 | * Fill # of entries of current SGL in previous |
435 | * chain the length of this current SGL may not |
436 | * full. |
437 | */ |
438 | |
439 | sgc->sge.prd.chain->ctl_len |= cpu_to_le32( |
440 | sgc->sge.prd.sgl_max_cnt); |
441 | } |
442 | |
443 | /* |
444 | * If no SGls are available, return failure. The |
445 | * caller can call us later with the current context |
446 | * to pick up here. |
447 | */ |
448 | |
449 | sgl = esas2r_alloc_sgl(a); |
450 | |
451 | if (unlikely(sgl == NULL)) |
452 | return false; |
453 | |
454 | /* |
455 | * Link the new SGL onto the chain |
456 | * They are in reverse order |
457 | */ |
458 | list_add(new: &sgl->next_desc, head: &rq->sg_table_head); |
459 | |
460 | /* |
461 | * An SGL was just filled in and we are starting |
462 | * a new SGL. Prime the chain of the ending SGL with |
463 | * info that points to the new SGL. The length gets |
464 | * filled in when the new SGL is filled or ended |
465 | */ |
466 | |
467 | sgc->sge.prd.chain = sgc->sge.prd.curr; |
468 | |
469 | sgc->sge.prd.chain->ctl_len = cpu_to_le32(PRD_CHAIN); |
470 | sgc->sge.prd.chain->address = |
471 | cpu_to_le64(sgl->phys_addr); |
472 | |
473 | /* |
474 | * Start a new segment. |
475 | * Take one away and save for chain SGE |
476 | */ |
477 | |
478 | sgc->sge.prd.curr = |
479 | (struct atto_physical_region_description *)sgl |
480 | -> |
481 | virt_addr; |
482 | sgc->sge.prd.sge_cnt = sgc->sge.prd.sgl_max_cnt - 1; |
483 | } |
484 | |
485 | sgc->sge.prd.sge_cnt--; |
486 | /* Build the simple SGE */ |
487 | sgc->sge.prd.curr->ctl_len = cpu_to_le32(PRD_DATA | len); |
488 | sgc->sge.prd.curr->address = cpu_to_le64(addr); |
489 | |
490 | /* Used another element. Point to the next one */ |
491 | |
492 | sgc->sge.prd.curr++; |
493 | |
494 | /* Adjust length related fields */ |
495 | |
496 | sgc->cur_offset += len; |
497 | sgc->length -= len; |
498 | |
499 | /* |
500 | * Check if we previously split an entry. If so we have to |
501 | * pick up where we left off. |
502 | */ |
503 | |
504 | if (rem) { |
505 | addr += len; |
506 | len = rem; |
507 | rem = 0; |
508 | goto another_entry; |
509 | } |
510 | } |
511 | |
512 | if (!list_empty(head: &rq->sg_table_head)) { |
513 | if (sgc->sge.prd.chain) { |
514 | sgc->sge.prd.chain->ctl_len |= |
515 | cpu_to_le32(sgc->sge.prd.sgl_max_cnt |
516 | - sgc->sge.prd.sge_cnt |
517 | - numchain); |
518 | } |
519 | } |
520 | |
521 | return true; |
522 | } |
523 | |
524 | bool esas2r_build_sg_list_prd(struct esas2r_adapter *a, |
525 | struct esas2r_sg_context *sgc) |
526 | { |
527 | struct esas2r_request *rq = sgc->first_req; |
528 | u32 len = sgc->length; |
529 | struct esas2r_target *t = a->targetdb + rq->target_id; |
530 | u8 is_i_o = 0; |
531 | u16 reqsize; |
532 | struct atto_physical_region_description *curr_iblk_chn; |
533 | u8 *cdb = (u8 *)&rq->vrq->scsi.cdb[0]; |
534 | |
535 | /* |
536 | * extract LBA from command so we can determine |
537 | * the I-Block boundary |
538 | */ |
539 | |
540 | if (rq->vrq->scsi.function == VDA_FUNC_SCSI |
541 | && t->target_state == TS_PRESENT |
542 | && !(t->flags & TF_PASS_THRU)) { |
543 | u32 lbalo = 0; |
544 | |
545 | switch (rq->vrq->scsi.cdb[0]) { |
546 | case READ_16: |
547 | case WRITE_16: |
548 | { |
549 | lbalo = |
550 | MAKEDWORD(MAKEWORD(cdb[9], |
551 | cdb[8]), |
552 | MAKEWORD(cdb[7], |
553 | cdb[6])); |
554 | is_i_o = 1; |
555 | break; |
556 | } |
557 | |
558 | case READ_12: |
559 | case WRITE_12: |
560 | case READ_10: |
561 | case WRITE_10: |
562 | { |
563 | lbalo = |
564 | MAKEDWORD(MAKEWORD(cdb[5], |
565 | cdb[4]), |
566 | MAKEWORD(cdb[3], |
567 | cdb[2])); |
568 | is_i_o = 1; |
569 | break; |
570 | } |
571 | |
572 | case READ_6: |
573 | case WRITE_6: |
574 | { |
575 | lbalo = |
576 | MAKEDWORD(MAKEWORD(cdb[3], |
577 | cdb[2]), |
578 | MAKEWORD(cdb[1] & 0x1F, |
579 | 0)); |
580 | is_i_o = 1; |
581 | break; |
582 | } |
583 | |
584 | default: |
585 | break; |
586 | } |
587 | |
588 | if (is_i_o) { |
589 | u32 startlba; |
590 | |
591 | rq->vrq->scsi.iblk_cnt_prd = 0; |
592 | |
593 | /* Determine size of 1st I-block PRD list */ |
594 | startlba = t->inter_block - (lbalo & (t->inter_block - |
595 | 1)); |
596 | sgc->length = startlba * t->block_size; |
597 | |
598 | /* Chk if the 1st iblk chain starts at base of Iblock */ |
599 | if ((lbalo & (t->inter_block - 1)) == 0) |
600 | rq->flags |= RF_1ST_IBLK_BASE; |
601 | |
602 | if (sgc->length > len) |
603 | sgc->length = len; |
604 | } else { |
605 | sgc->length = len; |
606 | } |
607 | } else { |
608 | sgc->length = len; |
609 | } |
610 | |
611 | /* get our starting chain address */ |
612 | |
613 | curr_iblk_chn = |
614 | (struct atto_physical_region_description *)sgc->sge.a64.curr; |
615 | |
616 | sgc->sge.prd.sgl_max_cnt = sgl_page_size / |
617 | sizeof(struct |
618 | atto_physical_region_description); |
619 | |
620 | /* create all of the I-block PRD lists */ |
621 | |
622 | while (len) { |
623 | sgc->sge.prd.sge_cnt = 0; |
624 | sgc->sge.prd.chain = NULL; |
625 | sgc->sge.prd.curr = curr_iblk_chn; |
626 | |
627 | /* increment to next I-Block */ |
628 | |
629 | len -= sgc->length; |
630 | |
631 | /* go build the next I-Block PRD list */ |
632 | |
633 | if (unlikely(!esas2r_build_prd_iblk(a, sgc))) |
634 | return false; |
635 | |
636 | curr_iblk_chn++; |
637 | |
638 | if (is_i_o) { |
639 | rq->vrq->scsi.iblk_cnt_prd++; |
640 | |
641 | if (len > t->inter_byte) |
642 | sgc->length = t->inter_byte; |
643 | else |
644 | sgc->length = len; |
645 | } |
646 | } |
647 | |
648 | /* figure out the size used of the VDA request */ |
649 | |
650 | reqsize = ((u16)((u8 *)curr_iblk_chn - (u8 *)rq->vrq)) |
651 | / sizeof(u32); |
652 | |
653 | /* |
654 | * only update the request size if it is bigger than what is |
655 | * already there. we can come in here twice for some management |
656 | * commands. |
657 | */ |
658 | |
659 | if (reqsize > rq->vda_req_sz) |
660 | rq->vda_req_sz = reqsize; |
661 | |
662 | return true; |
663 | } |
664 | |
665 | static void esas2r_handle_pending_reset(struct esas2r_adapter *a, u32 currtime) |
666 | { |
667 | u32 delta = currtime - a->chip_init_time; |
668 | |
669 | if (delta <= ESAS2R_CHPRST_WAIT_TIME) { |
670 | /* Wait before accessing registers */ |
671 | } else if (delta >= ESAS2R_CHPRST_TIME) { |
672 | /* |
673 | * The last reset failed so try again. Reset |
674 | * processing will give up after three tries. |
675 | */ |
676 | esas2r_local_reset_adapter(a); |
677 | } else { |
678 | /* We can now see if the firmware is ready */ |
679 | u32 doorbell; |
680 | |
681 | doorbell = esas2r_read_register_dword(a, MU_DOORBELL_OUT); |
682 | if (doorbell == 0xFFFFFFFF || !(doorbell & DRBL_FORCE_INT)) { |
683 | esas2r_force_interrupt(a); |
684 | } else { |
685 | u32 ver = (doorbell & DRBL_FW_VER_MSK); |
686 | |
687 | /* Driver supports API version 0 and 1 */ |
688 | esas2r_write_register_dword(a, MU_DOORBELL_OUT, |
689 | doorbell); |
690 | if (ver == DRBL_FW_VER_0) { |
691 | set_bit(AF_CHPRST_DETECTED, addr: &a->flags); |
692 | set_bit(AF_LEGACY_SGE_MODE, addr: &a->flags); |
693 | |
694 | a->max_vdareq_size = 128; |
695 | a->build_sgl = esas2r_build_sg_list_sge; |
696 | } else if (ver == DRBL_FW_VER_1) { |
697 | set_bit(AF_CHPRST_DETECTED, addr: &a->flags); |
698 | clear_bit(AF_LEGACY_SGE_MODE, addr: &a->flags); |
699 | |
700 | a->max_vdareq_size = 1024; |
701 | a->build_sgl = esas2r_build_sg_list_prd; |
702 | } else { |
703 | esas2r_local_reset_adapter(a); |
704 | } |
705 | } |
706 | } |
707 | } |
708 | |
709 | |
710 | /* This function must be called once per timer tick */ |
711 | void esas2r_timer_tick(struct esas2r_adapter *a) |
712 | { |
713 | u32 currtime = jiffies_to_msecs(j: jiffies); |
714 | u32 deltatime = currtime - a->last_tick_time; |
715 | |
716 | a->last_tick_time = currtime; |
717 | |
718 | /* count down the uptime */ |
719 | if (a->chip_uptime && |
720 | !test_bit(AF_CHPRST_PENDING, &a->flags) && |
721 | !test_bit(AF_DISC_PENDING, &a->flags)) { |
722 | if (deltatime >= a->chip_uptime) |
723 | a->chip_uptime = 0; |
724 | else |
725 | a->chip_uptime -= deltatime; |
726 | } |
727 | |
728 | if (test_bit(AF_CHPRST_PENDING, &a->flags)) { |
729 | if (!test_bit(AF_CHPRST_NEEDED, &a->flags) && |
730 | !test_bit(AF_CHPRST_DETECTED, &a->flags)) |
731 | esas2r_handle_pending_reset(a, currtime); |
732 | } else { |
733 | if (test_bit(AF_DISC_PENDING, &a->flags)) |
734 | esas2r_disc_check_complete(a); |
735 | if (test_bit(AF_HEARTBEAT_ENB, &a->flags)) { |
736 | if (test_bit(AF_HEARTBEAT, &a->flags)) { |
737 | if ((currtime - a->heartbeat_time) >= |
738 | ESAS2R_HEARTBEAT_TIME) { |
739 | clear_bit(AF_HEARTBEAT, addr: &a->flags); |
740 | esas2r_hdebug("heartbeat failed" ); |
741 | esas2r_log(level: ESAS2R_LOG_CRIT, |
742 | format: "heartbeat failed" ); |
743 | esas2r_bugon(); |
744 | esas2r_local_reset_adapter(a); |
745 | } |
746 | } else { |
747 | set_bit(AF_HEARTBEAT, addr: &a->flags); |
748 | a->heartbeat_time = currtime; |
749 | esas2r_force_interrupt(a); |
750 | } |
751 | } |
752 | } |
753 | |
754 | if (atomic_read(v: &a->disable_cnt) == 0) |
755 | esas2r_do_deferred_processes(a); |
756 | } |
757 | |
758 | /* |
759 | * Send the specified task management function to the target and LUN |
760 | * specified in rqaux. in addition, immediately abort any commands that |
761 | * are queued but not sent to the device according to the rules specified |
762 | * by the task management function. |
763 | */ |
764 | bool esas2r_send_task_mgmt(struct esas2r_adapter *a, |
765 | struct esas2r_request *rqaux, u8 task_mgt_func) |
766 | { |
767 | u16 targetid = rqaux->target_id; |
768 | u8 lun = (u8)le32_to_cpu(rqaux->vrq->scsi.flags); |
769 | bool ret = false; |
770 | struct esas2r_request *rq; |
771 | struct list_head *next, *element; |
772 | unsigned long flags; |
773 | |
774 | LIST_HEAD(comp_list); |
775 | |
776 | esas2r_trace_enter(); |
777 | esas2r_trace("rqaux:%p" , rqaux); |
778 | esas2r_trace("task_mgt_func:%x" , task_mgt_func); |
779 | spin_lock_irqsave(&a->queue_lock, flags); |
780 | |
781 | /* search the defer queue looking for requests for the device */ |
782 | list_for_each_safe(element, next, &a->defer_list) { |
783 | rq = list_entry(element, struct esas2r_request, req_list); |
784 | |
785 | if (rq->vrq->scsi.function == VDA_FUNC_SCSI |
786 | && rq->target_id == targetid |
787 | && (((u8)le32_to_cpu(rq->vrq->scsi.flags)) == lun |
788 | || task_mgt_func == 0x20)) { /* target reset */ |
789 | /* Found a request affected by the task management */ |
790 | if (rq->req_stat == RS_PENDING) { |
791 | /* |
792 | * The request is pending or waiting. We can |
793 | * safelycomplete the request now. |
794 | */ |
795 | if (esas2r_ioreq_aborted(a, rq, RS_ABORTED)) |
796 | list_add_tail(new: &rq->comp_list, |
797 | head: &comp_list); |
798 | } |
799 | } |
800 | } |
801 | |
802 | /* Send the task management request to the firmware */ |
803 | rqaux->sense_len = 0; |
804 | rqaux->vrq->scsi.length = 0; |
805 | rqaux->target_id = targetid; |
806 | rqaux->vrq->scsi.flags |= cpu_to_le32(lun); |
807 | memset(rqaux->vrq->scsi.cdb, 0, sizeof(rqaux->vrq->scsi.cdb)); |
808 | rqaux->vrq->scsi.flags |= |
809 | cpu_to_le16(task_mgt_func * LOBIT(FCP_CMND_TM_MASK)); |
810 | |
811 | if (test_bit(AF_FLASHING, &a->flags)) { |
812 | /* Assume success. if there are active requests, return busy */ |
813 | rqaux->req_stat = RS_SUCCESS; |
814 | |
815 | list_for_each_safe(element, next, &a->active_list) { |
816 | rq = list_entry(element, struct esas2r_request, |
817 | req_list); |
818 | if (rq->vrq->scsi.function == VDA_FUNC_SCSI |
819 | && rq->target_id == targetid |
820 | && (((u8)le32_to_cpu(rq->vrq->scsi.flags)) == lun |
821 | || task_mgt_func == 0x20)) /* target reset */ |
822 | rqaux->req_stat = RS_BUSY; |
823 | } |
824 | |
825 | ret = true; |
826 | } |
827 | |
828 | spin_unlock_irqrestore(lock: &a->queue_lock, flags); |
829 | |
830 | if (!test_bit(AF_FLASHING, &a->flags)) |
831 | esas2r_start_request(a, rq: rqaux); |
832 | |
833 | esas2r_comp_list_drain(a, comp_list: &comp_list); |
834 | |
835 | if (atomic_read(v: &a->disable_cnt) == 0) |
836 | esas2r_do_deferred_processes(a); |
837 | |
838 | esas2r_trace_exit(); |
839 | |
840 | return ret; |
841 | } |
842 | |
843 | void esas2r_reset_bus(struct esas2r_adapter *a) |
844 | { |
845 | esas2r_log(level: ESAS2R_LOG_INFO, format: "performing a bus reset" ); |
846 | |
847 | if (!test_bit(AF_DEGRADED_MODE, &a->flags) && |
848 | !test_bit(AF_CHPRST_PENDING, &a->flags) && |
849 | !test_bit(AF_DISC_PENDING, &a->flags)) { |
850 | set_bit(AF_BUSRST_NEEDED, addr: &a->flags); |
851 | set_bit(AF_BUSRST_PENDING, addr: &a->flags); |
852 | set_bit(AF_OS_RESET, addr: &a->flags); |
853 | |
854 | esas2r_schedule_tasklet(a); |
855 | } |
856 | } |
857 | |
858 | bool esas2r_ioreq_aborted(struct esas2r_adapter *a, struct esas2r_request *rq, |
859 | u8 status) |
860 | { |
861 | esas2r_trace_enter(); |
862 | esas2r_trace("rq:%p" , rq); |
863 | list_del_init(entry: &rq->req_list); |
864 | if (rq->timeout > RQ_MAX_TIMEOUT) { |
865 | /* |
866 | * The request timed out, but we could not abort it because a |
867 | * chip reset occurred. Return busy status. |
868 | */ |
869 | rq->req_stat = RS_BUSY; |
870 | esas2r_trace_exit(); |
871 | return true; |
872 | } |
873 | |
874 | rq->req_stat = status; |
875 | esas2r_trace_exit(); |
876 | return true; |
877 | } |
878 | |