← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise-security

« back to all changes in this revision

Viewing changes to drivers/scsi/mvsas/mv_94xx.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati
  • Date: 2011-12-06 15:56:07 UTC
  • Revision ID: package-import@ubuntu.com-20111206155607-pcf44kv5fmhk564f
Tags: 3.2.0-1401.1
[ Paolo Pisati ]

* Rebased on top of Ubuntu-3.2.0-3.8
* Tilt-tracking @ ef2487af4bb15bdd0689631774b5a5e3a59f74e2
* Delete debian.ti-omap4/control, it shoudln't be tracked
* Fix architecture spelling (s/armel/armhf/)
* [Config] Update configs following 3.2 import
* [Config] Fix compilation: disable CODA and ARCH_OMAP3
* [Config] Fix compilation: disable Ethernet Faraday
* Update series to precise

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/scsi/mvsas/mv_94xx.c
48
48
        }
49
49
}
50
50
 
 
51
void set_phy_tuning(struct mvs_info *mvi, int phy_id,
 
52
                        struct phy_tuning phy_tuning)
 
53
{
 
54
        u32 tmp, setting_0 = 0, setting_1 = 0;
 
55
        u8 i;
 
56
 
 
57
        /* Remap information for B0 chip:
 
58
        *
 
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))
 
67
        */
 
68
 
 
69
        /* A0 has a different set of registers */
 
70
        if (mvi->pdev->revision == VANIR_A0_REV)
 
71
                return;
 
72
 
 
73
        for (i = 0; i < 3; i++) {
 
74
                /* loop 3 times, set Gen 1, Gen 2, Gen 3 */
 
75
                switch (i) {
 
76
                case 0:
 
77
                        setting_0 = GENERATION_1_SETTING;
 
78
                        setting_1 = GENERATION_1_2_SETTING;
 
79
                        break;
 
80
                case 1:
 
81
                        setting_0 = GENERATION_1_2_SETTING;
 
82
                        setting_1 = GENERATION_2_3_SETTING;
 
83
                        break;
 
84
                case 2:
 
85
                        setting_0 = GENERATION_2_3_SETTING;
 
86
                        setting_1 = GENERATION_3_4_SETTING;
 
87
                        break;
 
88
                }
 
89
 
 
90
                /* Set:
 
91
                *
 
92
                * Transmitter Emphasis Enable
 
93
                * Transmitter Emphasis Amplitude
 
94
                * Transmitter Amplitude
 
95
                */
 
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);
 
103
 
 
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);
 
107
                tmp &= ~(0xC000);
 
108
                tmp |= (phy_tuning.trans_amp_adj << 14);
 
109
                mvs_write_port_vsr_data(mvi, phy_id, tmp);
 
110
        }
 
111
}
 
112
 
 
113
void set_phy_ffe_tuning(struct mvs_info *mvi, int phy_id,
 
114
                                struct ffe_control ffe)
 
