[SCSI] mvsas: misc improvements
[linux-2.6.git] / drivers / scsi / mvsas / mv_64xx.c
1 /*
2  * Marvell 88SE64xx hardware specific
3  *
4  * Copyright 2007 Red Hat, Inc.
5  * Copyright 2008 Marvell. <kewei@marvell.com>
6  * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
7  *
8  * This file is licensed under GPLv2.
9  *
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
13  * License.
14  *
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.
19  *
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
23  * USA
24 */
25
26 #include "mv_sas.h"
27 #include "mv_64xx.h"
28 #include "mv_chips.h"
29
30 static void mvs_64xx_detect_porttype(struct mvs_info *mvi, int i)
31 {
32         void __iomem *regs = mvi->regs;
33         u32 reg;
34         struct mvs_phy *phy = &mvi->phy[i];
35
36         /* TODO check & save device type */
37         reg = mr32(MVS_GBL_PORT_TYPE);
38         phy->phy_type &= ~(PORT_TYPE_SAS | PORT_TYPE_SATA);
39         if (reg & MODE_SAS_SATA & (1 << i))
40                 phy->phy_type |= PORT_TYPE_SAS;
41         else
42                 phy->phy_type |= PORT_TYPE_SATA;
43 }
44
45 static void __devinit mvs_64xx_enable_xmt(struct mvs_info *mvi, int phy_id)
46 {
47         void __iomem *regs = mvi->regs;
48         u32 tmp;
49
50         tmp = mr32(MVS_PCS);
51         if (mvi->chip->n_phy <= MVS_SOC_PORTS)
52                 tmp |= 1 << (phy_id + PCS_EN_PORT_XMT_SHIFT);
53         else
54                 tmp |= 1 << (phy_id + PCS_EN_PORT_XMT_SHIFT2);
55         mw32(MVS_PCS, tmp);
56 }
57
58 static void __devinit mvs_64xx_phy_hacks(struct mvs_info *mvi)
59 {
60         void __iomem *regs = mvi->regs;
61         int i;
62
63         mvs_phy_hacks(mvi);
64
65         if (!(mvi->flags & MVF_FLAG_SOC)) {
66                 /* TEST - for phy decoding error, adjust voltage levels */
67                 for (i = 0; i < MVS_SOC_PORTS; i++) {
68                         mvs_write_port_vsr_addr(mvi, i, VSR_PHY_MODE8);
69                         mvs_write_port_vsr_data(mvi, i, 0x2F0);
70                 }
71         } else {
72                 /* disable auto port detection */
73                 mw32(MVS_GBL_PORT_TYPE, 0);
74                 for (i = 0; i < mvi->chip->n_phy; i++) {
75                         mvs_write_port_vsr_addr(mvi, i, VSR_PHY_MODE7);
76                         mvs_write_port_vsr_data(mvi, i, 0x90000000);
77                         mvs_write_port_vsr_addr(mvi, i, VSR_PHY_MODE9);
78                         mvs_write_port_vsr_data(mvi, i, 0x50f2);
79                         mvs_write_port_vsr_addr(mvi, i, VSR_PHY_MODE11);
80                         mvs_write_port_vsr_data(mvi, i, 0x0e);
81                 }
82         }
83 }
84
85 static void mvs_64xx_stp_reset(struct mvs_info *mvi, u32 phy_id)
86 {
87         void __iomem *regs = mvi->regs;
88         u32 reg, tmp;
89
90         if (!(mvi->flags & MVF_FLAG_SOC)) {
91                 if (phy_id < MVS_SOC_PORTS)
92                         pci_read_config_dword(mvi->pdev, PCR_PHY_CTL, &reg);
93                 else
94                         pci_read_config_dword(mvi->pdev, PCR_PHY_CTL2, &reg);
95
96         } else
97                 reg = mr32(MVS_PHY_CTL);
98
99         tmp = reg;
100         if (phy_id < MVS_SOC_PORTS)
101                 tmp |= (1U << phy_id) << PCTL_LINK_OFFS;
102         else
103                 tmp |= (1U << (phy_id - MVS_SOC_PORTS)) << PCTL_LINK_OFFS;
104
105         if (!(mvi->flags & MVF_FLAG_SOC)) {
106                 if (phy_id < MVS_SOC_PORTS) {
107                         pci_write_config_dword(mvi->pdev, PCR_PHY_CTL, tmp);
108                         mdelay(10);
109                         pci_write_config_dword(mvi->pdev, PCR_PHY_CTL, reg);
110                 } else {
111                         pci_write_config_dword(mvi->pdev, PCR_PHY_CTL2, tmp);
112                         mdelay(10);
113                         pci_write_config_dword(mvi->pdev, PCR_PHY_CTL2, reg);
114                 }
115         } else {
116                 mw32(MVS_PHY_CTL, tmp);
117                 mdelay(10);
118                 mw32(MVS_PHY_CTL, reg);
119         }
120 }
121
122 static void mvs_64xx_phy_reset(struct mvs_info *mvi, u32 phy_id, int hard)
123 {
124         u32 tmp;
125         tmp = mvs_read_port_irq_stat(mvi, phy_id);
126         tmp &= ~PHYEV_RDY_CH;
127         mvs_write_port_irq_stat(mvi, phy_id, tmp);
128         tmp = mvs_read_phy_ctl(mvi, phy_id);
129         if (hard == MVS_HARD_RESET)
130                 tmp |= PHY_RST_HARD;
131         else if (hard == MVS_SOFT_RESET)
132                 tmp |= PHY_RST;
133         mvs_write_phy_ctl(mvi, phy_id, tmp);
134         if (hard) {
135                 do {
136                         tmp = mvs_read_phy_ctl(mvi, phy_id);
137                 } while (tmp & PHY_RST_HARD);
138         }
139 }
140
141 void mvs_64xx_clear_srs_irq(struct mvs_info *mvi, u8 reg_set, u8 clear_all)
142 {
143         void __iomem *regs = mvi->regs;
144         u32 tmp;
145         if (clear_all) {
146                 tmp = mr32(MVS_INT_STAT_SRS_0);
147                 if (tmp) {
148                         printk(KERN_DEBUG "check SRS 0 %08X.\n", tmp);
149                         mw32(MVS_INT_STAT_SRS_0, tmp);
150                 }
151         } else {
152                 tmp = mr32(MVS_INT_STAT_SRS_0);
153                 if (tmp &  (1 << (reg_set % 32))) {
154                         printk(KERN_DEBUG "register set 0x%x was stopped.\n",
155                                reg_set);
156                         mw32(MVS_INT_STAT_SRS_0, 1 << (reg_set % 32));
157                 }
158         }
159 }
160
161 static int __devinit mvs_64xx_chip_reset(struct mvs_info *mvi)
162 {
163         void __iomem *regs = mvi->regs;
164         u32 tmp;
165         int i;
166
167         /* make sure interrupts are masked immediately (paranoia) */
168         mw32(MVS_GBL_CTL, 0);
169         tmp = mr32(MVS_GBL_CTL);
170
171         /* Reset Controller */
172         if (!(tmp & HBA_RST)) {
173                 if (mvi->flags & MVF_PHY_PWR_FIX) {
174                         pci_read_config_dword(mvi->pdev, PCR_PHY_CTL, &tmp);
175                         tmp &= ~PCTL_PWR_OFF;
176                         tmp |= PCTL_PHY_DSBL;
177                         pci_write_config_dword(mvi->pdev, PCR_PHY_CTL, tmp);
178
179                         pci_read_config_dword(mvi->pdev, PCR_PHY_CTL2, &tmp);
180                         tmp &= ~PCTL_PWR_OFF;
181                         tmp |= PCTL_PHY_DSBL;
182                         pci_write_config_dword(mvi->pdev, PCR_PHY_CTL2, tmp);
183                 }
184         }
185
186         /* make sure interrupts are masked immediately (paranoia) */
187         mw32(MVS_GBL_CTL, 0);
188         tmp = mr32(MVS_GBL_CTL);
189
190         /* Reset Controller */
191         if (!(tmp & HBA_RST)) {
192                 /* global reset, incl. COMRESET/H_RESET_N (self-clearing) */
193                 mw32_f(MVS_GBL_CTL, HBA_RST);
194         }
195
196         /* wait for reset to finish; timeout is just a guess */
197         i = 1000;
198         while (i-- > 0) {
199                 msleep(10);
200
201                 if (!(mr32(MVS_GBL_CTL) & HBA_RST))
202                         break;
203         }
204         if (mr32(MVS_GBL_CTL) & HBA_RST) {
205                 dev_printk(KERN_ERR, mvi->dev, "HBA reset failed\n");
206                 return -EBUSY;
207         }
208         return 0;
209 }
210
211 static void mvs_64xx_phy_disable(struct mvs_info *mvi, u32 phy_id)
212 {
213         void __iomem *regs = mvi->regs;
214         u32 tmp;
215         if (!(mvi->flags & MVF_FLAG_SOC)) {
216                 u32 offs;
217                 if (phy_id < 4)
218                         offs = PCR_PHY_CTL;
219                 else {
220                         offs = PCR_PHY_CTL2;
221                         phy_id -= 4;
222                 }
223                 pci_read_config_dword(mvi->pdev, offs, &tmp);
224                 tmp |= 1U << (PCTL_PHY_DSBL_OFFS + phy_id);
225                 pci_write_config_dword(mvi->pdev, offs, tmp);
226         } else {
227                 tmp = mr32(MVS_PHY_CTL);
228                 tmp |= 1U << (PCTL_PHY_DSBL_OFFS + phy_id);
229                 mw32(MVS_PHY_CTL, tmp);
230         }
231 }
232
233 static void mvs_64xx_phy_enable(struct mvs_info *mvi, u32 phy_id)
234 {
235         void __iomem *regs = mvi->regs;
236         u32 tmp;
237         if (!(mvi->flags & MVF_FLAG_SOC)) {
238                 u32 offs;
239                 if (phy_id < 4)
240                         offs = PCR_PHY_CTL;
241                 else {
242                         offs = PCR_PHY_CTL2;
243                         phy_id -= 4;
244                 }
245                 pci_read_config_dword(mvi->pdev, offs, &tmp);
246                 tmp &= ~(1U << (PCTL_PHY_DSBL_OFFS + phy_id));
247                 pci_write_config_dword(mvi->pdev, offs, tmp);
248         } else {
249                 tmp = mr32(MVS_PHY_CTL);
250                 tmp &= ~(1U << (PCTL_PHY_DSBL_OFFS + phy_id));
251                 mw32(MVS_PHY_CTL, tmp);
252         }
253 }
254
255 static int __devinit mvs_64xx_init(struct mvs_info *mvi)
256 {
257         void __iomem *regs = mvi->regs;
258         int i;
259         u32 tmp, cctl;
260
261         if (mvi->pdev && mvi->pdev->revision == 0)
262                 mvi->flags |= MVF_PHY_PWR_FIX;
263         if (!(mvi->flags & MVF_FLAG_SOC)) {
264                 mvs_show_pcie_usage(mvi);
265                 tmp = mvs_64xx_chip_reset(mvi);
266                 if (tmp)
267                         return tmp;
268         } else {
269                 tmp = mr32(MVS_PHY_CTL);
270                 tmp &= ~PCTL_PWR_OFF;
271                 tmp |= PCTL_PHY_DSBL;
272                 mw32(MVS_PHY_CTL, tmp);
273         }
274
275         /* Init Chip */
276         /* make sure RST is set; HBA_RST /should/ have done that for us */
277         cctl = mr32(MVS_CTL) & 0xFFFF;
278         if (cctl & CCTL_RST)
279                 cctl &= ~CCTL_RST;
280         else
281                 mw32_f(MVS_CTL, cctl | CCTL_RST);
282
283         if (!(mvi->flags & MVF_FLAG_SOC)) {
284                 /* write to device control _AND_ device status register */
285                 pci_read_config_dword(mvi->pdev, PCR_DEV_CTRL, &tmp);
286                 tmp &= ~PRD_REQ_MASK;
287                 tmp |= PRD_REQ_SIZE;
288                 pci_write_config_dword(mvi->pdev, PCR_DEV_CTRL, tmp);
289
290                 pci_read_config_dword(mvi->pdev, PCR_PHY_CTL, &tmp);
291                 tmp &= ~PCTL_PWR_OFF;
292                 tmp &= ~PCTL_PHY_DSBL;
293                 pci_write_config_dword(mvi->pdev, PCR_PHY_CTL, tmp);
294
295                 pci_read_config_dword(mvi->pdev, PCR_PHY_CTL2, &tmp);
296                 tmp &= PCTL_PWR_OFF;
297                 tmp &= ~PCTL_PHY_DSBL;
298                 pci_write_config_dword(mvi->pdev, PCR_PHY_CTL2, tmp);
299         } else {
300                 tmp = mr32(MVS_PHY_CTL);
301                 tmp &= ~PCTL_PWR_OFF;
302                 tmp |= PCTL_COM_ON;
303                 tmp &= ~PCTL_PHY_DSBL;
304                 tmp |= PCTL_LINK_RST;
305                 mw32(MVS_PHY_CTL, tmp);
306                 msleep(100);
307                 tmp &= ~PCTL_LINK_RST;
308                 mw32(MVS_PHY_CTL, tmp);
309                 msleep(100);
310         }
311
312         /* reset control */
313         mw32(MVS_PCS, 0);               /* MVS_PCS */
314         /* init phys */
315         mvs_64xx_phy_hacks(mvi);
316
317         tmp = mvs_cr32(mvi, CMD_PHY_MODE_21);
318         tmp &= 0x0000ffff;
319         tmp |= 0x00fa0000;
320         mvs_cw32(mvi, CMD_PHY_MODE_21, tmp);
321
322         /* enable auto port detection */
323         mw32(MVS_GBL_PORT_TYPE, MODE_AUTO_DET_EN);
324
325         mw32(MVS_CMD_LIST_LO, mvi->slot_dma);
326         mw32(MVS_CMD_LIST_HI, (mvi->slot_dma >> 16) >> 16);
327
328         mw32(MVS_RX_FIS_LO, mvi->rx_fis_dma);
329         mw32(MVS_RX_FIS_HI, (mvi->rx_fis_dma >> 16) >> 16);
330
331         mw32(MVS_TX_CFG, MVS_CHIP_SLOT_SZ);
332         mw32(MVS_TX_LO, mvi->tx_dma);
333         mw32(MVS_TX_HI, (mvi->tx_dma >> 16) >> 16);
334
335         mw32(MVS_RX_CFG, MVS_RX_RING_SZ);
336         mw32(MVS_RX_LO, mvi->rx_dma);
337         mw32(MVS_RX_HI, (mvi->rx_dma >> 16) >> 16);
338
339         for (i = 0; i < mvi->chip->n_phy; i++) {
340                 /* set phy local SAS address */
341                 /* should set little endian SAS address to 64xx chip */
342                 mvs_set_sas_addr(mvi, i, PHYR_ADDR_LO, PHYR_ADDR_HI,
343                                 cpu_to_be64(mvi->phy[i].dev_sas_addr));
344
345                 mvs_64xx_enable_xmt(mvi, i);
346
347                 mvs_64xx_phy_reset(mvi, i, MVS_HARD_RESET);
348                 msleep(500);
349                 mvs_64xx_detect_porttype(mvi, i);
350         }
351         if (mvi->flags & MVF_FLAG_SOC) {
352                 /* set select registers */
353                 writel(0x0E008000, regs + 0x000);
354                 writel(0x59000008, regs + 0x004);
355                 writel(0x20, regs + 0x008);
356                 writel(0x20, regs + 0x00c);
357                 writel(0x20, regs + 0x010);
358                 writel(0x20, regs + 0x014);
359                 writel(0x20, regs + 0x018);
360                 writel(0x20, regs + 0x01c);
361         }
362         for (i = 0; i < mvi->chip->n_phy; i++) {
363                 /* clear phy int status */
364                 tmp = mvs_read_port_irq_stat(mvi, i);
365                 tmp &= ~PHYEV_SIG_FIS;
366                 mvs_write_port_irq_stat(mvi, i, tmp);
367
368                 /* set phy int mask */
369                 tmp = PHYEV_RDY_CH | PHYEV_BROAD_CH | PHYEV_UNASSOC_FIS |
370                         PHYEV_ID_DONE | PHYEV_DCDR_ERR | PHYEV_CRC_ERR |
371                         PHYEV_DEC_ERR;
372                 mvs_write_port_irq_mask(mvi, i, tmp);
373
374                 msleep(100);
375                 mvs_update_phyinfo(mvi, i, 1);
376         }
377
378         /* FIXME: update wide port bitmaps */
379
380         /* little endian for open address and command table, etc. */
381         /*
382          * it seems that ( from the spec ) turning on big-endian won't
383          * do us any good on big-endian machines, need further confirmation
384          */
385         cctl = mr32(MVS_CTL);
386         cctl |= CCTL_ENDIAN_CMD;
387         cctl |= CCTL_ENDIAN_DATA;
388         cctl &= ~CCTL_ENDIAN_OPEN;
389         cctl |= CCTL_ENDIAN_RSP;
390         mw32_f(MVS_CTL, cctl);
391
392         /* reset CMD queue */
393         tmp = mr32(MVS_PCS);
394         tmp |= PCS_CMD_RST;
395         tmp &= ~PCS_SELF_CLEAR;
396         mw32(MVS_PCS, tmp);
397         /* interrupt coalescing may cause missing HW interrput in some case,
398          * and the max count is 0x1ff, while our max slot is 0x200,
399          * it will make count 0.
400          */
401         tmp = 0;
402         if (MVS_CHIP_SLOT_SZ > 0x1ff)
403                 mw32(MVS_INT_COAL, 0x1ff | COAL_EN);
404         else
405                 mw32(MVS_INT_COAL, MVS_CHIP_SLOT_SZ | COAL_EN);
406
407         tmp = 0x10000 | interrupt_coalescing;
408         mw32(MVS_INT_COAL_TMOUT, tmp);
409
410         /* ladies and gentlemen, start your engines */
411         mw32(MVS_TX_CFG, 0);
412         mw32(MVS_TX_CFG, MVS_CHIP_SLOT_SZ | TX_EN);
413         mw32(MVS_RX_CFG, MVS_RX_RING_SZ | RX_EN);
414         /* enable CMD/CMPL_Q/RESP mode */
415         mw32(MVS_PCS, PCS_SATA_RETRY | PCS_FIS_RX_EN |
416                 PCS_CMD_EN | PCS_CMD_STOP_ERR);
417
418         /* enable completion queue interrupt */
419         tmp = (CINT_PORT_MASK | CINT_DONE | CINT_MEM | CINT_SRS | CINT_CI_STOP |
420                 CINT_DMA_PCIE);
421
422         mw32(MVS_INT_MASK, tmp);
423
424         /* Enable SRS interrupt */
425         mw32(MVS_INT_MASK_SRS_0, 0xFFFF);
426
427         return 0;
428 }
429
430 static int mvs_64xx_ioremap(struct mvs_info *mvi)
431 {
432         if (!mvs_ioremap(mvi, 4, 2))
433                 return 0;
434         return -1;
435 }
436
437 static void mvs_64xx_iounmap(struct mvs_info *mvi)
438 {
439         mvs_iounmap(mvi->regs);
440         mvs_iounmap(mvi->regs_ex);
441 }
442
443 static void mvs_64xx_interrupt_enable(struct mvs_info *mvi)
444 {
445         void __iomem *regs = mvi->regs;
446         u32 tmp;
447
448         tmp = mr32(MVS_GBL_CTL);
449         mw32(MVS_GBL_CTL, tmp | INT_EN);
450 }
451
452 static void mvs_64xx_interrupt_disable(struct mvs_info *mvi)
453 {
454         void __iomem *regs = mvi->regs;
455         u32 tmp;
456
457         tmp = mr32(MVS_GBL_CTL);
458         mw32(MVS_GBL_CTL, tmp & ~INT_EN);
459 }
460
461 static u32 mvs_64xx_isr_status(struct mvs_info *mvi, int irq)
462 {
463         void __iomem *regs = mvi->regs;
464         u32 stat;
465
466         if (!(mvi->flags & MVF_FLAG_SOC)) {
467                 stat = mr32(MVS_GBL_INT_STAT);
468
469                 if (stat == 0 || stat == 0xffffffff)
470                         return 0;
471         } else
472                 stat = 1;
473         return stat;
474 }
475
476 static irqreturn_t mvs_64xx_isr(struct mvs_info *mvi, int irq, u32 stat)
477 {
478         void __iomem *regs = mvi->regs;
479
480         /* clear CMD_CMPLT ASAP */
481         mw32_f(MVS_INT_STAT, CINT_DONE);
482 #ifndef MVS_USE_TASKLET
483         spin_lock(&mvi->lock);
484 #endif
485         mvs_int_full(mvi);
486 #ifndef MVS_USE_TASKLET
487         spin_unlock(&mvi->lock);
488 #endif
489         return IRQ_HANDLED;
490 }
491
492 static void mvs_64xx_command_active(struct mvs_info *mvi, u32 slot_idx)
493 {
494         u32 tmp;
495         mvs_cw32(mvi, 0x40 + (slot_idx >> 3), 1 << (slot_idx % 32));
496         mvs_cw32(mvi, 0x00 + (slot_idx >> 3), 1 << (slot_idx % 32));
497         do {
498                 tmp = mvs_cr32(mvi, 0x00 + (slot_idx >> 3));
499         } while (tmp & 1 << (slot_idx % 32));
500         do {
501                 tmp = mvs_cr32(mvi, 0x40 + (slot_idx >> 3));
502         } while (tmp & 1 << (slot_idx % 32));
503 }
504
505 static void mvs_64xx_issue_stop(struct mvs_info *mvi, enum mvs_port_type type,
506                                 u32 tfs)
507 {
508         void __iomem *regs = mvi->regs;
509         u32 tmp;
510
511         if (type == PORT_TYPE_SATA) {
512                 tmp = mr32(MVS_INT_STAT_SRS_0) | (1U << tfs);
513                 mw32(MVS_INT_STAT_SRS_0, tmp);
514         }
515         mw32(MVS_INT_STAT, CINT_CI_STOP);
516         tmp = mr32(MVS_PCS) | 0xFF00;
517         mw32(MVS_PCS, tmp);
518 }
519
520 static void mvs_64xx_free_reg_set(struct mvs_info *mvi, u8 *tfs)
521 {
522         void __iomem *regs = mvi->regs;
523         u32 tmp, offs;
524
525         if (*tfs == MVS_ID_NOT_MAPPED)
526                 return;
527
528         offs = 1U << ((*tfs & 0x0f) + PCS_EN_SATA_REG_SHIFT);
529         if (*tfs < 16) {
530                 tmp = mr32(MVS_PCS);
531                 mw32(MVS_PCS, tmp & ~offs);
532         } else {
533                 tmp = mr32(MVS_CTL);
534                 mw32(MVS_CTL, tmp & ~offs);
535         }
536
537         tmp = mr32(MVS_INT_STAT_SRS_0) & (1U << *tfs);
538         if (tmp)
539                 mw32(MVS_INT_STAT_SRS_0, tmp);
540
541         *tfs = MVS_ID_NOT_MAPPED;
542         return;
543 }
544
545 static u8 mvs_64xx_assign_reg_set(struct mvs_info *mvi, u8 *tfs)
546 {
547         int i;
548         u32 tmp, offs;
549         void __iomem *regs = mvi->regs;
550
551         if (*tfs != MVS_ID_NOT_MAPPED)
552                 return 0;
553
554         tmp = mr32(MVS_PCS);
555
556         for (i = 0; i < mvi->chip->srs_sz; i++) {
557                 if (i == 16)
558                         tmp = mr32(MVS_CTL);
559                 offs = 1U << ((i & 0x0f) + PCS_EN_SATA_REG_SHIFT);
560                 if (!(tmp & offs)) {
561                         *tfs = i;
562
563                         if (i < 16)
564                                 mw32(MVS_PCS, tmp | offs);
565                         else
566                                 mw32(MVS_CTL, tmp | offs);
567                         tmp = mr32(MVS_INT_STAT_SRS_0) & (1U << i);
568                         if (tmp)
569                                 mw32(MVS_INT_STAT_SRS_0, tmp);
570                         return 0;
571                 }
572         }
573         return MVS_ID_NOT_MAPPED;
574 }
575
576 void mvs_64xx_make_prd(struct scatterlist *scatter, int nr, void *prd)
577 {
578         int i;
579         struct scatterlist *sg;
580         struct mvs_prd *buf_prd = prd;
581         for_each_sg(scatter, sg, nr, i) {
582                 buf_prd->addr = cpu_to_le64(sg_dma_address(sg));
583                 buf_prd->len = cpu_to_le32(sg_dma_len(sg));
584                 buf_prd++;
585         }
586 }
587
588 static int mvs_64xx_oob_done(struct mvs_info *mvi, int i)
589 {
590         u32 phy_st;
591         mvs_write_port_cfg_addr(mvi, i,
592                         PHYR_PHY_STAT);
593         phy_st = mvs_read_port_cfg_data(mvi, i);
594         if (phy_st & PHY_OOB_DTCTD)
595                 return 1;
596         return 0;
597 }
598
599 static void mvs_64xx_fix_phy_info(struct mvs_info *mvi, int i,
600                                 struct sas_identify_frame *id)
601
602 {
603         struct mvs_phy *phy = &mvi->phy[i];
604         struct asd_sas_phy *sas_phy = &phy->sas_phy;
605
606         sas_phy->linkrate =
607                 (phy->phy_status & PHY_NEG_SPP_PHYS_LINK_RATE_MASK) >>
608                         PHY_NEG_SPP_PHYS_LINK_RATE_MASK_OFFSET;
609
610         phy->minimum_linkrate =
611                 (phy->phy_status &
612                         PHY_MIN_SPP_PHYS_LINK_RATE_MASK) >> 8;
613         phy->maximum_linkrate =
614                 (phy->phy_status &
615                         PHY_MAX_SPP_PHYS_LINK_RATE_MASK) >> 12;
616
617         mvs_write_port_cfg_addr(mvi, i, PHYR_IDENTIFY);
618         phy->dev_info = mvs_read_port_cfg_data(mvi, i);
619
620         mvs_write_port_cfg_addr(mvi, i, PHYR_ATT_DEV_INFO);
621         phy->att_dev_info = mvs_read_port_cfg_data(mvi, i);
622
623         mvs_write_port_cfg_addr(mvi, i, PHYR_ATT_ADDR_HI);
624         phy->att_dev_sas_addr =
625              (u64) mvs_read_port_cfg_data(mvi, i) << 32;
626         mvs_write_port_cfg_addr(mvi, i, PHYR_ATT_ADDR_LO);
627         phy->att_dev_sas_addr |= mvs_read_port_cfg_data(mvi, i);
628         phy->att_dev_sas_addr = SAS_ADDR(&phy->att_dev_sas_addr);
629 }
630
631 static void mvs_64xx_phy_work_around(struct mvs_info *mvi, int i)
632 {
633         u32 tmp;
634         struct mvs_phy *phy = &mvi->phy[i];
635         /* workaround for HW phy decoding error on 1.5g disk drive */
636         mvs_write_port_vsr_addr(mvi, i, VSR_PHY_MODE6);
637         tmp = mvs_read_port_vsr_data(mvi, i);
638         if (((phy->phy_status & PHY_NEG_SPP_PHYS_LINK_RATE_MASK) >>
639              PHY_NEG_SPP_PHYS_LINK_RATE_MASK_OFFSET) ==
640                 SAS_LINK_RATE_1_5_GBPS)
641                 tmp &= ~PHY_MODE6_LATECLK;
642         else
643                 tmp |= PHY_MODE6_LATECLK;
644         mvs_write_port_vsr_data(mvi, i, tmp);
645 }
646
647 void mvs_64xx_phy_set_link_rate(struct mvs_info *mvi, u32 phy_id,
648                         struct sas_phy_linkrates *rates)
649 {
650         u32 lrmin = 0, lrmax = 0;
651         u32 tmp;
652
653         tmp = mvs_read_phy_ctl(mvi, phy_id);
654         lrmin = (rates->minimum_linkrate << 8);
655         lrmax = (rates->maximum_linkrate << 12);
656
657         if (lrmin) {
658                 tmp &= ~(0xf << 8);
659                 tmp |= lrmin;
660         }
661         if (lrmax) {
662                 tmp &= ~(0xf << 12);
663                 tmp |= lrmax;
664         }
665         mvs_write_phy_ctl(mvi, phy_id, tmp);
666         mvs_64xx_phy_reset(mvi, phy_id, MVS_HARD_RESET);
667 }
668
669 static void mvs_64xx_clear_active_cmds(struct mvs_info *mvi)
670 {
671         u32 tmp;
672         void __iomem *regs = mvi->regs;
673         tmp = mr32(MVS_PCS);
674         mw32(MVS_PCS, tmp & 0xFFFF);
675         mw32(MVS_PCS, tmp);
676         tmp = mr32(MVS_CTL);
677         mw32(MVS_CTL, tmp & 0xFFFF);
678         mw32(MVS_CTL, tmp);
679 }
680
681
682 u32 mvs_64xx_spi_read_data(struct mvs_info *mvi)
683 {
684         void __iomem *regs = mvi->regs_ex;
685         return ior32(SPI_DATA_REG_64XX);
686 }
687
688 void mvs_64xx_spi_write_data(struct mvs_info *mvi, u32 data)
689 {
690         void __iomem *regs = mvi->regs_ex;
691          iow32(SPI_DATA_REG_64XX, data);
692 }
693
694
695 int mvs_64xx_spi_buildcmd(struct mvs_info *mvi,
696                         u32      *dwCmd,
697                         u8       cmd,
698                         u8       read,
699                         u8       length,
700                         u32      addr
701                         )
702 {
703         u32  dwTmp;
704
705         dwTmp = ((u32)cmd << 24) | ((u32)length << 19);
706         if (read)
707                 dwTmp |= 1U<<23;
708
709         if (addr != MV_MAX_U32) {
710                 dwTmp |= 1U<<22;
711                 dwTmp |= (addr & 0x0003FFFF);
712         }
713
714         *dwCmd = dwTmp;
715         return 0;
716 }
717
718
719 int mvs_64xx_spi_issuecmd(struct mvs_info *mvi, u32 cmd)
720 {
721         void __iomem *regs = mvi->regs_ex;
722         int     retry;
723
724         for (retry = 0; retry < 1; retry++) {
725                 iow32(SPI_CTRL_REG_64XX, SPI_CTRL_VENDOR_ENABLE);
726                 iow32(SPI_CMD_REG_64XX, cmd);
727                 iow32(SPI_CTRL_REG_64XX,
728                         SPI_CTRL_VENDOR_ENABLE | SPI_CTRL_SPISTART);
729         }
730
731         return 0;
732 }
733
734 int mvs_64xx_spi_waitdataready(struct mvs_info *mvi, u32 timeout)
735 {
736         void __iomem *regs = mvi->regs_ex;
737         u32 i, dwTmp;
738
739         for (i = 0; i < timeout; i++) {
740                 dwTmp = ior32(SPI_CTRL_REG_64XX);
741                 if (!(dwTmp & SPI_CTRL_SPISTART))
742                         return 0;
743                 msleep(10);
744         }
745
746         return -1;
747 }
748
749 void mvs_64xx_fix_dma(struct mvs_info *mvi, u32 phy_mask,
750                                 int buf_len, int from, void *prd)
751 {
752         int i;
753         struct mvs_prd *buf_prd = prd;
754         dma_addr_t buf_dma = mvi->bulk_buffer_dma;
755
756         buf_prd += from;
757         for (i = 0; i < MAX_SG_ENTRY - from; i++) {
758                 buf_prd->addr = cpu_to_le64(buf_dma);
759                 buf_prd->len = cpu_to_le32(buf_len);
760                 ++buf_prd;
761         }
762 }
763
764 static void mvs_64xx_tune_interrupt(struct mvs_info *mvi, u32 time)
765 {
766         void __iomem *regs = mvi->regs;
767         u32 tmp = 0;
768         /* interrupt coalescing may cause missing HW interrput in some case,
769          * and the max count is 0x1ff, while our max slot is 0x200,
770          * it will make count 0.
771          */
772         if (time == 0) {
773                 mw32(MVS_INT_COAL, 0);
774                 mw32(MVS_INT_COAL_TMOUT, 0x10000);
775         } else {
776                 if (MVS_CHIP_SLOT_SZ > 0x1ff)
777                         mw32(MVS_INT_COAL, 0x1ff|COAL_EN);
778                 else
779                         mw32(MVS_INT_COAL, MVS_CHIP_SLOT_SZ|COAL_EN);
780
781                 tmp = 0x10000 | time;
782                 mw32(MVS_INT_COAL_TMOUT, tmp);
783         }
784 }
785
786 const struct mvs_dispatch mvs_64xx_dispatch = {
787         "mv64xx",
788         mvs_64xx_init,
789         NULL,
790         mvs_64xx_ioremap,
791         mvs_64xx_iounmap,
792         mvs_64xx_isr,
793         mvs_64xx_isr_status,
794         mvs_64xx_interrupt_enable,
795         mvs_64xx_interrupt_disable,
796         mvs_read_phy_ctl,
797         mvs_write_phy_ctl,
798         mvs_read_port_cfg_data,
799         mvs_write_port_cfg_data,
800         mvs_write_port_cfg_addr,
801         mvs_read_port_vsr_data,
802         mvs_write_port_vsr_data,
803         mvs_write_port_vsr_addr,
804         mvs_read_port_irq_stat,
805         mvs_write_port_irq_stat,
806         mvs_read_port_irq_mask,
807         mvs_write_port_irq_mask,
808         mvs_64xx_command_active,
809         mvs_64xx_clear_srs_irq,
810         mvs_64xx_issue_stop,
811         mvs_start_delivery,
812         mvs_rx_update,
813         mvs_int_full,
814         mvs_64xx_assign_reg_set,
815         mvs_64xx_free_reg_set,
816         mvs_get_prd_size,
817         mvs_get_prd_count,
818         mvs_64xx_make_prd,
819         mvs_64xx_detect_porttype,
820         mvs_64xx_oob_done,
821         mvs_64xx_fix_phy_info,
822         mvs_64xx_phy_work_around,
823         mvs_64xx_phy_set_link_rate,
824         mvs_hw_max_link_rate,
825         mvs_64xx_phy_disable,
826         mvs_64xx_phy_enable,
827         mvs_64xx_phy_reset,
828         mvs_64xx_stp_reset,
829         mvs_64xx_clear_active_cmds,
830         mvs_64xx_spi_read_data,
831         mvs_64xx_spi_write_data,
832         mvs_64xx_spi_buildcmd,
833         mvs_64xx_spi_issuecmd,
834         mvs_64xx_spi_waitdataready,
835         mvs_64xx_fix_dma,
836         mvs_64xx_tune_interrupt,
837         NULL,
838 };
839