2 * PMC-Sierra SPC 8001 SAS/SATA based host adapters driver
4 * Copyright (c) 2008-2009 USI Co., Ltd.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions, and the following disclaimer,
12 * without modification.
13 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
14 * substantially similar to the "NO WARRANTY" disclaimer below
15 * ("Disclaimer") and any redistribution must be conditioned upon
16 * including a substantially similar Disclaimer requirement for further
17 * binary redistribution.
18 * 3. Neither the names of the above-listed copyright holders nor the names
19 * of any contributors may be used to endorse or promote products derived
20 * from this software without specific prior written permission.
22 * Alternatively, this software may be distributed under the terms of the
23 * GNU General Public License ("GPL") version 2 as published by the Free
24 * Software Foundation.
27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
30 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
31 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
35 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
36 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGES.
41 #include <linux/slab.h>
42 #include "pm8001_sas.h"
45 * pm8001_find_tag - from sas task to find out tag that belongs to this task
46 * @task: the task sent to the LLDD
47 * @tag: the found tag associated with the task
49 static int pm8001_find_tag(struct sas_task
*task
, u32
*tag
)
51 if (task
->lldd_task
) {
52 struct pm8001_ccb_info
*ccb
;
53 ccb
= task
->lldd_task
;
61 * pm8001_tag_clear - clear the tags bitmap
62 * @pm8001_ha: our hba struct
63 * @tag: the found tag associated with the task
65 static void pm8001_tag_clear(struct pm8001_hba_info
*pm8001_ha
, u32 tag
)
67 void *bitmap
= pm8001_ha
->tags
;
68 clear_bit(tag
, bitmap
);
71 static void pm8001_tag_free(struct pm8001_hba_info
*pm8001_ha
, u32 tag
)
73 pm8001_tag_clear(pm8001_ha
, tag
);
76 static void pm8001_tag_set(struct pm8001_hba_info
*pm8001_ha
, u32 tag
)
78 void *bitmap
= pm8001_ha
->tags
;
83 * pm8001_tag_alloc - allocate a empty tag for task used.
84 * @pm8001_ha: our hba struct
85 * @tag_out: the found empty tag .
87 inline int pm8001_tag_alloc(struct pm8001_hba_info
*pm8001_ha
, u32
*tag_out
)
89 unsigned int index
, tag
;
90 void *bitmap
= pm8001_ha
->tags
;
92 index
= find_first_zero_bit(bitmap
, pm8001_ha
->tags_num
);
94 if (tag
>= pm8001_ha
->tags_num
)
95 return -SAS_QUEUE_FULL
;
96 pm8001_tag_set(pm8001_ha
, tag
);
101 void pm8001_tag_init(struct pm8001_hba_info
*pm8001_ha
)
104 for (i
= 0; i
< pm8001_ha
->tags_num
; ++i
)
105 pm8001_tag_clear(pm8001_ha
, i
);
109 * pm8001_mem_alloc - allocate memory for pm8001.
111 * @virt_addr: the allocated virtual address
112 * @pphys_addr_hi: the physical address high byte address.
113 * @pphys_addr_lo: the physical address low byte address.
114 * @mem_size: memory size.
116 int pm8001_mem_alloc(struct pci_dev
*pdev
, void **virt_addr
,
117 dma_addr_t
*pphys_addr
, u32
*pphys_addr_hi
,
118 u32
*pphys_addr_lo
, u32 mem_size
, u32 align
)
120 caddr_t mem_virt_alloc
;
121 dma_addr_t mem_dma_handle
;
123 u64 align_offset
= 0;
125 align_offset
= (dma_addr_t
)align
- 1;
127 pci_alloc_consistent(pdev
, mem_size
+ align
, &mem_dma_handle
);
128 if (!mem_virt_alloc
) {
129 pm8001_printk("memory allocation error\n");
132 memset((void *)mem_virt_alloc
, 0, mem_size
+align
);
133 *pphys_addr
= mem_dma_handle
;
134 phys_align
= (*pphys_addr
+ align_offset
) & ~align_offset
;
135 *virt_addr
= (void *)mem_virt_alloc
+ phys_align
- *pphys_addr
;
136 *pphys_addr_hi
= upper_32_bits(phys_align
);
137 *pphys_addr_lo
= lower_32_bits(phys_align
);
141 * pm8001_find_ha_by_dev - from domain device which come from sas layer to
142 * find out our hba struct.
143 * @dev: the domain device which from sas layer.
146 struct pm8001_hba_info
*pm8001_find_ha_by_dev(struct domain_device
*dev
)
148 struct sas_ha_struct
*sha
= dev
->port
->ha
;
149 struct pm8001_hba_info
*pm8001_ha
= sha
->lldd_ha
;
154 * pm8001_phy_control - this function should be registered to
155 * sas_domain_function_template to provide libsas used, note: this is just
156 * control the HBA phy rather than other expander phy if you want control
157 * other phy, you should use SMP command.
158 * @sas_phy: which phy in HBA phys.
159 * @func: the operation.
160 * @funcdata: always NULL.
162 int pm8001_phy_control(struct asd_sas_phy
*sas_phy
, enum phy_func func
,
165 int rc
= 0, phy_id
= sas_phy
->id
;
166 struct pm8001_hba_info
*pm8001_ha
= NULL
;
167 struct sas_phy_linkrates
*rates
;
168 DECLARE_COMPLETION_ONSTACK(completion
);
170 pm8001_ha
= sas_phy
->ha
->lldd_ha
;
171 pm8001_ha
->phy
[phy_id
].enable_completion
= &completion
;
173 case PHY_FUNC_SET_LINK_RATE
:
175 if (rates
->minimum_linkrate
) {
176 pm8001_ha
->phy
[phy_id
].minimum_linkrate
=
177 rates
->minimum_linkrate
;
179 if (rates
->maximum_linkrate
) {
180 pm8001_ha
->phy
[phy_id
].maximum_linkrate
=
181 rates
->maximum_linkrate
;
183 if (pm8001_ha
->phy
[phy_id
].phy_state
== 0) {
184 PM8001_CHIP_DISP
->phy_start_req(pm8001_ha
, phy_id
);
185 wait_for_completion(&completion
);
187 PM8001_CHIP_DISP
->phy_ctl_req(pm8001_ha
, phy_id
,
190 case PHY_FUNC_HARD_RESET
:
191 if (pm8001_ha
->phy
[phy_id
].phy_state
== 0) {
192 PM8001_CHIP_DISP
->phy_start_req(pm8001_ha
, phy_id
);
193 wait_for_completion(&completion
);
195 PM8001_CHIP_DISP
->phy_ctl_req(pm8001_ha
, phy_id
,
198 case PHY_FUNC_LINK_RESET
:
199 if (pm8001_ha
->phy
[phy_id
].phy_state
== 0) {
200 PM8001_CHIP_DISP
->phy_start_req(pm8001_ha
, phy_id
);
201 wait_for_completion(&completion
);
203 PM8001_CHIP_DISP
->phy_ctl_req(pm8001_ha
, phy_id
,
206 case PHY_FUNC_RELEASE_SPINUP_HOLD
:
207 PM8001_CHIP_DISP
->phy_ctl_req(pm8001_ha
, phy_id
,
210 case PHY_FUNC_DISABLE
:
211 PM8001_CHIP_DISP
->phy_stop_req(pm8001_ha
, phy_id
);
213 case PHY_FUNC_GET_EVENTS
:
214 spin_lock_irqsave(&pm8001_ha
->lock
, flags
);
215 if (-1 == pm8001_bar4_shift(pm8001_ha
,
216 (phy_id
< 4) ? 0x30000 : 0x40000)) {
217 spin_unlock_irqrestore(&pm8001_ha
->lock
, flags
);
221 struct sas_phy
*phy
= sas_phy
->phy
;
222 uint32_t *qp
= (uint32_t *)(((char *)
223 pm8001_ha
->io_mem
[2].memvirtaddr
)
224 + 0x1034 + (0x4000 * (phy_id
& 3)));
226 phy
->invalid_dword_count
= qp
[0];
227 phy
->running_disparity_error_count
= qp
[1];
228 phy
->loss_of_dword_sync_count
= qp
[3];
229 phy
->phy_reset_problem_count
= qp
[4];
231 pm8001_bar4_shift(pm8001_ha
, 0);
232 spin_unlock_irqrestore(&pm8001_ha
->lock
, flags
);
242 * pm8001_scan_start - we should enable all HBA phys by sending the phy_start
244 * @shost: the scsi host data.
246 void pm8001_scan_start(struct Scsi_Host
*shost
)
249 struct pm8001_hba_info
*pm8001_ha
;
250 struct sas_ha_struct
*sha
= SHOST_TO_SAS_HA(shost
);
251 pm8001_ha
= sha
->lldd_ha
;
252 PM8001_CHIP_DISP
->sas_re_init_req(pm8001_ha
);
253 for (i
= 0; i
< pm8001_ha
->chip
->n_phy
; ++i
)
254 PM8001_CHIP_DISP
->phy_start_req(pm8001_ha
, i
);
257 int pm8001_scan_finished(struct Scsi_Host
*shost
, unsigned long time
)
259 /* give the phy enabling interrupt event time to come in (1s
260 * is empirically about all it takes) */
263 /* Wait for discovery to finish */
264 scsi_flush_work(shost
);
269 * pm8001_task_prep_smp - the dispatcher function, prepare data for smp task
270 * @pm8001_ha: our hba card information
271 * @ccb: the ccb which attached to smp task
273 static int pm8001_task_prep_smp(struct pm8001_hba_info
*pm8001_ha
,
274 struct pm8001_ccb_info
*ccb
)
276 return PM8001_CHIP_DISP
->smp_req(pm8001_ha
, ccb
);
279 u32
pm8001_get_ncq_tag(struct sas_task
*task
, u32
*tag
)
281 struct ata_queued_cmd
*qc
= task
->uldd_task
;
283 if (qc
->tf
.command
== ATA_CMD_FPDMA_WRITE
||
284 qc
->tf
.command
== ATA_CMD_FPDMA_READ
) {
293 * pm8001_task_prep_ata - the dispatcher function, prepare data for sata task
294 * @pm8001_ha: our hba card information
295 * @ccb: the ccb which attached to sata task
297 static int pm8001_task_prep_ata(struct pm8001_hba_info
*pm8001_ha
,
298 struct pm8001_ccb_info
*ccb
)
300 return PM8001_CHIP_DISP
->sata_req(pm8001_ha
, ccb
);
304 * pm8001_task_prep_ssp_tm - the dispatcher function, prepare task management data
305 * @pm8001_ha: our hba card information
306 * @ccb: the ccb which attached to TM
307 * @tmf: the task management IU
309 static int pm8001_task_prep_ssp_tm(struct pm8001_hba_info
*pm8001_ha
,
310 struct pm8001_ccb_info
*ccb
, struct pm8001_tmf_task
*tmf
)
312 return PM8001_CHIP_DISP
->ssp_tm_req(pm8001_ha
, ccb
, tmf
);
316 * pm8001_task_prep_ssp - the dispatcher function,prepare ssp data for ssp task
317 * @pm8001_ha: our hba card information
318 * @ccb: the ccb which attached to ssp task
320 static int pm8001_task_prep_ssp(struct pm8001_hba_info
*pm8001_ha
,
321 struct pm8001_ccb_info
*ccb
)
323 return PM8001_CHIP_DISP
->ssp_io_req(pm8001_ha
, ccb
);
326 /* Find the local port id that's attached to this device */
327 static int sas_find_local_port_id(struct domain_device
*dev
)
329 struct domain_device
*pdev
= dev
->parent
;
331 /* Directly attached device */
333 return dev
->port
->id
;
335 struct domain_device
*pdev_p
= pdev
->parent
;
337 return pdev
->port
->id
;
344 * pm8001_task_exec - queue the task(ssp, smp && ata) to the hardware.
345 * @task: the task to be execute.
346 * @num: if can_queue great than 1, the task can be queued up. for SMP task,
347 * we always execute one one time.
348 * @gfp_flags: gfp_flags.
349 * @is_tmf: if it is task management task.
350 * @tmf: the task management IU
352 #define DEV_IS_GONE(pm8001_dev) \
353 ((!pm8001_dev || (pm8001_dev->dev_type == NO_DEVICE)))
354 static int pm8001_task_exec(struct sas_task
*task
, const int num
,
355 gfp_t gfp_flags
, int is_tmf
, struct pm8001_tmf_task
*tmf
)
357 struct domain_device
*dev
= task
->dev
;
358 struct pm8001_hba_info
*pm8001_ha
;
359 struct pm8001_device
*pm8001_dev
;
360 struct pm8001_port
*port
= NULL
;
361 struct sas_task
*t
= task
;
362 struct pm8001_ccb_info
*ccb
;
363 u32 tag
= 0xdeadbeef, rc
, n_elem
= 0;
365 unsigned long flags
= 0, flags_libsas
= 0;
368 struct task_status_struct
*tsm
= &t
->task_status
;
369 tsm
->resp
= SAS_TASK_UNDELIVERED
;
370 tsm
->stat
= SAS_PHY_DOWN
;
371 if (dev
->dev_type
!= SATA_DEV
)
375 pm8001_ha
= pm8001_find_ha_by_dev(task
->dev
);
376 PM8001_IO_DBG(pm8001_ha
, pm8001_printk("pm8001_task_exec device \n "));
377 spin_lock_irqsave(&pm8001_ha
->lock
, flags
);
380 pm8001_dev
= dev
->lldd_dev
;
381 port
= &pm8001_ha
->port
[sas_find_local_port_id(dev
)];
382 if (DEV_IS_GONE(pm8001_dev
) || !port
->port_attached
) {
383 if (sas_protocol_ata(t
->task_proto
)) {
384 struct task_status_struct
*ts
= &t
->task_status
;
385 ts
->resp
= SAS_TASK_UNDELIVERED
;
386 ts
->stat
= SAS_PHY_DOWN
;
388 spin_unlock_irqrestore(&pm8001_ha
->lock
, flags
);
389 spin_unlock_irqrestore(dev
->sata_dev
.ap
->lock
,
392 spin_lock_irqsave(dev
->sata_dev
.ap
->lock
,
394 spin_lock_irqsave(&pm8001_ha
->lock
, flags
);
396 t
= list_entry(t
->list
.next
,
397 struct sas_task
, list
);
400 struct task_status_struct
*ts
= &t
->task_status
;
401 ts
->resp
= SAS_TASK_UNDELIVERED
;
402 ts
->stat
= SAS_PHY_DOWN
;
405 t
= list_entry(t
->list
.next
,
406 struct sas_task
, list
);
410 rc
= pm8001_tag_alloc(pm8001_ha
, &tag
);
413 ccb
= &pm8001_ha
->ccb_info
[tag
];
415 if (!sas_protocol_ata(t
->task_proto
)) {
416 if (t
->num_scatter
) {
417 n_elem
= dma_map_sg(pm8001_ha
->dev
,
427 n_elem
= t
->num_scatter
;
431 ccb
->n_elem
= n_elem
;
434 switch (t
->task_proto
) {
435 case SAS_PROTOCOL_SMP
:
436 rc
= pm8001_task_prep_smp(pm8001_ha
, ccb
);
438 case SAS_PROTOCOL_SSP
:
440 rc
= pm8001_task_prep_ssp_tm(pm8001_ha
,
443 rc
= pm8001_task_prep_ssp(pm8001_ha
, ccb
);
445 case SAS_PROTOCOL_SATA
:
446 case SAS_PROTOCOL_STP
:
447 case SAS_PROTOCOL_SATA
| SAS_PROTOCOL_STP
:
448 rc
= pm8001_task_prep_ata(pm8001_ha
, ccb
);
451 dev_printk(KERN_ERR
, pm8001_ha
->dev
,
452 "unknown sas_task proto: 0x%x\n",
459 PM8001_IO_DBG(pm8001_ha
,
460 pm8001_printk("rc is %x\n", rc
));
463 /* TODO: select normal or high priority */
464 spin_lock(&t
->task_state_lock
);
465 t
->task_state_flags
|= SAS_TASK_AT_INITIATOR
;
466 spin_unlock(&t
->task_state_lock
);
467 pm8001_dev
->running_req
++;
469 t
= list_entry(t
->list
.next
, struct sas_task
, list
);
475 pm8001_tag_free(pm8001_ha
, tag
);
477 dev_printk(KERN_ERR
, pm8001_ha
->dev
, "pm8001 exec failed[%d]!\n", rc
);
478 if (!sas_protocol_ata(t
->task_proto
))
480 dma_unmap_sg(pm8001_ha
->dev
, t
->scatter
, n_elem
,
483 spin_unlock_irqrestore(&pm8001_ha
->lock
, flags
);
488 * pm8001_queue_command - register for upper layer used, all IO commands sent
489 * to HBA are from this interface.
490 * @task: the task to be execute.
491 * @num: if can_queue great than 1, the task can be queued up. for SMP task,
492 * we always execute one one time
493 * @gfp_flags: gfp_flags
495 int pm8001_queue_command(struct sas_task
*task
, const int num
,
498 return pm8001_task_exec(task
, num
, gfp_flags
, 0, NULL
);
501 void pm8001_ccb_free(struct pm8001_hba_info
*pm8001_ha
, u32 ccb_idx
)
503 pm8001_tag_clear(pm8001_ha
, ccb_idx
);
507 * pm8001_ccb_task_free - free the sg for ssp and smp command, free the ccb.
508 * @pm8001_ha: our hba card information
509 * @ccb: the ccb which attached to ssp task
510 * @task: the task to be free.
511 * @ccb_idx: ccb index.
513 void pm8001_ccb_task_free(struct pm8001_hba_info
*pm8001_ha
,
514 struct sas_task
*task
, struct pm8001_ccb_info
*ccb
, u32 ccb_idx
)
518 if (!sas_protocol_ata(task
->task_proto
))
520 dma_unmap_sg(pm8001_ha
->dev
, task
->scatter
,
521 task
->num_scatter
, task
->data_dir
);
523 switch (task
->task_proto
) {
524 case SAS_PROTOCOL_SMP
:
525 dma_unmap_sg(pm8001_ha
->dev
, &task
->smp_task
.smp_resp
, 1,
527 dma_unmap_sg(pm8001_ha
->dev
, &task
->smp_task
.smp_req
, 1,
531 case SAS_PROTOCOL_SATA
:
532 case SAS_PROTOCOL_STP
:
533 case SAS_PROTOCOL_SSP
:
538 task
->lldd_task
= NULL
;
540 ccb
->ccb_tag
= 0xFFFFFFFF;
541 pm8001_ccb_free(pm8001_ha
, ccb_idx
);
545 * pm8001_alloc_dev - find a empty pm8001_device
546 * @pm8001_ha: our hba card information
548 struct pm8001_device
*pm8001_alloc_dev(struct pm8001_hba_info
*pm8001_ha
)
551 for (dev
= 0; dev
< PM8001_MAX_DEVICES
; dev
++) {
552 if (pm8001_ha
->devices
[dev
].dev_type
== NO_DEVICE
) {
553 pm8001_ha
->devices
[dev
].id
= dev
;
554 return &pm8001_ha
->devices
[dev
];
557 if (dev
== PM8001_MAX_DEVICES
) {
558 PM8001_FAIL_DBG(pm8001_ha
,
559 pm8001_printk("max support %d devices, ignore ..\n",
560 PM8001_MAX_DEVICES
));
565 static void pm8001_free_dev(struct pm8001_device
*pm8001_dev
)
567 u32 id
= pm8001_dev
->id
;
568 memset(pm8001_dev
, 0, sizeof(*pm8001_dev
));
570 pm8001_dev
->dev_type
= NO_DEVICE
;
571 pm8001_dev
->device_id
= PM8001_MAX_DEVICES
;
572 pm8001_dev
->sas_device
= NULL
;
576 * pm8001_dev_found_notify - libsas notify a device is found.
577 * @dev: the device structure which sas layer used.
579 * when libsas find a sas domain device, it should tell the LLDD that
580 * device is found, and then LLDD register this device to HBA firmware
581 * by the command "OPC_INB_REG_DEV", after that the HBA will assign a
582 * device ID(according to device's sas address) and returned it to LLDD. From
583 * now on, we communicate with HBA FW with the device ID which HBA assigned
584 * rather than sas address. it is the necessary step for our HBA but it is
585 * the optional for other HBA driver.
587 static int pm8001_dev_found_notify(struct domain_device
*dev
)
589 unsigned long flags
= 0;
591 struct pm8001_hba_info
*pm8001_ha
= NULL
;
592 struct domain_device
*parent_dev
= dev
->parent
;
593 struct pm8001_device
*pm8001_device
;
594 DECLARE_COMPLETION_ONSTACK(completion
);
596 pm8001_ha
= pm8001_find_ha_by_dev(dev
);
597 spin_lock_irqsave(&pm8001_ha
->lock
, flags
);
599 pm8001_device
= pm8001_alloc_dev(pm8001_ha
);
600 if (!pm8001_device
) {
604 pm8001_device
->sas_device
= dev
;
605 dev
->lldd_dev
= pm8001_device
;
606 pm8001_device
->dev_type
= dev
->dev_type
;
607 pm8001_device
->dcompletion
= &completion
;
608 if (parent_dev
&& DEV_IS_EXPANDER(parent_dev
->dev_type
)) {
611 for (phy_id
= 0; phy_id
< parent_dev
->ex_dev
.num_phys
;
613 phy
= &parent_dev
->ex_dev
.ex_phy
[phy_id
];
614 if (SAS_ADDR(phy
->attached_sas_addr
)
615 == SAS_ADDR(dev
->sas_addr
)) {
616 pm8001_device
->attached_phy
= phy_id
;
620 if (phy_id
== parent_dev
->ex_dev
.num_phys
) {
621 PM8001_FAIL_DBG(pm8001_ha
,
622 pm8001_printk("Error: no attached dev:%016llx"
623 " at ex:%016llx.\n", SAS_ADDR(dev
->sas_addr
),
624 SAS_ADDR(parent_dev
->sas_addr
)));
628 if (dev
->dev_type
== SATA_DEV
) {
629 pm8001_device
->attached_phy
=
630 dev
->rphy
->identify
.phy_identifier
;
631 flag
= 1; /* directly sata*/
633 } /*register this device to HBA*/
634 PM8001_DISC_DBG(pm8001_ha
, pm8001_printk("Found device\n"));
635 PM8001_CHIP_DISP
->reg_dev_req(pm8001_ha
, pm8001_device
, flag
);
636 spin_unlock_irqrestore(&pm8001_ha
->lock
, flags
);
637 wait_for_completion(&completion
);
638 if (dev
->dev_type
== SAS_END_DEV
)
640 pm8001_ha
->flags
= PM8001F_RUN_TIME
;
643 spin_unlock_irqrestore(&pm8001_ha
->lock
, flags
);
647 int pm8001_dev_found(struct domain_device
*dev
)
649 return pm8001_dev_found_notify(dev
);
652 static void pm8001_task_done(struct sas_task
*task
)
654 if (!del_timer(&task
->timer
))
656 complete(&task
->completion
);
659 static void pm8001_tmf_timedout(unsigned long data
)
661 struct sas_task
*task
= (struct sas_task
*)data
;
663 task
->task_state_flags
|= SAS_TASK_STATE_ABORTED
;
664 complete(&task
->completion
);
667 #define PM8001_TASK_TIMEOUT 20
669 * pm8001_exec_internal_tmf_task - execute some task management commands.
670 * @dev: the wanted device.
671 * @tmf: which task management wanted to be take.
672 * @para_len: para_len.
673 * @parameter: ssp task parameter.
675 * when errors or exception happened, we may want to do something, for example
676 * abort the issued task which result in this execption, it is done by calling
677 * this function, note it is also with the task execute interface.
679 static int pm8001_exec_internal_tmf_task(struct domain_device
*dev
,
680 void *parameter
, u32 para_len
, struct pm8001_tmf_task
*tmf
)
683 struct sas_task
*task
= NULL
;
684 struct pm8001_hba_info
*pm8001_ha
= pm8001_find_ha_by_dev(dev
);
686 for (retry
= 0; retry
< 3; retry
++) {
687 task
= sas_alloc_task(GFP_KERNEL
);
692 task
->task_proto
= dev
->tproto
;
693 memcpy(&task
->ssp_task
, parameter
, para_len
);
694 task
->task_done
= pm8001_task_done
;
695 task
->timer
.data
= (unsigned long)task
;
696 task
->timer
.function
= pm8001_tmf_timedout
;
697 task
->timer
.expires
= jiffies
+ PM8001_TASK_TIMEOUT
*HZ
;
698 add_timer(&task
->timer
);
700 res
= pm8001_task_exec(task
, 1, GFP_KERNEL
, 1, tmf
);
703 del_timer(&task
->timer
);
704 PM8001_FAIL_DBG(pm8001_ha
,
705 pm8001_printk("Executing internal task "
709 wait_for_completion(&task
->completion
);
710 res
= -TMF_RESP_FUNC_FAILED
;
711 /* Even TMF timed out, return direct. */
712 if ((task
->task_state_flags
& SAS_TASK_STATE_ABORTED
)) {
713 if (!(task
->task_state_flags
& SAS_TASK_STATE_DONE
)) {
714 PM8001_FAIL_DBG(pm8001_ha
,
715 pm8001_printk("TMF task[%x]timeout.\n",
721 if (task
->task_status
.resp
== SAS_TASK_COMPLETE
&&
722 task
->task_status
.stat
== SAM_STAT_GOOD
) {
723 res
= TMF_RESP_FUNC_COMPLETE
;
727 if (task
->task_status
.resp
== SAS_TASK_COMPLETE
&&
728 task
->task_status
.stat
== SAS_DATA_UNDERRUN
) {
729 /* no error, but return the number of bytes of
731 res
= task
->task_status
.residual
;
735 if (task
->task_status
.resp
== SAS_TASK_COMPLETE
&&
736 task
->task_status
.stat
== SAS_DATA_OVERRUN
) {
737 PM8001_FAIL_DBG(pm8001_ha
,
738 pm8001_printk("Blocked task error.\n"));
742 PM8001_EH_DBG(pm8001_ha
,
743 pm8001_printk(" Task to dev %016llx response:"
744 "0x%x status 0x%x\n",
745 SAS_ADDR(dev
->sas_addr
),
746 task
->task_status
.resp
,
747 task
->task_status
.stat
));
753 BUG_ON(retry
== 3 && task
!= NULL
);
759 pm8001_exec_internal_task_abort(struct pm8001_hba_info
*pm8001_ha
,
760 struct pm8001_device
*pm8001_dev
, struct domain_device
*dev
, u32 flag
,
765 struct pm8001_ccb_info
*ccb
;
766 struct sas_task
*task
= NULL
;
768 for (retry
= 0; retry
< 3; retry
++) {
769 task
= sas_alloc_task(GFP_KERNEL
);
774 task
->task_proto
= dev
->tproto
;
775 task
->task_done
= pm8001_task_done
;
776 task
->timer
.data
= (unsigned long)task
;
777 task
->timer
.function
= pm8001_tmf_timedout
;
778 task
->timer
.expires
= jiffies
+ PM8001_TASK_TIMEOUT
* HZ
;
779 add_timer(&task
->timer
);
781 res
= pm8001_tag_alloc(pm8001_ha
, &ccb_tag
);
784 ccb
= &pm8001_ha
->ccb_info
[ccb_tag
];
785 ccb
->device
= pm8001_dev
;
786 ccb
->ccb_tag
= ccb_tag
;
789 res
= PM8001_CHIP_DISP
->task_abort(pm8001_ha
,
790 pm8001_dev
, flag
, task_tag
, ccb_tag
);
793 del_timer(&task
->timer
);
794 PM8001_FAIL_DBG(pm8001_ha
,
795 pm8001_printk("Executing internal task "
799 wait_for_completion(&task
->completion
);
800 res
= TMF_RESP_FUNC_FAILED
;
801 /* Even TMF timed out, return direct. */
802 if ((task
->task_state_flags
& SAS_TASK_STATE_ABORTED
)) {
803 if (!(task
->task_state_flags
& SAS_TASK_STATE_DONE
)) {
804 PM8001_FAIL_DBG(pm8001_ha
,
805 pm8001_printk("TMF task timeout.\n"));
810 if (task
->task_status
.resp
== SAS_TASK_COMPLETE
&&
811 task
->task_status
.stat
== SAM_STAT_GOOD
) {
812 res
= TMF_RESP_FUNC_COMPLETE
;
816 PM8001_EH_DBG(pm8001_ha
,
817 pm8001_printk(" Task to dev %016llx response: "
818 "0x%x status 0x%x\n",
819 SAS_ADDR(dev
->sas_addr
),
820 task
->task_status
.resp
,
821 task
->task_status
.stat
));
827 BUG_ON(retry
== 3 && task
!= NULL
);
833 * pm8001_dev_gone_notify - see the comments for "pm8001_dev_found_notify"
834 * @dev: the device structure which sas layer used.
836 static void pm8001_dev_gone_notify(struct domain_device
*dev
)
838 unsigned long flags
= 0;
840 struct pm8001_hba_info
*pm8001_ha
;
841 struct pm8001_device
*pm8001_dev
= dev
->lldd_dev
;
843 pm8001_ha
= pm8001_find_ha_by_dev(dev
);
844 spin_lock_irqsave(&pm8001_ha
->lock
, flags
);
845 pm8001_tag_alloc(pm8001_ha
, &tag
);
847 u32 device_id
= pm8001_dev
->device_id
;
849 PM8001_DISC_DBG(pm8001_ha
,
850 pm8001_printk("found dev[%d:%x] is gone.\n",
851 pm8001_dev
->device_id
, pm8001_dev
->dev_type
));
852 if (pm8001_dev
->running_req
) {
853 spin_unlock_irqrestore(&pm8001_ha
->lock
, flags
);
854 pm8001_exec_internal_task_abort(pm8001_ha
, pm8001_dev
,
856 spin_lock_irqsave(&pm8001_ha
->lock
, flags
);
858 PM8001_CHIP_DISP
->dereg_dev_req(pm8001_ha
, device_id
);
859 pm8001_free_dev(pm8001_dev
);
861 PM8001_DISC_DBG(pm8001_ha
,
862 pm8001_printk("Found dev has gone.\n"));
864 dev
->lldd_dev
= NULL
;
865 spin_unlock_irqrestore(&pm8001_ha
->lock
, flags
);
868 void pm8001_dev_gone(struct domain_device
*dev
)
870 pm8001_dev_gone_notify(dev
);
873 static int pm8001_issue_ssp_tmf(struct domain_device
*dev
,
874 u8
*lun
, struct pm8001_tmf_task
*tmf
)
876 struct sas_ssp_task ssp_task
;
877 if (!(dev
->tproto
& SAS_PROTOCOL_SSP
))
878 return TMF_RESP_FUNC_ESUPP
;
880 strncpy((u8
*)&ssp_task
.LUN
, lun
, 8);
881 return pm8001_exec_internal_tmf_task(dev
, &ssp_task
, sizeof(ssp_task
),
886 * Standard mandates link reset for ATA (type 0) and hard reset for
887 * SSP (type 1) , only for RECOVERY
889 int pm8001_I_T_nexus_reset(struct domain_device
*dev
)
891 int rc
= TMF_RESP_FUNC_FAILED
;
892 struct pm8001_device
*pm8001_dev
;
893 struct pm8001_hba_info
*pm8001_ha
;
895 if (!dev
|| !dev
->lldd_dev
)
898 pm8001_dev
= dev
->lldd_dev
;
899 pm8001_ha
= pm8001_find_ha_by_dev(dev
);
900 phy
= sas_find_local_phy(dev
);
902 if (dev_is_sata(dev
)) {
903 DECLARE_COMPLETION_ONSTACK(completion_setstate
);
904 if (scsi_is_sas_phy_local(phy
))
906 rc
= sas_phy_reset(phy
, 1);
908 rc
= pm8001_exec_internal_task_abort(pm8001_ha
, pm8001_dev
,
910 pm8001_dev
->setds_completion
= &completion_setstate
;
911 rc
= PM8001_CHIP_DISP
->set_dev_state_req(pm8001_ha
,
913 wait_for_completion(&completion_setstate
);
915 rc
= sas_phy_reset(phy
, 1);
918 PM8001_EH_DBG(pm8001_ha
, pm8001_printk(" for device[%x]:rc=%d\n",
919 pm8001_dev
->device_id
, rc
));
923 /* mandatory SAM-3, the task reset the specified LUN*/
924 int pm8001_lu_reset(struct domain_device
*dev
, u8
*lun
)
926 int rc
= TMF_RESP_FUNC_FAILED
;
927 struct pm8001_tmf_task tmf_task
;
928 struct pm8001_device
*pm8001_dev
= dev
->lldd_dev
;
929 struct pm8001_hba_info
*pm8001_ha
= pm8001_find_ha_by_dev(dev
);
930 if (dev_is_sata(dev
)) {
931 struct sas_phy
*phy
= sas_find_local_phy(dev
);
932 rc
= pm8001_exec_internal_task_abort(pm8001_ha
, pm8001_dev
,
934 rc
= sas_phy_reset(phy
, 1);
935 rc
= PM8001_CHIP_DISP
->set_dev_state_req(pm8001_ha
,
939 tmf_task
.tmf
= TMF_LU_RESET
;
940 rc
= pm8001_issue_ssp_tmf(dev
, lun
, &tmf_task
);
942 /* If failed, fall-through I_T_Nexus reset */
943 PM8001_EH_DBG(pm8001_ha
, pm8001_printk("for device[%x]:rc=%d\n",
944 pm8001_dev
->device_id
, rc
));
949 int pm8001_query_task(struct sas_task
*task
)
951 u32 tag
= 0xdeadbeef;
954 struct pm8001_tmf_task tmf_task
;
955 int rc
= TMF_RESP_FUNC_FAILED
;
956 if (unlikely(!task
|| !task
->lldd_task
|| !task
->dev
))
959 if (task
->task_proto
& SAS_PROTOCOL_SSP
) {
960 struct scsi_cmnd
*cmnd
= task
->uldd_task
;
961 struct domain_device
*dev
= task
->dev
;
962 struct pm8001_hba_info
*pm8001_ha
=
963 pm8001_find_ha_by_dev(dev
);
965 int_to_scsilun(cmnd
->device
->lun
, &lun
);
966 rc
= pm8001_find_tag(task
, &tag
);
968 rc
= TMF_RESP_FUNC_FAILED
;
971 PM8001_EH_DBG(pm8001_ha
, pm8001_printk("Query:["));
972 for (i
= 0; i
< 16; i
++)
973 printk(KERN_INFO
"%02x ", cmnd
->cmnd
[i
]);
974 printk(KERN_INFO
"]\n");
975 tmf_task
.tmf
= TMF_QUERY_TASK
;
976 tmf_task
.tag_of_task_to_be_managed
= tag
;
978 rc
= pm8001_issue_ssp_tmf(dev
, lun
.scsi_lun
, &tmf_task
);
980 /* The task is still in Lun, release it then */
981 case TMF_RESP_FUNC_SUCC
:
982 PM8001_EH_DBG(pm8001_ha
,
983 pm8001_printk("The task is still in Lun\n"));
985 /* The task is not in Lun or failed, reset the phy */
986 case TMF_RESP_FUNC_FAILED
:
987 case TMF_RESP_FUNC_COMPLETE
:
988 PM8001_EH_DBG(pm8001_ha
,
989 pm8001_printk("The task is not in Lun or failed,"
990 " reset the phy\n"));
994 pm8001_printk(":rc= %d\n", rc
);
998 /* mandatory SAM-3, still need free task/ccb info, abord the specified task */
999 int pm8001_abort_task(struct sas_task
*task
)
1001 unsigned long flags
;
1002 u32 tag
= 0xdeadbeef;
1004 struct domain_device
*dev
;
1005 struct pm8001_hba_info
*pm8001_ha
= NULL
;
1006 struct pm8001_ccb_info
*ccb
;
1007 struct scsi_lun lun
;
1008 struct pm8001_device
*pm8001_dev
;
1009 struct pm8001_tmf_task tmf_task
;
1010 int rc
= TMF_RESP_FUNC_FAILED
;
1011 if (unlikely(!task
|| !task
->lldd_task
|| !task
->dev
))
1013 spin_lock_irqsave(&task
->task_state_lock
, flags
);
1014 if (task
->task_state_flags
& SAS_TASK_STATE_DONE
) {
1015 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
1016 rc
= TMF_RESP_FUNC_COMPLETE
;
1019 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
1020 if (task
->task_proto
& SAS_PROTOCOL_SSP
) {
1021 struct scsi_cmnd
*cmnd
= task
->uldd_task
;
1023 ccb
= task
->lldd_task
;
1024 pm8001_dev
= dev
->lldd_dev
;
1025 pm8001_ha
= pm8001_find_ha_by_dev(dev
);
1026 int_to_scsilun(cmnd
->device
->lun
, &lun
);
1027 rc
= pm8001_find_tag(task
, &tag
);
1029 printk(KERN_INFO
"No such tag in %s\n", __func__
);
1030 rc
= TMF_RESP_FUNC_FAILED
;
1033 device_id
= pm8001_dev
->device_id
;
1034 PM8001_EH_DBG(pm8001_ha
,
1035 pm8001_printk("abort io to deviceid= %d\n", device_id
));
1036 tmf_task
.tmf
= TMF_ABORT_TASK
;
1037 tmf_task
.tag_of_task_to_be_managed
= tag
;
1038 rc
= pm8001_issue_ssp_tmf(dev
, lun
.scsi_lun
, &tmf_task
);
1039 pm8001_exec_internal_task_abort(pm8001_ha
, pm8001_dev
,
1040 pm8001_dev
->sas_device
, 0, tag
);
1041 } else if (task
->task_proto
& SAS_PROTOCOL_SATA
||
1042 task
->task_proto
& SAS_PROTOCOL_STP
) {
1044 pm8001_dev
= dev
->lldd_dev
;
1045 pm8001_ha
= pm8001_find_ha_by_dev(dev
);
1046 rc
= pm8001_find_tag(task
, &tag
);
1048 printk(KERN_INFO
"No such tag in %s\n", __func__
);
1049 rc
= TMF_RESP_FUNC_FAILED
;
1052 rc
= pm8001_exec_internal_task_abort(pm8001_ha
, pm8001_dev
,
1053 pm8001_dev
->sas_device
, 0, tag
);
1054 } else if (task
->task_proto
& SAS_PROTOCOL_SMP
) {
1057 pm8001_dev
= dev
->lldd_dev
;
1058 pm8001_ha
= pm8001_find_ha_by_dev(dev
);
1059 rc
= pm8001_find_tag(task
, &tag
);
1061 printk(KERN_INFO
"No such tag in %s\n", __func__
);
1062 rc
= TMF_RESP_FUNC_FAILED
;
1065 rc
= pm8001_exec_internal_task_abort(pm8001_ha
, pm8001_dev
,
1066 pm8001_dev
->sas_device
, 0, tag
);
1070 if (rc
!= TMF_RESP_FUNC_COMPLETE
)
1071 pm8001_printk("rc= %d\n", rc
);
1075 int pm8001_abort_task_set(struct domain_device
*dev
, u8
*lun
)
1077 int rc
= TMF_RESP_FUNC_FAILED
;
1078 struct pm8001_tmf_task tmf_task
;
1080 tmf_task
.tmf
= TMF_ABORT_TASK_SET
;
1081 rc
= pm8001_issue_ssp_tmf(dev
, lun
, &tmf_task
);
1085 int pm8001_clear_aca(struct domain_device
*dev
, u8
*lun
)
1087 int rc
= TMF_RESP_FUNC_FAILED
;
1088 struct pm8001_tmf_task tmf_task
;
1090 tmf_task
.tmf
= TMF_CLEAR_ACA
;
1091 rc
= pm8001_issue_ssp_tmf(dev
, lun
, &tmf_task
);
1096 int pm8001_clear_task_set(struct domain_device
*dev
, u8
*lun
)
1098 int rc
= TMF_RESP_FUNC_FAILED
;
1099 struct pm8001_tmf_task tmf_task
;
1100 struct pm8001_device
*pm8001_dev
= dev
->lldd_dev
;
1101 struct pm8001_hba_info
*pm8001_ha
= pm8001_find_ha_by_dev(dev
);
1103 PM8001_EH_DBG(pm8001_ha
,
1104 pm8001_printk("I_T_L_Q clear task set[%x]\n",
1105 pm8001_dev
->device_id
));
1106 tmf_task
.tmf
= TMF_CLEAR_TASK_SET
;
1107 rc
= pm8001_issue_ssp_tmf(dev
, lun
, &tmf_task
);