115
{
 
116
        u32 tmp;
 
117
 
 
118
        /* Don't run this if A0/B0 */
 
119
        if ((mvi->pdev->revision == VANIR_A0_REV)
 
120
                || (mvi->pdev->revision == VANIR_B0_REV))
 
121
                return;
 
122
 
 
123
        /* FFE Resistor and Capacitor */
 
124
        /* R10Ch DFE Resolution Control/Squelch and FFE Setting
 
125
         *
 
126
         * FFE_FORCE            [7]
 
127
         * FFE_RES_SEL          [6:4]
 
128
         * FFE_CAP_SEL          [3:0]
 
129
         */
 
130
        mvs_write_port_vsr_addr(mvi, phy_id, VSR_PHY_FFE_CONTROL);
 
131
        tmp = mvs_read_port_vsr_data(mvi, phy_id);
 
132
        tmp &= ~0xFF;
 
133
 
 
134
        /* Read from HBA_Info_Page */
 
135
        tmp |= ((0x1 << 7) |
 
136
                (ffe.ffe_rss_sel << 4) |
 
137
                (ffe.ffe_cap_sel << 0));
 
138
 
 
139
        mvs_write_port_vsr_data(mvi, phy_id, tmp);
 
140
 
 
141
        /* R064h PHY Mode Register 1
 
142
         *
 
143
         * DFE_DIS              18
 
144
         */
 
145
        mvs_write_port_vsr_addr(mvi, phy_id, VSR_REF_CLOCK_CRTL);
 
146
        tmp = mvs_read_port_vsr_data(mvi, phy_id);
 
147
        tmp &= ~0x40001;
 
148
        /* Hard coding */
 
149
        /* No defines in HBA_Info_Page */
 
150
        tmp |= (0 << 18);
 
151
        mvs_write_port_vsr_data(mvi, phy_id, tmp);
 
152
 
 
153
        /* R110h DFE F0-F1 Coefficient Control/DFE Update Control
 
154
         *
 
155
         * DFE_UPDATE_EN        [11:6]
 
156
         * DFE_FX_FORCE         [5:0]
 
157
         */
 
158
        mvs_write_port_vsr_addr(mvi, phy_id, VSR_PHY_DFE_UPDATE_CRTL);
 
159
        tmp = mvs_read_port_vsr_data(mvi, phy_id);
 
160
        tmp &= ~0xFFF;
 
161
        /* Hard coding */
 
162
        /* No defines in HBA_Info_Page */
 
163
        tmp |= ((0x3F << 6) | (0x0 << 0));
 
164
        mvs_write_port_vsr_data(mvi, phy_id, tmp);
 
165
 
 
166
        /* R1A0h Interface and Digital Reference Clock Control/Reserved_50h
 
167
         *
 
168
         * FFE_TRAIN_EN         3
 
169
         */
 
170
        mvs_write_port_vsr_addr(mvi, phy_id, VSR_REF_CLOCK_CRTL);
 
171
        tmp = mvs_read_port_vsr_data(mvi, phy_id);
 
172
        tmp &= ~0x8;
 
173
        /* Hard coding */
 
174
        /* No defines in HBA_Info_Page */
 
175
        tmp |= (0 << 3);
 
176
        mvs_write_port_vsr_data(mvi, phy_id, tmp);
 
177
}
 
178
 
 
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)
 
181
{
 
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);
 
185
        phy_cfg.v = 0;
 
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;
 
190
 
 
191
        switch (rate) {
 
192
        case 0x0:
 
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;
 
198
                break;
 
199
        case 0x1:
 
200
 
 
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;
 
205
                break;
 
206
        case 0x2:
 
207
        default:
 
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;
 
214
                break;
 
215
        }
 
216
        mvs_write_port_vsr_data(mvi, phy_id, phy_cfg.v);
 
217
}
 
218
 
 
219
static void __devinit
 
220
mvs_94xx_config_reg_from_hba(struct mvs_info *mvi, int phy_id)
 
221
{
 
222
        u32 temp;
 
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;
 
228
        }
 
229
 
 
230
        temp = (u8)(*(u8 *)&mvi->hba_info_param.ffe_ctl[phy_id]);
 
231
        if (temp == 0xFFL) {
 
232
                switch (mvi->pdev->revision) {
 
233
                case VANIR_A0_REV:
 
234
                case VANIR_B0_REV:
 
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;
 
237
                        break;
 
238
                case VANIR_C0_REV:
 
239
                case VANIR_C1_REV:
 
240
                case VANIR_C2_REV:
 
241
                default:
 
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;
 
244
                        break;
 
245
                }
 
246
        }
 
247
 
 
248
        temp = (u8)(*(u8 *)&mvi->hba_info_param.phy_rate[phy_id]);
 
249
        if (temp == 0xFFL)
 
250
                /*set default phy_rate = 6Gbps*/
 
251
                mvi->hba_info_param.phy_rate[phy_id] = 0x2;
 
252
 
 
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]);
 
259
}
 
260
 
51
261
static void __devinit mvs_94xx_enable_xmt(struct mvs_info *mvi, int phy_id)
52
262
{
53
263
        void __iomem *regs = mvi->regs;
61
271
static void mvs_94xx_phy_reset(struct mvs_info *mvi, u32 phy_id, int hard)
62
272
{
63
273
        u32 tmp;
64
 
 
 
274
        u32 delay = 5000;
 
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);
 
280
                return;
 
281
        }
65
282
        tmp = mvs_read_port_irq_stat(mvi, phy_id);
66
283
        tmp &= ~PHYEV_RDY_CH;
67
284
        mvs_write_port_irq_stat(mvi, phy_id, tmp);
71
288
                mvs_write_phy_ctl(mvi, phy_id, tmp);
