2 * Marvell 88SE64xx/88SE94xx main function
4 * Copyright 2007 Red Hat, Inc.
5 * Copyright 2008 Marvell. <kewei@marvell.com>
6 * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
8 * This file is licensed under GPLv2.
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation; version 2 of the
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
28 static int mvs_find_tag(struct mvs_info
*mvi
, struct sas_task
*task
, u32
*tag
)
30 if (task
->lldd_task
) {
31 struct mvs_slot_info
*slot
;
32 slot
= task
->lldd_task
;
33 *tag
= slot
->slot_tag
;
39 void mvs_tag_clear(struct mvs_info
*mvi
, u32 tag
)
41 void *bitmap
= mvi
->tags
;
42 clear_bit(tag
, bitmap
);
45 void mvs_tag_free(struct mvs_info
*mvi
, u32 tag
)
47 mvs_tag_clear(mvi
, tag
);
50 void mvs_tag_set(struct mvs_info
*mvi
, unsigned int tag
)
52 void *bitmap
= mvi
->tags
;
56 inline int mvs_tag_alloc(struct mvs_info
*mvi
, u32
*tag_out
)
58 unsigned int index
, tag
;
59 void *bitmap
= mvi
->tags
;
61 index
= find_first_zero_bit(bitmap
, mvi
->tags_num
);
63 if (tag
>= mvi
->tags_num
)
64 return -SAS_QUEUE_FULL
;
65 mvs_tag_set(mvi
, tag
);
70 void mvs_tag_init(struct mvs_info
*mvi
)
73 for (i
= 0; i
< mvi
->tags_num
; ++i
)
74 mvs_tag_clear(mvi
, i
);
77 struct mvs_info
*mvs_find_dev_mvi(struct domain_device
*dev
)
79 unsigned long i
= 0, j
= 0, hi
= 0;
80 struct sas_ha_struct
*sha
= dev
->port
->ha
;
81 struct mvs_info
*mvi
= NULL
;
82 struct asd_sas_phy
*phy
;
84 while (sha
->sas_port
[i
]) {
85 if (sha
->sas_port
[i
] == dev
->port
) {
86 phy
= container_of(sha
->sas_port
[i
]->phy_list
.next
,
87 struct asd_sas_phy
, port_phy_el
);
89 while (sha
->sas_phy
[j
]) {
90 if (sha
->sas_phy
[j
] == phy
)
98 hi
= j
/((struct mvs_prv_info
*)sha
->lldd_ha
)->n_phy
;
99 mvi
= ((struct mvs_prv_info
*)sha
->lldd_ha
)->mvi
[hi
];
105 int mvs_find_dev_phyno(struct domain_device
*dev
, int *phyno
)
107 unsigned long i
= 0, j
= 0, n
= 0, num
= 0;
108 struct mvs_device
*mvi_dev
= (struct mvs_device
*)dev
->lldd_dev
;
109 struct mvs_info
*mvi
= mvi_dev
->mvi_info
;
110 struct sas_ha_struct
*sha
= dev
->port
->ha
;
112 while (sha
->sas_port
[i
]) {
113 if (sha
->sas_port
[i
] == dev
->port
) {
114 struct asd_sas_phy
*phy
;
115 list_for_each_entry(phy
,
116 &sha
->sas_port
[i
]->phy_list
, port_phy_el
) {
118 while (sha
->sas_phy
[j
]) {
119 if (sha
->sas_phy
[j
] == phy
)
123 phyno
[n
] = (j
>= mvi
->chip
->n_phy
) ?
124 (j
- mvi
->chip
->n_phy
) : j
;
135 struct mvs_device
*mvs_find_dev_by_reg_set(struct mvs_info
*mvi
,
139 for (dev_no
= 0; dev_no
< MVS_MAX_DEVICES
; dev_no
++) {
140 if (mvi
->devices
[dev_no
].taskfileset
== MVS_ID_NOT_MAPPED
)
143 if (mvi
->devices
[dev_no
].taskfileset
== reg_set
)
144 return &mvi
->devices
[dev_no
];
149 static inline void mvs_free_reg_set(struct mvs_info
*mvi
,
150 struct mvs_device
*dev
)
153 mv_printk("device has been free.\n");
156 if (dev
->taskfileset
== MVS_ID_NOT_MAPPED
)
158 MVS_CHIP_DISP
->free_reg_set(mvi
, &dev
->taskfileset
);
161 static inline u8
mvs_assign_reg_set(struct mvs_info
*mvi
,
162 struct mvs_device
*dev
)
164 if (dev
->taskfileset
!= MVS_ID_NOT_MAPPED
)
166 return MVS_CHIP_DISP
->assign_reg_set(mvi
, &dev
->taskfileset
);
169 void mvs_phys_reset(struct mvs_info
*mvi
, u32 phy_mask
, int hard
)
172 for_each_phy(phy_mask
, phy_mask
, no
) {
175 MVS_CHIP_DISP
->phy_reset(mvi
, no
, hard
);
179 int mvs_phy_control(struct asd_sas_phy
*sas_phy
, enum phy_func func
,
182 int rc
= 0, phy_id
= sas_phy
->id
;
184 struct sas_ha_struct
*sha
= sas_phy
->ha
;
185 struct mvs_info
*mvi
= NULL
;
187 while (sha
->sas_phy
[i
]) {
188 if (sha
->sas_phy
[i
] == sas_phy
)
192 hi
= i
/((struct mvs_prv_info
*)sha
->lldd_ha
)->n_phy
;
193 mvi
= ((struct mvs_prv_info
*)sha
->lldd_ha
)->mvi
[hi
];
196 case PHY_FUNC_SET_LINK_RATE
:
197 MVS_CHIP_DISP
->phy_set_link_rate(mvi
, phy_id
, funcdata
);
200 case PHY_FUNC_HARD_RESET
:
201 tmp
= MVS_CHIP_DISP
->read_phy_ctl(mvi
, phy_id
);
202 if (tmp
& PHY_RST_HARD
)
204 MVS_CHIP_DISP
->phy_reset(mvi
, phy_id
, MVS_HARD_RESET
);
207 case PHY_FUNC_LINK_RESET
:
208 MVS_CHIP_DISP
->phy_enable(mvi
, phy_id
);
209 MVS_CHIP_DISP
->phy_reset(mvi
, phy_id
, MVS_SOFT_RESET
);
212 case PHY_FUNC_DISABLE
:
213 MVS_CHIP_DISP
->phy_disable(mvi
, phy_id
);
215 case PHY_FUNC_RELEASE_SPINUP_HOLD
:
223 void __devinit
mvs_set_sas_addr(struct mvs_info
*mvi
, int port_id
,
224 u32 off_lo
, u32 off_hi
, u64 sas_addr
)
226 u32 lo
= (u32
)sas_addr
;
227 u32 hi
= (u32
)(sas_addr
>>32);
229 MVS_CHIP_DISP
->write_port_cfg_addr(mvi
, port_id
, off_lo
);
230 MVS_CHIP_DISP
->write_port_cfg_data(mvi
, port_id
, lo
);
231 MVS_CHIP_DISP
->write_port_cfg_addr(mvi
, port_id
, off_hi
);
232 MVS_CHIP_DISP
->write_port_cfg_data(mvi
, port_id
, hi
);
235 static void mvs_bytes_dmaed(struct mvs_info
*mvi
, int i
)
237 struct mvs_phy
*phy
= &mvi
->phy
[i
];
238 struct asd_sas_phy
*sas_phy
= &phy
->sas_phy
;
239 struct sas_ha_struct
*sas_ha
;
240 if (!phy
->phy_attached
)
243 if (!(phy
->att_dev_info
& PORT_DEV_TRGT_MASK
)
244 && phy
->phy_type
& PORT_TYPE_SAS
) {
249 sas_ha
->notify_phy_event(sas_phy
, PHYE_OOB_DONE
);
252 struct sas_phy
*sphy
= sas_phy
->phy
;
254 sphy
->negotiated_linkrate
= sas_phy
->linkrate
;
255 sphy
->minimum_linkrate
= phy
->minimum_linkrate
;
256 sphy
->minimum_linkrate_hw
= SAS_LINK_RATE_1_5_GBPS
;
257 sphy
->maximum_linkrate
= phy
->maximum_linkrate
;
258 sphy
->maximum_linkrate_hw
= MVS_CHIP_DISP
->phy_max_link_rate();
261 if (phy
->phy_type
& PORT_TYPE_SAS
) {
262 struct sas_identify_frame
*id
;
264 id
= (struct sas_identify_frame
*)phy
->frame_rcvd
;
265 id
->dev_type
= phy
->identify
.device_type
;
266 id
->initiator_bits
= SAS_PROTOCOL_ALL
;
267 id
->target_bits
= phy
->identify
.target_port_protocols
;
268 } else if (phy
->phy_type
& PORT_TYPE_SATA
) {
271 mv_dprintk("phy %d byte dmaded.\n", i
+ mvi
->id
* mvi
->chip
->n_phy
);
273 sas_phy
->frame_rcvd_size
= phy
->frame_rcvd_size
;
275 mvi
->sas
->notify_port_event(sas_phy
,
279 void mvs_scan_start(struct Scsi_Host
*shost
)
282 unsigned short core_nr
;
283 struct mvs_info
*mvi
;
284 struct sas_ha_struct
*sha
= SHOST_TO_SAS_HA(shost
);
285 struct mvs_prv_info
*mvs_prv
= sha
->lldd_ha
;
287 core_nr
= ((struct mvs_prv_info
*)sha
->lldd_ha
)->n_host
;
289 for (j
= 0; j
< core_nr
; j
++) {
290 mvi
= ((struct mvs_prv_info
*)sha
->lldd_ha
)->mvi
[j
];
291 for (i
= 0; i
< mvi
->chip
->n_phy
; ++i
)
292 mvs_bytes_dmaed(mvi
, i
);
294 mvs_prv
->scan_finished
= 1;
297 int mvs_scan_finished(struct Scsi_Host
*shost
, unsigned long time
)
299 struct sas_ha_struct
*sha
= SHOST_TO_SAS_HA(shost
);
300 struct mvs_prv_info
*mvs_prv
= sha
->lldd_ha
;
302 if (mvs_prv
->scan_finished
== 0)
305 scsi_flush_work(shost
);
309 static int mvs_task_prep_smp(struct mvs_info
*mvi
,
310 struct mvs_task_exec_info
*tei
)
313 struct sas_task
*task
= tei
->task
;
314 struct mvs_cmd_hdr
*hdr
= tei
->hdr
;
315 struct domain_device
*dev
= task
->dev
;
316 struct asd_sas_port
*sas_port
= dev
->port
;
317 struct scatterlist
*sg_req
, *sg_resp
;
318 u32 req_len
, resp_len
, tag
= tei
->tag
;
321 dma_addr_t buf_tmp_dma
;
323 struct mvs_slot_info
*slot
= &mvi
->slot_info
[tag
];
324 u32 flags
= (tei
->n_elem
<< MCH_PRD_LEN_SHIFT
);
327 * DMA-map SMP request, response buffers
329 sg_req
= &task
->smp_task
.smp_req
;
330 elem
= dma_map_sg(mvi
->dev
, sg_req
, 1, PCI_DMA_TODEVICE
);
333 req_len
= sg_dma_len(sg_req
);
335 sg_resp
= &task
->smp_task
.smp_resp
;
336 elem
= dma_map_sg(mvi
->dev
, sg_resp
, 1, PCI_DMA_FROMDEVICE
);
341 resp_len
= SB_RFB_MAX
;
343 /* must be in dwords */
344 if ((req_len
& 0x3) || (resp_len
& 0x3)) {
350 * arrange MVS_SLOT_BUF_SZ-sized DMA buffer according to our needs
353 /* region 1: command table area (MVS_SSP_CMD_SZ bytes) ***** */
355 buf_tmp_dma
= slot
->buf_dma
;
357 hdr
->cmd_tbl
= cpu_to_le64(sg_dma_address(sg_req
));
359 /* region 2: open address frame area (MVS_OAF_SZ bytes) ********* */
361 hdr
->open_frame
= cpu_to_le64(buf_tmp_dma
);
363 buf_tmp
+= MVS_OAF_SZ
;
364 buf_tmp_dma
+= MVS_OAF_SZ
;
366 /* region 3: PRD table *********************************** */
369 hdr
->prd_tbl
= cpu_to_le64(buf_tmp_dma
);
373 i
= MVS_CHIP_DISP
->prd_size() * tei
->n_elem
;
377 /* region 4: status buffer (larger the PRD, smaller this buf) ****** */
378 slot
->response
= buf_tmp
;
379 hdr
->status_buf
= cpu_to_le64(buf_tmp_dma
);
380 if (mvi
->flags
& MVF_FLAG_SOC
)
381 hdr
->reserved
[0] = 0;
384 * Fill in TX ring and command slot header
386 slot
->tx
= mvi
->tx_prod
;
387 mvi
->tx
[mvi
->tx_prod
] = cpu_to_le32((TXQ_CMD_SMP
<< TXQ_CMD_SHIFT
) |
389 (sas_port
->phy_mask
<< TXQ_PHY_SHIFT
));
392 hdr
->lens
= cpu_to_le32(((resp_len
/ 4) << 16) | ((req_len
- 4) / 4));
393 hdr
->tags
= cpu_to_le32(tag
);
396 /* generate open address frame hdr (first 12 bytes) */
397 /* initiator, SMP, ftype 1h */
398 buf_oaf
[0] = (1 << 7) | (PROTOCOL_SMP
<< 4) | 0x01;
399 buf_oaf
[1] = min(sas_port
->linkrate
, dev
->linkrate
) & 0xf;
400 *(u16
*)(buf_oaf
+ 2) = 0xFFFF; /* SAS SPEC */
401 memcpy(buf_oaf
+ 4, dev
->sas_addr
, SAS_ADDR_SIZE
);
403 /* fill in PRD (scatter/gather) table, if any */
404 MVS_CHIP_DISP
->make_prd(task
->scatter
, tei
->n_elem
, buf_prd
);
409 dma_unmap_sg(mvi
->dev
, &tei
->task
->smp_task
.smp_resp
, 1,
412 dma_unmap_sg(mvi
->dev
, &tei
->task
->smp_task
.smp_req
, 1,
417 static u32
mvs_get_ncq_tag(struct sas_task
*task
, u32
*tag
)
419 struct ata_queued_cmd
*qc
= task
->uldd_task
;
422 if (qc
->tf
.command
== ATA_CMD_FPDMA_WRITE
||
423 qc
->tf
.command
== ATA_CMD_FPDMA_READ
) {
432 static int mvs_task_prep_ata(struct mvs_info
*mvi
,
433 struct mvs_task_exec_info
*tei
)
435 struct sas_task
*task
= tei
->task
;
436 struct domain_device
*dev
= task
->dev
;
437 struct mvs_device
*mvi_dev
= dev
->lldd_dev
;
438 struct mvs_cmd_hdr
*hdr
= tei
->hdr
;
439 struct asd_sas_port
*sas_port
= dev
->port
;
440 struct mvs_slot_info
*slot
;
442 u32 tag
= tei
->tag
, hdr_tag
;
445 u8
*buf_cmd
, *buf_oaf
;
446 dma_addr_t buf_tmp_dma
;
447 u32 i
, req_len
, resp_len
;
448 const u32 max_resp_len
= SB_RFB_MAX
;
450 if (mvs_assign_reg_set(mvi
, mvi_dev
) == MVS_ID_NOT_MAPPED
) {
451 mv_dprintk("Have not enough regiset for dev %d.\n",
455 slot
= &mvi
->slot_info
[tag
];
456 slot
->tx
= mvi
->tx_prod
;
457 del_q
= TXQ_MODE_I
| tag
|
458 (TXQ_CMD_STP
<< TXQ_CMD_SHIFT
) |
459 (sas_port
->phy_mask
<< TXQ_PHY_SHIFT
) |
460 (mvi_dev
->taskfileset
<< TXQ_SRS_SHIFT
);
461 mvi
->tx
[mvi
->tx_prod
] = cpu_to_le32(del_q
);
463 if (task
->data_dir
== DMA_FROM_DEVICE
)
464 flags
= (MVS_CHIP_DISP
->prd_count() << MCH_PRD_LEN_SHIFT
);
466 flags
= (tei
->n_elem
<< MCH_PRD_LEN_SHIFT
);
468 if (task
->ata_task
.use_ncq
)
470 if (dev
->sata_dev
.command_set
== ATAPI_COMMAND_SET
) {
471 if (task
->ata_task
.fis
.command
!= ATA_CMD_ID_ATAPI
)
475 hdr
->flags
= cpu_to_le32(flags
);
477 if (task
->ata_task
.use_ncq
&& mvs_get_ncq_tag(task
, &hdr_tag
))
478 task
->ata_task
.fis
.sector_count
|= (u8
) (hdr_tag
<< 3);
482 hdr
->tags
= cpu_to_le32(hdr_tag
);
484 hdr
->data_len
= cpu_to_le32(task
->total_xfer_len
);
487 * arrange MVS_SLOT_BUF_SZ-sized DMA buffer according to our needs
490 /* region 1: command table area (MVS_ATA_CMD_SZ bytes) ************** */
491 buf_cmd
= buf_tmp
= slot
->buf
;
492 buf_tmp_dma
= slot
->buf_dma
;
494 hdr
->cmd_tbl
= cpu_to_le64(buf_tmp_dma
);
496 buf_tmp
+= MVS_ATA_CMD_SZ
;
497 buf_tmp_dma
+= MVS_ATA_CMD_SZ
;
499 /* region 2: open address frame area (MVS_OAF_SZ bytes) ********* */
500 /* used for STP. unused for SATA? */
502 hdr
->open_frame
= cpu_to_le64(buf_tmp_dma
);
504 buf_tmp
+= MVS_OAF_SZ
;
505 buf_tmp_dma
+= MVS_OAF_SZ
;
507 /* region 3: PRD table ********************************************* */
511 hdr
->prd_tbl
= cpu_to_le64(buf_tmp_dma
);
514 i
= MVS_CHIP_DISP
->prd_size() * MVS_CHIP_DISP
->prd_count();
519 /* region 4: status buffer (larger the PRD, smaller this buf) ****** */
520 slot
->response
= buf_tmp
;
521 hdr
->status_buf
= cpu_to_le64(buf_tmp_dma
);
522 if (mvi
->flags
& MVF_FLAG_SOC
)
523 hdr
->reserved
[0] = 0;
525 req_len
= sizeof(struct host_to_dev_fis
);
526 resp_len
= MVS_SLOT_BUF_SZ
- MVS_ATA_CMD_SZ
-
527 sizeof(struct mvs_err_info
) - i
;
529 /* request, response lengths */
530 resp_len
= min(resp_len
, max_resp_len
);
531 hdr
->lens
= cpu_to_le32(((resp_len
/ 4) << 16) | (req_len
/ 4));
533 if (likely(!task
->ata_task
.device_control_reg_update
))
534 task
->ata_task
.fis
.flags
|= 0x80; /* C=1: update ATA cmd reg */
535 /* fill in command FIS and ATAPI CDB */
536 memcpy(buf_cmd
, &task
->ata_task
.fis
, sizeof(struct host_to_dev_fis
));
537 if (dev
->sata_dev
.command_set
== ATAPI_COMMAND_SET
)
538 memcpy(buf_cmd
+ STP_ATAPI_CMD
,
539 task
->ata_task
.atapi_packet
, 16);
541 /* generate open address frame hdr (first 12 bytes) */
542 /* initiator, STP, ftype 1h */
543 buf_oaf
[0] = (1 << 7) | (PROTOCOL_STP
<< 4) | 0x1;
544 buf_oaf
[1] = min(sas_port
->linkrate
, dev
->linkrate
) & 0xf;
545 *(u16
*)(buf_oaf
+ 2) = cpu_to_be16(mvi_dev
->device_id
+ 1);
546 memcpy(buf_oaf
+ 4, dev
->sas_addr
, SAS_ADDR_SIZE
);
548 /* fill in PRD (scatter/gather) table, if any */
549 MVS_CHIP_DISP
->make_prd(task
->scatter
, tei
->n_elem
, buf_prd
);
551 if (task
->data_dir
== DMA_FROM_DEVICE
)
552 MVS_CHIP_DISP
->dma_fix(mvi
, sas_port
->phy_mask
,
553 TRASH_BUCKET_SIZE
, tei
->n_elem
, buf_prd
);
558 static int mvs_task_prep_ssp(struct mvs_info
*mvi
,
559 struct mvs_task_exec_info
*tei
, int is_tmf
,
560 struct mvs_tmf_task
*tmf
)
562 struct sas_task
*task
= tei
->task
;
563 struct mvs_cmd_hdr
*hdr
= tei
->hdr
;
564 struct mvs_port
*port
= tei
->port
;
565 struct domain_device
*dev
= task
->dev
;
566 struct mvs_device
*mvi_dev
= dev
->lldd_dev
;
567 struct asd_sas_port
*sas_port
= dev
->port
;
568 struct mvs_slot_info
*slot
;
570 struct ssp_frame_hdr
*ssp_hdr
;
572 u8
*buf_cmd
, *buf_oaf
, fburst
= 0;
573 dma_addr_t buf_tmp_dma
;
575 u32 resp_len
, req_len
, i
, tag
= tei
->tag
;
576 const u32 max_resp_len
= SB_RFB_MAX
;
579 slot
= &mvi
->slot_info
[tag
];
581 phy_mask
= ((port
->wide_port_phymap
) ? port
->wide_port_phymap
:
582 sas_port
->phy_mask
) & TXQ_PHY_MASK
;
584 slot
->tx
= mvi
->tx_prod
;
585 mvi
->tx
[mvi
->tx_prod
] = cpu_to_le32(TXQ_MODE_I
| tag
|
586 (TXQ_CMD_SSP
<< TXQ_CMD_SHIFT
) |
587 (phy_mask
<< TXQ_PHY_SHIFT
));
590 if (task
->ssp_task
.enable_first_burst
) {
595 flags
|= (MCH_SSP_FR_TASK
<< MCH_SSP_FR_TYPE_SHIFT
);
597 flags
|= (MCH_SSP_FR_CMD
<< MCH_SSP_FR_TYPE_SHIFT
);
599 hdr
->flags
= cpu_to_le32(flags
| (tei
->n_elem
<< MCH_PRD_LEN_SHIFT
));
600 hdr
->tags
= cpu_to_le32(tag
);
601 hdr
->data_len
= cpu_to_le32(task
->total_xfer_len
);
604 * arrange MVS_SLOT_BUF_SZ-sized DMA buffer according to our needs
607 /* region 1: command table area (MVS_SSP_CMD_SZ bytes) ************** */
608 buf_cmd
= buf_tmp
= slot
->buf
;
609 buf_tmp_dma
= slot
->buf_dma
;
611 hdr
->cmd_tbl
= cpu_to_le64(buf_tmp_dma
);
613 buf_tmp
+= MVS_SSP_CMD_SZ
;
614 buf_tmp_dma
+= MVS_SSP_CMD_SZ
;
616 /* region 2: open address frame area (MVS_OAF_SZ bytes) ********* */
618 hdr
->open_frame
= cpu_to_le64(buf_tmp_dma
);
620 buf_tmp
+= MVS_OAF_SZ
;
621 buf_tmp_dma
+= MVS_OAF_SZ
;
623 /* region 3: PRD table ********************************************* */
626 hdr
->prd_tbl
= cpu_to_le64(buf_tmp_dma
);
630 i
= MVS_CHIP_DISP
->prd_size() * tei
->n_elem
;
634 /* region 4: status buffer (larger the PRD, smaller this buf) ****** */
635 slot
->response
= buf_tmp
;
636 hdr
->status_buf
= cpu_to_le64(buf_tmp_dma
);
637 if (mvi
->flags
& MVF_FLAG_SOC
)
638 hdr
->reserved
[0] = 0;
640 resp_len
= MVS_SLOT_BUF_SZ
- MVS_SSP_CMD_SZ
- MVS_OAF_SZ
-
641 sizeof(struct mvs_err_info
) - i
;
642 resp_len
= min(resp_len
, max_resp_len
);
644 req_len
= sizeof(struct ssp_frame_hdr
) + 28;
646 /* request, response lengths */
647 hdr
->lens
= cpu_to_le32(((resp_len
/ 4) << 16) | (req_len
/ 4));
649 /* generate open address frame hdr (first 12 bytes) */
650 /* initiator, SSP, ftype 1h */
651 buf_oaf
[0] = (1 << 7) | (PROTOCOL_SSP
<< 4) | 0x1;
652 buf_oaf
[1] = min(sas_port
->linkrate
, dev
->linkrate
) & 0xf;
653 *(u16
*)(buf_oaf
+ 2) = cpu_to_be16(mvi_dev
->device_id
+ 1);
654 memcpy(buf_oaf
+ 4, dev
->sas_addr
, SAS_ADDR_SIZE
);
656 /* fill in SSP frame header (Command Table.SSP frame header) */
657 ssp_hdr
= (struct ssp_frame_hdr
*)buf_cmd
;
660 ssp_hdr
->frame_type
= SSP_TASK
;
662 ssp_hdr
->frame_type
= SSP_COMMAND
;
664 memcpy(ssp_hdr
->hashed_dest_addr
, dev
->hashed_sas_addr
,
665 HASHED_SAS_ADDR_SIZE
);
666 memcpy(ssp_hdr
->hashed_src_addr
,
667 dev
->hashed_sas_addr
, HASHED_SAS_ADDR_SIZE
);
668 ssp_hdr
->tag
= cpu_to_be16(tag
);
670 /* fill in IU for TASK and Command Frame */
671 buf_cmd
+= sizeof(*ssp_hdr
);
672 memcpy(buf_cmd
, &task
->ssp_task
.LUN
, 8);
674 if (ssp_hdr
->frame_type
!= SSP_TASK
) {
675 buf_cmd
[9] = fburst
| task
->ssp_task
.task_attr
|
676 (task
->ssp_task
.task_prio
<< 3);
677 memcpy(buf_cmd
+ 12, &task
->ssp_task
.cdb
, 16);
679 buf_cmd
[10] = tmf
->tmf
;
684 (tmf
->tag_of_task_to_be_managed
>> 8) & 0xff;
686 tmf
->tag_of_task_to_be_managed
& 0xff;
692 /* fill in PRD (scatter/gather) table, if any */
693 MVS_CHIP_DISP
->make_prd(task
->scatter
, tei
->n_elem
, buf_prd
);
697 #define DEV_IS_GONE(mvi_dev) ((!mvi_dev || (mvi_dev->dev_type == NO_DEVICE)))
698 static int mvs_task_prep(struct sas_task
*task
, struct mvs_info
*mvi
, int is_tmf
,
699 struct mvs_tmf_task
*tmf
, int *pass
)
701 struct domain_device
*dev
= task
->dev
;
702 struct mvs_device
*mvi_dev
= dev
->lldd_dev
;
703 struct mvs_task_exec_info tei
;
704 struct mvs_slot_info
*slot
;
705 u32 tag
= 0xdeadbeef, n_elem
= 0;
709 struct task_status_struct
*tsm
= &task
->task_status
;
711 tsm
->resp
= SAS_TASK_UNDELIVERED
;
712 tsm
->stat
= SAS_PHY_DOWN
;
714 * libsas will use dev->port, should
715 * not call task_done for sata
717 if (dev
->dev_type
!= SATA_DEV
)
718 task
->task_done(task
);
722 if (DEV_IS_GONE(mvi_dev
)) {
724 mv_dprintk("device %d not ready.\n",
727 mv_dprintk("device %016llx not ready.\n",
728 SAS_ADDR(dev
->sas_addr
));
733 tei
.port
= dev
->port
->lldd_port
;
734 if (tei
.port
&& !tei
.port
->port_attached
&& !tmf
) {
735 if (sas_protocol_ata(task
->task_proto
)) {
736 struct task_status_struct
*ts
= &task
->task_status
;
737 mv_dprintk("SATA/STP port %d does not attach"
738 "device.\n", dev
->port
->id
);
739 ts
->resp
= SAS_TASK_COMPLETE
;
740 ts
->stat
= SAS_PHY_DOWN
;
742 task
->task_done(task
);
745 struct task_status_struct
*ts
= &task
->task_status
;
746 mv_dprintk("SAS port %d does not attach"
747 "device.\n", dev
->port
->id
);
748 ts
->resp
= SAS_TASK_UNDELIVERED
;
749 ts
->stat
= SAS_PHY_DOWN
;
750 task
->task_done(task
);
755 if (!sas_protocol_ata(task
->task_proto
)) {
756 if (task
->num_scatter
) {
757 n_elem
= dma_map_sg(mvi
->dev
,
767 n_elem
= task
->num_scatter
;
770 rc
= mvs_tag_alloc(mvi
, &tag
);
774 slot
= &mvi
->slot_info
[tag
];
776 task
->lldd_task
= NULL
;
777 slot
->n_elem
= n_elem
;
778 slot
->slot_tag
= tag
;
780 slot
->buf
= pci_pool_alloc(mvi
->dma_pool
, GFP_ATOMIC
, &slot
->buf_dma
);
783 memset(slot
->buf
, 0, MVS_SLOT_BUF_SZ
);
786 tei
.hdr
= &mvi
->slot
[tag
];
789 switch (task
->task_proto
) {
790 case SAS_PROTOCOL_SMP
:
791 rc
= mvs_task_prep_smp(mvi
, &tei
);
793 case SAS_PROTOCOL_SSP
:
794 rc
= mvs_task_prep_ssp(mvi
, &tei
, is_tmf
, tmf
);
796 case SAS_PROTOCOL_SATA
:
797 case SAS_PROTOCOL_STP
:
798 case SAS_PROTOCOL_SATA
| SAS_PROTOCOL_STP
:
799 rc
= mvs_task_prep_ata(mvi
, &tei
);
802 dev_printk(KERN_ERR
, mvi
->dev
,
803 "unknown sas_task proto: 0x%x\n",
810 mv_dprintk("rc is %x\n", rc
);
811 goto err_out_slot_buf
;
814 slot
->port
= tei
.port
;
815 task
->lldd_task
= slot
;
816 list_add_tail(&slot
->entry
, &tei
.port
->list
);
817 spin_lock(&task
->task_state_lock
);
818 task
->task_state_flags
|= SAS_TASK_AT_INITIATOR
;
819 spin_unlock(&task
->task_state_lock
);
821 mvi_dev
->running_req
++;
823 mvi
->tx_prod
= (mvi
->tx_prod
+ 1) & (MVS_CHIP_SLOT_SZ
- 1);
828 pci_pool_free(mvi
->dma_pool
, slot
->buf
, slot
->buf_dma
);
830 mvs_tag_free(mvi
, tag
);
833 dev_printk(KERN_ERR
, mvi
->dev
, "mvsas prep failed[%d]!\n", rc
);
834 if (!sas_protocol_ata(task
->task_proto
))
836 dma_unmap_sg(mvi
->dev
, task
->scatter
, n_elem
,
842 static struct mvs_task_list
*mvs_task_alloc_list(int *num
, gfp_t gfp_flags
)
844 struct mvs_task_list
*first
= NULL
;
846 for (; *num
> 0; --*num
) {
847 struct mvs_task_list
*mvs_list
= kmem_cache_zalloc(mvs_task_list_cache
, gfp_flags
);
852 INIT_LIST_HEAD(&mvs_list
->list
);
856 list_add_tail(&mvs_list
->list
, &first
->list
);
863 static inline void mvs_task_free_list(struct mvs_task_list
*mvs_list
)
866 struct list_head
*pos
, *a
;
867 struct mvs_task_list
*mlist
= NULL
;
869 __list_add(&list
, mvs_list
->list
.prev
, &mvs_list
->list
);
871 list_for_each_safe(pos
, a
, &list
) {
873 mlist
= list_entry(pos
, struct mvs_task_list
, list
);
874 kmem_cache_free(mvs_task_list_cache
, mlist
);
878 static int mvs_task_exec(struct sas_task
*task
, const int num
, gfp_t gfp_flags
,
879 struct completion
*completion
, int is_tmf
,
880 struct mvs_tmf_task
*tmf
)
882 struct domain_device
*dev
= task
->dev
;
883 struct mvs_info
*mvi
= NULL
;
886 unsigned long flags
= 0;
888 mvi
= ((struct mvs_device
*)task
->dev
->lldd_dev
)->mvi_info
;
890 if ((dev
->dev_type
== SATA_DEV
) && (dev
->sata_dev
.ap
!= NULL
))
891 spin_unlock_irq(dev
->sata_dev
.ap
->lock
);
893 spin_lock_irqsave(&mvi
->lock
, flags
);
894 rc
= mvs_task_prep(task
, mvi
, is_tmf
, tmf
, &pass
);
896 dev_printk(KERN_ERR
, mvi
->dev
, "mvsas exec failed[%d]!\n", rc
);
899 MVS_CHIP_DISP
->start_delivery(mvi
, (mvi
->tx_prod
- 1) &
900 (MVS_CHIP_SLOT_SZ
- 1));
901 spin_unlock_irqrestore(&mvi
->lock
, flags
);
903 if ((dev
->dev_type
== SATA_DEV
) && (dev
->sata_dev
.ap
!= NULL
))
904 spin_lock_irq(dev
->sata_dev
.ap
->lock
);
909 static int mvs_collector_task_exec(struct sas_task
*task
, const int num
, gfp_t gfp_flags
,
910 struct completion
*completion
, int is_tmf
,
911 struct mvs_tmf_task
*tmf
)
913 struct domain_device
*dev
= task
->dev
;
914 struct mvs_prv_info
*mpi
= dev
->port
->ha
->lldd_ha
;
915 struct mvs_info
*mvi
= NULL
;
916 struct sas_task
*t
= task
;
917 struct mvs_task_list
*mvs_list
= NULL
, *a
;
922 unsigned long flags
= 0;
924 mvs_list
= mvs_task_alloc_list(&n
, gfp_flags
);
926 printk(KERN_ERR
"%s: mvs alloc list failed.\n", __func__
);
931 __list_add(&q
, mvs_list
->list
.prev
, &mvs_list
->list
);
933 list_for_each_entry(a
, &q
, list
) {
935 t
= list_entry(t
->list
.next
, struct sas_task
, list
);
938 list_for_each_entry(a
, &q
, list
) {
941 mvi
= ((struct mvs_device
*)t
->dev
->lldd_dev
)->mvi_info
;
943 spin_lock_irqsave(&mvi
->lock
, flags
);
944 rc
= mvs_task_prep(t
, mvi
, is_tmf
, tmf
, &pass
[mvi
->id
]);
946 dev_printk(KERN_ERR
, mvi
->dev
, "mvsas exec failed[%d]!\n", rc
);
947 spin_unlock_irqrestore(&mvi
->lock
, flags
);
951 MVS_CHIP_DISP
->start_delivery(mpi
->mvi
[0],
952 (mpi
->mvi
[0]->tx_prod
- 1) & (MVS_CHIP_SLOT_SZ
- 1));
955 MVS_CHIP_DISP
->start_delivery(mpi
->mvi
[1],
956 (mpi
->mvi
[1]->tx_prod
- 1) & (MVS_CHIP_SLOT_SZ
- 1));
962 mvs_task_free_list(mvs_list
);
967 int mvs_queue_command(struct sas_task
*task
, const int num
,
970 struct mvs_device
*mvi_dev
= task
->dev
->lldd_dev
;
971 struct sas_ha_struct
*sas
= mvi_dev
->mvi_info
->sas
;
973 if (sas
->lldd_max_execute_num
< 2)
974 return mvs_task_exec(task
, num
, gfp_flags
, NULL
, 0, NULL
);
976 return mvs_collector_task_exec(task
, num
, gfp_flags
, NULL
, 0, NULL
);
979 static void mvs_slot_free(struct mvs_info
*mvi
, u32 rx_desc
)
981 u32 slot_idx
= rx_desc
& RXQ_SLOT_MASK
;
982 mvs_tag_clear(mvi
, slot_idx
);
985 static void mvs_slot_task_free(struct mvs_info
*mvi
, struct sas_task
*task
,
986 struct mvs_slot_info
*slot
, u32 slot_idx
)
990 if (!sas_protocol_ata(task
->task_proto
))
992 dma_unmap_sg(mvi
->dev
, task
->scatter
,
993 slot
->n_elem
, task
->data_dir
);
995 switch (task
->task_proto
) {
996 case SAS_PROTOCOL_SMP
:
997 dma_unmap_sg(mvi
->dev
, &task
->smp_task
.smp_resp
, 1,
999 dma_unmap_sg(mvi
->dev
, &task
->smp_task
.smp_req
, 1,
1003 case SAS_PROTOCOL_SATA
:
1004 case SAS_PROTOCOL_STP
:
1005 case SAS_PROTOCOL_SSP
:
1012 pci_pool_free(mvi
->dma_pool
, slot
->buf
, slot
->buf_dma
);
1015 list_del_init(&slot
->entry
);
1016 task
->lldd_task
= NULL
;
1019 slot
->slot_tag
= 0xFFFFFFFF;
1020 mvs_slot_free(mvi
, slot_idx
);
1023 static void mvs_update_wideport(struct mvs_info
*mvi
, int phy_no
)
1025 struct mvs_phy
*phy
= &mvi
->phy
[phy_no
];
1026 struct mvs_port
*port
= phy
->port
;
1029 for_each_phy(port
->wide_port_phymap
, j
, no
) {
1031 MVS_CHIP_DISP
->write_port_cfg_addr(mvi
, no
,
1033 MVS_CHIP_DISP
->write_port_cfg_data(mvi
, no
,
1034 port
->wide_port_phymap
);
1036 MVS_CHIP_DISP
->write_port_cfg_addr(mvi
, no
,
1038 MVS_CHIP_DISP
->write_port_cfg_data(mvi
, no
,
1044 static u32
mvs_is_phy_ready(struct mvs_info
*mvi
, int i
)
1047 struct mvs_phy
*phy
= &mvi
->phy
[i
];
1048 struct mvs_port
*port
= phy
->port
;
1050 tmp
= MVS_CHIP_DISP
->read_phy_ctl(mvi
, i
);
1051 if ((tmp
& PHY_READY_MASK
) && !(phy
->irq_status
& PHYEV_POOF
)) {
1053 phy
->phy_attached
= 1;
1058 if (phy
->phy_type
& PORT_TYPE_SAS
) {
1059 port
->wide_port_phymap
&= ~(1U << i
);
1060 if (!port
->wide_port_phymap
)
1061 port
->port_attached
= 0;
1062 mvs_update_wideport(mvi
, i
);
1063 } else if (phy
->phy_type
& PORT_TYPE_SATA
)
1064 port
->port_attached
= 0;
1066 phy
->phy_attached
= 0;
1067 phy
->phy_type
&= ~(PORT_TYPE_SAS
| PORT_TYPE_SATA
);
1072 static void *mvs_get_d2h_reg(struct mvs_info
*mvi
, int i
, void *buf
)
1074 u32
*s
= (u32
*) buf
;
1079 MVS_CHIP_DISP
->write_port_cfg_addr(mvi
, i
, PHYR_SATA_SIG3
);
1080 s
[3] = cpu_to_le32(MVS_CHIP_DISP
->read_port_cfg_data(mvi
, i
));
1082 MVS_CHIP_DISP
->write_port_cfg_addr(mvi
, i
, PHYR_SATA_SIG2
);
1083 s
[2] = cpu_to_le32(MVS_CHIP_DISP
->read_port_cfg_data(mvi
, i
));
1085 MVS_CHIP_DISP
->write_port_cfg_addr(mvi
, i
, PHYR_SATA_SIG1
);
1086 s
[1] = cpu_to_le32(MVS_CHIP_DISP
->read_port_cfg_data(mvi
, i
));
1088 MVS_CHIP_DISP
->write_port_cfg_addr(mvi
, i
, PHYR_SATA_SIG0
);
1089 s
[0] = cpu_to_le32(MVS_CHIP_DISP
->read_port_cfg_data(mvi
, i
));
1091 if (((s
[1] & 0x00FFFFFF) == 0x00EB1401) && (*(u8
*)&s
[3] == 0x01))
1092 s
[1] = 0x00EB1401 | (*((u8
*)&s
[1] + 3) & 0x10);
1097 static u32
mvs_is_sig_fis_received(u32 irq_status
)
1099 return irq_status
& PHYEV_SIG_FIS
;
1102 static void mvs_sig_remove_timer(struct mvs_phy
*phy
)
1104 if (phy
->timer
.function
)
1105 del_timer(&phy
->timer
);
1106 phy
->timer
.function
= NULL
;
1109 void mvs_update_phyinfo(struct mvs_info
*mvi
, int i
, int get_st
)
1111 struct mvs_phy
*phy
= &mvi
->phy
[i
];
1112 struct sas_identify_frame
*id
;
1114 id
= (struct sas_identify_frame
*)phy
->frame_rcvd
;
1117 phy
->irq_status
= MVS_CHIP_DISP
->read_port_irq_stat(mvi
, i
);
1118 phy
->phy_status
= mvs_is_phy_ready(mvi
, i
);
1121 if (phy
->phy_status
) {
1123 struct asd_sas_phy
*sas_phy
= &mvi
->phy
[i
].sas_phy
;
1125 oob_done
= MVS_CHIP_DISP
->oob_done(mvi
, i
);
1127 MVS_CHIP_DISP
->fix_phy_info(mvi
, i
, id
);
1128 if (phy
->phy_type
& PORT_TYPE_SATA
) {
1129 phy
->identify
.target_port_protocols
= SAS_PROTOCOL_STP
;
1130 if (mvs_is_sig_fis_received(phy
->irq_status
)) {
1131 mvs_sig_remove_timer(phy
);
1132 phy
->phy_attached
= 1;
1133 phy
->att_dev_sas_addr
=
1134 i
+ mvi
->id
* mvi
->chip
->n_phy
;
1136 sas_phy
->oob_mode
= SATA_OOB_MODE
;
1137 phy
->frame_rcvd_size
=
1138 sizeof(struct dev_to_host_fis
);
1139 mvs_get_d2h_reg(mvi
, i
, id
);
1142 dev_printk(KERN_DEBUG
, mvi
->dev
,
1143 "Phy%d : No sig fis\n", i
);
1144 tmp
= MVS_CHIP_DISP
->read_port_irq_mask(mvi
, i
);
1145 MVS_CHIP_DISP
->write_port_irq_mask(mvi
, i
,
1146 tmp
| PHYEV_SIG_FIS
);
1147 phy
->phy_attached
= 0;
1148 phy
->phy_type
&= ~PORT_TYPE_SATA
;
1151 } else if (phy
->phy_type
& PORT_TYPE_SAS
1152 || phy
->att_dev_info
& PORT_SSP_INIT_MASK
) {
1153 phy
->phy_attached
= 1;
1154 phy
->identify
.device_type
=
1155 phy
->att_dev_info
& PORT_DEV_TYPE_MASK
;
1157 if (phy
->identify
.device_type
== SAS_END_DEV
)
1158 phy
->identify
.target_port_protocols
=
1160 else if (phy
->identify
.device_type
!= NO_DEVICE
)
1161 phy
->identify
.target_port_protocols
=
1164 sas_phy
->oob_mode
= SAS_OOB_MODE
;
1165 phy
->frame_rcvd_size
=
1166 sizeof(struct sas_identify_frame
);
1168 memcpy(sas_phy
->attached_sas_addr
,
1169 &phy
->att_dev_sas_addr
, SAS_ADDR_SIZE
);
1171 if (MVS_CHIP_DISP
->phy_work_around
)
1172 MVS_CHIP_DISP
->phy_work_around(mvi
, i
);
1174 mv_dprintk("phy %d attach dev info is %x\n",
1175 i
+ mvi
->id
* mvi
->chip
->n_phy
, phy
->att_dev_info
);
1176 mv_dprintk("phy %d attach sas addr is %llx\n",
1177 i
+ mvi
->id
* mvi
->chip
->n_phy
, phy
->att_dev_sas_addr
);
1180 MVS_CHIP_DISP
->write_port_irq_stat(mvi
, i
, phy
->irq_status
);
1183 static void mvs_port_notify_formed(struct asd_sas_phy
*sas_phy
, int lock
)
1185 struct sas_ha_struct
*sas_ha
= sas_phy
->ha
;
1186 struct mvs_info
*mvi
= NULL
; int i
= 0, hi
;
1187 struct mvs_phy
*phy
= sas_phy
->lldd_phy
;
1188 struct asd_sas_port
*sas_port
= sas_phy
->port
;
1189 struct mvs_port
*port
;
1190 unsigned long flags
= 0;
1194 while (sas_ha
->sas_phy
[i
]) {
1195 if (sas_ha
->sas_phy
[i
] == sas_phy
)
1199 hi
= i
/((struct mvs_prv_info
*)sas_ha
->lldd_ha
)->n_phy
;
1200 mvi
= ((struct mvs_prv_info
*)sas_ha
->lldd_ha
)->mvi
[hi
];
1201 if (i
>= mvi
->chip
->n_phy
)
1202 port
= &mvi
->port
[i
- mvi
->chip
->n_phy
];
1204 port
= &mvi
->port
[i
];
1206 spin_lock_irqsave(&mvi
->lock
, flags
);
1207 port
->port_attached
= 1;
1209 sas_port
->lldd_port
= port
;
1210 if (phy
->phy_type
& PORT_TYPE_SAS
) {
1211 port
->wide_port_phymap
= sas_port
->phy_mask
;
1212 mv_printk("set wide port phy map %x\n", sas_port
->phy_mask
);
1213 mvs_update_wideport(mvi
, sas_phy
->id
);
1216 spin_unlock_irqrestore(&mvi
->lock
, flags
);
1219 static void mvs_port_notify_deformed(struct asd_sas_phy
*sas_phy
, int lock
)
1221 struct domain_device
*dev
;
1222 struct mvs_phy
*phy
= sas_phy
->lldd_phy
;
1223 struct mvs_info
*mvi
= phy
->mvi
;
1224 struct asd_sas_port
*port
= sas_phy
->port
;
1227 while (phy
!= &mvi
->phy
[phy_no
]) {
1229 if (phy_no
>= MVS_MAX_PHYS
)
1232 list_for_each_entry(dev
, &port
->dev_list
, dev_list_node
)
1233 mvs_do_release_task(phy
->mvi
, phy_no
, dev
);
1238 void mvs_port_formed(struct asd_sas_phy
*sas_phy
)
1240 mvs_port_notify_formed(sas_phy
, 1);
1243 void mvs_port_deformed(struct asd_sas_phy
*sas_phy
)
1245 mvs_port_notify_deformed(sas_phy
, 1);
1248 struct mvs_device
*mvs_alloc_dev(struct mvs_info
*mvi
)
1251 for (dev
= 0; dev
< MVS_MAX_DEVICES
; dev
++) {
1252 if (mvi
->devices
[dev
].dev_type
== NO_DEVICE
) {
1253 mvi
->devices
[dev
].device_id
= dev
;
1254 return &mvi
->devices
[dev
];
1258 if (dev
== MVS_MAX_DEVICES
)
1259 mv_printk("max support %d devices, ignore ..\n",
1265 void mvs_free_dev(struct mvs_device
*mvi_dev
)
1267 u32 id
= mvi_dev
->device_id
;
1268 memset(mvi_dev
, 0, sizeof(*mvi_dev
));
1269 mvi_dev
->device_id
= id
;
1270 mvi_dev
->dev_type
= NO_DEVICE
;
1271 mvi_dev
->dev_status
= MVS_DEV_NORMAL
;
1272 mvi_dev
->taskfileset
= MVS_ID_NOT_MAPPED
;
1275 int mvs_dev_found_notify(struct domain_device
*dev
, int lock
)
1277 unsigned long flags
= 0;
1279 struct mvs_info
*mvi
= NULL
;
1280 struct domain_device
*parent_dev
= dev
->parent
;
1281 struct mvs_device
*mvi_device
;
1283 mvi
= mvs_find_dev_mvi(dev
);
1286 spin_lock_irqsave(&mvi
->lock
, flags
);
1288 mvi_device
= mvs_alloc_dev(mvi
);
1293 dev
->lldd_dev
= mvi_device
;
1294 mvi_device
->dev_status
= MVS_DEV_NORMAL
;
1295 mvi_device
->dev_type
= dev
->dev_type
;
1296 mvi_device
->mvi_info
= mvi
;
1297 mvi_device
->sas_device
= dev
;
1298 if (parent_dev
&& DEV_IS_EXPANDER(parent_dev
->dev_type
)) {
1300 u8 phy_num
= parent_dev
->ex_dev
.num_phys
;
1302 for (phy_id
= 0; phy_id
< phy_num
; phy_id
++) {
1303 phy
= &parent_dev
->ex_dev
.ex_phy
[phy_id
];
1304 if (SAS_ADDR(phy
->attached_sas_addr
) ==
1305 SAS_ADDR(dev
->sas_addr
)) {
1306 mvi_device
->attached_phy
= phy_id
;
1311 if (phy_id
== phy_num
) {
1312 mv_printk("Error: no attached dev:%016llx"
1314 SAS_ADDR(dev
->sas_addr
),
1315 SAS_ADDR(parent_dev
->sas_addr
));
1322 spin_unlock_irqrestore(&mvi
->lock
, flags
);
1326 int mvs_dev_found(struct domain_device
*dev
)
1328 return mvs_dev_found_notify(dev
, 1);
1331 void mvs_dev_gone_notify(struct domain_device
*dev
)
1333 unsigned long flags
= 0;
1334 struct mvs_device
*mvi_dev
= dev
->lldd_dev
;
1335 struct mvs_info
*mvi
= mvi_dev
->mvi_info
;
1337 spin_lock_irqsave(&mvi
->lock
, flags
);
1340 mv_dprintk("found dev[%d:%x] is gone.\n",
1341 mvi_dev
->device_id
, mvi_dev
->dev_type
);
1342 mvs_release_task(mvi
, dev
);
1343 mvs_free_reg_set(mvi
, mvi_dev
);
1344 mvs_free_dev(mvi_dev
);
1346 mv_dprintk("found dev has gone.\n");
1348 dev
->lldd_dev
= NULL
;
1349 mvi_dev
->sas_device
= NULL
;
1351 spin_unlock_irqrestore(&mvi
->lock
, flags
);
1355 void mvs_dev_gone(struct domain_device
*dev
)
1357 mvs_dev_gone_notify(dev
);
1360 static void mvs_task_done(struct sas_task
*task
)
1362 if (!del_timer(&task
->timer
))
1364 complete(&task
->completion
);
1367 static void mvs_tmf_timedout(unsigned long data
)
1369 struct sas_task
*task
= (struct sas_task
*)data
;
1371 task
->task_state_flags
|= SAS_TASK_STATE_ABORTED
;
1372 complete(&task
->completion
);
1375 #define MVS_TASK_TIMEOUT 20
1376 static int mvs_exec_internal_tmf_task(struct domain_device
*dev
,
1377 void *parameter
, u32 para_len
, struct mvs_tmf_task
*tmf
)
1380 struct sas_task
*task
= NULL
;
1382 for (retry
= 0; retry
< 3; retry
++) {
1383 task
= sas_alloc_task(GFP_KERNEL
);
1388 task
->task_proto
= dev
->tproto
;
1390 memcpy(&task
->ssp_task
, parameter
, para_len
);
1391 task
->task_done
= mvs_task_done
;
1393 task
->timer
.data
= (unsigned long) task
;
1394 task
->timer
.function
= mvs_tmf_timedout
;
1395 task
->timer
.expires
= jiffies
+ MVS_TASK_TIMEOUT
*HZ
;
1396 add_timer(&task
->timer
);
1398 res
= mvs_task_exec(task
, 1, GFP_KERNEL
, NULL
, 1, tmf
);
1401 del_timer(&task
->timer
);
1402 mv_printk("executing internel task failed:%d\n", res
);
1406 wait_for_completion(&task
->completion
);
1407 res
= TMF_RESP_FUNC_FAILED
;
1408 /* Even TMF timed out, return direct. */
1409 if ((task
->task_state_flags
& SAS_TASK_STATE_ABORTED
)) {
1410 if (!(task
->task_state_flags
& SAS_TASK_STATE_DONE
)) {
1411 mv_printk("TMF task[%x] timeout.\n", tmf
->tmf
);
1416 if (task
->task_status
.resp
== SAS_TASK_COMPLETE
&&
1417 task
->task_status
.stat
== SAM_STAT_GOOD
) {
1418 res
= TMF_RESP_FUNC_COMPLETE
;
1422 if (task
->task_status
.resp
== SAS_TASK_COMPLETE
&&
1423 task
->task_status
.stat
== SAS_DATA_UNDERRUN
) {
1424 /* no error, but return the number of bytes of
1426 res
= task
->task_status
.residual
;
1430 if (task
->task_status
.resp
== SAS_TASK_COMPLETE
&&
1431 task
->task_status
.stat
== SAS_DATA_OVERRUN
) {
1432 mv_dprintk("blocked task error.\n");
1436 mv_dprintk(" task to dev %016llx response: 0x%x "
1438 SAS_ADDR(dev
->sas_addr
),
1439 task
->task_status
.resp
,
1440 task
->task_status
.stat
);
1441 sas_free_task(task
);
1447 BUG_ON(retry
== 3 && task
!= NULL
);
1448 sas_free_task(task
);
1452 static int mvs_debug_issue_ssp_tmf(struct domain_device
*dev
,
1453 u8
*lun
, struct mvs_tmf_task
*tmf
)
1455 struct sas_ssp_task ssp_task
;
1456 if (!(dev
->tproto
& SAS_PROTOCOL_SSP
))
1457 return TMF_RESP_FUNC_ESUPP
;
1459 memcpy(ssp_task
.LUN
, lun
, 8);
1461 return mvs_exec_internal_tmf_task(dev
, &ssp_task
,
1462 sizeof(ssp_task
), tmf
);
1466 /* Standard mandates link reset for ATA (type 0)
1467 and hard reset for SSP (type 1) , only for RECOVERY */
1468 static int mvs_debug_I_T_nexus_reset(struct domain_device
*dev
)
1471 struct sas_phy
*phy
= sas_find_local_phy(dev
);
1472 int reset_type
= (dev
->dev_type
== SATA_DEV
||
1473 (dev
->tproto
& SAS_PROTOCOL_STP
)) ? 0 : 1;
1474 rc
= sas_phy_reset(phy
, reset_type
);
1479 /* mandatory SAM-3 */
1480 int mvs_lu_reset(struct domain_device
*dev
, u8
*lun
)
1482 unsigned long flags
;
1483 int rc
= TMF_RESP_FUNC_FAILED
;
1484 struct mvs_tmf_task tmf_task
;
1485 struct mvs_device
* mvi_dev
= dev
->lldd_dev
;
1486 struct mvs_info
*mvi
= mvi_dev
->mvi_info
;
1488 tmf_task
.tmf
= TMF_LU_RESET
;
1489 mvi_dev
->dev_status
= MVS_DEV_EH
;
1490 rc
= mvs_debug_issue_ssp_tmf(dev
, lun
, &tmf_task
);
1491 if (rc
== TMF_RESP_FUNC_COMPLETE
) {
1492 spin_lock_irqsave(&mvi
->lock
, flags
);
1493 mvs_release_task(mvi
, dev
);
1494 spin_unlock_irqrestore(&mvi
->lock
, flags
);
1496 /* If failed, fall-through I_T_Nexus reset */
1497 mv_printk("%s for device[%x]:rc= %d\n", __func__
,
1498 mvi_dev
->device_id
, rc
);
1502 int mvs_I_T_nexus_reset(struct domain_device
*dev
)
1504 unsigned long flags
;
1505 int rc
= TMF_RESP_FUNC_FAILED
;
1506 struct mvs_device
* mvi_dev
= (struct mvs_device
*)dev
->lldd_dev
;
1507 struct mvs_info
*mvi
= mvi_dev
->mvi_info
;
1509 if (mvi_dev
->dev_status
!= MVS_DEV_EH
)
1510 return TMF_RESP_FUNC_COMPLETE
;
1512 mvi_dev
->dev_status
= MVS_DEV_NORMAL
;
1513 rc
= mvs_debug_I_T_nexus_reset(dev
);
1514 mv_printk("%s for device[%x]:rc= %d\n",
1515 __func__
, mvi_dev
->device_id
, rc
);
1517 spin_lock_irqsave(&mvi
->lock
, flags
);
1518 mvs_release_task(mvi
, dev
);
1519 spin_unlock_irqrestore(&mvi
->lock
, flags
);
1523 /* optional SAM-3 */
1524 int mvs_query_task(struct sas_task
*task
)
1527 struct scsi_lun lun
;
1528 struct mvs_tmf_task tmf_task
;
1529 int rc
= TMF_RESP_FUNC_FAILED
;
1531 if (task
->lldd_task
&& task
->task_proto
& SAS_PROTOCOL_SSP
) {
1532 struct scsi_cmnd
* cmnd
= (struct scsi_cmnd
*)task
->uldd_task
;
1533 struct domain_device
*dev
= task
->dev
;
1534 struct mvs_device
*mvi_dev
= (struct mvs_device
*)dev
->lldd_dev
;
1535 struct mvs_info
*mvi
= mvi_dev
->mvi_info
;
1537 int_to_scsilun(cmnd
->device
->lun
, &lun
);
1538 rc
= mvs_find_tag(mvi
, task
, &tag
);
1540 rc
= TMF_RESP_FUNC_FAILED
;
1544 tmf_task
.tmf
= TMF_QUERY_TASK
;
1545 tmf_task
.tag_of_task_to_be_managed
= cpu_to_le16(tag
);
1547 rc
= mvs_debug_issue_ssp_tmf(dev
, lun
.scsi_lun
, &tmf_task
);
1549 /* The task is still in Lun, release it then */
1550 case TMF_RESP_FUNC_SUCC
:
1551 /* The task is not in Lun or failed, reset the phy */
1552 case TMF_RESP_FUNC_FAILED
:
1553 case TMF_RESP_FUNC_COMPLETE
:
1557 mv_printk("%s:rc= %d\n", __func__
, rc
);
1561 /* mandatory SAM-3, still need free task/slot info */
1562 int mvs_abort_task(struct sas_task
*task
)
1564 struct scsi_lun lun
;
1565 struct mvs_tmf_task tmf_task
;
1566 struct domain_device
*dev
= task
->dev
;
1567 struct mvs_device
*mvi_dev
= (struct mvs_device
*)dev
->lldd_dev
;
1568 struct mvs_info
*mvi
;
1569 int rc
= TMF_RESP_FUNC_FAILED
;
1570 unsigned long flags
;
1574 mv_printk("Device has removed\n");
1575 return TMF_RESP_FUNC_FAILED
;
1578 mvi
= mvi_dev
->mvi_info
;
1580 spin_lock_irqsave(&task
->task_state_lock
, flags
);
1581 if (task
->task_state_flags
& SAS_TASK_STATE_DONE
) {
1582 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
1583 rc
= TMF_RESP_FUNC_COMPLETE
;
1586 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
1587 mvi_dev
->dev_status
= MVS_DEV_EH
;
1588 if (task
->lldd_task
&& task
->task_proto
& SAS_PROTOCOL_SSP
) {
1589 struct scsi_cmnd
* cmnd
= (struct scsi_cmnd
*)task
->uldd_task
;
1591 int_to_scsilun(cmnd
->device
->lun
, &lun
);
1592 rc
= mvs_find_tag(mvi
, task
, &tag
);
1594 mv_printk("No such tag in %s\n", __func__
);
1595 rc
= TMF_RESP_FUNC_FAILED
;
1599 tmf_task
.tmf
= TMF_ABORT_TASK
;
1600 tmf_task
.tag_of_task_to_be_managed
= cpu_to_le16(tag
);
1602 rc
= mvs_debug_issue_ssp_tmf(dev
, lun
.scsi_lun
, &tmf_task
);
1604 /* if successful, clear the task and callback forwards.*/
1605 if (rc
== TMF_RESP_FUNC_COMPLETE
) {
1607 struct mvs_slot_info
*slot
;
1609 if (task
->lldd_task
) {
1610 slot
= task
->lldd_task
;
1611 slot_no
= (u32
) (slot
- mvi
->slot_info
);
1612 spin_lock_irqsave(&mvi
->lock
, flags
);
1613 mvs_slot_complete(mvi
, slot_no
, 1);
1614 spin_unlock_irqrestore(&mvi
->lock
, flags
);
1618 } else if (task
->task_proto
& SAS_PROTOCOL_SATA
||
1619 task
->task_proto
& SAS_PROTOCOL_STP
) {
1620 if (SATA_DEV
== dev
->dev_type
) {
1621 struct mvs_slot_info
*slot
= task
->lldd_task
;
1622 u32 slot_idx
= (u32
)(slot
- mvi
->slot_info
);
1623 mv_dprintk("mvs_abort_task() mvi=%p task=%p "
1624 "slot=%p slot_idx=x%x\n",
1625 mvi
, task
, slot
, slot_idx
);
1626 mvs_tmf_timedout((unsigned long)task
);
1627 mvs_slot_task_free(mvi
, task
, slot
, slot_idx
);
1628 rc
= TMF_RESP_FUNC_COMPLETE
;
1634 if (rc
!= TMF_RESP_FUNC_COMPLETE
)
1635 mv_printk("%s:rc= %d\n", __func__
, rc
);
1639 int mvs_abort_task_set(struct domain_device
*dev
, u8
*lun
)
1641 int rc
= TMF_RESP_FUNC_FAILED
;
1642 struct mvs_tmf_task tmf_task
;
1644 tmf_task
.tmf
= TMF_ABORT_TASK_SET
;
1645 rc
= mvs_debug_issue_ssp_tmf(dev
, lun
, &tmf_task
);
1650 int mvs_clear_aca(struct domain_device
*dev
, u8
*lun
)
1652 int rc
= TMF_RESP_FUNC_FAILED
;
1653 struct mvs_tmf_task tmf_task
;
1655 tmf_task
.tmf
= TMF_CLEAR_ACA
;
1656 rc
= mvs_debug_issue_ssp_tmf(dev
, lun
, &tmf_task
);
1661 int mvs_clear_task_set(struct domain_device
*dev
, u8
*lun
)
1663 int rc
= TMF_RESP_FUNC_FAILED
;
1664 struct mvs_tmf_task tmf_task
;
1666 tmf_task
.tmf
= TMF_CLEAR_TASK_SET
;
1667 rc
= mvs_debug_issue_ssp_tmf(dev
, lun
, &tmf_task
);
1672 static int mvs_sata_done(struct mvs_info
*mvi
, struct sas_task
*task
,
1673 u32 slot_idx
, int err
)
1675 struct mvs_device
*mvi_dev
= task
->dev
->lldd_dev
;
1676 struct task_status_struct
*tstat
= &task
->task_status
;
1677 struct ata_task_resp
*resp
= (struct ata_task_resp
*)tstat
->buf
;
1678 int stat
= SAM_STAT_GOOD
;
1681 resp
->frame_len
= sizeof(struct dev_to_host_fis
);
1682 memcpy(&resp
->ending_fis
[0],
1683 SATA_RECEIVED_D2H_FIS(mvi_dev
->taskfileset
),
1684 sizeof(struct dev_to_host_fis
));
1685 tstat
->buf_valid_size
= sizeof(*resp
);
1686 if (unlikely(err
)) {
1687 if (unlikely(err
& CMD_ISS_STPD
))
1688 stat
= SAS_OPEN_REJECT
;
1690 stat
= SAS_PROTO_RESPONSE
;
1696 void mvs_set_sense(u8
*buffer
, int len
, int d_sense
,
1697 int key
, int asc
, int ascq
)
1699 memset(buffer
, 0, len
);
1702 /* Descriptor format */
1704 mv_printk("Length %d of sense buffer too small to "
1705 "fit sense %x:%x:%x", len
, key
, asc
, ascq
);
1708 buffer
[0] = 0x72; /* Response Code */
1710 buffer
[1] = key
; /* Sense Key */
1712 buffer
[2] = asc
; /* ASC */
1714 buffer
[3] = ascq
; /* ASCQ */
1717 mv_printk("Length %d of sense buffer too small to "
1718 "fit sense %x:%x:%x", len
, key
, asc
, ascq
);
1721 buffer
[0] = 0x70; /* Response Code */
1723 buffer
[2] = key
; /* Sense Key */
1725 buffer
[7] = 0x0a; /* Additional Sense Length */
1727 buffer
[12] = asc
; /* ASC */
1729 buffer
[13] = ascq
; /* ASCQ */
1735 void mvs_fill_ssp_resp_iu(struct ssp_response_iu
*iu
,
1736 u8 key
, u8 asc
, u8 asc_q
)
1739 iu
->response_data_len
= 0;
1740 iu
->sense_data_len
= 17;
1742 mvs_set_sense(iu
->sense_data
, 17, 0,
1746 static int mvs_slot_err(struct mvs_info
*mvi
, struct sas_task
*task
,
1749 struct mvs_slot_info
*slot
= &mvi
->slot_info
[slot_idx
];
1751 u32 err_dw0
= le32_to_cpu(*(u32
*)slot
->response
);
1752 u32 err_dw1
= le32_to_cpu(*((u32
*)slot
->response
+ 1));
1754 enum mvs_port_type type
= PORT_TYPE_SAS
;
1756 if (err_dw0
& CMD_ISS_STPD
)
1757 MVS_CHIP_DISP
->issue_stop(mvi
, type
, tfs
);
1759 MVS_CHIP_DISP
->command_active(mvi
, slot_idx
);
1761 stat
= SAM_STAT_CHECK_CONDITION
;
1762 switch (task
->task_proto
) {
1763 case SAS_PROTOCOL_SSP
:
1765 stat
= SAS_ABORTED_TASK
;
1766 if ((err_dw0
& NO_DEST
) || err_dw1
& bit(31)) {
1767 struct ssp_response_iu
*iu
= slot
->response
+
1768 sizeof(struct mvs_err_info
);
1769 mvs_fill_ssp_resp_iu(iu
, NOT_READY
, 0x04, 01);
1770 sas_ssp_task_response(mvi
->dev
, task
, iu
);
1771 stat
= SAM_STAT_CHECK_CONDITION
;
1773 if (err_dw1
& bit(31))
1774 mv_printk("reuse same slot, retry command.\n");
1777 case SAS_PROTOCOL_SMP
:
1778 stat
= SAM_STAT_CHECK_CONDITION
;
1781 case SAS_PROTOCOL_SATA
:
1782 case SAS_PROTOCOL_STP
:
1783 case SAS_PROTOCOL_SATA
| SAS_PROTOCOL_STP
:
1785 task
->ata_task
.use_ncq
= 0;
1786 stat
= SAS_PROTO_RESPONSE
;
1787 mvs_sata_done(mvi
, task
, slot_idx
, err_dw0
);
1797 int mvs_slot_complete(struct mvs_info
*mvi
, u32 rx_desc
, u32 flags
)
1799 u32 slot_idx
= rx_desc
& RXQ_SLOT_MASK
;
1800 struct mvs_slot_info
*slot
= &mvi
->slot_info
[slot_idx
];
1801 struct sas_task
*task
= slot
->task
;
1802 struct mvs_device
*mvi_dev
= NULL
;
1803 struct task_status_struct
*tstat
;
1804 struct domain_device
*dev
;
1808 enum exec_status sts
;
1810 if (unlikely(!task
|| !task
->lldd_task
|| !task
->dev
))
1813 tstat
= &task
->task_status
;
1815 mvi_dev
= dev
->lldd_dev
;
1817 spin_lock(&task
->task_state_lock
);
1818 task
->task_state_flags
&=
1819 ~(SAS_TASK_STATE_PENDING
| SAS_TASK_AT_INITIATOR
);
1820 task
->task_state_flags
|= SAS_TASK_STATE_DONE
;
1822 aborted
= task
->task_state_flags
& SAS_TASK_STATE_ABORTED
;
1823 spin_unlock(&task
->task_state_lock
);
1825 memset(tstat
, 0, sizeof(*tstat
));
1826 tstat
->resp
= SAS_TASK_COMPLETE
;
1828 if (unlikely(aborted
)) {
1829 tstat
->stat
= SAS_ABORTED_TASK
;
1830 if (mvi_dev
&& mvi_dev
->running_req
)
1831 mvi_dev
->running_req
--;
1832 if (sas_protocol_ata(task
->task_proto
))
1833 mvs_free_reg_set(mvi
, mvi_dev
);
1835 mvs_slot_task_free(mvi
, task
, slot
, slot_idx
);
1839 /* when no device attaching, go ahead and complete by error handling*/
1840 if (unlikely(!mvi_dev
|| flags
)) {
1842 mv_dprintk("port has not device.\n");
1843 tstat
->stat
= SAS_PHY_DOWN
;
1847 /* error info record present */
1848 if (unlikely((rx_desc
& RXQ_ERR
) && (*(u64
*) slot
->response
))) {
1849 mv_dprintk("port %d slot %d rx_desc %X has error info"
1850 "%016llX.\n", slot
->port
->sas_port
.id
, slot_idx
,
1851 rx_desc
, (u64
)(*(u64
*)slot
->response
));
1852 tstat
->stat
= mvs_slot_err(mvi
, task
, slot_idx
);
1853 tstat
->resp
= SAS_TASK_COMPLETE
;
1857 switch (task
->task_proto
) {
1858 case SAS_PROTOCOL_SSP
:
1859 /* hw says status == 0, datapres == 0 */
1860 if (rx_desc
& RXQ_GOOD
) {
1861 tstat
->stat
= SAM_STAT_GOOD
;
1862 tstat
->resp
= SAS_TASK_COMPLETE
;
1864 /* response frame present */
1865 else if (rx_desc
& RXQ_RSP
) {
1866 struct ssp_response_iu
*iu
= slot
->response
+
1867 sizeof(struct mvs_err_info
);
1868 sas_ssp_task_response(mvi
->dev
, task
, iu
);
1870 tstat
->stat
= SAM_STAT_CHECK_CONDITION
;
1873 case SAS_PROTOCOL_SMP
: {
1874 struct scatterlist
*sg_resp
= &task
->smp_task
.smp_resp
;
1875 tstat
->stat
= SAM_STAT_GOOD
;
1876 to
= kmap_atomic(sg_page(sg_resp
), KM_IRQ0
);
1877 memcpy(to
+ sg_resp
->offset
,
1878 slot
->response
+ sizeof(struct mvs_err_info
),
1879 sg_dma_len(sg_resp
));
1880 kunmap_atomic(to
, KM_IRQ0
);
1884 case SAS_PROTOCOL_SATA
:
1885 case SAS_PROTOCOL_STP
:
1886 case SAS_PROTOCOL_SATA
| SAS_PROTOCOL_STP
: {
1887 tstat
->stat
= mvs_sata_done(mvi
, task
, slot_idx
, 0);
1892 tstat
->stat
= SAM_STAT_CHECK_CONDITION
;
1895 if (!slot
->port
->port_attached
) {
1896 mv_dprintk("port %d has removed.\n", slot
->port
->sas_port
.id
);
1897 tstat
->stat
= SAS_PHY_DOWN
;
1902 if (mvi_dev
&& mvi_dev
->running_req
) {
1903 mvi_dev
->running_req
--;
1904 if (sas_protocol_ata(task
->task_proto
) && !mvi_dev
->running_req
)
1905 mvs_free_reg_set(mvi
, mvi_dev
);
1907 mvs_slot_task_free(mvi
, task
, slot
, slot_idx
);
1910 spin_unlock(&mvi
->lock
);
1911 if (task
->task_done
)
1912 task
->task_done(task
);
1914 spin_lock(&mvi
->lock
);
1919 void mvs_do_release_task(struct mvs_info
*mvi
,
1920 int phy_no
, struct domain_device
*dev
)
1923 struct mvs_phy
*phy
;
1924 struct mvs_port
*port
;
1925 struct mvs_slot_info
*slot
, *slot2
;
1927 phy
= &mvi
->phy
[phy_no
];
1931 /* clean cmpl queue in case request is already finished */
1932 mvs_int_rx(mvi
, false);
1936 list_for_each_entry_safe(slot
, slot2
, &port
->list
, entry
) {
1937 struct sas_task
*task
;
1938 slot_idx
= (u32
) (slot
- mvi
->slot_info
);
1941 if (dev
&& task
->dev
!= dev
)
1944 mv_printk("Release slot [%x] tag[%x], task [%p]:\n",
1945 slot_idx
, slot
->slot_tag
, task
);
1946 MVS_CHIP_DISP
->command_active(mvi
, slot_idx
);
1948 mvs_slot_complete(mvi
, slot_idx
, 1);
1952 void mvs_release_task(struct mvs_info
*mvi
,
1953 struct domain_device
*dev
)
1955 int i
, phyno
[WIDE_PORT_MAX_PHY
], num
;
1956 num
= mvs_find_dev_phyno(dev
, phyno
);
1957 for (i
= 0; i
< num
; i
++)
1958 mvs_do_release_task(mvi
, phyno
[i
], dev
);
1961 static void mvs_phy_disconnected(struct mvs_phy
*phy
)
1963 phy
->phy_attached
= 0;
1964 phy
->att_dev_info
= 0;
1965 phy
->att_dev_sas_addr
= 0;
1968 static void mvs_work_queue(struct work_struct
*work
)
1970 struct delayed_work
*dw
= container_of(work
, struct delayed_work
, work
);
1971 struct mvs_wq
*mwq
= container_of(dw
, struct mvs_wq
, work_q
);
1972 struct mvs_info
*mvi
= mwq
->mvi
;
1973 unsigned long flags
;
1974 u32 phy_no
= (unsigned long) mwq
->data
;
1975 struct sas_ha_struct
*sas_ha
= mvi
->sas
;
1976 struct mvs_phy
*phy
= &mvi
->phy
[phy_no
];
1977 struct asd_sas_phy
*sas_phy
= &phy
->sas_phy
;
1979 spin_lock_irqsave(&mvi
->lock
, flags
);
1980 if (mwq
->handler
& PHY_PLUG_EVENT
) {
1982 if (phy
->phy_event
& PHY_PLUG_OUT
) {
1984 struct sas_identify_frame
*id
;
1985 id
= (struct sas_identify_frame
*)phy
->frame_rcvd
;
1986 tmp
= MVS_CHIP_DISP
->read_phy_ctl(mvi
, phy_no
);
1987 phy
->phy_event
&= ~PHY_PLUG_OUT
;
1988 if (!(tmp
& PHY_READY_MASK
)) {
1989 sas_phy_disconnected(sas_phy
);
1990 mvs_phy_disconnected(phy
);
1991 sas_ha
->notify_phy_event(sas_phy
,
1992 PHYE_LOSS_OF_SIGNAL
);
1993 mv_dprintk("phy%d Removed Device\n", phy_no
);
1995 MVS_CHIP_DISP
->detect_porttype(mvi
, phy_no
);
1996 mvs_update_phyinfo(mvi
, phy_no
, 1);
1997 mvs_bytes_dmaed(mvi
, phy_no
);
1998 mvs_port_notify_formed(sas_phy
, 0);
1999 mv_dprintk("phy%d Attached Device\n", phy_no
);
2002 } else if (mwq
->handler
& EXP_BRCT_CHG
) {
2003 phy
->phy_event
&= ~EXP_BRCT_CHG
;
2004 sas_ha
->notify_port_event(sas_phy
,
2005 PORTE_BROADCAST_RCVD
);
2006 mv_dprintk("phy%d Got Broadcast Change\n", phy_no
);
2008 list_del(&mwq
->entry
);
2009 spin_unlock_irqrestore(&mvi
->lock
, flags
);
2013 static int mvs_handle_event(struct mvs_info
*mvi
, void *data
, int handler
)
2018 mwq
= kmalloc(sizeof(struct mvs_wq
), GFP_ATOMIC
);
2022 mwq
->handler
= handler
;
2023 MV_INIT_DELAYED_WORK(&mwq
->work_q
, mvs_work_queue
, mwq
);
2024 list_add_tail(&mwq
->entry
, &mvi
->wq_list
);
2025 schedule_delayed_work(&mwq
->work_q
, HZ
* 2);
2032 static void mvs_sig_time_out(unsigned long tphy
)
2034 struct mvs_phy
*phy
= (struct mvs_phy
*)tphy
;
2035 struct mvs_info
*mvi
= phy
->mvi
;
2038 for (phy_no
= 0; phy_no
< mvi
->chip
->n_phy
; phy_no
++) {
2039 if (&mvi
->phy
[phy_no
] == phy
) {
2040 mv_dprintk("Get signature time out, reset phy %d\n",
2041 phy_no
+mvi
->id
*mvi
->chip
->n_phy
);
2042 MVS_CHIP_DISP
->phy_reset(mvi
, phy_no
, MVS_HARD_RESET
);
2047 void mvs_int_port(struct mvs_info
*mvi
, int phy_no
, u32 events
)
2050 struct mvs_phy
*phy
= &mvi
->phy
[phy_no
];
2052 phy
->irq_status
= MVS_CHIP_DISP
->read_port_irq_stat(mvi
, phy_no
);
2053 MVS_CHIP_DISP
->write_port_irq_stat(mvi
, phy_no
, phy
->irq_status
);
2054 mv_dprintk("phy %d ctrl sts=0x%08X.\n", phy_no
+mvi
->id
*mvi
->chip
->n_phy
,
2055 MVS_CHIP_DISP
->read_phy_ctl(mvi
, phy_no
));
2056 mv_dprintk("phy %d irq sts = 0x%08X\n", phy_no
+mvi
->id
*mvi
->chip
->n_phy
,
2060 * events is port event now ,
2061 * we need check the interrupt status which belongs to per port.
2064 if (phy
->irq_status
& PHYEV_DCDR_ERR
) {
2065 mv_dprintk("phy %d STP decoding error.\n",
2066 phy_no
+ mvi
->id
*mvi
->chip
->n_phy
);
2069 if (phy
->irq_status
& PHYEV_POOF
) {
2071 if (!(phy
->phy_event
& PHY_PLUG_OUT
)) {
2072 int dev_sata
= phy
->phy_type
& PORT_TYPE_SATA
;
2074 mvs_do_release_task(mvi
, phy_no
, NULL
);
2075 phy
->phy_event
|= PHY_PLUG_OUT
;
2076 MVS_CHIP_DISP
->clear_srs_irq(mvi
, 0, 1);
2077 mvs_handle_event(mvi
,
2078 (void *)(unsigned long)phy_no
,
2080 ready
= mvs_is_phy_ready(mvi
, phy_no
);
2081 if (ready
|| dev_sata
) {
2082 if (MVS_CHIP_DISP
->stp_reset
)
2083 MVS_CHIP_DISP
->stp_reset(mvi
,
2086 MVS_CHIP_DISP
->phy_reset(mvi
,
2087 phy_no
, MVS_SOFT_RESET
);
2093 if (phy
->irq_status
& PHYEV_COMWAKE
) {
2094 tmp
= MVS_CHIP_DISP
->read_port_irq_mask(mvi
, phy_no
);
2095 MVS_CHIP_DISP
->write_port_irq_mask(mvi
, phy_no
,
2096 tmp
| PHYEV_SIG_FIS
);
2097 if (phy
->timer
.function
== NULL
) {
2098 phy
->timer
.data
= (unsigned long)phy
;
2099 phy
->timer
.function
= mvs_sig_time_out
;
2100 phy
->timer
.expires
= jiffies
+ 5*HZ
;
2101 add_timer(&phy
->timer
);
2104 if (phy
->irq_status
& (PHYEV_SIG_FIS
| PHYEV_ID_DONE
)) {
2105 phy
->phy_status
= mvs_is_phy_ready(mvi
, phy_no
);
2106 mv_dprintk("notify plug in on phy[%d]\n", phy_no
);
2107 if (phy
->phy_status
) {
2109 MVS_CHIP_DISP
->detect_porttype(mvi
, phy_no
);
2110 if (phy
->phy_type
& PORT_TYPE_SATA
) {
2111 tmp
= MVS_CHIP_DISP
->read_port_irq_mask(
2113 tmp
&= ~PHYEV_SIG_FIS
;
2114 MVS_CHIP_DISP
->write_port_irq_mask(mvi
,
2117 mvs_update_phyinfo(mvi
, phy_no
, 0);
2118 if (phy
->phy_type
& PORT_TYPE_SAS
) {
2119 MVS_CHIP_DISP
->phy_reset(mvi
, phy_no
, MVS_PHY_TUNE
);
2123 mvs_bytes_dmaed(mvi
, phy_no
);
2124 /* whether driver is going to handle hot plug */
2125 if (phy
->phy_event
& PHY_PLUG_OUT
) {
2126 mvs_port_notify_formed(&phy
->sas_phy
, 0);
2127 phy
->phy_event
&= ~PHY_PLUG_OUT
;
2130 mv_dprintk("plugin interrupt but phy%d is gone\n",
2131 phy_no
+ mvi
->id
*mvi
->chip
->n_phy
);
2133 } else if (phy
->irq_status
& PHYEV_BROAD_CH
) {
2134 mv_dprintk("phy %d broadcast change.\n",
2135 phy_no
+ mvi
->id
*mvi
->chip
->n_phy
);
2136 mvs_handle_event(mvi
, (void *)(unsigned long)phy_no
,
2141 int mvs_int_rx(struct mvs_info
*mvi
, bool self_clear
)
2143 u32 rx_prod_idx
, rx_desc
;
2146 /* the first dword in the RX ring is special: it contains
2147 * a mirror of the hardware's RX producer index, so that
2148 * we don't have to stall the CPU reading that register.
2149 * The actual RX ring is offset by one dword, due to this.
2151 rx_prod_idx
= mvi
->rx_cons
;
2152 mvi
->rx_cons
= le32_to_cpu(mvi
->rx
[0]);
2153 if (mvi
->rx_cons
== 0xfff) /* h/w hasn't touched RX ring yet */
2156 /* The CMPL_Q may come late, read from register and try again
2157 * note: if coalescing is enabled,
2158 * it will need to read from register every time for sure
2160 if (unlikely(mvi
->rx_cons
== rx_prod_idx
))
2161 mvi
->rx_cons
= MVS_CHIP_DISP
->rx_update(mvi
) & RX_RING_SZ_MASK
;
2163 if (mvi
->rx_cons
== rx_prod_idx
)
2166 while (mvi
->rx_cons
!= rx_prod_idx
) {
2167 /* increment our internal RX consumer pointer */
2168 rx_prod_idx
= (rx_prod_idx
+ 1) & (MVS_RX_RING_SZ
- 1);
2169 rx_desc
= le32_to_cpu(mvi
->rx
[rx_prod_idx
+ 1]);
2171 if (likely(rx_desc
& RXQ_DONE
))
2172 mvs_slot_complete(mvi
, rx_desc
, 0);
2173 if (rx_desc
& RXQ_ATTN
) {
2175 } else if (rx_desc
& RXQ_ERR
) {
2176 if (!(rx_desc
& RXQ_DONE
))
2177 mvs_slot_complete(mvi
, rx_desc
, 0);
2178 } else if (rx_desc
& RXQ_SLOT_RESET
) {
2179 mvs_slot_free(mvi
, rx_desc
);
2183 if (attn
&& self_clear
)
2184 MVS_CHIP_DISP
->int_full(mvi
);