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