72
289
                do {
73
290
                        tmp = mvs_read_phy_ctl(mvi, phy_id);
74
 
                } while (tmp & PHY_RST_HARD);
 
291
                        udelay(10);
 
292
                        delay--;
 
293
                } while ((tmp & PHY_RST_HARD) && delay);
 
294
                if (!delay)
 
295
                        mv_dprintk("phy hard reset failed.\n");
75
296
        } else {
76
 
                mvs_write_port_vsr_addr(mvi, phy_id, VSR_PHY_STAT);
77
 
                tmp = mvs_read_port_vsr_data(mvi, phy_id);
 
297
                tmp = mvs_read_phy_ctl(mvi, phy_id);
78
298
                tmp |= PHY_RST;
79
 
                mvs_write_port_vsr_data(mvi, phy_id, tmp);
 
299
                mvs_write_phy_ctl(mvi, phy_id, tmp);
80
300
        }
81
301
}
82
302
 
90
310
 
91
311
static void mvs_94xx_phy_enable(struct mvs_info *mvi, u32 phy_id)
92
312
{
93
 
        mvs_write_port_vsr_addr(mvi, phy_id, 0x1B4);
94
 
        mvs_write_port_vsr_data(mvi, phy_id, 0x8300ffc1);
95
 
        mvs_write_port_vsr_addr(mvi, phy_id, 0x104);
96
 
        mvs_write_port_vsr_data(mvi, phy_id, 0x00018080);
 
313
        u32 tmp;
 
314
        u8 revision = 0;
 
315
 
 
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);
 
320
        }
 
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);
 
326
        }
 
327
 
97
328
        mvs_write_port_vsr_addr(mvi, phy_id, VSR_PHY_MODE2);
98
 
        mvs_write_port_vsr_data(mvi, phy_id, 0x00207fff);
 
329
        tmp = mvs_read_port_vsr_data(mvi, phy_id);
 
330
        tmp |= bit(0);
 
331
        mvs_write_port_vsr_data(mvi, phy_id, tmp & 0xfd7fffff);
99
332
}
100
333
 
101
334
static int __devinit mvs_94xx_init(struct mvs_info *mvi)
103
336
        void __iomem *regs = mvi->regs;
104
337
        int i;
105
338
        u32 tmp, cctl;
 
339
        u8 revision;
106
340
 
 
341
        revision = mvi->pdev->revision;
107
342
        mvs_show_pcie_usage(mvi);
108
343
        if (mvi->flags & MVF_FLAG_SOC) {
109
344
                tmp = mr32(MVS_PHY_CTL);
133
368
                msleep(100);
134
369
        }
135
370
 
 
371
        /* disable Multiplexing, enable phy implemented */
 
372
        mw32(MVS_PORTS_IMP, 0xFF);
 
373
 
 
374
        if (revision == VANIR_A0_REV) {
 
375
                mw32(MVS_PA_VSR_ADDR, CMD_CMWK_OOB_DET);
 
376
                mw32(MVS_PA_VSR_PORT, 0x00018080);
 
377
        }
 
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);
 
382
        else
 
383
                /* set 6G/3G/1.5G, multiplexing, with and without SSC */
 
384
                mw32(MVS_PA_VSR_PORT, 0x0084fffe);
 
385
 
 
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);
 
391
        }
 
392
 
136
393
        /* reset control */
137
394
        mw32(MVS_PCS, 0);               /* MVS_PCS */
138
395
        mw32(MVS_STP_REG_SET_0, 0);
141
398
        /* init phys */
142
399
        mvs_phy_hacks(mvi);
143
400
 
144
 
        /* disable Multiplexing, enable phy implemented */
145
 
        mw32(MVS_PORTS_IMP, 0xFF);
146
 
 
147
 
 
148
 
        mw32(MVS_PA_VSR_ADDR, 0x00000104);
149
 
        mw32(MVS_PA_VSR_PORT, 0x00018080);
150
 
        mw32(MVS_PA_VSR_ADDR, VSR_PHY_MODE8);
151
 
        mw32(MVS_PA_VSR_PORT, 0x0084ffff);
 
401
        /* disable non data frame retry */
 
402
        tmp = mvs_cr32(mvi, CMD_SAS_CTL1);
 
