2 * Marvell 88SE94xx hardware specific
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
30 static void mvs_94xx_detect_porttype(struct mvs_info
*mvi
, int i
)
33 struct mvs_phy
*phy
= &mvi
->phy
[i
];
36 mvs_write_port_vsr_addr(mvi
, i
, VSR_PHY_MODE3
);
37 reg
= mvs_read_port_vsr_data(mvi
, i
);
38 phy_status
= ((reg
& 0x3f0000) >> 16) & 0xff;
39 phy
->phy_type
&= ~(PORT_TYPE_SAS
| PORT_TYPE_SATA
);
42 phy
->phy_type
|= PORT_TYPE_SAS
;
46 phy
->phy_type
|= PORT_TYPE_SATA
;
51 void set_phy_tuning(struct mvs_info
*mvi
, int phy_id
,
52 struct phy_tuning phy_tuning
)
54 u32 tmp
, setting_0
= 0, setting_1
= 0;
57 /* Remap information for B0 chip:
59 * R0Ch -> R118h[15:0] (Adapted DFE F3 - F5 coefficient)
60 * R0Dh -> R118h[31:16] (Generation 1 Setting 0)
61 * R0Eh -> R11Ch[15:0] (Generation 1 Setting 1)
62 * R0Fh -> R11Ch[31:16] (Generation 2 Setting 0)
63 * R10h -> R120h[15:0] (Generation 2 Setting 1)
64 * R11h -> R120h[31:16] (Generation 3 Setting 0)
65 * R12h -> R124h[15:0] (Generation 3 Setting 1)
66 * R13h -> R124h[31:16] (Generation 4 Setting 0 (Reserved))
69 /* A0 has a different set of registers */
70 if (mvi
->pdev
->revision
== VANIR_A0_REV
)
73 for (i
= 0; i
< 3; i
++) {
74 /* loop 3 times, set Gen 1, Gen 2, Gen 3 */
77 setting_0
= GENERATION_1_SETTING
;
78 setting_1
= GENERATION_1_2_SETTING
;
81 setting_0
= GENERATION_1_2_SETTING
;
82 setting_1
= GENERATION_2_3_SETTING
;
85 setting_0
= GENERATION_2_3_SETTING
;
86 setting_1
= GENERATION_3_4_SETTING
;
92 * Transmitter Emphasis Enable
93 * Transmitter Emphasis Amplitude
94 * Transmitter Amplitude
96 mvs_write_port_vsr_addr(mvi
, phy_id
, setting_0
);
97 tmp
= mvs_read_port_vsr_data(mvi
, phy_id
);
98 tmp
&= ~(0xFBE << 16);
99 tmp
|= (((phy_tuning
.trans_emp_en
<< 11) |
100 (phy_tuning
.trans_emp_amp
<< 7) |
101 (phy_tuning
.trans_amp
<< 1)) << 16);
102 mvs_write_port_vsr_data(mvi
, phy_id
, tmp
);
104 /* Set Transmitter Amplitude Adjust */
105 mvs_write_port_vsr_addr(mvi
, phy_id
, setting_1
);
106 tmp
= mvs_read_port_vsr_data(mvi
, phy_id
);
108 tmp
|= (phy_tuning
.trans_amp_adj
<< 14);
109 mvs_write_port_vsr_data(mvi
, phy_id
, tmp
);
113 void set_phy_ffe_tuning(struct mvs_info
*mvi
, int phy_id
,
114 struct ffe_control ffe
)
118 /* Don't run this if A0/B0 */
119 if ((mvi
->pdev
->revision
== VANIR_A0_REV
)
120 || (mvi
->pdev
->revision
== VANIR_B0_REV
))
123 /* FFE Resistor and Capacitor */
124 /* R10Ch DFE Resolution Control/Squelch and FFE Setting
130 mvs_write_port_vsr_addr(mvi
, phy_id
, VSR_PHY_FFE_CONTROL
);
131 tmp
= mvs_read_port_vsr_data(mvi
, phy_id
);
134 /* Read from HBA_Info_Page */
136 (ffe
.ffe_rss_sel
<< 4) |
137 (ffe
.ffe_cap_sel
<< 0));
139 mvs_write_port_vsr_data(mvi
, phy_id
, tmp
);
141 /* R064h PHY Mode Register 1
145 mvs_write_port_vsr_addr(mvi
, phy_id
, VSR_REF_CLOCK_CRTL
);
146 tmp
= mvs_read_port_vsr_data(mvi
, phy_id
);
149 /* No defines in HBA_Info_Page */
151 mvs_write_port_vsr_data(mvi
, phy_id
, tmp
);
153 /* R110h DFE F0-F1 Coefficient Control/DFE Update Control
155 * DFE_UPDATE_EN [11:6]
158 mvs_write_port_vsr_addr(mvi
, phy_id
, VSR_PHY_DFE_UPDATE_CRTL
);
159 tmp
= mvs_read_port_vsr_data(mvi
, phy_id
);
162 /* No defines in HBA_Info_Page */
163 tmp
|= ((0x3F << 6) | (0x0 << 0));
164 mvs_write_port_vsr_data(mvi
, phy_id
, tmp
);
166 /* R1A0h Interface and Digital Reference Clock Control/Reserved_50h
170 mvs_write_port_vsr_addr(mvi
, phy_id
, VSR_REF_CLOCK_CRTL
);
171 tmp
= mvs_read_port_vsr_data(mvi
, phy_id
);
174 /* No defines in HBA_Info_Page */
176 mvs_write_port_vsr_data(mvi
, phy_id
, tmp
);
179 /*Notice: this function must be called when phy is disabled*/
180 void set_phy_rate(struct mvs_info
*mvi
, int phy_id
, u8 rate
)
182 union reg_phy_cfg phy_cfg
, phy_cfg_tmp
;
183 mvs_write_port_vsr_addr(mvi
, phy_id
, VSR_PHY_MODE2
);
184 phy_cfg_tmp
.v
= mvs_read_port_vsr_data(mvi
, phy_id
);
186 phy_cfg
.u
.disable_phy
= phy_cfg_tmp
.u
.disable_phy
;
187 phy_cfg
.u
.sas_support
= 1;
188 phy_cfg
.u
.sata_support
= 1;
189 phy_cfg
.u
.sata_host_mode
= 1;
193 /* support 1.5 Gbps */
194 phy_cfg
.u
.speed_support
= 1;
195 phy_cfg
.u
.snw_3_support
= 0;
196 phy_cfg
.u
.tx_lnk_parity
= 1;
197 phy_cfg
.u
.tx_spt_phs_lnk_rate
= 0x30;
201 /* support 1.5, 3.0 Gbps */
202 phy_cfg
.u
.speed_support
= 3;
203 phy_cfg
.u
.tx_spt_phs_lnk_rate
= 0x3c;
204 phy_cfg
.u
.tx_lgcl_lnk_rate
= 0x08;
208 /* support 1.5, 3.0, 6.0 Gbps */
209 phy_cfg
.u
.speed_support
= 7;
210 phy_cfg
.u
.snw_3_support
= 1;
211 phy_cfg
.u
.tx_lnk_parity
= 1;
212 phy_cfg
.u
.tx_spt_phs_lnk_rate
= 0x3f;
213 phy_cfg
.u
.tx_lgcl_lnk_rate
= 0x09;
216 mvs_write_port_vsr_data(mvi
, phy_id
, phy_cfg
.v
);
219 static void __devinit
220 mvs_94xx_config_reg_from_hba(struct mvs_info
*mvi
, int phy_id
)
223 temp
= (u32
)(*(u32
*)&mvi
->hba_info_param
.phy_tuning
[phy_id
]);
224 if (temp
== 0xFFFFFFFFL
) {
225 mvi
->hba_info_param
.phy_tuning
[phy_id
].trans_emp_amp
= 0x6;
226 mvi
->hba_info_param
.phy_tuning
[phy_id
].trans_amp
= 0x1A;
227 mvi
->hba_info_param
.phy_tuning
[phy_id
].trans_amp_adj
= 0x3;
230 temp
= (u8
)(*(u8
*)&mvi
->hba_info_param
.ffe_ctl
[phy_id
]);
232 switch (mvi
->pdev
->revision
) {
235 mvi
->hba_info_param
.ffe_ctl
[phy_id
].ffe_rss_sel
= 0x7;
236 mvi
->hba_info_param
.ffe_ctl
[phy_id
].ffe_cap_sel
= 0x7;
242 mvi
->hba_info_param
.ffe_ctl
[phy_id
].ffe_rss_sel
= 0x7;
243 mvi
->hba_info_param
.ffe_ctl
[phy_id
].ffe_cap_sel
= 0xC;
248 temp
= (u8
)(*(u8
*)&mvi
->hba_info_param
.phy_rate
[phy_id
]);
250 /*set default phy_rate = 6Gbps*/
251 mvi
->hba_info_param
.phy_rate
[phy_id
] = 0x2;
253 set_phy_tuning(mvi
, phy_id
,
254 mvi
->hba_info_param
.phy_tuning
[phy_id
]);
255 set_phy_ffe_tuning(mvi
, phy_id
,
256 mvi
->hba_info_param
.ffe_ctl
[phy_id
]);
257 set_phy_rate(mvi
, phy_id
,
258 mvi
->hba_info_param
.phy_rate
[phy_id
]);
261 static void __devinit
mvs_94xx_enable_xmt(struct mvs_info
*mvi
, int phy_id
)
263 void __iomem
*regs
= mvi
->regs
;
267 tmp
|= 1 << (phy_id
+ PCS_EN_PORT_XMT_SHIFT2
);
271 static void mvs_94xx_phy_reset(struct mvs_info
*mvi
, u32 phy_id
, int hard
)
275 if (hard
== MVS_PHY_TUNE
) {
276 mvs_write_port_cfg_addr(mvi
, phy_id
, PHYR_SATA_CTL
);
277 tmp
= mvs_read_port_cfg_data(mvi
, phy_id
);
278 mvs_write_port_cfg_data(mvi
, phy_id
, tmp
|0x20000000);
279 mvs_write_port_cfg_data(mvi
, phy_id
, tmp
|0x100000);
282 tmp
= mvs_read_port_irq_stat(mvi
, phy_id
);
283 tmp
&= ~PHYEV_RDY_CH
;
284 mvs_write_port_irq_stat(mvi
, phy_id
, tmp
);
286 tmp
= mvs_read_phy_ctl(mvi
, phy_id
);
288 mvs_write_phy_ctl(mvi
, phy_id
, tmp
);
290 tmp
= mvs_read_phy_ctl(mvi
, phy_id
);
293 } while ((tmp
& PHY_RST_HARD
) && delay
);
295 mv_dprintk("phy hard reset failed.\n");
297 tmp
= mvs_read_phy_ctl(mvi
, phy_id
);
299 mvs_write_phy_ctl(mvi
, phy_id
, tmp
);
303 static void mvs_94xx_phy_disable(struct mvs_info
*mvi
, u32 phy_id
)
306 mvs_write_port_vsr_addr(mvi
, phy_id
, VSR_PHY_MODE2
);
307 tmp
= mvs_read_port_vsr_data(mvi
, phy_id
);
308 mvs_write_port_vsr_data(mvi
, phy_id
, tmp
| 0x00800000);
311 static void mvs_94xx_phy_enable(struct mvs_info
*mvi
, u32 phy_id
)
316 revision
= mvi
->pdev
->revision
;
317 if (revision
== VANIR_A0_REV
) {
318 mvs_write_port_vsr_addr(mvi
, phy_id
, CMD_HOST_RD_DATA
);
319 mvs_write_port_vsr_data(mvi
, phy_id
, 0x8300ffc1);
321 if (revision
== VANIR_B0_REV
) {
322 mvs_write_port_vsr_addr(mvi
, phy_id
, CMD_APP_MEM_CTL
);
323 mvs_write_port_vsr_data(mvi
, phy_id
, 0x08001006);
324 mvs_write_port_vsr_addr(mvi
, phy_id
, CMD_HOST_RD_DATA
);
325 mvs_write_port_vsr_data(mvi
, phy_id
, 0x0000705f);
328 mvs_write_port_vsr_addr(mvi
, phy_id
, VSR_PHY_MODE2
);
329 tmp
= mvs_read_port_vsr_data(mvi
, phy_id
);
331 mvs_write_port_vsr_data(mvi
, phy_id
, tmp
& 0xfd7fffff);
334 static int __devinit
mvs_94xx_init(struct mvs_info
*mvi
)
336 void __iomem
*regs
= mvi
->regs
;
341 revision
= mvi
->pdev
->revision
;
342 mvs_show_pcie_usage(mvi
);
343 if (mvi
->flags
& MVF_FLAG_SOC
) {
344 tmp
= mr32(MVS_PHY_CTL
);
345 tmp
&= ~PCTL_PWR_OFF
;
346 tmp
|= PCTL_PHY_DSBL
;
347 mw32(MVS_PHY_CTL
, tmp
);
351 /* make sure RST is set; HBA_RST /should/ have done that for us */
352 cctl
= mr32(MVS_CTL
) & 0xFFFF;
356 mw32_f(MVS_CTL
, cctl
| CCTL_RST
);
358 if (mvi
->flags
& MVF_FLAG_SOC
) {
359 tmp
= mr32(MVS_PHY_CTL
);
360 tmp
&= ~PCTL_PWR_OFF
;
362 tmp
&= ~PCTL_PHY_DSBL
;
363 tmp
|= PCTL_LINK_RST
;
364 mw32(MVS_PHY_CTL
, tmp
);
366 tmp
&= ~PCTL_LINK_RST
;
367 mw32(MVS_PHY_CTL
, tmp
);
371 /* disable Multiplexing, enable phy implemented */
372 mw32(MVS_PORTS_IMP
, 0xFF);
374 if (revision
== VANIR_A0_REV
) {
375 mw32(MVS_PA_VSR_ADDR
, CMD_CMWK_OOB_DET
);
376 mw32(MVS_PA_VSR_PORT
, 0x00018080);
378 mw32(MVS_PA_VSR_ADDR
, VSR_PHY_MODE2
);
379 if (revision
== VANIR_A0_REV
|| revision
== VANIR_B0_REV
)
380 /* set 6G/3G/1.5G, multiplexing, without SSC */
381 mw32(MVS_PA_VSR_PORT
, 0x0084d4fe);
383 /* set 6G/3G/1.5G, multiplexing, with and without SSC */
384 mw32(MVS_PA_VSR_PORT
, 0x0084fffe);
386 if (revision
== VANIR_B0_REV
) {
387 mw32(MVS_PA_VSR_ADDR
, CMD_APP_MEM_CTL
);
388 mw32(MVS_PA_VSR_PORT
, 0x08001006);
389 mw32(MVS_PA_VSR_ADDR
, CMD_HOST_RD_DATA
);
390 mw32(MVS_PA_VSR_PORT
, 0x0000705f);
394 mw32(MVS_PCS
, 0); /* MVS_PCS */
395 mw32(MVS_STP_REG_SET_0
, 0);
396 mw32(MVS_STP_REG_SET_1
, 0);
401 /* set LED blink when IO*/
402 mw32(MVS_PA_VSR_ADDR
, VSR_PHY_ACT_LED
);
403 tmp
= mr32(MVS_PA_VSR_PORT
);
406 mw32(MVS_PA_VSR_PORT
, tmp
);
408 mw32(MVS_CMD_LIST_LO
, mvi
->slot_dma
);
409 mw32(MVS_CMD_LIST_HI
, (mvi
->slot_dma
>> 16) >> 16);
411 mw32(MVS_RX_FIS_LO
, mvi
->rx_fis_dma
);
412 mw32(MVS_RX_FIS_HI
, (mvi
->rx_fis_dma
>> 16) >> 16);
414 mw32(MVS_TX_CFG
, MVS_CHIP_SLOT_SZ
);
415 mw32(MVS_TX_LO
, mvi
->tx_dma
);
416 mw32(MVS_TX_HI
, (mvi
->tx_dma
>> 16) >> 16);
418 mw32(MVS_RX_CFG
, MVS_RX_RING_SZ
);
419 mw32(MVS_RX_LO
, mvi
->rx_dma
);
420 mw32(MVS_RX_HI
, (mvi
->rx_dma
>> 16) >> 16);
422 for (i
= 0; i
< mvi
->chip
->n_phy
; i
++) {
423 mvs_94xx_phy_disable(mvi
, i
);
424 /* set phy local SAS address */
425 mvs_set_sas_addr(mvi
, i
, CONFIG_ID_FRAME3
, CONFIG_ID_FRAME4
,
426 cpu_to_le64(mvi
->phy
[i
].dev_sas_addr
));
428 mvs_94xx_enable_xmt(mvi
, i
);
429 mvs_94xx_config_reg_from_hba(mvi
, i
);
430 mvs_94xx_phy_enable(mvi
, i
);
432 mvs_94xx_phy_reset(mvi
, i
, PHY_RST_HARD
);
434 mvs_94xx_detect_porttype(mvi
, i
);
437 if (mvi
->flags
& MVF_FLAG_SOC
) {
438 /* set select registers */
439 writel(0x0E008000, regs
+ 0x000);
440 writel(0x59000008, regs
+ 0x004);
441 writel(0x20, regs
+ 0x008);
442 writel(0x20, regs
+ 0x00c);
443 writel(0x20, regs
+ 0x010);
444 writel(0x20, regs
+ 0x014);
445 writel(0x20, regs
+ 0x018);
446 writel(0x20, regs
+ 0x01c);
448 for (i
= 0; i
< mvi
->chip
->n_phy
; i
++) {
449 /* clear phy int status */
450 tmp
= mvs_read_port_irq_stat(mvi
, i
);
451 tmp
&= ~PHYEV_SIG_FIS
;
452 mvs_write_port_irq_stat(mvi
, i
, tmp
);
454 /* set phy int mask */
455 tmp
= PHYEV_RDY_CH
| PHYEV_BROAD_CH
|
456 PHYEV_ID_DONE
| PHYEV_DCDR_ERR
| PHYEV_CRC_ERR
;
457 mvs_write_port_irq_mask(mvi
, i
, tmp
);
460 mvs_update_phyinfo(mvi
, i
, 1);
463 /* FIXME: update wide port bitmaps */
465 /* little endian for open address and command table, etc. */
467 * it seems that ( from the spec ) turning on big-endian won't
468 * do us any good on big-endian machines, need further confirmation
470 cctl
= mr32(MVS_CTL
);
471 cctl
|= CCTL_ENDIAN_CMD
;
472 cctl
&= ~CCTL_ENDIAN_OPEN
;
473 cctl
|= CCTL_ENDIAN_RSP
;
474 mw32_f(MVS_CTL
, cctl
);
476 /* reset CMD queue */
479 tmp
&= ~PCS_SELF_CLEAR
;
481 /* interrupt coalescing may cause missing HW interrput in some case,
482 * and the max count is 0x1ff, while our max slot is 0x200,
483 * it will make count 0.
486 if (MVS_CHIP_SLOT_SZ
> 0x1ff)
487 mw32(MVS_INT_COAL
, 0x1ff | COAL_EN
);
489 mw32(MVS_INT_COAL
, MVS_CHIP_SLOT_SZ
| COAL_EN
);
491 tmp
= 0x10000 | interrupt_coalescing
;
492 mw32(MVS_INT_COAL_TMOUT
, tmp
);
494 /* ladies and gentlemen, start your engines */
496 mw32(MVS_TX_CFG
, MVS_CHIP_SLOT_SZ
| TX_EN
);
497 mw32(MVS_RX_CFG
, MVS_RX_RING_SZ
| RX_EN
);
498 /* enable CMD/CMPL_Q/RESP mode */
499 mw32(MVS_PCS
, PCS_SATA_RETRY_2
| PCS_FIS_RX_EN
|
500 PCS_CMD_EN
| PCS_CMD_STOP_ERR
);
502 /* enable completion queue interrupt */
503 tmp
= (CINT_PORT_MASK
| CINT_DONE
| CINT_MEM
| CINT_SRS
| CINT_CI_STOP
|
504 CINT_DMA_PCIE
| CINT_NON_SPEC_NCQ_ERROR
);
505 tmp
|= CINT_PHY_MASK
;
506 mw32(MVS_INT_MASK
, tmp
);
508 /* Enable SRS interrupt */
509 mw32(MVS_INT_MASK_SRS_0
, 0xFFFF);
514 static int mvs_94xx_ioremap(struct mvs_info
*mvi
)
516 if (!mvs_ioremap(mvi
, 2, -1)) {
517 mvi
->regs_ex
= mvi
->regs
+ 0x10200;
518 mvi
->regs
+= 0x20000;
526 static void mvs_94xx_iounmap(struct mvs_info
*mvi
)
529 mvi
->regs
-= 0x20000;
532 mvs_iounmap(mvi
->regs
);
536 static void mvs_94xx_interrupt_enable(struct mvs_info
*mvi
)
538 void __iomem
*regs
= mvi
->regs_ex
;
541 tmp
= mr32(MVS_GBL_CTL
);
542 tmp
|= (IRQ_SAS_A
| IRQ_SAS_B
);
543 mw32(MVS_GBL_INT_STAT
, tmp
);
544 writel(tmp
, regs
+ 0x0C);
545 writel(tmp
, regs
+ 0x10);
546 writel(tmp
, regs
+ 0x14);
547 writel(tmp
, regs
+ 0x18);
548 mw32(MVS_GBL_CTL
, tmp
);
551 static void mvs_94xx_interrupt_disable(struct mvs_info
*mvi
)
553 void __iomem
*regs
= mvi
->regs_ex
;
556 tmp
= mr32(MVS_GBL_CTL
);
558 tmp
&= ~(IRQ_SAS_A
| IRQ_SAS_B
);
559 mw32(MVS_GBL_INT_STAT
, tmp
);
560 writel(tmp
, regs
+ 0x0C);
561 writel(tmp
, regs
+ 0x10);
562 writel(tmp
, regs
+ 0x14);
563 writel(tmp
, regs
+ 0x18);
564 mw32(MVS_GBL_CTL
, tmp
);
567 static u32
mvs_94xx_isr_status(struct mvs_info
*mvi
, int irq
)
569 void __iomem
*regs
= mvi
->regs_ex
;
571 if (!(mvi
->flags
& MVF_FLAG_SOC
)) {
572 stat
= mr32(MVS_GBL_INT_STAT
);
574 if (!(stat
& (IRQ_SAS_A
| IRQ_SAS_B
)))
580 static irqreturn_t
mvs_94xx_isr(struct mvs_info
*mvi
, int irq
, u32 stat
)
582 void __iomem
*regs
= mvi
->regs
;
584 if (((stat
& IRQ_SAS_A
) && mvi
->id
== 0) ||
585 ((stat
& IRQ_SAS_B
) && mvi
->id
== 1)) {
586 mw32_f(MVS_INT_STAT
, CINT_DONE
);
587 #ifndef MVS_USE_TASKLET
588 spin_lock(&mvi
->lock
);
591 #ifndef MVS_USE_TASKLET
592 spin_unlock(&mvi
->lock
);
598 static void mvs_94xx_command_active(struct mvs_info
*mvi
, u32 slot_idx
)
601 tmp
= mvs_cr32(mvi
, MVS_COMMAND_ACTIVE
+(slot_idx
>> 3));
602 if (tmp
&& 1 << (slot_idx
% 32)) {
603 mv_printk("command active %08X, slot [%x].\n", tmp
, slot_idx
);
604 mvs_cw32(mvi
, MVS_COMMAND_ACTIVE
+ (slot_idx
>> 3),
605 1 << (slot_idx
% 32));
608 MVS_COMMAND_ACTIVE
+ (slot_idx
>> 3));
609 } while (tmp
& 1 << (slot_idx
% 32));
613 void mvs_94xx_clear_srs_irq(struct mvs_info
*mvi
, u8 reg_set
, u8 clear_all
)
615 void __iomem
*regs
= mvi
->regs
;
619 tmp
= mr32(MVS_INT_STAT_SRS_0
);
621 mv_dprintk("check SRS 0 %08X.\n", tmp
);
622 mw32(MVS_INT_STAT_SRS_0
, tmp
);
624 tmp
= mr32(MVS_INT_STAT_SRS_1
);
626 mv_dprintk("check SRS 1 %08X.\n", tmp
);
627 mw32(MVS_INT_STAT_SRS_1
, tmp
);
631 tmp
= mr32(MVS_INT_STAT_SRS_1
);
633 tmp
= mr32(MVS_INT_STAT_SRS_0
);
635 if (tmp
& (1 << (reg_set
% 32))) {
636 mv_dprintk("register set 0x%x was stopped.\n", reg_set
);
638 mw32(MVS_INT_STAT_SRS_1
, 1 << (reg_set
% 32));
640 mw32(MVS_INT_STAT_SRS_0
, 1 << (reg_set
% 32));
645 static void mvs_94xx_issue_stop(struct mvs_info
*mvi
, enum mvs_port_type type
,
648 void __iomem
*regs
= mvi
->regs
;
650 mvs_94xx_clear_srs_irq(mvi
, 0, 1);
652 tmp
= mr32(MVS_INT_STAT
);
653 mw32(MVS_INT_STAT
, tmp
| CINT_CI_STOP
);
654 tmp
= mr32(MVS_PCS
) | 0xFF00;
658 static void mvs_94xx_non_spec_ncq_error(struct mvs_info
*mvi
)
660 void __iomem
*regs
= mvi
->regs
;
663 struct mvs_device
*device
;
665 err_0
= mr32(MVS_NON_NCQ_ERR_0
);
666 err_1
= mr32(MVS_NON_NCQ_ERR_1
);
668 mv_dprintk("non specific ncq error err_0:%x,err_1:%x.\n",
670 for (i
= 0; i
< 32; i
++) {
671 if (err_0
& bit(i
)) {
672 device
= mvs_find_dev_by_reg_set(mvi
, i
);
674 mvs_release_task(mvi
, device
->sas_device
);
676 if (err_1
& bit(i
)) {
677 device
= mvs_find_dev_by_reg_set(mvi
, i
+32);
679 mvs_release_task(mvi
, device
->sas_device
);
683 mw32(MVS_NON_NCQ_ERR_0
, err_0
);
684 mw32(MVS_NON_NCQ_ERR_1
, err_1
);
687 static void mvs_94xx_free_reg_set(struct mvs_info
*mvi
, u8
*tfs
)
689 void __iomem
*regs
= mvi
->regs
;
692 if (*tfs
== MVS_ID_NOT_MAPPED
)
695 mvi
->sata_reg_set
&= ~bit(reg_set
);
697 w_reg_set_enable(reg_set
, (u32
)mvi
->sata_reg_set
);
699 w_reg_set_enable(reg_set
, (u32
)(mvi
->sata_reg_set
>> 32));
701 *tfs
= MVS_ID_NOT_MAPPED
;
706 static u8
mvs_94xx_assign_reg_set(struct mvs_info
*mvi
, u8
*tfs
)
709 void __iomem
*regs
= mvi
->regs
;
711 if (*tfs
!= MVS_ID_NOT_MAPPED
)
714 i
= mv_ffc64(mvi
->sata_reg_set
);
716 mvi
->sata_reg_set
|= bit(i
);
717 w_reg_set_enable(i
, (u32
)(mvi
->sata_reg_set
>> 32));
721 mvi
->sata_reg_set
|= bit(i
);
722 w_reg_set_enable(i
, (u32
)mvi
->sata_reg_set
);
726 return MVS_ID_NOT_MAPPED
;
729 static void mvs_94xx_make_prd(struct scatterlist
*scatter
, int nr
, void *prd
)
732 struct scatterlist
*sg
;
733 struct mvs_prd
*buf_prd
= prd
;
734 struct mvs_prd_imt im_len
;
736 for_each_sg(scatter
, sg
, nr
, i
) {
737 buf_prd
->addr
= cpu_to_le64(sg_dma_address(sg
));
738 im_len
.len
= sg_dma_len(sg
);
739 buf_prd
->im_len
= cpu_to_le32(*(u32
*)&im_len
);
744 static int mvs_94xx_oob_done(struct mvs_info
*mvi
, int i
)
747 phy_st
= mvs_read_phy_ctl(mvi
, i
);
748 if (phy_st
& PHY_READY_MASK
) /* phy ready */
753 static void mvs_94xx_get_dev_identify_frame(struct mvs_info
*mvi
, int port_id
,
754 struct sas_identify_frame
*id
)
759 for (i
= 0; i
< 7; i
++) {
760 mvs_write_port_cfg_addr(mvi
, port_id
,
761 CONFIG_ID_FRAME0
+ i
* 4);
762 id_frame
[i
] = cpu_to_le32(mvs_read_port_cfg_data(mvi
, port_id
));
764 memcpy(id
, id_frame
, 28);
767 static void mvs_94xx_get_att_identify_frame(struct mvs_info
*mvi
, int port_id
,
768 struct sas_identify_frame
*id
)
773 /* mvs_hexdump(28, (u8 *)id_frame, 0); */
774 for (i
= 0; i
< 7; i
++) {
775 mvs_write_port_cfg_addr(mvi
, port_id
,
776 CONFIG_ATT_ID_FRAME0
+ i
* 4);
777 id_frame
[i
] = cpu_to_le32(mvs_read_port_cfg_data(mvi
, port_id
));
778 mv_dprintk("94xx phy %d atta frame %d %x.\n",
779 port_id
+ mvi
->id
* mvi
->chip
->n_phy
, i
, id_frame
[i
]);
781 /* mvs_hexdump(28, (u8 *)id_frame, 0); */
782 memcpy(id
, id_frame
, 28);
785 static u32
mvs_94xx_make_dev_info(struct sas_identify_frame
*id
)
787 u32 att_dev_info
= 0;
789 att_dev_info
|= id
->dev_type
;
791 att_dev_info
|= PORT_DEV_STP_INIT
;
793 att_dev_info
|= PORT_DEV_SMP_INIT
;
795 att_dev_info
|= PORT_DEV_SSP_INIT
;
797 att_dev_info
|= PORT_DEV_STP_TRGT
;
799 att_dev_info
|= PORT_DEV_SMP_TRGT
;
801 att_dev_info
|= PORT_DEV_SSP_TRGT
;
803 att_dev_info
|= (u32
)id
->phy_id
<<24;
807 static u32
mvs_94xx_make_att_info(struct sas_identify_frame
*id
)
809 return mvs_94xx_make_dev_info(id
);
812 static void mvs_94xx_fix_phy_info(struct mvs_info
*mvi
, int i
,
813 struct sas_identify_frame
*id
)
815 struct mvs_phy
*phy
= &mvi
->phy
[i
];
816 struct asd_sas_phy
*sas_phy
= &phy
->sas_phy
;
817 mv_dprintk("get all reg link rate is 0x%x\n", phy
->phy_status
);
819 (phy
->phy_status
& PHY_NEG_SPP_PHYS_LINK_RATE_MASK
) >>
820 PHY_NEG_SPP_PHYS_LINK_RATE_MASK_OFFSET
;
821 sas_phy
->linkrate
+= 0x8;
822 mv_dprintk("get link rate is %d\n", sas_phy
->linkrate
);
823 phy
->minimum_linkrate
= SAS_LINK_RATE_1_5_GBPS
;
824 phy
->maximum_linkrate
= SAS_LINK_RATE_6_0_GBPS
;
825 mvs_94xx_get_dev_identify_frame(mvi
, i
, id
);
826 phy
->dev_info
= mvs_94xx_make_dev_info(id
);
828 if (phy
->phy_type
& PORT_TYPE_SAS
) {
829 mvs_94xx_get_att_identify_frame(mvi
, i
, id
);
830 phy
->att_dev_info
= mvs_94xx_make_att_info(id
);
831 phy
->att_dev_sas_addr
= *(u64
*)id
->sas_addr
;
833 phy
->att_dev_info
= PORT_DEV_STP_TRGT
| 1;
838 void mvs_94xx_phy_set_link_rate(struct mvs_info
*mvi
, u32 phy_id
,
839 struct sas_phy_linkrates
*rates
)
844 tmp
= mvs_read_phy_ctl(mvi
, phy_id
);
845 lrmax
= (rates
->maximum_linkrate
- SAS_LINK_RATE_1_5_GBPS
) << 12;
851 mvs_write_phy_ctl(mvi
, phy_id
, tmp
);
852 mvs_94xx_phy_reset(mvi
, phy_id
, PHY_RST_HARD
);
855 static void mvs_94xx_clear_active_cmds(struct mvs_info
*mvi
)
858 void __iomem
*regs
= mvi
->regs
;
859 tmp
= mr32(MVS_STP_REG_SET_0
);
860 mw32(MVS_STP_REG_SET_0
, 0);
861 mw32(MVS_STP_REG_SET_0
, tmp
);
862 tmp
= mr32(MVS_STP_REG_SET_1
);
863 mw32(MVS_STP_REG_SET_1
, 0);
864 mw32(MVS_STP_REG_SET_1
, tmp
);
868 u32
mvs_94xx_spi_read_data(struct mvs_info
*mvi
)
870 void __iomem
*regs
= mvi
->regs_ex
- 0x10200;
871 return mr32(SPI_RD_DATA_REG_94XX
);
874 void mvs_94xx_spi_write_data(struct mvs_info
*mvi
, u32 data
)
876 void __iomem
*regs
= mvi
->regs_ex
- 0x10200;
877 mw32(SPI_RD_DATA_REG_94XX
, data
);
881 int mvs_94xx_spi_buildcmd(struct mvs_info
*mvi
,
889 void __iomem
*regs
= mvi
->regs_ex
- 0x10200;
892 dwTmp
= ((u32
)cmd
<< 8) | ((u32
)length
<< 4);
894 dwTmp
|= SPI_CTRL_READ_94XX
;
896 if (addr
!= MV_MAX_U32
) {
897 mw32(SPI_ADDR_REG_94XX
, (addr
& 0x0003FFFFL
));
898 dwTmp
|= SPI_ADDR_VLD_94XX
;
906 int mvs_94xx_spi_issuecmd(struct mvs_info
*mvi
, u32 cmd
)
908 void __iomem
*regs
= mvi
->regs_ex
- 0x10200;
909 mw32(SPI_CTRL_REG_94XX
, cmd
| SPI_CTRL_SpiStart_94XX
);
914 int mvs_94xx_spi_waitdataready(struct mvs_info
*mvi
, u32 timeout
)
916 void __iomem
*regs
= mvi
->regs_ex
- 0x10200;
919 for (i
= 0; i
< timeout
; i
++) {
920 dwTmp
= mr32(SPI_CTRL_REG_94XX
);
921 if (!(dwTmp
& SPI_CTRL_SpiStart_94XX
))
929 void mvs_94xx_fix_dma(struct mvs_info
*mvi
, u32 phy_mask
,
930 int buf_len
, int from
, void *prd
)
933 struct mvs_prd
*buf_prd
= prd
;
935 struct mvs_prd_imt im_len
;
940 #define PRD_CHAINED_ENTRY 0x01
941 if ((mvi
->pdev
->revision
== VANIR_A0_REV
) ||
942 (mvi
->pdev
->revision
== VANIR_B0_REV
))
943 buf_dma
= (phy_mask
<= 0x08) ?
944 mvi
->bulk_buffer_dma
: mvi
->bulk_buffer_dma1
;
948 for (i
= from
; i
< MAX_SG_ENTRY
; i
++, ++buf_prd
) {
949 if (i
== MAX_SG_ENTRY
- 1) {
950 buf_prd
->addr
= cpu_to_le64(virt_to_phys(buf_prd
- 1));
952 im_len
.misc_ctl
= PRD_CHAINED_ENTRY
;
954 buf_prd
->addr
= cpu_to_le64(buf_dma
);
955 im_len
.len
= buf_len
;
957 buf_prd
->im_len
= cpu_to_le32(*(u32
*)&im_len
);
961 static void mvs_94xx_tune_interrupt(struct mvs_info
*mvi
, u32 time
)
963 void __iomem
*regs
= mvi
->regs
;
965 /* interrupt coalescing may cause missing HW interrput in some case,
966 * and the max count is 0x1ff, while our max slot is 0x200,
967 * it will make count 0.
970 mw32(MVS_INT_COAL
, 0);
971 mw32(MVS_INT_COAL_TMOUT
, 0x10000);
973 if (MVS_CHIP_SLOT_SZ
> 0x1ff)
974 mw32(MVS_INT_COAL
, 0x1ff|COAL_EN
);
976 mw32(MVS_INT_COAL
, MVS_CHIP_SLOT_SZ
|COAL_EN
);
978 tmp
= 0x10000 | time
;
979 mw32(MVS_INT_COAL_TMOUT
, tmp
);
984 const struct mvs_dispatch mvs_94xx_dispatch
= {
992 mvs_94xx_interrupt_enable
,
993 mvs_94xx_interrupt_disable
,
996 mvs_read_port_cfg_data
,
997 mvs_write_port_cfg_data
,
998 mvs_write_port_cfg_addr
,
999 mvs_read_port_vsr_data
,
1000 mvs_write_port_vsr_data
,
1001 mvs_write_port_vsr_addr
,
1002 mvs_read_port_irq_stat
,
1003 mvs_write_port_irq_stat
,
1004 mvs_read_port_irq_mask
,
1005 mvs_write_port_irq_mask
,
1006 mvs_94xx_command_active
,
1007 mvs_94xx_clear_srs_irq
,
1008 mvs_94xx_issue_stop
,
1012 mvs_94xx_assign_reg_set
,
1013 mvs_94xx_free_reg_set
,
1017 mvs_94xx_detect_porttype
,
1019 mvs_94xx_fix_phy_info
,
1021 mvs_94xx_phy_set_link_rate
,
1022 mvs_hw_max_link_rate
,
1023 mvs_94xx_phy_disable
,
1024 mvs_94xx_phy_enable
,
1027 mvs_94xx_clear_active_cmds
,
1028 mvs_94xx_spi_read_data
,
1029 mvs_94xx_spi_write_data
,
1030 mvs_94xx_spi_buildcmd
,
1031 mvs_94xx_spi_issuecmd
,
1032 mvs_94xx_spi_waitdataready
,
1034 mvs_94xx_tune_interrupt
,
1035 mvs_94xx_non_spec_ncq_error
,