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