403
        if ((revision == VANIR_A0_REV) ||
 
404
                (revision == VANIR_B0_REV) ||
 
405
                (revision == VANIR_C0_REV)) {
 
406
                tmp &= ~0xffff;
 
407
                tmp |= 0x007f;
 
408
                mvs_cw32(mvi, CMD_SAS_CTL1, tmp);
 
409
        }
152
410
 
153
411
        /* set LED blink when IO*/
154
 
        mw32(MVS_PA_VSR_ADDR, 0x00000030);
 
412
        mw32(MVS_PA_VSR_ADDR, VSR_PHY_ACT_LED);
155
413
        tmp = mr32(MVS_PA_VSR_PORT);
156
414
        tmp &= 0xFFFF00FF;
157
415
        tmp |= 0x00003300;
175
433
                mvs_94xx_phy_disable(mvi, i);
176
434
                /* set phy local SAS address */
177
435
                mvs_set_sas_addr(mvi, i, CONFIG_ID_FRAME3, CONFIG_ID_FRAME4,
178
 
                                                (mvi->phy[i].dev_sas_addr));
 
436
                                                cpu_to_le64(mvi->phy[i].dev_sas_addr));
179
437
 
180
438
                mvs_94xx_enable_xmt(mvi, i);
 
439
                mvs_94xx_config_reg_from_hba(mvi, i);
181
440
                mvs_94xx_phy_enable(mvi, i);
182
441
 
183
 
                mvs_94xx_phy_reset(mvi, i, 1);
 
442
                mvs_94xx_phy_reset(mvi, i, PHY_RST_HARD);
184
443
                msleep(500);
185
444
                mvs_94xx_detect_porttype(mvi, i);
186
445
        }
211
470
                mvs_update_phyinfo(mvi, i, 1);
212
471
        }
213
472
 
214
 
        /* FIXME: update wide port bitmaps */
215
 
 
216
473
        /* little endian for open address and command table, etc. */
217
 
        /*
218
 
         * it seems that ( from the spec ) turning on big-endian won't
219
 
         * do us any good on big-endian machines, need further confirmation
220
 
         */
221
474
        cctl = mr32(MVS_CTL);
222
475
        cctl |= CCTL_ENDIAN_CMD;
223
 
        cctl |= CCTL_ENDIAN_DATA;
224
476
        cctl &= ~CCTL_ENDIAN_OPEN;
225
477
        cctl |= CCTL_ENDIAN_RSP;
226
478
        mw32_f(MVS_CTL, cctl);
228
480
        /* reset CMD queue */
229
481
        tmp = mr32(MVS_PCS);
230
482
        tmp |= PCS_CMD_RST;
 
483
        tmp &= ~PCS_SELF_CLEAR;
231
484
        mw32(MVS_PCS, tmp);
232
 
        /* interrupt coalescing may cause missing HW interrput in some case,
233
 
         * and the max count is 0x1ff, while our max slot is 0x200,
 
485
        /*
 
486
         * the max count is 0x1ff, while our max slot is 0x200,
234
487
         * it will make count 0.
235
488
         */
236
489
        tmp = 0;
237
 
        mw32(MVS_INT_COAL, tmp);
 
490
        if (MVS_CHIP_SLOT_SZ > 0x1ff)
 
491
                mw32(MVS_INT_COAL, 0x1ff | COAL_EN);
 
492
        else
 
493
                mw32(MVS_INT_COAL, MVS_CHIP_SLOT_SZ | COAL_EN);
238
494
 
239
 
        tmp = 0x100;
 
495
        /* default interrupt coalescing time is 128us */
 
496
        tmp = 0x10000 | interrupt_coalescing;
240
497
        mw32(MVS_INT_COAL_TMOUT, tmp);
241
498
 
242
499
        /* ladies and gentlemen, start your engines */
249
506
 
250
507
        /* enable completion queue interrupt */
251
508
        tmp = (CINT_PORT_MASK | CINT_DONE | CINT_MEM | CINT_SRS | CINT_CI_STOP |
252
 
                CINT_DMA_PCIE);
 
509
                CINT_DMA_PCIE | CINT_NON_SPEC_NCQ_ERROR);
253
510
        tmp |= CINT_PHY_MASK;
254
511
        mw32(MVS_INT_MASK, tmp);
255
512
 
 
513
        tmp = mvs_cr32(mvi, CMD_LINK_TIMER);
 
