Commit | Line | Data |
---|---|---|
65c85c83 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
2908d778 JB |
2 | /* |
3 | * Aic94xx SAS/SATA Tasks | |
4 | * | |
5 | * Copyright (C) 2005 Adaptec, Inc. All rights reserved. | |
6 | * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com> | |
2908d778 JB |
7 | */ |
8 | ||
9 | #include <linux/spinlock.h> | |
10 | #include "aic94xx.h" | |
11 | #include "aic94xx_sas.h" | |
12 | #include "aic94xx_hwi.h" | |
13 | ||
14 | static void asd_unbuild_ata_ascb(struct asd_ascb *a); | |
15 | static void asd_unbuild_smp_ascb(struct asd_ascb *a); | |
16 | static void asd_unbuild_ssp_ascb(struct asd_ascb *a); | |
17 | ||
81e56ded | 18 | static void asd_can_dequeue(struct asd_ha_struct *asd_ha, int num) |
2908d778 JB |
19 | { |
20 | unsigned long flags; | |
21 | ||
22 | spin_lock_irqsave(&asd_ha->seq.pend_q_lock, flags); | |
23 | asd_ha->seq.can_queue += num; | |
24 | spin_unlock_irqrestore(&asd_ha->seq.pend_q_lock, flags); | |
25 | } | |
26 | ||
3a21986f | 27 | /* DMA_... to our direction translation. |
2908d778 JB |
28 | */ |
29 | static const u8 data_dir_flags[] = { | |
3a21986f CH |
30 | [DMA_BIDIRECTIONAL] = DATA_DIR_BYRECIPIENT, /* UNSPECIFIED */ |
31 | [DMA_TO_DEVICE] = DATA_DIR_OUT, /* OUTBOUND */ | |
32 | [DMA_FROM_DEVICE] = DATA_DIR_IN, /* INBOUND */ | |
33 | [DMA_NONE] = DATA_DIR_NONE, /* NO TRANSFER */ | |
2908d778 JB |
34 | }; |
35 | ||
81e56ded AB |
36 | static int asd_map_scatterlist(struct sas_task *task, |
37 | struct sg_el *sg_arr, | |
38 | gfp_t gfp_flags) | |
2908d778 JB |
39 | { |
40 | struct asd_ascb *ascb = task->lldd_task; | |
41 | struct asd_ha_struct *asd_ha = ascb->ha; | |
42 | struct scatterlist *sc; | |
43 | int num_sg, res; | |
44 | ||
3a21986f | 45 | if (task->data_dir == DMA_NONE) |
2908d778 JB |
46 | return 0; |
47 | ||
48 | if (task->num_scatter == 0) { | |
49 | void *p = task->scatter; | |
3a21986f | 50 | dma_addr_t dma = dma_map_single(&asd_ha->pcidev->dev, p, |
2908d778 JB |
51 | task->total_xfer_len, |
52 | task->data_dir); | |
53 | sg_arr[0].bus_addr = cpu_to_le64((u64)dma); | |
54 | sg_arr[0].size = cpu_to_le32(task->total_xfer_len); | |
55 | sg_arr[0].flags |= ASD_SG_EL_LIST_EOL; | |
56 | return 0; | |
57 | } | |
58 | ||
ba330ffe DW |
59 | /* STP tasks come from libata which has already mapped |
60 | * the SG list */ | |
0f05df8b | 61 | if (sas_protocol_ata(task->task_proto)) |
ba330ffe DW |
62 | num_sg = task->num_scatter; |
63 | else | |
3a21986f | 64 | num_sg = dma_map_sg(&asd_ha->pcidev->dev, task->scatter, |
ba330ffe | 65 | task->num_scatter, task->data_dir); |
2908d778 JB |
66 | if (num_sg == 0) |
67 | return -ENOMEM; | |
68 | ||
69 | if (num_sg > 3) { | |
70 | int i; | |
71 | ||
72 | ascb->sg_arr = asd_alloc_coherent(asd_ha, | |
73 | num_sg*sizeof(struct sg_el), | |
74 | gfp_flags); | |
75 | if (!ascb->sg_arr) { | |
76 | res = -ENOMEM; | |
77 | goto err_unmap; | |
78 | } | |
8145bfe4 | 79 | for_each_sg(task->scatter, sc, num_sg, i) { |
2908d778 JB |
80 | struct sg_el *sg = |
81 | &((struct sg_el *)ascb->sg_arr->vaddr)[i]; | |
82 | sg->bus_addr = cpu_to_le64((u64)sg_dma_address(sc)); | |
83 | sg->size = cpu_to_le32((u32)sg_dma_len(sc)); | |
84 | if (i == num_sg-1) | |
85 | sg->flags |= ASD_SG_EL_LIST_EOL; | |
86 | } | |
87 | ||
8145bfe4 | 88 | for_each_sg(task->scatter, sc, 2, i) { |
2908d778 JB |
89 | sg_arr[i].bus_addr = |
90 | cpu_to_le64((u64)sg_dma_address(sc)); | |
91 | sg_arr[i].size = cpu_to_le32((u32)sg_dma_len(sc)); | |
92 | } | |
93 | sg_arr[1].next_sg_offs = 2 * sizeof(*sg_arr); | |
94 | sg_arr[1].flags |= ASD_SG_EL_LIST_EOS; | |
95 | ||
96 | memset(&sg_arr[2], 0, sizeof(*sg_arr)); | |
97 | sg_arr[2].bus_addr=cpu_to_le64((u64)ascb->sg_arr->dma_handle); | |
98 | } else { | |
99 | int i; | |
8145bfe4 | 100 | for_each_sg(task->scatter, sc, num_sg, i) { |
2908d778 JB |
101 | sg_arr[i].bus_addr = |
102 | cpu_to_le64((u64)sg_dma_address(sc)); | |
103 | sg_arr[i].size = cpu_to_le32((u32)sg_dma_len(sc)); | |
104 | } | |
105 | sg_arr[i-1].flags |= ASD_SG_EL_LIST_EOL; | |
106 | } | |
107 | ||
108 | return 0; | |
109 | err_unmap: | |
0f05df8b | 110 | if (sas_protocol_ata(task->task_proto)) |
3a21986f CH |
111 | dma_unmap_sg(&asd_ha->pcidev->dev, task->scatter, |
112 | task->num_scatter, task->data_dir); | |
2908d778 JB |
113 | return res; |
114 | } | |
115 | ||
81e56ded | 116 | static void asd_unmap_scatterlist(struct asd_ascb *ascb) |
2908d778 JB |
117 | { |
118 | struct asd_ha_struct *asd_ha = ascb->ha; | |
119 | struct sas_task *task = ascb->uldd_task; | |
120 | ||
3a21986f | 121 | if (task->data_dir == DMA_NONE) |
2908d778 JB |
122 | return; |
123 | ||
124 | if (task->num_scatter == 0) { | |
125 | dma_addr_t dma = (dma_addr_t) | |
126 | le64_to_cpu(ascb->scb->ssp_task.sg_element[0].bus_addr); | |
3a21986f CH |
127 | dma_unmap_single(&ascb->ha->pcidev->dev, dma, |
128 | task->total_xfer_len, task->data_dir); | |
2908d778 JB |
129 | return; |
130 | } | |
131 | ||
132 | asd_free_coherent(asd_ha, ascb->sg_arr); | |
ba330ffe | 133 | if (task->task_proto != SAS_PROTOCOL_STP) |
3a21986f CH |
134 | dma_unmap_sg(&asd_ha->pcidev->dev, task->scatter, |
135 | task->num_scatter, task->data_dir); | |
2908d778 JB |
136 | } |
137 | ||
138 | /* ---------- Task complete tasklet ---------- */ | |
139 | ||
140 | static void asd_get_response_tasklet(struct asd_ascb *ascb, | |
141 | struct done_list_struct *dl) | |
142 | { | |
143 | struct asd_ha_struct *asd_ha = ascb->ha; | |
144 | struct sas_task *task = ascb->uldd_task; | |
145 | struct task_status_struct *ts = &task->task_status; | |
146 | unsigned long flags; | |
147 | struct tc_resp_sb_struct { | |
148 | __le16 index_escb; | |
149 | u8 len_lsb; | |
150 | u8 flags; | |
151 | } __attribute__ ((packed)) *resp_sb = (void *) dl->status_block; | |
152 | ||
153 | /* int size = ((resp_sb->flags & 7) << 8) | resp_sb->len_lsb; */ | |
154 | int edb_id = ((resp_sb->flags & 0x70) >> 4)-1; | |
155 | struct asd_ascb *escb; | |
156 | struct asd_dma_tok *edb; | |
157 | void *r; | |
158 | ||
159 | spin_lock_irqsave(&asd_ha->seq.tc_index_lock, flags); | |
160 | escb = asd_tc_index_find(&asd_ha->seq, | |
161 | (int)le16_to_cpu(resp_sb->index_escb)); | |
162 | spin_unlock_irqrestore(&asd_ha->seq.tc_index_lock, flags); | |
163 | ||
164 | if (!escb) { | |
165 | ASD_DPRINTK("Uh-oh! No escb for this dl?!\n"); | |
166 | return; | |
167 | } | |
168 | ||
169 | ts->buf_valid_size = 0; | |
170 | edb = asd_ha->seq.edb_arr[edb_id + escb->edb_index]; | |
171 | r = edb->vaddr; | |
5929faf3 | 172 | if (task->task_proto == SAS_PROTOCOL_SSP) { |
2908d778 JB |
173 | struct ssp_response_iu *iu = |
174 | r + 16 + sizeof(struct ssp_frame_hdr); | |
175 | ||
176 | ts->residual = le32_to_cpu(*(__le32 *)r); | |
366ca51f JB |
177 | |
178 | sas_ssp_task_response(&asd_ha->pcidev->dev, task, iu); | |
2908d778 JB |
179 | } else { |
180 | struct ata_task_resp *resp = (void *) &ts->buf[0]; | |
181 | ||
182 | ts->residual = le32_to_cpu(*(__le32 *)r); | |
183 | ||
184 | if (SAS_STATUS_BUF_SIZE >= sizeof(*resp)) { | |
185 | resp->frame_len = le16_to_cpu(*(__le16 *)(r+6)); | |
6ef1b512 | 186 | memcpy(&resp->ending_fis[0], r+16, ATA_RESP_FIS_SIZE); |
2908d778 JB |
187 | ts->buf_valid_size = sizeof(*resp); |
188 | } | |
189 | } | |
190 | ||
191 | asd_invalidate_edb(escb, edb_id); | |
192 | } | |
193 | ||
194 | static void asd_task_tasklet_complete(struct asd_ascb *ascb, | |
195 | struct done_list_struct *dl) | |
196 | { | |
197 | struct sas_task *task = ascb->uldd_task; | |
198 | struct task_status_struct *ts = &task->task_status; | |
199 | unsigned long flags; | |
200 | u8 opcode = dl->opcode; | |
201 | ||
202 | asd_can_dequeue(ascb->ha, 1); | |
203 | ||
204 | Again: | |
205 | switch (opcode) { | |
206 | case TC_NO_ERROR: | |
207 | ts->resp = SAS_TASK_COMPLETE; | |
df64d3ca | 208 | ts->stat = SAM_STAT_GOOD; |
2908d778 JB |
209 | break; |
210 | case TC_UNDERRUN: | |
211 | ts->resp = SAS_TASK_COMPLETE; | |
212 | ts->stat = SAS_DATA_UNDERRUN; | |
213 | ts->residual = le32_to_cpu(*(__le32 *)dl->status_block); | |
214 | break; | |
215 | case TC_OVERRUN: | |
216 | ts->resp = SAS_TASK_COMPLETE; | |
217 | ts->stat = SAS_DATA_OVERRUN; | |
218 | ts->residual = 0; | |
219 | break; | |
220 | case TC_SSP_RESP: | |
221 | case TC_ATA_RESP: | |
222 | ts->resp = SAS_TASK_COMPLETE; | |
223 | ts->stat = SAS_PROTO_RESPONSE; | |
224 | asd_get_response_tasklet(ascb, dl); | |
225 | break; | |
226 | case TF_OPEN_REJECT: | |
227 | ts->resp = SAS_TASK_UNDELIVERED; | |
228 | ts->stat = SAS_OPEN_REJECT; | |
229 | if (dl->status_block[1] & 2) | |
230 | ts->open_rej_reason = 1 + dl->status_block[2]; | |
231 | else if (dl->status_block[1] & 1) | |
232 | ts->open_rej_reason = (dl->status_block[2] >> 4)+10; | |
233 | else | |
234 | ts->open_rej_reason = SAS_OREJ_UNKNOWN; | |
235 | break; | |
236 | case TF_OPEN_TO: | |
237 | ts->resp = SAS_TASK_UNDELIVERED; | |
238 | ts->stat = SAS_OPEN_TO; | |
239 | break; | |
240 | case TF_PHY_DOWN: | |
241 | case TU_PHY_DOWN: | |
242 | ts->resp = SAS_TASK_UNDELIVERED; | |
243 | ts->stat = SAS_PHY_DOWN; | |
244 | break; | |
245 | case TI_PHY_DOWN: | |
246 | ts->resp = SAS_TASK_COMPLETE; | |
247 | ts->stat = SAS_PHY_DOWN; | |
248 | break; | |
249 | case TI_BREAK: | |
250 | case TI_PROTO_ERR: | |
251 | case TI_NAK: | |
252 | case TI_ACK_NAK_TO: | |
253 | case TF_SMP_XMIT_RCV_ERR: | |
254 | case TC_ATA_R_ERR_RECV: | |
255 | ts->resp = SAS_TASK_COMPLETE; | |
256 | ts->stat = SAS_INTERRUPTED; | |
257 | break; | |
258 | case TF_BREAK: | |
259 | case TU_BREAK: | |
260 | case TU_ACK_NAK_TO: | |
261 | case TF_SMPRSP_TO: | |
262 | ts->resp = SAS_TASK_UNDELIVERED; | |
263 | ts->stat = SAS_DEV_NO_RESPONSE; | |
264 | break; | |
265 | case TF_NAK_RECV: | |
266 | ts->resp = SAS_TASK_COMPLETE; | |
267 | ts->stat = SAS_NAK_R_ERR; | |
268 | break; | |
269 | case TA_I_T_NEXUS_LOSS: | |
270 | opcode = dl->status_block[0]; | |
271 | goto Again; | |
272 | break; | |
273 | case TF_INV_CONN_HANDLE: | |
274 | ts->resp = SAS_TASK_UNDELIVERED; | |
275 | ts->stat = SAS_DEVICE_UNKNOWN; | |
276 | break; | |
277 | case TF_REQUESTED_N_PENDING: | |
278 | ts->resp = SAS_TASK_UNDELIVERED; | |
279 | ts->stat = SAS_PENDING; | |
280 | break; | |
281 | case TC_TASK_CLEARED: | |
282 | case TA_ON_REQ: | |
283 | ts->resp = SAS_TASK_COMPLETE; | |
284 | ts->stat = SAS_ABORTED_TASK; | |
285 | break; | |
286 | ||
287 | case TF_NO_SMP_CONN: | |
288 | case TF_TMF_NO_CTX: | |
289 | case TF_TMF_NO_TAG: | |
290 | case TF_TMF_TAG_FREE: | |
291 | case TF_TMF_TASK_DONE: | |
292 | case TF_TMF_NO_CONN_HANDLE: | |
293 | case TF_IRTT_TO: | |
294 | case TF_IU_SHORT: | |
295 | case TF_DATA_OFFS_ERR: | |
296 | ts->resp = SAS_TASK_UNDELIVERED; | |
297 | ts->stat = SAS_DEV_NO_RESPONSE; | |
298 | break; | |
299 | ||
300 | case TC_LINK_ADM_RESP: | |
301 | case TC_CONTROL_PHY: | |
302 | case TC_RESUME: | |
303 | case TC_PARTIAL_SG_LIST: | |
304 | default: | |
cadbd4a5 | 305 | ASD_DPRINTK("%s: dl opcode: 0x%x?\n", __func__, opcode); |
2908d778 JB |
306 | break; |
307 | } | |
308 | ||
309 | switch (task->task_proto) { | |
5929faf3 DW |
310 | case SAS_PROTOCOL_SATA: |
311 | case SAS_PROTOCOL_STP: | |
2908d778 JB |
312 | asd_unbuild_ata_ascb(ascb); |
313 | break; | |
5929faf3 | 314 | case SAS_PROTOCOL_SMP: |
2908d778 JB |
315 | asd_unbuild_smp_ascb(ascb); |
316 | break; | |
5929faf3 | 317 | case SAS_PROTOCOL_SSP: |
2908d778 JB |
318 | asd_unbuild_ssp_ascb(ascb); |
319 | default: | |
320 | break; | |
321 | } | |
322 | ||
323 | spin_lock_irqsave(&task->task_state_lock, flags); | |
324 | task->task_state_flags &= ~SAS_TASK_STATE_PENDING; | |
b218a0d8 | 325 | task->task_state_flags &= ~SAS_TASK_AT_INITIATOR; |
2908d778 JB |
326 | task->task_state_flags |= SAS_TASK_STATE_DONE; |
327 | if (unlikely((task->task_state_flags & SAS_TASK_STATE_ABORTED))) { | |
e2396f1e | 328 | struct completion *completion = ascb->completion; |
2908d778 JB |
329 | spin_unlock_irqrestore(&task->task_state_lock, flags); |
330 | ASD_DPRINTK("task 0x%p done with opcode 0x%x resp 0x%x " | |
331 | "stat 0x%x but aborted by upper layer!\n", | |
332 | task, opcode, ts->resp, ts->stat); | |
e2396f1e JB |
333 | if (completion) |
334 | complete(completion); | |
2908d778 JB |
335 | } else { |
336 | spin_unlock_irqrestore(&task->task_state_lock, flags); | |
337 | task->lldd_task = NULL; | |
338 | asd_ascb_free(ascb); | |
339 | mb(); | |
340 | task->task_done(task); | |
341 | } | |
342 | } | |
343 | ||
344 | /* ---------- ATA ---------- */ | |
345 | ||
346 | static int asd_build_ata_ascb(struct asd_ascb *ascb, struct sas_task *task, | |
3cc27547 | 347 | gfp_t gfp_flags) |
2908d778 JB |
348 | { |
349 | struct domain_device *dev = task->dev; | |
350 | struct scb *scb; | |
351 | u8 flags; | |
352 | int res = 0; | |
353 | ||
354 | scb = ascb->scb; | |
355 | ||
356 | if (unlikely(task->ata_task.device_control_reg_update)) | |
357 | scb->header.opcode = CONTROL_ATA_DEV; | |
1cbd772d | 358 | else if (dev->sata_dev.class == ATA_DEV_ATAPI) |
2908d778 | 359 | scb->header.opcode = INITIATE_ATAPI_TASK; |
1cbd772d HR |
360 | else |
361 | scb->header.opcode = INITIATE_ATA_TASK; | |
2908d778 JB |
362 | |
363 | scb->ata_task.proto_conn_rate = (1 << 5); /* STP */ | |
364 | if (dev->port->oob_mode == SAS_OOB_MODE) | |
365 | scb->ata_task.proto_conn_rate |= dev->linkrate; | |
366 | ||
367 | scb->ata_task.total_xfer_len = cpu_to_le32(task->total_xfer_len); | |
368 | scb->ata_task.fis = task->ata_task.fis; | |
2908d778 JB |
369 | if (likely(!task->ata_task.device_control_reg_update)) |
370 | scb->ata_task.fis.flags |= 0x80; /* C=1: update ATA cmd reg */ | |
371 | scb->ata_task.fis.flags &= 0xF0; /* PM_PORT field shall be 0 */ | |
1cbd772d | 372 | if (dev->sata_dev.class == ATA_DEV_ATAPI) |
2908d778 JB |
373 | memcpy(scb->ata_task.atapi_packet, task->ata_task.atapi_packet, |
374 | 16); | |
375 | scb->ata_task.sister_scb = cpu_to_le16(0xFFFF); | |
376 | scb->ata_task.conn_handle = cpu_to_le16( | |
377 | (u16)(unsigned long)dev->lldd_dev); | |
378 | ||
379 | if (likely(!task->ata_task.device_control_reg_update)) { | |
380 | flags = 0; | |
381 | if (task->ata_task.dma_xfer) | |
382 | flags |= DATA_XFER_MODE_DMA; | |
383 | if (task->ata_task.use_ncq && | |
1cbd772d | 384 | dev->sata_dev.class != ATA_DEV_ATAPI) |
2908d778 JB |
385 | flags |= ATA_Q_TYPE_NCQ; |
386 | flags |= data_dir_flags[task->data_dir]; | |
387 | scb->ata_task.ata_flags = flags; | |
388 | ||
389 | scb->ata_task.retry_count = task->ata_task.retry_count; | |
390 | ||
391 | flags = 0; | |
392 | if (task->ata_task.set_affil_pol) | |
393 | flags |= SET_AFFIL_POLICY; | |
394 | if (task->ata_task.stp_affil_pol) | |
395 | flags |= STP_AFFIL_POLICY; | |
396 | scb->ata_task.flags = flags; | |
397 | } | |
398 | ascb->tasklet_complete = asd_task_tasklet_complete; | |
399 | ||
400 | if (likely(!task->ata_task.device_control_reg_update)) | |
401 | res = asd_map_scatterlist(task, scb->ata_task.sg_element, | |
402 | gfp_flags); | |
403 | ||
404 | return res; | |
405 | } | |
406 | ||
407 | static void asd_unbuild_ata_ascb(struct asd_ascb *a) | |
408 | { | |
409 | asd_unmap_scatterlist(a); | |
410 | } | |
411 | ||
412 | /* ---------- SMP ---------- */ | |
413 | ||
414 | static int asd_build_smp_ascb(struct asd_ascb *ascb, struct sas_task *task, | |
3cc27547 | 415 | gfp_t gfp_flags) |
2908d778 JB |
416 | { |
417 | struct asd_ha_struct *asd_ha = ascb->ha; | |
418 | struct domain_device *dev = task->dev; | |
419 | struct scb *scb; | |
420 | ||
3a21986f CH |
421 | dma_map_sg(&asd_ha->pcidev->dev, &task->smp_task.smp_req, 1, |
422 | DMA_TO_DEVICE); | |
423 | dma_map_sg(&asd_ha->pcidev->dev, &task->smp_task.smp_resp, 1, | |
424 | DMA_FROM_DEVICE); | |
2908d778 JB |
425 | |
426 | scb = ascb->scb; | |
427 | ||
428 | scb->header.opcode = INITIATE_SMP_TASK; | |
429 | ||
430 | scb->smp_task.proto_conn_rate = dev->linkrate; | |
431 | ||
432 | scb->smp_task.smp_req.bus_addr = | |
433 | cpu_to_le64((u64)sg_dma_address(&task->smp_task.smp_req)); | |
434 | scb->smp_task.smp_req.size = | |
435 | cpu_to_le32((u32)sg_dma_len(&task->smp_task.smp_req)-4); | |
436 | ||
437 | scb->smp_task.smp_resp.bus_addr = | |
438 | cpu_to_le64((u64)sg_dma_address(&task->smp_task.smp_resp)); | |
439 | scb->smp_task.smp_resp.size = | |
440 | cpu_to_le32((u32)sg_dma_len(&task->smp_task.smp_resp)-4); | |
441 | ||
442 | scb->smp_task.sister_scb = cpu_to_le16(0xFFFF); | |
443 | scb->smp_task.conn_handle = cpu_to_le16((u16) | |
444 | (unsigned long)dev->lldd_dev); | |
445 | ||
446 | ascb->tasklet_complete = asd_task_tasklet_complete; | |
447 | ||
448 | return 0; | |
449 | } | |
450 | ||
451 | static void asd_unbuild_smp_ascb(struct asd_ascb *a) | |
452 | { | |
453 | struct sas_task *task = a->uldd_task; | |
454 | ||
455 | BUG_ON(!task); | |
3a21986f CH |
456 | dma_unmap_sg(&a->ha->pcidev->dev, &task->smp_task.smp_req, 1, |
457 | DMA_TO_DEVICE); | |
458 | dma_unmap_sg(&a->ha->pcidev->dev, &task->smp_task.smp_resp, 1, | |
459 | DMA_FROM_DEVICE); | |
2908d778 JB |
460 | } |
461 | ||
462 | /* ---------- SSP ---------- */ | |
463 | ||
464 | static int asd_build_ssp_ascb(struct asd_ascb *ascb, struct sas_task *task, | |
3cc27547 | 465 | gfp_t gfp_flags) |
2908d778 JB |
466 | { |
467 | struct domain_device *dev = task->dev; | |
468 | struct scb *scb; | |
469 | int res = 0; | |
470 | ||
471 | scb = ascb->scb; | |
472 | ||
473 | scb->header.opcode = INITIATE_SSP_TASK; | |
474 | ||
475 | scb->ssp_task.proto_conn_rate = (1 << 4); /* SSP */ | |
476 | scb->ssp_task.proto_conn_rate |= dev->linkrate; | |
477 | scb->ssp_task.total_xfer_len = cpu_to_le32(task->total_xfer_len); | |
478 | scb->ssp_task.ssp_frame.frame_type = SSP_DATA; | |
479 | memcpy(scb->ssp_task.ssp_frame.hashed_dest_addr, dev->hashed_sas_addr, | |
480 | HASHED_SAS_ADDR_SIZE); | |
481 | memcpy(scb->ssp_task.ssp_frame.hashed_src_addr, | |
482 | dev->port->ha->hashed_sas_addr, HASHED_SAS_ADDR_SIZE); | |
483 | scb->ssp_task.ssp_frame.tptt = cpu_to_be16(0xFFFF); | |
484 | ||
485 | memcpy(scb->ssp_task.ssp_cmd.lun, task->ssp_task.LUN, 8); | |
486 | if (task->ssp_task.enable_first_burst) | |
487 | scb->ssp_task.ssp_cmd.efb_prio_attr |= EFB_MASK; | |
488 | scb->ssp_task.ssp_cmd.efb_prio_attr |= (task->ssp_task.task_prio << 3); | |
489 | scb->ssp_task.ssp_cmd.efb_prio_attr |= (task->ssp_task.task_attr & 7); | |
e73823f7 JB |
490 | memcpy(scb->ssp_task.ssp_cmd.cdb, task->ssp_task.cmd->cmnd, |
491 | task->ssp_task.cmd->cmd_len); | |
2908d778 JB |
492 | |
493 | scb->ssp_task.sister_scb = cpu_to_le16(0xFFFF); | |
494 | scb->ssp_task.conn_handle = cpu_to_le16( | |
495 | (u16)(unsigned long)dev->lldd_dev); | |
496 | scb->ssp_task.data_dir = data_dir_flags[task->data_dir]; | |
497 | scb->ssp_task.retry_count = scb->ssp_task.retry_count; | |
498 | ||
499 | ascb->tasklet_complete = asd_task_tasklet_complete; | |
500 | ||
501 | res = asd_map_scatterlist(task, scb->ssp_task.sg_element, gfp_flags); | |
502 | ||
503 | return res; | |
504 | } | |
505 | ||
506 | static void asd_unbuild_ssp_ascb(struct asd_ascb *a) | |
507 | { | |
508 | asd_unmap_scatterlist(a); | |
509 | } | |
510 | ||
511 | /* ---------- Execute Task ---------- */ | |
512 | ||
81e56ded | 513 | static int asd_can_queue(struct asd_ha_struct *asd_ha, int num) |
2908d778 JB |
514 | { |
515 | int res = 0; | |
516 | unsigned long flags; | |
517 | ||
518 | spin_lock_irqsave(&asd_ha->seq.pend_q_lock, flags); | |
519 | if ((asd_ha->seq.can_queue - num) < 0) | |
520 | res = -SAS_QUEUE_FULL; | |
521 | else | |
522 | asd_ha->seq.can_queue -= num; | |
523 | spin_unlock_irqrestore(&asd_ha->seq.pend_q_lock, flags); | |
524 | ||
525 | return res; | |
526 | } | |
527 | ||
79855d17 | 528 | int asd_execute_task(struct sas_task *task, gfp_t gfp_flags) |
2908d778 JB |
529 | { |
530 | int res = 0; | |
531 | LIST_HEAD(alist); | |
532 | struct sas_task *t = task; | |
533 | struct asd_ascb *ascb = NULL, *a; | |
534 | struct asd_ha_struct *asd_ha = task->dev->port->ha->lldd_ha; | |
b218a0d8 | 535 | unsigned long flags; |
2908d778 | 536 | |
79855d17 | 537 | res = asd_can_queue(asd_ha, 1); |
2908d778 JB |
538 | if (res) |
539 | return res; | |
540 | ||
79855d17 | 541 | res = 1; |
2908d778 JB |
542 | ascb = asd_ascb_alloc_list(asd_ha, &res, gfp_flags); |
543 | if (res) { | |
544 | res = -ENOMEM; | |
545 | goto out_err; | |
546 | } | |
547 | ||
548 | __list_add(&alist, ascb->list.prev, &ascb->list); | |
549 | list_for_each_entry(a, &alist, list) { | |
550 | a->uldd_task = t; | |
551 | t->lldd_task = a; | |
79855d17 | 552 | break; |
2908d778 JB |
553 | } |
554 | list_for_each_entry(a, &alist, list) { | |
555 | t = a->uldd_task; | |
556 | a->uldd_timer = 1; | |
5929faf3 DW |
557 | if (t->task_proto & SAS_PROTOCOL_STP) |
558 | t->task_proto = SAS_PROTOCOL_STP; | |
2908d778 | 559 | switch (t->task_proto) { |
5929faf3 DW |
560 | case SAS_PROTOCOL_SATA: |
561 | case SAS_PROTOCOL_STP: | |
2908d778 JB |
562 | res = asd_build_ata_ascb(a, t, gfp_flags); |
563 | break; | |
5929faf3 | 564 | case SAS_PROTOCOL_SMP: |
2908d778 JB |
565 | res = asd_build_smp_ascb(a, t, gfp_flags); |
566 | break; | |
5929faf3 | 567 | case SAS_PROTOCOL_SSP: |
2908d778 JB |
568 | res = asd_build_ssp_ascb(a, t, gfp_flags); |
569 | break; | |
570 | default: | |
571 | asd_printk("unknown sas_task proto: 0x%x\n", | |
572 | t->task_proto); | |
573 | res = -ENOMEM; | |
574 | break; | |
575 | } | |
576 | if (res) | |
577 | goto out_err_unmap; | |
b218a0d8 DW |
578 | |
579 | spin_lock_irqsave(&t->task_state_lock, flags); | |
580 | t->task_state_flags |= SAS_TASK_AT_INITIATOR; | |
581 | spin_unlock_irqrestore(&t->task_state_lock, flags); | |
2908d778 JB |
582 | } |
583 | list_del_init(&alist); | |
584 | ||
79855d17 | 585 | res = asd_post_ascb_list(asd_ha, ascb, 1); |
2908d778 JB |
586 | if (unlikely(res)) { |
587 | a = NULL; | |
588 | __list_add(&alist, ascb->list.prev, &ascb->list); | |
589 | goto out_err_unmap; | |
590 | } | |
591 | ||
592 | return 0; | |
593 | out_err_unmap: | |
594 | { | |
595 | struct asd_ascb *b = a; | |
596 | list_for_each_entry(a, &alist, list) { | |
597 | if (a == b) | |
598 | break; | |
599 | t = a->uldd_task; | |
b218a0d8 DW |
600 | spin_lock_irqsave(&t->task_state_lock, flags); |
601 | t->task_state_flags &= ~SAS_TASK_AT_INITIATOR; | |
602 | spin_unlock_irqrestore(&t->task_state_lock, flags); | |
2908d778 | 603 | switch (t->task_proto) { |
5929faf3 DW |
604 | case SAS_PROTOCOL_SATA: |
605 | case SAS_PROTOCOL_STP: | |
2908d778 JB |
606 | asd_unbuild_ata_ascb(a); |
607 | break; | |
5929faf3 | 608 | case SAS_PROTOCOL_SMP: |
2908d778 JB |
609 | asd_unbuild_smp_ascb(a); |
610 | break; | |
5929faf3 | 611 | case SAS_PROTOCOL_SSP: |
2908d778 JB |
612 | asd_unbuild_ssp_ascb(a); |
613 | default: | |
614 | break; | |
615 | } | |
616 | t->lldd_task = NULL; | |
617 | } | |
618 | } | |
619 | list_del_init(&alist); | |
620 | out_err: | |
621 | if (ascb) | |
622 | asd_ascb_free_list(ascb); | |
79855d17 | 623 | asd_can_dequeue(asd_ha, 1); |
2908d778 JB |
624 | return res; |
625 | } |