514
        tmp |= 0xFFFF0000;
 
515
        mvs_cw32(mvi, CMD_LINK_TIMER, tmp);
 
516
 
 
517
        /* tune STP performance */
 
518
        tmp = 0x003F003F;
 
519
        mvs_cw32(mvi, CMD_PL_TIMER, tmp);
 
520
 
 
521
        /* This can improve expander large block size seq write performance */
 
522
        tmp = mvs_cr32(mvi, CMD_PORT_LAYER_TIMER1);
 
523
        tmp |= 0xFFFF007F;
 
524
        mvs_cw32(mvi, CMD_PORT_LAYER_TIMER1, tmp);
 
525
 
 
526
        /* change the connection open-close behavior (bit 9)
 
527
         * set bit8 to 1 for performance tuning */
 
528
        tmp = mvs_cr32(mvi, CMD_SL_MODE0);
 
529
        tmp |= 0x00000300;
 
530
        /* set bit0 to 0 to enable retry for no_dest reject case */
 
531
        tmp &= 0xFFFFFFFE;
 
532
        mvs_cw32(mvi, CMD_SL_MODE0, tmp);
 
533
 
256
534
        /* Enable SRS interrupt */
257
535
        mw32(MVS_INT_MASK_SRS_0, 0xFFFF);
258
536
 
332
610
        if (((stat & IRQ_SAS_A) && mvi->id == 0) ||
333
611
                        ((stat & IRQ_SAS_B) && mvi->id == 1)) {
334
612
                mw32_f(MVS_INT_STAT, CINT_DONE);
335
 
        #ifndef MVS_USE_TASKLET
 
613
 
336
614
                spin_lock(&mvi->lock);
337
 
        #endif
338
615
                mvs_int_full(mvi);
339
 
        #ifndef MVS_USE_TASKLET
340
616
                spin_unlock(&mvi->lock);
341
 
        #endif
342
617
        }
343
618
        return IRQ_HANDLED;
344
619
}
346
621
static void mvs_94xx_command_active(struct mvs_info *mvi, u32 slot_idx)
347
622
{
348
623
        u32 tmp;
349
 
        mvs_cw32(mvi, 0x300 + (slot_idx >> 3), 1 << (slot_idx % 32));
350
 
        do {
351
 
                tmp = mvs_cr32(mvi, 0x300 + (slot_idx >> 3));
352
 
        } while (tmp & 1 << (slot_idx % 32));
 
624
        tmp = mvs_cr32(mvi, MVS_COMMAND_ACTIVE+(slot_idx >> 3));
 
625
        if (tmp && 1 << (slot_idx % 32)) {
 
626
                mv_printk("command active %08X,  slot [%x].\n", tmp, slot_idx);
 
627
                mvs_cw32(mvi, MVS_COMMAND_ACTIVE + (slot_idx >> 3),
 
628
                        1 << (slot_idx % 32));
 
629
                do {
 
630
                        tmp = mvs_cr32(mvi,
 
631
                                MVS_COMMAND_ACTIVE + (slot_idx >> 3));
 
632
                } while (tmp & 1 << (slot_idx % 32));
 
633
        }
 
634
}
 
635
 
 
636
void mvs_94xx_clear_srs_irq(struct mvs_info *mvi, u8 reg_set, u8 clear_all)
 
637
{
 
638
        void __iomem *regs = mvi->regs;
 
639
        u32 tmp;
 
640
 
 
641
        if (clear_all) {
 
642
                tmp = mr32(MVS_INT_STAT_SRS_0);
 
643
                if (tmp) {
 
644
                        mv_dprintk("check SRS 0 %08X.\n", tmp);
 
645
                        mw32(MVS_INT_STAT_SRS_0, tmp);
 
646
                }
 
647
                tmp = mr32(MVS_INT_STAT_SRS_1);
 
648
                if (tmp) {
 
649
                        mv_dprintk("check SRS 1 %08X.\n", tmp);
 
650
                        mw32(MVS_INT_STAT_SRS_1, tmp);
 
651
                }
 
652
        } else {
 
653
                if (reg_set > 31)
 
654
                        tmp = mr32(MVS_INT_STAT_SRS_1);
 
655
                else
 
656
                        tmp = mr32(MVS_INT_STAT_SRS_0);
 
657
 
 
658
                if (tmp & (1 << (reg_set % 32))) {
 
659
                        mv_dprintk("register set 0x%x was stopped.\n", reg_set);
 
660
                        if (reg_set > 31)
 
661
                                mw32(MVS_INT_STAT_SRS_1, 1 << (reg_set % 32));
 
662
                        else
 
663
                                mw32(MVS_INT_STAT_SRS_0, 1 << (reg_set % 32));
 
664
                }
 
665
        }
353
666
}
354
667
 
355
668
static void mvs_94xx_issue_stop(struct mvs_info *mvi, enum mvs_port_type type,
357
670
{
358
671
        void __iomem *regs = mvi->regs;
359
672
        u32 tmp;
 
673
        mvs_94xx_clear_srs_irq(mvi, 0, 1);
360
674
 
361
 
        if (type == PORT_TYPE_SATA) {
362
 
                tmp = mr32(MVS_INT_STAT_SRS_0) | (1U << tfs);
363
 
                mw32(MVS_INT_STAT_SRS_0, tmp);
364
 
        }
365
 
        mw32(MVS_INT_STAT, CINT_CI_STOP);
 
675
        tmp = mr32(MVS_INT_STAT);
 
676
        mw32(MVS_INT_STAT, tmp | CINT_CI_STOP);
366
677
        tmp = mr32(MVS_PCS) | 0xFF00;
367
678
        mw32(MVS_PCS, tmp);
368
679
}
369
680
 
 
681
static void mvs_94xx_non_spec_ncq_error(struct mvs_info *mvi)
 
682
{
 
683
        void __iomem *regs = mvi->regs;
 
684
        u32 err_0, err_1;
 
685
        u8 i;
 
686
        struct mvs_device *device;
 
687
 
 
688
        err_0 = mr32(MVS_NON_NCQ_ERR_0);
 
689
        err_1 = mr32(MVS_NON_NCQ_ERR_1);
 
690
 
 
691
        mv_dprintk("non specific ncq error err_0:%x,err_1:%x.\n",
 
692
                        err_0, err_1);
 
693
        for (i = 0; i < 32; i++) {
 
694
                if (err_0 & bit(i)) {
 
695
                        device = mvs_find_dev_by_reg_set(mvi, i);
 
696
                        if (device)
 
697
                                mvs_release_task(mvi, device->sas_device);
 
698
                }
 
699
                if (err_1 & bit(i)) {
 
700
                        device = mvs_find_dev_by_reg_set(mvi, i+32);
 
701
                        if (device)
 
702
                                mvs_release_task(mvi, device->sas_device);
 
703
                }
 
704
        }
 
705
 
 
706
        mw32(MVS_NON_NCQ_ERR_0, err_0);
 
707
        mw32(MVS_NON_NCQ_ERR_1, err_1);
 
708
}
 
709
 
370
710
static void mvs_94xx_free_reg_set(struct mvs_info *mvi, u8 *tfs)
371
711
{
372
712
        void __iomem *regs = mvi->regs;
373
 
        u32 tmp;
374
713
        u8 reg_set = *tfs;
375
714
 
376
715
        if (*tfs == MVS_ID_NOT_MAPPED)
377
716
                return;
378
717
 
379
718
        mvi->sata_reg_set &= ~bit(reg_set);
380
 
        if (reg_set < 32) {
 
719
        if (reg_set < 32)
381
720
                w_reg_set_enable(reg_set, (u32)mvi->sata_reg_set);
382
 
                tmp = mr32(MVS_INT_STAT_SRS_0) & (u32)mvi->sata_reg_set;
383
 
                if (tmp)
384
 
                        mw32(MVS_INT_STAT_SRS_0, tmp);
385
 
        } else {
386
 
                w_reg_set_enable(reg_set, mvi->sata_reg_set);
387
 
                tmp = mr32(MVS_INT_STAT_SRS_1) & mvi->sata_reg_set;
388
 
                if (tmp)
389
 
                        mw32(MVS_INT_STAT_SRS_1, tmp);
390
 
        }
 
721
        else
 
722
                w_reg_set_enable(reg_set, (u32)(mvi->sata_reg_set >> 32));
391
723
 
392
724
        *tfs = MVS_ID_NOT_MAPPED;
393
725
 
403
735
                return 0;
404
736
 
405
737
        i = mv_ffc64(mvi->sata_reg_set);
406
 
        if (i > 32) {
 
738
        if (i >= 32) {
407
739
                mvi->sata_reg_set |= bit(i);
408
740
                w_reg_set_enable(i, (u32)(mvi->sata_reg_set >> 32));
409
741
                *tfs = i;
422
754
        int i;
423
755
        struct scatterlist *sg;
424
756
        struct mvs_prd *buf_prd = prd;
 
757
        struct mvs_prd_imt im_len;
 
758
        *(u32 *)&im_len = 0;
425
759
        for_each_sg(scatter, sg, nr, i) {
426
760
                buf_prd->addr = cpu_to_le64(sg_dma_address(sg));
427
 
                buf_prd->im_len.len = cpu_to_le32(sg_dma_len(sg));
 
761
                im_len.len = sg_dma_len(sg);
 
762
                buf_prd->im_len = cpu_to_le32(*(u32 *)&im_len);
428
763
                buf_prd++;
429
764
        }
430
765
}
433
768
{
434
769
        u32 phy_st;
435
770
        phy_st = mvs_read_phy_ctl(mvi, i);
436
 
        if (phy_st & PHY_READY_MASK)    /* phy ready */
 
771
        if (phy_st & PHY_READY_MASK)
437
772
                return 1;
438
773
        return 0;
439
774
}
447
782
        for (i = 0; i < 7; i++) {
448
783
                mvs_write_port_cfg_addr(mvi, port_id,
449
784
                                        CONFIG_ID_FRAME0 + i * 4);
450
 
                id_frame[i] = mvs_read_port_cfg_data(mvi, port_id);
 
785
                id_frame[i] = cpu_to_le32(mvs_read_port_cfg_data(mvi, port_id));
451
786
        }
452
787
        memcpy(id, id_frame, 28);
453
788
}
458
793
        int i;
459
794
        u32 id_frame[7];
460
795
 
461
 
        /* mvs_hexdump(28, (u8 *)id_frame, 0); */
462
796
        for (i = 0; i < 7; i++) {
463
797
                mvs_write_port_cfg_addr(mvi, port_id,
464
798
                                        CONFIG_ATT_ID_FRAME0 + i * 4);
465
 
                id_frame[i] = mvs_read_port_cfg_data(mvi, port_id);
 
799
                id_frame[i] = cpu_to_le32(mvs_read_port_cfg_data(mvi, port_id));
466
800
                mv_dprintk("94xx phy %d atta frame %d %x.\n",
467
801
                        port_id + mvi->id * mvi->chip->n_phy, i, id_frame[i]);
468
802
        }
469
 
        /* mvs_hexdump(28, (u8 *)id_frame, 0); */
470
803
        memcpy(id, id_frame, 28);
471
804
}
472
805
 
521
854
                phy->att_dev_info = PORT_DEV_STP_TRGT | 1;
522
855
        }
523
856
 
 
857
        /* enable spin up bit */
 
858
        mvs_write_port_cfg_addr(mvi, i, PHYR_PHY_STAT);
 
859
        mvs_write_port_cfg_data(mvi, i, 0x04);
 
860
 
524
861
}
525
862
 
526
863
void mvs_94xx_phy_set_link_rate(struct mvs_info *mvi, u32 phy_id,
527
864
                        struct sas_phy_linkrates *rates)
528
865
{
529
 
        /* TODO */
 
866
        u32 lrmax = 0;
 
867
        u32 tmp;
 
868
 
 
869
        tmp = mvs_read_phy_ctl(mvi, phy_id);
 
870
        lrmax = (rates->maximum_linkrate - SAS_LINK_RATE_1_5_GBPS) << 12;
 
871
 
 
872
        if (lrmax) {
 
873
                tmp &= ~(0x3 << 12);
 
874
                tmp |= lrmax;
 
875
        }
 
876
        mvs_write_phy_ctl(mvi, phy_id, tmp);
 
877
        mvs_94xx_phy_reset(mvi, phy_id, PHY_RST_HARD);
530
878
}
531
879
 
532
880
static void mvs_94xx_clear_active_cmds(struct mvs_info *mvi)
603
951
        return -1;
604
952
}
605
953
 
606
 
#ifndef DISABLE_HOTPLUG_DMA_FIX
607
 
void mvs_94xx_fix_dma(dma_addr_t buf_dma, int buf_len, int from, void *prd)
 
954
void mvs_94xx_fix_dma(struct mvs_info *mvi, u32 phy_mask,
 
955
                                int buf_len, int from, void *prd)
608
956
{
609
957
        int i;
610
958
        struct mvs_prd *buf_prd = prd;
 
959
        dma_addr_t buf_dma;
 
960
        struct mvs_prd_imt im_len;
 
961
 
 
962
        *(u32 *)&im_len = 0;
611
963
        buf_prd += from;
612
 
        for (i = 0; i < MAX_SG_ENTRY - from; i++) {
613
 
                buf_prd->addr = cpu_to_le64(buf_dma);
614
 
                buf_prd->im_len.len = cpu_to_le32(buf_len);
615
 
                ++buf_prd;
 
964
 
 
965
#define PRD_CHAINED_ENTRY 0x01
 
966
        if ((mvi->pdev->revision == VANIR_A0_REV) ||
 
967
                        (mvi->pdev->revision == VANIR_B0_REV))
 
968
                buf_dma = (phy_mask <= 0x08) ?
 
969
                                mvi->bulk_buffer_dma : mvi->bulk_buffer_dma1;
 
970
        else
 
971
                return;
 
972
 
 
973
        for (i = from; i < MAX_SG_ENTRY; i++, ++buf_prd) {
 
974
                if (i == MAX_SG_ENTRY - 1) {
 
975
                        buf_prd->addr = cpu_to_le64(virt_to_phys(buf_prd - 1));
 
976
                        im_len.len = 2;
 
977
                        im_len.misc_ctl = PRD_CHAINED_ENTRY;
 
978
                } else {
 
979
                        buf_prd->addr = cpu_to_le64(buf_dma);
 
980
                        im_len.len = buf_len;
 
981
                }
 
982
                buf_prd->im_len = cpu_to_le32(*(u32 *)&im_len);
616
983
        }
617
984
}
618
 
#endif
619
985
 
620
 
/*
621
 
 * FIXME JEJB: temporary nop clear_srs_irq to make 94xx still work
622
 
 * with 64xx fixes
623
 
 */
624
 
static void mvs_94xx_clear_srs_irq(struct mvs_info *mvi, u8 reg_set,
625
 
                                   u8 clear_all)
 
986
static void mvs_94xx_tune_interrupt(struct mvs_info *mvi, u32 time)
626
987
{
 
988
        void __iomem *regs = mvi->regs;
 
989
        u32 tmp = 0;
 
990
        /*
 
991
         * the max count is 0x1ff, while our max slot is 0x200,
 
992
         * it will make count 0.
 
993
         */
 
994
        if (time == 0) {
 
995
                mw32(MVS_INT_COAL, 0);
 
996
                mw32(MVS_INT_COAL_TMOUT, 0x10000);
 
997
        } else {
 
998
                if (MVS_CHIP_SLOT_SZ > 0x1ff)
 
999
                        mw32(MVS_INT_COAL, 0x1ff|COAL_EN);
 
1000
                else
 
1001
                        mw32(MVS_INT_COAL, MVS_CHIP_SLOT_SZ|COAL_EN);
 
1002
 
 
1003
                tmp = 0x10000 | time;
 
1004
                mw32(MVS_INT_COAL_TMOUT, tmp);
 
1005
        }
 
1006
 
627
1007
}
628
1008
 
629
1009
const struct mvs_dispatch mvs_94xx_dispatch = {
648
1028
        mvs_write_port_irq_stat,
649
1029
        mvs_read_port_irq_mask,
650
1030
        mvs_write_port_irq_mask,
651
 
        mvs_get_sas_addr,
652
1031
        mvs_94xx_command_active,
653
1032
        mvs_94xx_clear_srs_irq,
654
1033
        mvs_94xx_issue_stop,
676
1055
        mvs_94xx_spi_buildcmd,
677
1056
        mvs_94xx_spi_issuecmd,
678
1057
        mvs_94xx_spi_waitdataready,
679
 
#ifndef DISABLE_HOTPLUG_DMA_FIX
680
1058
        mvs_94xx_fix_dma,
681
 
#endif
 
1059
        mvs_94xx_tune_interrupt,
 
1060
        mvs_94xx_non_spec_ncq_error,
682
1061
};
683
1062