← Back to branch summary

~ubuntu-branches/ubuntu/wily/linux-ti-omap4/wily

« back to all changes in this revision

Viewing changes to ubuntu/alx/alx_hw.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati, Ubuntu: 3.5.0-25.38
  • Date: 2013-02-20 22:03:31 UTC
  • mfrom: (74.1.1 quantal-proposed)
  • Revision ID: package-import@ubuntu.com-20130220220331-0ea4l33x3cr61nch
Tags: 3.5.0-220.28
https://launchpad.net/bugs/1130311
https://launchpad.net/bugs/1129472
https://launchpad.net/bugs/1119885
https://launchpad.net/bugs/1129192
https://launchpad.net/bugs/1119885
https://launchpad.net/bugs/1129192
https://launchpad.net/bugs/1119885
https://launchpad.net/bugs/1129192
* Release Tracking Bug
  - LP: #1130311

[ Paolo Pisati ]

* rebased on Ubuntu-3.5.0-25.38

[ Ubuntu: 3.5.0-25.38 ]

* Release Tracking Bug
  - LP: #1129472
* ptrace: introduce signal_wake_up_state() and ptrace_signal_wake_up()
  - LP: #1119885, #1129192
  - CVE-2013-0871
* ptrace: ensure arch_ptrace/ptrace_request can never race with SIGKILL
  - LP: #1119885, #1129192
  - CVE-2013-0871
* wake_up_process() should be never used to wakeup a TASK_STOPPED/TRACED
  task
  - LP: #1119885, #1129192
  - CVE-2013-0871

Show diffs side-by-side

added added

removed removed

Lines of Context:
ubuntu/alx/alx_hw.c
 
1
/*
 
2
 * Copyright (c) 2012 Qualcomm Atheros, Inc.
 
3
 *
 
4
 * Permission to use, copy, modify, and/or distribute this software for any
 
5
 * purpose with or without fee is hereby granted, provided that the above
 
6
 * copyright notice and this permission notice appear in all copies.
 
7
 *
 
8
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 
9
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 
10
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 
11
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 
12
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 
13
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 
14
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
15
 */
 
16
#include <linux/pci.h>
 
17
#include <linux/crc32.h>
 
18
#include <linux/etherdevice.h>
 
19
#include <linux/mdio.h>
 
20
 
 
21
#include "alx_reg.h"
 
22
#include "alx_hw.h"
 
23
 
 
24
#define ALX_REV_A(_r) ((_r) == ALX_REV_A0 || (_r) == ALX_REV_A1)
 
25
 
 
26
/* get permanent mac address from */
 
27
int alx_get_perm_macaddr(struct alx_hw *hw, u8 *addr)
 
28
{
 
29
        u32 val, mac0, mac1;
 
30
        u16 flag, i;
 
31
 
 
32
#define INTN_LOADED 0x1
 
33
#define EXTN_LOADED 0x2
 
34
 
 
35
        flag = 0;
 
36
        val = 0;
 
37
 
 
38
read_mcadr:
 
39
 
 
40
        /* get it from register first */
 
41
        ALX_MEM_R32(hw, ALX_STAD0, &mac0);
 
42
        ALX_MEM_R32(hw, ALX_STAD1, &mac1);
 
43
 
 
44
        /* addr should be big-endian */
 
45
        *(__be32 *)(addr + 2) = cpu_to_be32(mac0);
 
46
        *(__be16 *)addr = cpu_to_be16((u16)mac1);
 
47
 
 
48
        if (is_valid_ether_addr(addr))
 
49
                return 0;
 
50
 
 
51
        if ((flag & INTN_LOADED) == 0) {
 
52
                /* load from efuse ? */
 
53
                for (i = 0; i < ALX_SLD_MAX_TO; i++) {
 
54
                        ALX_MEM_R32(hw, ALX_SLD, &val);
 
55
                        if ((val & (ALX_SLD_STAT | ALX_SLD_START)) == 0)
 
56
                                break;
 
57
                        mdelay(1);
 
58
                }
 
59
                if (i == ALX_SLD_MAX_TO)
 
60
                        goto out;
 
61
                ALX_MEM_W32(hw, ALX_SLD, val | ALX_SLD_START);
 
62
                for (i = 0; i < ALX_SLD_MAX_TO; i++) {
 
63
                        mdelay(1);
 
64
                        ALX_MEM_R32(hw, ALX_SLD, &val);
 
65
                        if ((val & ALX_SLD_START) == 0)
 
66
                                break;
 
67
                }
 
68
                if (i == ALX_SLD_MAX_TO)
 
69
                        goto out;
 
70
                flag |= INTN_LOADED;
 
71
                goto read_mcadr;
 
72
        }
 
73
 
 
74
        if ((flag & EXTN_LOADED) == 0) {
 
75
                ALX_MEM_R32(hw, ALX_EFLD, &val);
 
76
                if ((val & (ALX_EFLD_F_EXIST | ALX_EFLD_E_EXIST)) != 0) {
 
77
                        /* load from eeprom/flash ? */
 
78
                        for (i = 0; i < ALX_SLD_MAX_TO; i++) {
 
79
                                ALX_MEM_R32(hw, ALX_EFLD, &val);
 
80
                                if ((val & (ALX_EFLD_STAT |
 
81
                                            ALX_EFLD_START)) == 0) {
 
82
                                        break;
 
83
                                }
 
84
                                mdelay(1);
 
85
                        }
 
86
                        if (i == ALX_SLD_MAX_TO)
 
87
                                goto out;
 
88
                        ALX_MEM_W32(hw, ALX_EFLD, val | ALX_EFLD_START);
 
89
                        for (i = 0; i < ALX_SLD_MAX_TO; i++) {
 
90
                                mdelay(1);
 
91
                                ALX_MEM_R32(hw, ALX_EFLD, &val);
 
92
                                if ((val & ALX_EFLD_START) == 0)
 
93
                                        break;
 
94
                        }
 
95
                        if (i == ALX_SLD_MAX_TO)
 
96
                                goto out;
 
97
                        flag |= EXTN_LOADED;
 
98
                        goto read_mcadr;
 
99
                }
 
100
        }
 
101
 
 
102
out:
 
103
        return ALX_ERR_ALOAD;
 
104
}
 
105
 
 
106
void alx_set_macaddr(struct alx_hw *hw, u8 *addr)
 
107
{
 
108
        u32 val;
 
109
 
 
110
        /* for example: 00-0B-6A-F6-00-DC * STAD0=6AF600DC, STAD1=000B */
 
111
        val = be32_to_cpu(*(__be32 *)(addr + 2));
 
112
        ALX_MEM_W32(hw, ALX_STAD0, val);
 
113
        val = be16_to_cpu(*(__be16 *)addr);
 
114
        ALX_MEM_W32(hw, ALX_STAD1, val);
 
115
}
 
116
 
 
117
void alx_add_mc_addr(struct alx_hw *hw, u8 *addr)
 
118
{
 
119
        u32 crc32, bit, reg;
 
120
 
 
121
        crc32 = ether_crc(ETH_ALEN, addr);
 
122
 
 
123
        /* The HASH Table  is a register array of 2 32-bit registers.
 
124
         * It is treated like an array of 64 bits.  We want to set
 
125
         * bit BitArray[hash_value]. So we figure out what register
 
126
         * the bit is in, read it, OR in the new bit, then write
 
127
         * back the new value.  The register is determined by the
 
128
         * upper 7 bits of the hash value and the bit within that
 
129
         * register are determined by the lower 5 bits of the value.
 
130
         */
 
131
        reg = (crc32 >> 31) & 0x1;
 
132
        bit = (crc32 >> 26) & 0x1F;
 
133
 
 
134
        hw->mc_hash[reg] |= (0x1 << bit);
 
135
}
 
136
 
 
137
void alx_enable_osc(struct alx_hw *hw)
 
138
{
 
139
        u32 val;
 
140
 
 
141
        /* rising edge */
 
142
        ALX_MEM_R32(hw, ALX_MISC, &val);
 
143
        ALX_MEM_W32(hw, ALX_MISC, val & ~ALX_MISC_INTNLOSC_OPEN);
 
144
        ALX_MEM_W32(hw, ALX_MISC, val | ALX_MISC_INTNLOSC_OPEN);
 
145
}
 
146
 
 
147
void alx_reset_osc(struct alx_hw *hw, u8 rev)
 
148
{
 
149
        u32 val, val2;
 
150
 
 
151
        /* clear Internal OSC settings, switching OSC by hw itself */
 
152
        ALX_MEM_R32(hw, ALX_MISC3, &val);
 
153
        ALX_MEM_W32(hw, ALX_MISC3,
 
154
                (val & ~ALX_MISC3_25M_BY_SW) | ALX_MISC3_25M_NOTO_INTNL);
 
155
 
 
156
        /* 25M clk from chipset may be unstable 1s after de-assert of
 
157
         * PERST, driver need re-calibrate before enter Sleep for WoL
 
158
         */
 
159
        ALX_MEM_R32(hw, ALX_MISC, &val);
 
160
        if (rev >= ALX_REV_B0) {
 
161
                /* restore over current protection def-val,
 
162
                 * this val could be reset by MAC-RST
 
163
                 */
 
164
                FIELD_SET32(val, ALX_MISC_PSW_OCP, ALX_MISC_PSW_OCP_DEF);
 
165
                /* a 0->1 change will update the internal val of osc */
 
166
                val &= ~ALX_MISC_INTNLOSC_OPEN;
 
167
                ALX_MEM_W32(hw, ALX_MISC, val);
 
168
                ALX_MEM_W32(hw, ALX_MISC, val | ALX_MISC_INTNLOSC_OPEN);
 
169
                /* hw will automatically dis OSC after cab. */
 
170
                ALX_MEM_R32(hw, ALX_MSIC2, &val2);
 
171
                val2 &= ~ALX_MSIC2_CALB_START;
 
172
                ALX_MEM_W32(hw, ALX_MSIC2, val2);
 
173
                ALX_MEM_W32(hw, ALX_MSIC2, val2 | ALX_MSIC2_CALB_START);
 
174
        } else {
 
175
                val &= ~ALX_MISC_INTNLOSC_OPEN;
 
176
                /* disable isoloate for A0 */
 
177
                if (ALX_REV_A(rev))
 
178
                        val &= ~ALX_MISC_ISO_EN;
 
179
 
 
180
                ALX_MEM_W32(hw, ALX_MISC, val | ALX_MISC_INTNLOSC_OPEN);
 
181
                ALX_MEM_W32(hw, ALX_MISC, val);
 
182
        }
 
183
 
 
184
        udelay(20);
 
185
}
 
186
 
 
187
int alx_reset_mac(struct alx_hw *hw)
 
188
{
 
189
        u32 val, pmctrl;
 
190
        int i, ret;
 
191
        u8 rev;
 
192
        bool a_cr;
 
193
 
 
194
        pmctrl = 0;
 
195
        rev = (u8)ALX_REVID(hw);
 
196
        a_cr = ALX_REV_A(rev) && ALX_WITH_CR(hw);
 
197
 
 
198
        /* disable all interrupts, RXQ/TXQ */
 
199
        ALX_MEM_W32(hw, ALX_MSIX_MASK, 0xFFFFFFFF);
 
200
        ALX_MEM_W32(hw, ALX_IMR, 0);
 
201
        ALX_MEM_W32(hw, ALX_ISR, ALX_ISR_DIS);
 
202
 
 
203
        ret = alx_stop_mac(hw);
 
204
        if (ret)
 
205
                return ret;
 
206
 
 
207
        /* mac reset workaroud */
 
208
        ALX_MEM_W32(hw, ALX_RFD_PIDX, 1);
 
209
 
 
210
        /* dis l0s/l1 before mac reset */
 
211
        if (a_cr) {
 
212
                ALX_MEM_R32(hw, ALX_PMCTRL, &pmctrl);
 
213
                if ((pmctrl & (ALX_PMCTRL_L1_EN | ALX_PMCTRL_L0S_EN)) != 0) {
 
214
                        ALX_MEM_W32(hw, ALX_PMCTRL,
 
215
                                    pmctrl & ~(ALX_PMCTRL_L1_EN |
 
216
                                               ALX_PMCTRL_L0S_EN));
 
217
                }
 
218
        }
 
219
 
 
220
        /* reset whole mac safely */
 
221
        ALX_MEM_R32(hw, ALX_MASTER, &val);
 
222
        ALX_MEM_W32(hw, ALX_MASTER,
 
223
                    val | ALX_MASTER_DMA_MAC_RST | ALX_MASTER_OOB_DIS);
 
224
 
 
225
        /* make sure it's real idle */
 
226
        udelay(10);
 
227
        for (i = 0; i < ALX_DMA_MAC_RST_TO; i++) {
 
228
                ALX_MEM_R32(hw, ALX_RFD_PIDX, &val);
 
229
                if (val == 0)
 
230
                        break;
 
231
                udelay(10);
 
232
        }
 
233
        for (; i < ALX_DMA_MAC_RST_TO; i++) {
 
234
                ALX_MEM_R32(hw, ALX_MASTER, &val);
 
235
                if ((val & ALX_MASTER_DMA_MAC_RST) == 0)
 
236
                        break;
 
237
                udelay(10);
 
238
        }
 
239
        if (i == ALX_DMA_MAC_RST_TO)
 
240
                return ALX_ERR_RSTMAC;
 
241
        udelay(10);
 
242
 
 
243
        if (a_cr) {
 
244
                /* set ALX_MASTER_PCLKSEL_SRDS (affect by soft-rst, PERST) */
 
245
                ALX_MEM_W32(hw, ALX_MASTER, val | ALX_MASTER_PCLKSEL_SRDS);
 
246
                /* resoter l0s / l1 */
 
247
                if (pmctrl & (ALX_PMCTRL_L1_EN | ALX_PMCTRL_L0S_EN))
 
248
                        ALX_MEM_W32(hw, ALX_PMCTRL, pmctrl);
 
249
        }
 
250
 
 
251
        alx_reset_osc(hw, rev);
 
252
        /* clear Internal OSC settings, switching OSC by hw itself,
 
253
         * disable isoloate for A version
 
254
         */
 
255
        ALX_MEM_R32(hw, ALX_MISC3, &val);
 
256
        ALX_MEM_W32(hw, ALX_MISC3,
 
257
                    (val & ~ALX_MISC3_25M_BY_SW) | ALX_MISC3_25M_NOTO_INTNL);
 
258
        ALX_MEM_R32(hw, ALX_MISC, &val);
 
259
        val &= ~ALX_MISC_INTNLOSC_OPEN;
 
260
        if (ALX_REV_A(rev))
 
261
                val &= ~ALX_MISC_ISO_EN;
 
262
        ALX_MEM_W32(hw, ALX_MISC, val);
 
263
        udelay(20);
 
264
 
 
265
        /* driver control speed/duplex, hash-alg */
 
266
        ALX_MEM_W32(hw, ALX_MAC_CTRL, hw->rx_ctrl);
 
267
 
 
268
        /* clk sw */
 
269
        ALX_MEM_R32(hw, ALX_SERDES, &val);
 
270
        ALX_MEM_W32(hw, ALX_SERDES,
 
271
                val | ALX_SERDES_MACCLK_SLWDWN | ALX_SERDES_PHYCLK_SLWDWN);
 
272
 
 
273
        /* mac reset cause MDIO ctrl restore non-polling status */
 
274
        if (hw->is_fpga)
 
275
                __alx_start_phy_polling(hw, ALX_MDIO_CLK_SEL_25MD128);
 
276
 
 
277
 
 
278
        return ret;
 
279
}
 
280
 
 
281
/* alx_reset_phy
 
282
 *     completely reset phy, all settings/workaround will be re-configureed
 
283
 *     hib_en: enable/disable hibernation on PHY
 
284
 */
 
285
void alx_reset_phy(struct alx_hw *hw, bool hib_en)
 
286
{
 
287
        int i;
 
288
        u32 val;
 
289
        u16 phy_val;
 
290
 
 
291
        /* (DSP)reset PHY core */
 
292
        ALX_MEM_R32(hw, ALX_PHY_CTRL, &val);
 
293
        val &= ~(ALX_PHY_CTRL_DSPRST_OUT | ALX_PHY_CTRL_IDDQ |
 
294
                 ALX_PHY_CTRL_GATE_25M | ALX_PHY_CTRL_POWER_DOWN |
 
295
                 ALX_PHY_CTRL_CLS);
 
296
        val |= ALX_PHY_CTRL_RST_ANALOG;
 
297
 
 
298
        if (hib_en)
 
299
                val |= (ALX_PHY_CTRL_HIB_PULSE | ALX_PHY_CTRL_HIB_EN);
 
300
        else
 
301
                val &= ~(ALX_PHY_CTRL_HIB_PULSE | ALX_PHY_CTRL_HIB_EN);
 
302
        ALX_MEM_W32(hw, ALX_PHY_CTRL, val);
 
303
        udelay(10);
 
304
        ALX_MEM_W32(hw, ALX_PHY_CTRL, val | ALX_PHY_CTRL_DSPRST_OUT);
 
305
 
 
306
        /* delay 800us */
 
307
        for (i = 0; i < ALX_PHY_CTRL_DSPRST_TO; i++)
 
308
                udelay(10);
 
309
 
 
310
        if (hw->is_fpga)
 
311
                goto set_imr;
 
312
 
 
313
        /* phy power saving & hib */
 
314
        if (hib_en) {
 
315
                alx_write_phy_dbg(hw, ALX_MIIDBG_LEGCYPS, ALX_LEGCYPS_DEF);
 
316
                alx_write_phy_dbg(hw, ALX_MIIDBG_SYSMODCTRL,
 
317
                        ALX_SYSMODCTRL_IECHOADJ_DEF);
 
318
                alx_write_phy_ext(hw, ALX_MIIEXT_PCS, ALX_MIIEXT_VDRVBIAS,
 
319
                        ALX_VDRVBIAS_DEF);
 
320
        } else {
 
321
                alx_write_phy_dbg(hw, ALX_MIIDBG_LEGCYPS,
 
322
                        ALX_LEGCYPS_DEF & ~ALX_LEGCYPS_EN);
 
323
                alx_write_phy_dbg(hw, ALX_MIIDBG_HIBNEG, ALX_HIBNEG_NOHIB);
 
324
                alx_write_phy_dbg(hw, ALX_MIIDBG_GREENCFG, ALX_GREENCFG_DEF);
 
325
        }
 
326
 
 
327
        /* EEE advertisement */
 
328
        if (ALX_CAP(hw, AZ)) {
 
329
                alx_write_phy_ext(hw, ALX_MIIEXT_ANEG,
 
330
                        ALX_MIIEXT_LOCAL_EEEADV,
 
331
                        ALX_CAP(hw, GIGA) ?
 
332
                        ALX_LOCAL_EEEADV_1000BT | ALX_LOCAL_EEEADV_100BT :
 
333
                        ALX_LOCAL_EEEADV_100BT);
 
334
                /* half amplify */
 
335
                alx_write_phy_dbg(hw, ALX_MIIDBG_AZ_ANADECT,
 
336
                        ALX_AZ_ANADECT_DEF);
 
337
        } else {
 
338
                ALX_MEM_R32(hw, ALX_LPI_CTRL, &val);
 
339
                ALX_MEM_W32(hw, ALX_LPI_CTRL, val & ~ALX_LPI_CTRL_EN);
 
340
                alx_write_phy_ext(hw, ALX_MIIEXT_ANEG,
 
341
                        ALX_MIIEXT_LOCAL_EEEADV, 0);
 
342
        }
 
343
 
 
344
        /* phy power saving */
 
345
        alx_write_phy_dbg(hw, ALX_MIIDBG_TST10BTCFG, ALX_TST10BTCFG_DEF);
 
346
        alx_write_phy_dbg(hw, ALX_MIIDBG_SRDSYSMOD, ALX_SRDSYSMOD_DEF);
 
347
        alx_write_phy_dbg(hw, ALX_MIIDBG_TST100BTCFG, ALX_TST100BTCFG_DEF);
 
348
        alx_write_phy_dbg(hw, ALX_MIIDBG_ANACTRL, ALX_ANACTRL_DEF);
 
349
        alx_read_phy_dbg(hw, ALX_MIIDBG_GREENCFG2, &phy_val);
 
350
        alx_write_phy_dbg(hw, ALX_MIIDBG_GREENCFG2,
 
351
                phy_val & ~ALX_GREENCFG2_GATE_DFSE_EN);
 
352
        /* rtl8139c, 120m issue */
 
353
        alx_write_phy_ext(hw, ALX_MIIEXT_ANEG, ALX_MIIEXT_NLP78,
 
354
                ALX_MIIEXT_NLP78_120M_DEF);
 
355
        alx_write_phy_ext(hw, ALX_MIIEXT_ANEG, ALX_MIIEXT_S3DIG10,
 
356
                ALX_MIIEXT_S3DIG10_DEF);
 
357
 
 
358
        if (hw->lnk_patch) {
 
359
                /* Turn off half amplitude */
 
360
                alx_read_phy_ext(hw, ALX_MIIEXT_PCS, ALX_MIIEXT_CLDCTRL3,
 
361
                        &phy_val);
 
362
                alx_write_phy_ext(hw, ALX_MIIEXT_PCS, ALX_MIIEXT_CLDCTRL3,
 
363
                              phy_val | ALX_CLDCTRL3_BP_CABLE1TH_DET_GT);
 
364
                /* Turn off Green feature */
 
365
                alx_read_phy_dbg(hw, ALX_MIIDBG_GREENCFG2, &phy_val);
 
366
                alx_write_phy_dbg(hw, ALX_MIIDBG_GREENCFG2,
 
367
                                 phy_val | ALX_GREENCFG2_BP_GREEN);
 
368
                /* Turn off half Bias */
 
369
                alx_read_phy_ext(hw, ALX_MIIEXT_PCS, ALX_MIIEXT_CLDCTRL5,
 
370
                        &phy_val);
 
371
                alx_write_phy_ext(hw, ALX_MIIEXT_PCS, ALX_MIIEXT_CLDCTRL5,
 
372
                              phy_val | ALX_CLDCTRL5_BP_VD_HLFBIAS);
 
373
        }
 
374
 
 
375
set_imr:
 
376
        /* set phy interrupt mask */
 
377
        alx_write_phy_reg(hw, ALX_MII_IER,
 
378
                ALX_IER_LINK_UP | ALX_IER_LINK_DOWN);
 
379
}
 
380
 
 
381
#define ALX_PCI_CMD     (\
 
382
        PCI_COMMAND_MASTER |\
 
383
        PCI_COMMAND_MEMORY |\
 
384
        PCI_COMMAND_IO)
 
385
/*
 
386
 * alx_reset_pcie
 
387
 *   reset pcie relative registers (pci command, clk, aspm...)
 
388
 */
 
389
void alx_reset_pcie(struct alx_hw *hw)
 
390
{
 
391
        u32 val;
 
392
        u16 val16;
 
393
        u8 rev = (u8)ALX_REVID(hw);
 
394
 
 
395
        /* Workaround for PCI problem when BIOS sets MMRBC incorrectly. */
 
396
        ALX_CFG_R16(hw, PCI_COMMAND, &val16);
 
397
        if (!(val16 & ALX_PCI_CMD) || (val16 & PCI_COMMAND_INTX_DISABLE)) {
 
398
                val16 = (val16 | ALX_PCI_CMD) & ~PCI_COMMAND_INTX_DISABLE;
 
399
                ALX_CFG_W16(hw, PCI_COMMAND, val16);
 
400
        }
 
401
 
 
402
        /* clear WoL setting/status */
 
403
        ALX_MEM_R32(hw, ALX_WOL0, &val);
 
404
        ALX_MEM_W32(hw, ALX_WOL0, 0);
 
405
 
 
406
        /* deflt val of PDLL D3PLLOFF */
 
407
        ALX_MEM_R32(hw, ALX_PDLL_TRNS1, &val);
 
408
        ALX_MEM_W32(hw, ALX_PDLL_TRNS1, val & ~ALX_PDLL_TRNS1_D3PLLOFF_EN);
 
409
 
 
410
        /* mask some pcie error bits */
 
411
        ALX_MEM_R32(hw, ALX_UE_SVRT, &val);
 
412
        val &= ~(ALX_UE_SVRT_DLPROTERR | ALX_UE_SVRT_FCPROTERR);
 
413
        ALX_MEM_W32(hw, ALX_UE_SVRT, val);
 
414
 
 
415
        /* wol 25M  & pclk */
 
416
        ALX_MEM_R32(hw, ALX_MASTER, &val);
 
417
        if (ALX_REV_A(rev) && ALX_WITH_CR(hw)) {
 
418
                if ((val & ALX_MASTER_WAKEN_25M) == 0 ||
 
419
                    (val & ALX_MASTER_PCLKSEL_SRDS) == 0) {
 
420
                        ALX_MEM_W32(hw, ALX_MASTER,
 
421
                                    val | ALX_MASTER_PCLKSEL_SRDS |
 
422
                                    ALX_MASTER_WAKEN_25M);
 
423
                }
 
424
        } else {
 
425
                if ((val & ALX_MASTER_WAKEN_25M) == 0 ||
 
426
                    (val & ALX_MASTER_PCLKSEL_SRDS) != 0) {
 
427
                        ALX_MEM_W32(hw, ALX_MASTER,
 
428
                                    (val & ~ALX_MASTER_PCLKSEL_SRDS) |
 
429
                                    ALX_MASTER_WAKEN_25M);
 
430
                }
 
431
        }
 
432
 
 
433
        /* ASPM setting */
 
434
        alx_enable_aspm(hw, ALX_CAP(hw, L0S), ALX_CAP(hw, L1));
 
435
 
 
436
        udelay(10);
 
437
}
 
438
 
 
439
/* alx_stop_mac
 
440
 *     stop the mac, transmit & receive modules
 
441
 * return : 0 if ok, none-0 if busy
 
442
 */
 
443
int alx_stop_mac(struct alx_hw *hw)
 
444
{
 
445
        u32 rxq, txq, val;
 
446
        u16 i;
 
447
 
 
448
        ALX_MEM_R32(hw, ALX_RXQ0, &rxq);
 
449
        ALX_MEM_W32(hw, ALX_RXQ0, rxq & ~ALX_RXQ0_EN);
 
450
        ALX_MEM_R32(hw, ALX_TXQ0, &txq);
 
451
        ALX_MEM_W32(hw, ALX_TXQ0, txq & ~ALX_TXQ0_EN);
 
452
 
 
453
        udelay(40);
 
454
 
 
455
        hw->rx_ctrl &= ~(ALX_MAC_CTRL_RX_EN | ALX_MAC_CTRL_TX_EN);
 
456
        ALX_MEM_W32(hw, ALX_MAC_CTRL, hw->rx_ctrl);
 
457
 
 
458
        for (i = 0; i < ALX_DMA_MAC_RST_TO; i++) {
 
459
                ALX_MEM_R32(hw, ALX_MAC_STS, &val);
 
460
                if (!(val & ALX_MAC_STS_IDLE))
 
461
                        break;
 
462
                udelay(10);
 
463
        }
 
464
 
 
465
        return (ALX_DMA_MAC_RST_TO == i) ? ALX_ERR_RSTMAC : 0;
 
466
}
 
467
 
 
468
/* alx_start_mac
 
469
 *     enable rx/tx MAC module
 
470
 */
 
471
void alx_start_mac(struct alx_hw *hw)
 
472
{
 
473
        u32 mac, txq, rxq;
 
474
 
 
475
        ALX_MEM_R32(hw, ALX_RXQ0, &rxq);
 
476
        ALX_MEM_W32(hw, ALX_RXQ0, rxq | ALX_RXQ0_EN);
 
477
        ALX_MEM_R32(hw, ALX_TXQ0, &txq);
 
478
        ALX_MEM_W32(hw, ALX_TXQ0, txq | ALX_TXQ0_EN);
 
479
 
 
480
        mac = hw->rx_ctrl;
 
481
        if (hw->link_duplex == FULL_DUPLEX)
 
482
                mac |= ALX_MAC_CTRL_FULLD;
 
483
        else
 
484
                mac &= ~ALX_MAC_CTRL_FULLD;
 
485
        FIELD_SET32(mac, ALX_MAC_CTRL_SPEED, hw->link_speed == SPEED_1000 ?
 
486
                   ALX_MAC_CTRL_SPEED_1000 : ALX_MAC_CTRL_SPEED_10_100);
 
487
        mac |= ALX_MAC_CTRL_TX_EN | ALX_MAC_CTRL_RX_EN;
 
488
        hw->rx_ctrl = mac;
 
489
        ALX_MEM_W32(hw, ALX_MAC_CTRL, mac);
 
490
}
 
491
 
 
492
/* set flow control on MAC side */
 
493
void alx_cfg_mac_fc(struct alx_hw *hw, u8 fc)
 
494
{
 
495
        if (fc & ALX_FC_RX)
 
496
                hw->rx_ctrl |= ALX_MAC_CTRL_RXFC_EN;
 
497
        else
 
498
                hw->rx_ctrl &= ~ALX_MAC_CTRL_RXFC_EN;
 
499
 
 
500
        if (fc & ALX_FC_TX)
 
501
                hw->rx_ctrl |= ALX_MAC_CTRL_TXFC_EN;
 
502
        else
 
503
                hw->rx_ctrl &= ~ALX_MAC_CTRL_TXFC_EN;
 
504
 
 
505
        ALX_MEM_W32(hw, ALX_MAC_CTRL, hw->rx_ctrl);
 
506
}
 
507
 
 
508
/* enable/disable aspm support */
 
509
void alx_enable_aspm(struct alx_hw *hw, bool l0s_en, bool l1_en)
 
510
{
 
511
        u32 pmctrl;
 
512
        u8 rev = (u8)ALX_REVID(hw);
 
513
 
 
514
        ALX_MEM_R32(hw, ALX_PMCTRL, &pmctrl);
 
515
 
 
516
        FIELD_SET32(pmctrl, ALX_PMCTRL_LCKDET_TIMER,
 
517
                   ALX_PMCTRL_LCKDET_TIMER_DEF);
 
518
        pmctrl |= ALX_PMCTRL_RCVR_WT_1US    |
 
519
                  ALX_PMCTRL_L1_CLKSW_EN    |
 
520
                  ALX_PMCTRL_L1_SRDSRX_PWD  ;
 
521
        FIELD_SET32(pmctrl, ALX_PMCTRL_L1REQ_TO, ALX_PMCTRL_L1REG_TO_DEF);
 
522
        FIELD_SET32(pmctrl, ALX_PMCTRL_L1_TIMER, ALX_PMCTRL_L1_TIMER_16US);
 
523
        pmctrl &= ~(ALX_PMCTRL_L1_SRDS_EN |
 
524
                    ALX_PMCTRL_L1_SRDSPLL_EN |
 
525
                    ALX_PMCTRL_L1_BUFSRX_EN |
 
526
                    ALX_PMCTRL_SADLY_EN |
 
527
                    ALX_PMCTRL_HOTRST_WTEN|
 
528
                    ALX_PMCTRL_L0S_EN |
 
529
                    ALX_PMCTRL_L1_EN |
 
530
                    ALX_PMCTRL_ASPM_FCEN |
 
531
                    ALX_PMCTRL_TXL1_AFTER_L0S |
 
532
                    ALX_PMCTRL_RXL1_AFTER_L0S
 
533
                    );
 
534
        if (ALX_REV_A(rev) && ALX_WITH_CR(hw))
 
535
                pmctrl |= ALX_PMCTRL_L1_SRDS_EN | ALX_PMCTRL_L1_SRDSPLL_EN;
 
536
 
 
537
        if (l0s_en)
 
538
                pmctrl |= (ALX_PMCTRL_L0S_EN | ALX_PMCTRL_ASPM_FCEN);
 
539
        if (l1_en)
 
540
                pmctrl |= (ALX_PMCTRL_L1_EN | ALX_PMCTRL_ASPM_FCEN);
 
541
 
 
542
        ALX_MEM_W32(hw, ALX_PMCTRL, pmctrl);
 
543
}
 
544
 
 
545
 
 
546
/* translate ethtool adv /speed/duplex settting to hw specific value */
 
547
u32 ethadv_to_hw_cfg(struct alx_hw *hw, u32 ethadv_cfg)
 
548
{
 
549
        u32 cfg = 0;
 
550
 
 
551
        if (ethadv_cfg & ADVERTISED_Autoneg) {
 
552
                cfg |= ALX_DRV_PHY_AUTO;
 
553
                if (ethadv_cfg & ADVERTISED_10baseT_Half)
 
554
                        cfg |= ALX_DRV_PHY_10;
 
555
                if (ethadv_cfg & ADVERTISED_10baseT_Full)
 
556
                        cfg |= ALX_DRV_PHY_10 | ALX_DRV_PHY_DUPLEX;
 
557
                if (ethadv_cfg & ADVERTISED_100baseT_Half)
 
558
                        cfg |= ALX_DRV_PHY_100;
 
559
                if (ethadv_cfg & ADVERTISED_100baseT_Full)
 
560
                        cfg |= ALX_DRV_PHY_100 | ALX_DRV_PHY_DUPLEX;
 
561
                if (ethadv_cfg & ADVERTISED_1000baseT_Half)
 
562
                        cfg |= ALX_DRV_PHY_1000;
 
563
                if (ethadv_cfg & ADVERTISED_1000baseT_Full)
 
564
                        cfg |= ALX_DRV_PHY_100 | ALX_DRV_PHY_DUPLEX;
 
565
                if (ethadv_cfg & ADVERTISED_Pause)
 
566
                        cfg |= ADVERTISE_PAUSE_CAP;
 
567
                if (ethadv_cfg & ADVERTISED_Asym_Pause)
 
568
                        cfg |= ADVERTISE_PAUSE_ASYM;
 
569
                if (ALX_CAP(hw, AZ))
 
570
                        cfg |= ALX_DRV_PHY_EEE;
 
571
        } else {
 
572
                switch (ethadv_cfg) {
 
573
                case ADVERTISED_10baseT_Half:
 
574
                        cfg |= ALX_DRV_PHY_10;
 
575
                        break;
 
576
                case ADVERTISED_100baseT_Half:
 
577
                        cfg |= ALX_DRV_PHY_100;
 
578
                        break;
 
579
                case ADVERTISED_10baseT_Full:
 
580
                        cfg |= ALX_DRV_PHY_10 | ALX_DRV_PHY_DUPLEX;
 
581
                        break;
 
582
                case ADVERTISED_100baseT_Full:
 
583
                        cfg |= ALX_DRV_PHY_100 | ALX_DRV_PHY_DUPLEX;
 
584
                        break;
 
585
                }
 
586
        }
 
587
 
 
588
        return cfg;
 
589
}
 
590
 
 
591
/* initialize phy for speed / flow control
 
592
 * ethadv:
 
593
 *    format from ethtool, we use it for both autoneg and force mode
 
594
 */
 
595
int alx_setup_speed_duplex(struct alx_hw *hw, u32 ethadv, u8 flowctrl)
 
596
{
 
597
        u16 adv, giga, cr;
 
598
        u32 val;
 
599
        int err = 0;
 
600
 
 
601
        /* clear flag */
 
602
        alx_write_phy_reg(hw, ALX_MII_DBG_ADDR, 0);
 
603
        ALX_MEM_R32(hw, ALX_DRV, &val);
 
604
        FIELD_SET32(val, ALX_DRV_PHY, 0);
 
605
 
 
606
        if (ethadv & ADVERTISED_Autoneg) {
 
607
                adv = ADVERTISE_CSMA;
 
608
                adv |= ethtool_adv_to_mii_adv_t(ethadv);
 
609
 
 
610
                if (flowctrl & ALX_FC_ANEG) {
 
611
                        if (flowctrl & ALX_FC_RX) {
 
612
                                adv |= ADVERTISED_Pause;
 
613
                                if (!(flowctrl & ALX_FC_TX))
 
614
                                        adv |= ADVERTISED_Asym_Pause;
 
615
                        } else if (flowctrl & ALX_FC_TX)
 
616
                                adv |= ADVERTISED_Asym_Pause;
 
617
                }
 
618
                giga = 0;
 
619
                if (ALX_CAP(hw, GIGA))
 
620
                        giga = ethtool_adv_to_mii_ctrl1000_t(ethadv);
 
621
 
 
622
                cr = BMCR_RESET | BMCR_ANENABLE | BMCR_ANRESTART;
 
623
 
 
624
                if (alx_write_phy_reg(hw, MII_ADVERTISE, adv) ||
 
625
                    alx_write_phy_reg(hw, MII_CTRL1000, giga) ||
 
626
                    alx_write_phy_reg(hw, MII_BMCR, cr))
 
627
                        err = ALX_ERR_MIIBUSY;
 
628
        } else {
 
629
                cr = BMCR_RESET;
 
630
                if (ethadv == ADVERTISED_100baseT_Half ||
 
631
                    ethadv == ADVERTISED_100baseT_Full)
 
632
                        cr |= BMCR_SPEED100;
 
633
                if (ethadv == ADVERTISED_10baseT_Full ||
 
634
                    ethadv == ADVERTISED_100baseT_Full)
 
635
                        cr |= BMCR_FULLDPLX;
 
636
 
 
637
                err = alx_write_phy_reg(hw, MII_BMCR, cr);
 
638
        }
 
639
 
 
640
        if (!err) {
 
641
                alx_write_phy_reg(hw, ALX_MII_DBG_ADDR, ALX_PHY_INITED);
 
642
                /* save config to HW */
 
643
                val |= ethadv_to_hw_cfg(hw, ethadv);
 
644
        }
 
645
 
 
646
        ALX_MEM_W32(hw, ALX_DRV, val);
 
647
 
 
648
        return err;
 
649
}
 
650
 
 
651
 
 
652
/* do post setting on phy if link up/down event occur */
 
653
void alx_post_phy_link(struct alx_hw *hw, u16 speed, bool az_en)
 
654
{
 
655
        u16 phy_val, len, agc;
 
656
        u8 revid = (u8)ALX_REVID(hw);
 
657
        bool adj_th;
 
658
 
 
659
        if (revid != ALX_REV_B0 &&
 
660
            revid != ALX_REV_A1 &&
 
661
            revid != ALX_REV_A0) {
 
662
                return;
 
663
        }
 
664
        adj_th = (revid == ALX_REV_B0) ? true : false;
 
665
 
 
666
        /* 1000BT/AZ, wrong cable length */
 
667
        if (speed != SPEED_0) {
 
668
                alx_read_phy_ext(hw, ALX_MIIEXT_PCS, ALX_MIIEXT_CLDCTRL6,
 
669
                                 &phy_val);
 
670
                len = FIELD_GETX(phy_val, ALX_CLDCTRL6_CAB_LEN);
 
671
                alx_read_phy_dbg(hw, ALX_MIIDBG_AGC, &phy_val);
 
672
                agc = FIELD_GETX(phy_val, ALX_AGC_2_VGA);
 
673
 
 
674
                if ((speed == SPEED_1000 &&
 
675
                    (len > ALX_CLDCTRL6_CAB_LEN_SHORT1G ||
 
676
                    (0 == len && agc > ALX_AGC_LONG1G_LIMT))) ||
 
677
                    (speed == SPEED_100 &&
 
678
                    (len > ALX_CLDCTRL6_CAB_LEN_SHORT100M ||
 
679
                    (0 == len && agc > ALX_AGC_LONG100M_LIMT)))) {
 
680
                        alx_write_phy_dbg(hw, ALX_MIIDBG_AZ_ANADECT,
 
681
                                          ALX_AZ_ANADECT_LONG);
 
682
                        alx_read_phy_ext(hw, ALX_MIIEXT_ANEG, ALX_MIIEXT_AFE,
 
683
                                         &phy_val);
 
684
                        alx_write_phy_ext(hw, ALX_MIIEXT_ANEG, ALX_MIIEXT_AFE,
 
685
                                          phy_val | ALX_AFE_10BT_100M_TH);
 
686
                } else {
 
687
                        alx_write_phy_dbg(hw, ALX_MIIDBG_AZ_ANADECT,
 
688
                                          ALX_AZ_ANADECT_DEF);
 
689
                        alx_read_phy_ext(hw, ALX_MIIEXT_ANEG,
 
690
                                         ALX_MIIEXT_AFE, &phy_val);
 
691
                        alx_write_phy_ext(hw, ALX_MIIEXT_ANEG, ALX_MIIEXT_AFE,
 
692
                                          phy_val & ~ALX_AFE_10BT_100M_TH);
 
693
                }
 
694
 
 
695
                /* threashold adjust */
 
696
                if (adj_th && hw->lnk_patch) {
 
697
                        if (speed == SPEED_100) {
 
698
                                alx_write_phy_dbg(hw, ALX_MIIDBG_MSE16DB,
 
699
                                                  ALX_MSE16DB_UP);
 
700
                        } else if (speed == SPEED_1000) {
 
701
                                /*
 
702
                                 * Giga link threshold, raise the tolerance of
 
703
                                 * noise 50%
 
704
                                 */
 
705
                                alx_read_phy_dbg(hw, ALX_MIIDBG_MSE20DB,
 
706
                                                 &phy_val);
 
707
                                FIELD_SETS(phy_val, ALX_MSE20DB_TH,
 
708
                                           ALX_MSE20DB_TH_HI);
 
709
                                alx_write_phy_dbg(hw, ALX_MIIDBG_MSE20DB,
 
710
                                                  phy_val);
 
711
                        }
 
712
                }
 
713
                /* phy link-down in 1000BT/AZ mode */
 
714
                if (az_en && revid == ALX_REV_B0 && speed == SPEED_1000) {
 
715
                        alx_write_phy_dbg(hw, ALX_MIIDBG_SRDSYSMOD,
 
716
                                ALX_SRDSYSMOD_DEF & ~ALX_SRDSYSMOD_DEEMP_EN);
 
717
                }
 
718
        } else {
 
719
                alx_read_phy_ext(hw, ALX_MIIEXT_ANEG, ALX_MIIEXT_AFE,
 
720
                                 &phy_val);
 
721
                alx_write_phy_ext(hw, ALX_MIIEXT_ANEG, ALX_MIIEXT_AFE,
 
722
                                  phy_val & ~ALX_AFE_10BT_100M_TH);
 
723
 
 
724
                if (adj_th && hw->lnk_patch) {
 
725
                        alx_write_phy_dbg(hw, ALX_MIIDBG_MSE16DB,
 
726
                                          ALX_MSE16DB_DOWN);
 
727
                        alx_read_phy_dbg(hw, ALX_MIIDBG_MSE20DB, &phy_val);
 
728
                        FIELD_SETS(phy_val, ALX_MSE20DB_TH, ALX_MSE20DB_TH_DEF);
 
729
                        alx_write_phy_dbg(hw, ALX_MIIDBG_MSE20DB, phy_val);
 
730
                }
 
731
                if (az_en && revid == ALX_REV_B0) {
 
732
                        alx_write_phy_dbg(hw, ALX_MIIDBG_SRDSYSMOD,
 
733
                                          ALX_SRDSYSMOD_DEF);
 
734
                }
 
735
        }
 
736
}
 
737
 
 
738
 
 
739
/* do power saving setting befor enter suspend mode
 
740
 * NOTE:
 
741
 *    1. phy link must be established before calling this function
 
742
 *    2. wol option (pattern,magic,link,etc.) is configed before call it.
 
743
 */
 
744
int alx_pre_suspend(struct alx_hw *hw, u16 speed)
 
745
{
 
746
        u32 master, mac, phy, val;
 
747
        int err = 0;
 
748
 
 
749
        ALX_MEM_R32(hw, ALX_MASTER, &master);
 
750
        master &= ~ALX_MASTER_PCLKSEL_SRDS;
 
751
        mac = hw->rx_ctrl;
 
752
        /* 10/100 half */
 
753
        FIELD_SET32(mac, ALX_MAC_CTRL_SPEED,  ALX_MAC_CTRL_SPEED_10_100);
 
754
        mac &= ~(ALX_MAC_CTRL_FULLD | ALX_MAC_CTRL_RX_EN | ALX_MAC_CTRL_TX_EN);
 
755
 
 
756
        ALX_MEM_R32(hw, ALX_PHY_CTRL, &phy);
 
757
        phy &= ~(ALX_PHY_CTRL_DSPRST_OUT | ALX_PHY_CTRL_CLS);
 
758
        phy |= ALX_PHY_CTRL_RST_ANALOG | ALX_PHY_CTRL_HIB_PULSE |
 
759
               ALX_PHY_CTRL_HIB_EN;
 
760
 
 
761
        /* without any activity  */
 
762
        if (!(hw->sleep_ctrl & ALX_SLEEP_ACTIVE)) {
 
763
                err = alx_write_phy_reg(hw, ALX_MII_IER, 0);
 
764
                phy |= ALX_PHY_CTRL_IDDQ | ALX_PHY_CTRL_POWER_DOWN;
 
765
                goto config_reg;
 
766
        }
 
767
 
 
768
        if (hw->sleep_ctrl & (ALX_SLEEP_WOL_MAGIC | ALX_SLEEP_CIFS))
 
769
                mac |= ALX_MAC_CTRL_RX_EN | ALX_MAC_CTRL_BRD_EN;
 
770
        if (hw->sleep_ctrl & ALX_SLEEP_CIFS)
 
771
                mac |= ALX_MAC_CTRL_TX_EN;
 
772
        if (speed % 10 == FULL_DUPLEX)
 
773
                mac |= ALX_MAC_CTRL_FULLD;
 
774
        if (speed >= SPEED_1000)
 
775
                FIELD_SET32(mac, ALX_MAC_CTRL_SPEED, ALX_MAC_CTRL_SPEED_1000);
 
776
        phy |= ALX_PHY_CTRL_DSPRST_OUT;
 
777
        err = alx_write_phy_ext(hw, ALX_MIIEXT_ANEG,
 
778
                ALX_MIIEXT_S3DIG10, ALX_MIIEXT_S3DIG10_SL);
 
779
config_reg:
 
780
 
 
781
        if (!err) {
 
782
                alx_enable_osc(hw);
 
783
                hw->rx_ctrl = mac;
 
784
                ALX_MEM_W32(hw, ALX_MASTER, master);
 
785
                ALX_MEM_W32(hw, ALX_MAC_CTRL, mac);
 
786
                ALX_MEM_W32(hw, ALX_PHY_CTRL, phy);
 
787
 
 
788
                /* set val of PDLL D3PLLOFF */
 
789
                ALX_MEM_R32(hw, ALX_PDLL_TRNS1, &val);
 
790
                val |= ALX_PDLL_TRNS1_D3PLLOFF_EN;
 
791
                ALX_MEM_W32(hw, ALX_PDLL_TRNS1, val);
 
792
        }
 
793
 
 
794
        return err;
 
795
}
 
796
 
 
797
/* wait mdio module to be idle */
 
798
bool __alx_wait_mdio_idle(struct alx_hw *hw)
 
799
{
 
800
        u32 val;
 
801
        int i;
 
802
 
 
803
        for (i = 0; i < ALX_MDIO_MAX_AC_TO; i++) {
 
804
                ALX_MEM_R32(hw, ALX_MDIO, &val);
 
805
                if (!(val & ALX_MDIO_BUSY))
 
806
                        break;
 
807
                udelay(10);
 
808
        }
 
809
        return i != ALX_MDIO_MAX_AC_TO;
 
810
}
 
811
 
 
812
void __alx_stop_phy_polling(struct alx_hw *hw)
 
813
{
 
814
        if (!hw->is_fpga)
 
815
                return;
 
816
 
 
817
        ALX_MEM_W32(hw, ALX_MDIO, 0);
 
818
        __alx_wait_mdio_idle(hw);
 
819
}
 
820
 
 
821
void __alx_start_phy_polling(struct alx_hw *hw, u16 clk_sel)
 
822
{
 
823
        u32 val;
 
824
 
 
825
        if (!hw->is_fpga)
 
826
                return;
 
827
 
 
828
        val = ALX_MDIO_SPRES_PRMBL |
 
829
              FIELDX(ALX_MDIO_CLK_SEL, clk_sel) |
 
830
              FIELDX(ALX_MDIO_REG, 1) |
 
831
              ALX_MDIO_START |
 
832
              ALX_MDIO_OP_READ;
 
833
        ALX_MEM_W32(hw, ALX_MDIO, val);
 
834
        __alx_wait_mdio_idle(hw);
 
835
        val |= ALX_MDIO_AUTO_POLLING;
 
836
        val &= ~ALX_MDIO_START;
 
837
        ALX_MEM_W32(hw, ALX_MDIO, val);
 
838
        udelay(30);
 
839
}
 
840
 
 
841
/* __alx_read_phy_core
 
842
 *     core function to read register in PHY via MDIO interface
 
843
 * ext: extension register (see IEEE 802.3)
 
844
 * dev: device address (see IEEE 802.3 DEVAD, PRTAD is fixed to 0)
 
845
 * reg: register to read
 
846
 */
 
847
int __alx_read_phy_core(struct alx_hw *hw, bool ext, u8 dev,
 
848
                             u16 reg, u16 *phy_data)
 
849
{
 
850
        u32 val, clk_sel;
 
851
        int err;
 
852
 
 
853
        __alx_stop_phy_polling(hw);
 
854
 
 
855
        *phy_data = 0;
 
856
 
 
857
        /* use slow clock when it's in hibernation status */
 
858
        clk_sel = !hw->link_up ?
 
859
                ALX_MDIO_CLK_SEL_25MD128 : ALX_MDIO_CLK_SEL_25MD4;
 
860
 
 
861
        if (ext) {
 
862
                val = FIELDX(ALX_MDIO_EXTN_DEVAD, dev) |
 
863
                      FIELDX(ALX_MDIO_EXTN_REG, reg);
 
864
                ALX_MEM_W32(hw, ALX_MDIO_EXTN, val);
 
865
 
 
866
                val = ALX_MDIO_SPRES_PRMBL |
 
867
                      FIELDX(ALX_MDIO_CLK_SEL, clk_sel) |
 
868
                      ALX_MDIO_START |
 
869
                      ALX_MDIO_MODE_EXT |
 
870
                      ALX_MDIO_OP_READ;
 
871
        } else {
 
872
                val = ALX_MDIO_SPRES_PRMBL |
 
873
                      FIELDX(ALX_MDIO_CLK_SEL, clk_sel) |
 
874
                      FIELDX(ALX_MDIO_REG, reg) |
 
875
                      ALX_MDIO_START |
 
876
                      ALX_MDIO_OP_READ;
 
877
        }
 
878
        ALX_MEM_W32(hw, ALX_MDIO, val);
 
879
 
 
880
        if (unlikely(!__alx_wait_mdio_idle(hw)))
 
881
                err = ALX_ERR_MIIBUSY;
 
882
        else {
 
883
                ALX_MEM_R32(hw, ALX_MDIO, &val);
 
884
                *phy_data = (u16)FIELD_GETX(val, ALX_MDIO_DATA);
 
885
                err = 0;
 
886
        }
 
887
 
 
888
        __alx_start_phy_polling(hw, clk_sel);
 
889
 
 
890
        return err;
 
891
}
 
892
 
 
893
/* __alx_write_phy_core
 
894
 *     core function to write to register in PHY via MDIO interface
 
895
 * ext: extension register (see IEEE 802.3)
 
896
 * dev: device address (see IEEE 802.3 DEVAD, PRTAD is fixed to 0)
 
897
 * reg: register to write
 
898
 */
 
899
int __alx_write_phy_core(struct alx_hw *hw, bool ext, u8 dev,
 
900
                       u16 reg, u16 phy_data)
 
901
{
 
902
        u32 val, clk_sel;
 
903
        int err = 0;
 
904
 
 
905
        __alx_stop_phy_polling(hw);
 
906
 
 
907
        /* use slow clock when it's in hibernation status */
 
908
        clk_sel = !hw->link_up ?
 
909
                ALX_MDIO_CLK_SEL_25MD128 : ALX_MDIO_CLK_SEL_25MD4;
 
910
 
 
911
        if (ext) {
 
912
                val = FIELDX(ALX_MDIO_EXTN_DEVAD, dev) |
 
913
                      FIELDX(ALX_MDIO_EXTN_REG, reg);
 
914
                ALX_MEM_W32(hw, ALX_MDIO_EXTN, val);
 
915
 
 
916
                val = ALX_MDIO_SPRES_PRMBL |
 
917
                      FIELDX(ALX_MDIO_CLK_SEL, clk_sel) |
 
918
                      FIELDX(ALX_MDIO_DATA, phy_data) |
 
919
                      ALX_MDIO_START |
 
920
                      ALX_MDIO_MODE_EXT;
 
921
        } else {
 
922
                val = ALX_MDIO_SPRES_PRMBL |
 
923
                      FIELDX(ALX_MDIO_CLK_SEL, clk_sel) |
 
924
                      FIELDX(ALX_MDIO_REG, reg) |
 
925
                      FIELDX(ALX_MDIO_DATA, phy_data) |
 
926
                      ALX_MDIO_START;
 
927
        }
 
928
        ALX_MEM_W32(hw, ALX_MDIO, val);
 
929
 
 
930
        if (unlikely(!__alx_wait_mdio_idle(hw)))
 
931
                err = ALX_ERR_MIIBUSY;
 
932
 
 
933
        __alx_start_phy_polling(hw, clk_sel);
 
934
 
 
935
        return err;
 
936
}
 
937
 
 
938
/* read from PHY normal register */
 
939
int __alx_read_phy_reg(struct alx_hw *hw, u16 reg, u16 *phy_data)
 
940
{
 
941
        return __alx_read_phy_core(hw, false, 0, reg, phy_data);
 
942
}
 
943
 
 
944
/* write to PHY normal register */
 
945
int __alx_write_phy_reg(struct alx_hw *hw, u16 reg, u16 phy_data)
 
946
{
 
947
        return __alx_write_phy_core(hw, false, 0, reg, phy_data);
 
948
}
 
949
 
 
950
/* read from PHY extension register */
 
951
int __alx_read_phy_ext(struct alx_hw *hw, u8 dev, u16 reg, u16 *pdata)
 
952
{
 
953
        return __alx_read_phy_core(hw, true, dev, reg, pdata);
 
954
}
 
955
 
 
956
/* write to PHY extension register */
 
957
int __alx_write_phy_ext(struct alx_hw *hw, u8 dev, u16 reg, u16 data)
 
958
{
 
959
        return __alx_write_phy_core(hw, true, dev, reg, data);
 
960
}
 
961
 
 
962
/* read from PHY debug port */
 
963
int __alx_read_phy_dbg(struct alx_hw *hw, u16 reg, u16 *pdata)
 
964
{
 
965
        int err;
 
966
 
 
967
        err = __alx_write_phy_reg(hw, ALX_MII_DBG_ADDR, reg);
 
968
        if (unlikely(err))
 
969
                return err;
 
970
        else
 
971
                err = __alx_read_phy_reg(hw, ALX_MII_DBG_DATA, pdata);
 
972
 
 
973
        return err;
 
974
}
 
975
 
 
976
/* write to PHY debug port */
 
977
int __alx_write_phy_dbg(struct alx_hw *hw, u16 reg, u16 data)
 
978
{
 
979
        int err;
 
980
 
 
981
        err = __alx_write_phy_reg(hw, ALX_MII_DBG_ADDR, reg);
 
982
        if (unlikely(err))
 
983
                return err;
 
984
        else
 
985
                err = __alx_write_phy_reg(hw, ALX_MII_DBG_DATA, data);
 
986
 
 
987
        return err;
 
988
}
 
989
 
 
990
int alx_read_phy_reg(struct alx_hw *hw, u16 reg, u16 *phy_data)
 
991
{
 
992
        int err;
 
993
 
 
994
        spin_lock(&hw->mdio_lock);
 
995
        err = __alx_read_phy_reg(hw, reg, phy_data);
 
996
        spin_unlock(&hw->mdio_lock);
 
997
 
 
998
        return err;
 
999
}
 
1000
 
 
1001
int alx_write_phy_reg(struct alx_hw *hw, u16 reg, u16 phy_data)
 
1002
{
 
1003
        int err;
 
1004
 
 
1005
        spin_lock(&hw->mdio_lock);
 
1006
        err = __alx_write_phy_reg(hw, reg, phy_data);
 
1007
        spin_unlock(&hw->mdio_lock);
 
1008
 
 
1009
        return err;
 
1010
}
 
1011
 
 
1012
int alx_read_phy_ext(struct alx_hw *hw, u8 dev, u16 reg, u16 *pdata)
 
1013
{
 
1014
        int err;
 
1015
 
 
1016
        spin_lock(&hw->mdio_lock);
 
1017
        err = __alx_read_phy_ext(hw, dev, reg, pdata);
 
1018
        spin_unlock(&hw->mdio_lock);
 
1019
 
 
1020
        return err;
 
1021
}
 
1022
 
 
1023
int alx_write_phy_ext(struct alx_hw *hw, u8 dev, u16 reg, u16 data)
 
1024
{
 
1025
        int err;
 
1026
 
 
1027
        spin_lock(&hw->mdio_lock);
 
1028
        err = __alx_write_phy_ext(hw, dev, reg, data);
 
1029
        spin_unlock(&hw->mdio_lock);
 
1030
 
 
1031
        return err;
 
1032
}
 
1033
 
 
1034
int alx_read_phy_dbg(struct alx_hw *hw, u16 reg, u16 *pdata)
 
1035
{
 
1036
        int err;
 
1037
 
 
1038
        spin_lock(&hw->mdio_lock);
 
1039
        err = __alx_read_phy_dbg(hw, reg, pdata);
 
1040
        spin_unlock(&hw->mdio_lock);
 
1041
 
 
1042
        return err;
 
1043
}
 
1044
 
 
1045
int alx_write_phy_dbg(struct alx_hw *hw, u16 reg, u16 data)
 
1046
{
 
1047
        int err;
 
1048
 
 
1049
        spin_lock(&hw->mdio_lock);
 
1050
        err = __alx_write_phy_dbg(hw, reg, data);
 
1051
        spin_unlock(&hw->mdio_lock);
 
1052
 
 
1053
        return err;
 
1054
}
 
1055
 
 
1056
u16 alx_get_phy_config(struct alx_hw *hw)
 
1057
{
 
1058
        u32 val;
 
1059
        u16 phy_val;
 
1060
 
 
1061
        ALX_MEM_R32(hw, ALX_PHY_CTRL, &val);
 
1062
        /* phy in rst */
 
1063
        if ((val & ALX_PHY_CTRL_DSPRST_OUT) == 0)
 
1064
                return ALX_DRV_PHY_UNKNOWN;
 
1065
 
 
1066
        ALX_MEM_R32(hw, ALX_DRV, &val);
 
1067
        val = FIELD_GETX(val, ALX_DRV_PHY);
 
1068
        if (ALX_DRV_PHY_UNKNOWN == val)
 
1069
                return ALX_DRV_PHY_UNKNOWN;
 
1070
 
 
1071
        alx_read_phy_reg(hw, ALX_MII_DBG_ADDR, &phy_val);
 
1072
        if (ALX_PHY_INITED == phy_val)
 
1073
                return (u16) val;
 
1074
 
 
1075
        return ALX_DRV_PHY_UNKNOWN;
 
1076
}
 
1077
 
 
1078
bool alx_phy_configed(struct alx_hw *hw)
 
1079
{
 
1080
        u32 cfg, hw_cfg;
 
1081
 
 
1082
        cfg = ethadv_to_hw_cfg(hw, hw->adv_cfg);
 
1083
        cfg = FIELD_GETX(cfg, ALX_DRV_PHY);
 
1084
        hw_cfg = alx_get_phy_config(hw);
 
1085
        if (hw_cfg == ALX_DRV_PHY_UNKNOWN)
 
1086
                return false;
 
1087
 
 
1088
        return cfg == hw_cfg;
 
1089
}
 
1090
 
 
1091
int alx_get_phy_link(struct alx_hw *hw, bool *link_up, u16 *speed)
 
1092
{
 
1093
        struct pci_dev *pdev = hw->pdev;
 
1094
        u16 bmsr, giga;
 
1095
        int err;
 
1096
 
 
1097
        err = alx_read_phy_reg(hw, MII_BMSR, &bmsr);
 
1098
        err = alx_read_phy_reg(hw, MII_BMSR, &bmsr);
 
1099
        if (unlikely(err))
 
1100
                goto out;
 
1101
 
 
1102
        if (!(bmsr & BMSR_LSTATUS)) {
 
1103
                *link_up = false;
 
1104
                goto out;
 
1105
        }
 
1106
 
 
1107
        *link_up = true;
 
1108
 
 
1109
        /* speed/duplex result is saved in PHY Specific Status Register */
 
1110
        err = alx_read_phy_reg(hw, ALX_MII_GIGA_PSSR, &giga);
 
1111
        if (unlikely(err))
 
1112
                goto out;
 
1113
 
 
1114
        if (!(giga & ALX_GIGA_PSSR_SPD_DPLX_RESOLVED))
 
1115
                goto wrong_spd_out;
 
1116
 
 
1117
        switch (giga & ALX_GIGA_PSSR_SPEED) {
 
1118
        case ALX_GIGA_PSSR_1000MBS:
 
1119
                *speed = SPEED_1000;
 
1120
                break;
 
1121
        case ALX_GIGA_PSSR_100MBS:
 
1122
                *speed = SPEED_100;
 
1123
                break;
 
1124
        case ALX_GIGA_PSSR_10MBS:
 
1125
                *speed = SPEED_10;
 
1126
                break;
 
1127
        default:
 
1128
                goto wrong_spd_out;
 
1129
        }
 
1130
        *speed += (giga & ALX_GIGA_PSSR_DPLX) ? FULL_DUPLEX : HALF_DUPLEX;
 
1131
        goto out;
 
1132
 
 
1133
wrong_spd_out:
 
1134
        dev_err(&pdev->dev, "PHY SPD/DPLX unresolved :%x\n", giga);
 
1135
        err = -EINVAL;
 
1136
out:
 
1137
        return err;
 
1138
}
 
1139
 
 
1140
int alx_clear_phy_intr(struct alx_hw *hw)
 
1141
{
 
1142
        u16 isr;
 
1143
 
 
1144
        /* clear interrupt status by read it */
 
1145
        return alx_read_phy_reg(hw, ALX_MII_ISR, &isr);
 
1146
}
 
1147
 
 
1148
int alx_config_wol(struct alx_hw *hw)
 
1149
{
 
1150
        u32 wol;
 
1151
        int err = 0;
 
1152
 
 
1153
        wol = 0;
 
1154
        /* turn on magic packet event */
 
1155
        if (hw->sleep_ctrl & ALX_SLEEP_WOL_MAGIC) {
 
1156
                wol |= ALX_WOL0_MAGIC_EN | ALX_WOL0_PME_MAGIC_EN;
 
1157
                /* magic packet maybe Broadcast&multicast&Unicast frame */
 
1158
                /* mac |= MAC_CTRL_BC_EN; */
 
1159
        }
 
1160
 
 
1161
        /* turn on link up event */
 
1162
        if (hw->sleep_ctrl & ALX_SLEEP_WOL_PHY) {
 
1163
                wol |=  ALX_WOL0_LINK_EN | ALX_WOL0_PME_LINK;
 
1164
                /* only link up can wake up */
 
1165
                err = alx_write_phy_reg(hw, ALX_MII_IER, ALX_IER_LINK_UP);
 
1166
        }
 
1167
        ALX_MEM_W32(hw, ALX_WOL0, wol);
 
1168
 
 
1169
        return err;
 
1170
}
 
1171
 
 
1172
void alx_configure_rss(struct alx_hw *hw, bool en)
 
1173
{
 
1174
        u32 ctrl;
 
1175
        int i;
 
1176
 
 
1177
        ALX_MEM_R32(hw, ALX_RXQ0, &ctrl);
 
1178
 
 
1179
        if (en) {
 
1180
                for (i = 0; i < sizeof(hw->rss_key); i++) {
 
1181
                        /* rss key should be saved in chip with
 
1182
                         * reversed order.
 
1183
                         */
 
1184
                        int j = sizeof(hw->rss_key) - i - 1;
 
1185
 
 
1186
                        ALX_MEM_W8(hw, ALX_RSS_KEY0 + j, hw->rss_key[i]);
 
1187
                }
 
1188
 
 
1189
                for (i = 0; i < ARRAY_SIZE(hw->rss_idt); i++)
 
1190
                        ALX_MEM_W32(hw, ALX_RSS_IDT_TBL0 + i * 4,
 
1191
                                    hw->rss_idt[i]);
 
1192
 
 
1193
                FIELD_SET32(ctrl, ALX_RXQ0_RSS_HSTYP, hw->rss_hash_type);
 
1194
                FIELD_SET32(ctrl, ALX_RXQ0_RSS_MODE, ALX_RXQ0_RSS_MODE_MQMI);
 
1195
                FIELD_SET32(ctrl, ALX_RXQ0_IDT_TBL_SIZE, hw->rss_idt_size);
 
1196
                ctrl |= ALX_RXQ0_RSS_HASH_EN;
 
1197
        } else {
 
1198
                ctrl &= ~ALX_RXQ0_RSS_HASH_EN;
 
1199
        }
 
1200
 
 
1201
        ALX_MEM_W32(hw, ALX_RXQ0, ctrl);
 
1202
}
 
1203
 
 
1204
void alx_configure_basic(struct alx_hw *hw)
 
1205
{
 
1206
        u32 val, raw_mtu, max_payload;
 
1207
        u16 val16;
 
1208
        u8 chip_rev = ALX_REVID(hw);
 
1209
 
 
1210
        /* mac address */
 
1211
        alx_set_macaddr(hw, hw->mac_addr);
 
1212
 
 
1213
        /* clk gating */
 
1214
        ALX_MEM_W32(hw, ALX_CLK_GATE, ALX_CLK_GATE_ALL_A0);
 
1215
 
 
1216
        /* idle timeout to switch clk_125M */
 
1217
        if (chip_rev >= ALX_REV_B0) {
 
1218
                ALX_MEM_W32(hw, ALX_IDLE_DECISN_TIMER,
 
1219
                        ALX_IDLE_DECISN_TIMER_DEF);
 
1220
        }
 
1221
 
 
1222
        /* stats refresh timeout */
 
1223
        ALX_MEM_W32(hw, ALX_SMB_TIMER, hw->smb_timer * 500UL);
 
1224
 
 
1225
        /* intr moduration */
 
1226
        ALX_MEM_R32(hw, ALX_MASTER, &val);
 
1227
        val = val | ALX_MASTER_IRQMOD2_EN |
 
1228
                    ALX_MASTER_IRQMOD1_EN |
 
1229
                    ALX_MASTER_SYSALVTIMER_EN;
 
1230
        ALX_MEM_W32(hw, ALX_MASTER, val);
 
1231
        ALX_MEM_W32(hw, ALX_IRQ_MODU_TIMER,
 
1232
                    FIELDX(ALX_IRQ_MODU_TIMER1, hw->imt >> 1));
 
1233
        /* intr re-trig timeout */
 
1234
        ALX_MEM_W32(hw, ALX_INT_RETRIG, ALX_INT_RETRIG_TO);
 
1235
        /* tpd threshold to trig int */
 
1236
        ALX_MEM_W32(hw, ALX_TINT_TPD_THRSHLD, hw->ith_tpd);
 
1237
        ALX_MEM_W32(hw, ALX_TINT_TIMER, hw->imt);
 
1238
 
 
1239
        /* mtu, 8:fcs+vlan */
 
1240
        raw_mtu = hw->mtu + ETH_HLEN;
 
1241
        ALX_MEM_W32(hw, ALX_MTU, raw_mtu + 8);
 
1242
        if (raw_mtu > ALX_MTU_JUMBO_TH)
 
1243
                hw->rx_ctrl &= ~ALX_MAC_CTRL_FAST_PAUSE;
 
1244
 
 
1245
        /* txq */
 
1246
        if ((raw_mtu + 8) < ALX_TXQ1_JUMBO_TSO_TH)
 
1247
                val = (raw_mtu + 8 + 7) >> 3;
 
1248
        else
 
1249
                val = ALX_TXQ1_JUMBO_TSO_TH >> 3;
 
1250
        ALX_MEM_W32(hw, ALX_TXQ1, val | ALX_TXQ1_ERRLGPKT_DROP_EN);
 
1251
        max_payload = alx_get_readrq(hw) >> 8;
 
1252
        /*
 
1253
         * if BIOS had changed the default dma read max length,
 
1254
         * restore it to default value
 
1255
         */
 
1256
        if (max_payload < ALX_DEV_CTRL_MAXRRS_MIN)
 
1257
                alx_set_readrq(hw, 128 << ALX_DEV_CTRL_MAXRRS_MIN);
 
1258
 
 
1259
        val = FIELDX(ALX_TXQ0_TPD_BURSTPREF, ALX_TXQ_TPD_BURSTPREF_DEF) |
 
1260
              ALX_TXQ0_MODE_ENHANCE |
 
1261
              ALX_TXQ0_LSO_8023_EN |
 
1262
              ALX_TXQ0_SUPT_IPOPT |
 
1263
              FIELDX(ALX_TXQ0_TXF_BURST_PREF, ALX_TXQ_TXF_BURST_PREF_DEF);
 
1264
        ALX_MEM_W32(hw, ALX_TXQ0, val);
 
1265
        val = FIELDX(ALX_HQTPD_Q1_NUMPREF, ALX_TXQ_TPD_BURSTPREF_DEF) |
 
1266
              FIELDX(ALX_HQTPD_Q2_NUMPREF, ALX_TXQ_TPD_BURSTPREF_DEF) |
 
1267
              FIELDX(ALX_HQTPD_Q3_NUMPREF, ALX_TXQ_TPD_BURSTPREF_DEF) |
 
1268
              ALX_HQTPD_BURST_EN;
 
1269
        ALX_MEM_W32(hw, ALX_HQTPD, val);
 
1270
 
 
1271
        /* rxq, flow control */
 
1272
        ALX_MEM_R32(hw, ALX_SRAM5, &val);
 
1273
        val = FIELD_GETX(val, ALX_SRAM_RXF_LEN) << 3;
 
1274
        if (val > ALX_SRAM_RXF_LEN_8K) {
 
1275
                val16 = ALX_MTU_STD_ALGN >> 3;
 
1276
                val = (val - ALX_RXQ2_RXF_FLOW_CTRL_RSVD) >> 3;
 
1277
        } else {
 
1278
                val16 = ALX_MTU_STD_ALGN >> 3;
 
1279
                val = (val - ALX_MTU_STD_ALGN) >> 3;
 
1280
        }
 
1281
        ALX_MEM_W32(hw, ALX_RXQ2,
 
1282
                    FIELDX(ALX_RXQ2_RXF_XOFF_THRESH, val16) |
 
1283
                    FIELDX(ALX_RXQ2_RXF_XON_THRESH, val));
 
1284
        val = FIELDX(ALX_RXQ0_NUM_RFD_PREF, ALX_RXQ0_NUM_RFD_PREF_DEF) |
 
1285
              FIELDX(ALX_RXQ0_RSS_MODE, ALX_RXQ0_RSS_MODE_DIS) |
 
1286
              FIELDX(ALX_RXQ0_IDT_TBL_SIZE, ALX_RXQ0_IDT_TBL_SIZE_DEF) |
 
1287
              ALX_RXQ0_RSS_HSTYP_ALL |
 
1288
              ALX_RXQ0_RSS_HASH_EN |
 
1289
              ALX_RXQ0_IPV6_PARSE_EN;
 
1290
        if (ALX_CAP(hw, GIGA)) {
 
1291
                FIELD_SET32(val, ALX_RXQ0_ASPM_THRESH,
 
1292
                            ALX_RXQ0_ASPM_THRESH_100M);
 
1293
        }
 
1294
        ALX_MEM_W32(hw, ALX_RXQ0, val);
 
1295
 
 
1296
        /* DMA */
 
1297
        ALX_MEM_R32(hw, ALX_DMA, &val);
 
1298
        val = FIELDX(ALX_DMA_RORDER_MODE, ALX_DMA_RORDER_MODE_OUT) |
 
1299
              ALX_DMA_RREQ_PRI_DATA |
 
1300
              FIELDX(ALX_DMA_RREQ_BLEN, max_payload) |
 
1301
              FIELDX(ALX_DMA_WDLY_CNT, ALX_DMA_WDLY_CNT_DEF) |
 
1302
              FIELDX(ALX_DMA_RDLY_CNT, ALX_DMA_RDLY_CNT_DEF) |
 
1303
              FIELDX(ALX_DMA_RCHNL_SEL, hw->dma_chnl - 1);
 
1304
        ALX_MEM_W32(hw, ALX_DMA, val);
 
1305
 
 
1306
        /* multi-tx-q weight */
 
1307
        if (ALX_CAP(hw, MTQ)) {
 
1308
                val = FIELDX(ALX_WRR_PRI, hw->wrr_ctrl) |
 
1309
                      FIELDX(ALX_WRR_PRI0, hw->wrr[0]) |
 
1310
                      FIELDX(ALX_WRR_PRI1, hw->wrr[1]) |
 
1311
                      FIELDX(ALX_WRR_PRI2, hw->wrr[2]) |
 
1312
                      FIELDX(ALX_WRR_PRI3, hw->wrr[3]);
 
1313
                ALX_MEM_W32(hw, ALX_WRR, val);
 
1314
        }
 
1315
}
 
1316
 
 
1317
void alx_mask_msix(struct alx_hw *hw, int index, bool mask)
 
1318
{
 
1319
        u32 reg, val;
 
1320
 
 
1321
        reg = ALX_MSIX_ENTRY_BASE + index * PCI_MSIX_ENTRY_SIZE +
 
1322
                   PCI_MSIX_ENTRY_VECTOR_CTRL;
 
1323
 
 
1324
        val = mask ? PCI_MSIX_ENTRY_CTRL_MASKBIT : 0;
 
1325
 
 
1326
        ALX_MEM_W32(hw, reg, val);
 
1327
        ALX_MEM_FLUSH(hw);
 
1328
}
 
1329
 
 
1330
int alx_select_powersaving_speed(struct alx_hw *hw, u16 *speed)
 
1331
{
 
1332
        int i, err;
 
1333
        u16 spd, lpa;
 
1334
        bool linkup;
 
1335
 
 
1336
        err = alx_get_phy_link(hw, &linkup, &spd);
 
1337
        if (err)
 
1338
                goto out;
 
1339
 
 
1340
        if (!linkup) {
 
1341
                *speed = SPEED_0;
 
1342
                goto out;
 
1343
        }
 
1344
 
 
1345
        err = alx_read_phy_reg(hw, MII_LPA, &lpa);
 
1346
        if (err)
 
1347
                goto out;
 
1348
 
 
1349
        if (!(lpa & LPA_LPACK)) {
 
1350
                *speed = spd;
 
1351
                goto out;
 
1352
        }
 
1353
        if (lpa & LPA_10FULL)
 
1354
                *speed = SPEED_10 + FULL_DUPLEX;
 
1355
        else if (lpa & LPA_10HALF)
 
1356
                *speed = SPEED_10 + HALF_DUPLEX;
 
1357
        else if (lpa & LPA_100FULL)
 
1358
                *speed = SPEED_100 + FULL_DUPLEX;
 
1359
        else
 
1360
                *speed = SPEED_100 + HALF_DUPLEX;
 
1361
 
 
1362
        if (*speed != spd) {
 
1363
                err = alx_write_phy_reg(hw, ALX_MII_IER, 0);
 
1364
                if (err)
 
1365
                        goto out;
 
1366
                err = alx_setup_speed_duplex(hw,
 
1367
                        ALX_SPEED_TO_ETHADV(*speed) | ADVERTISED_Autoneg,
 
1368
                        ALX_FC_ANEG | ALX_FC_RX | ALX_FC_TX);
 
1369
                if (err)
 
1370
                        goto out;
 
1371
 
 
1372
                /* wait for linkup */
 
1373
                for (i = 0; i < ALX_MAX_SETUP_LNK_CYCLE; i++) {
 
1374
                        u16 speed2;
 
1375
                        bool link_on;
 
1376
 
 
1377
                        msleep(100);
 
1378
                        err = alx_get_phy_link(hw, &link_on, &speed2);
 
1379
                        if (err)
 
1380
                                goto out;
 
1381
                        if (link_on)
 
1382
                                break;
 
1383
                }
 
1384
                if (i == ALX_MAX_SETUP_LNK_CYCLE) {
 
1385
                        err = ALX_LINK_TIMEOUT;
 
1386
                        goto out;
 
1387
                }
 
1388
        }
 
1389
 
 
1390
out:
 
1391
        return err;
 
1392
}
 
1393
 
 
1394
void __alx_update_hw_stats(struct alx_hw *hw)
 
1395
{
 
1396
        u16 reg;
 
1397
        u32 data;
 
1398
        unsigned long *p;
 
1399
 
 
1400
        /* RX stats */
 
1401
        reg = ALX_RX_STATS_BIN;
 
1402
        p = &hw->stats.rx_ok;
 
1403
        while (reg <=  ALX_RX_STATS_END) {
 
1404
                ALX_MEM_R32(hw, reg, &data);
 
1405
                *p++ += data;
 
1406
                reg += 4;
 
1407
        }
 
1408
 
 
1409
        /* TX stats */
 
1410
        reg = ALX_TX_STATS_BIN;
 
1411
        p = &hw->stats.tx_ok;
 
1412
        while (reg <= ALX_TX_STATS_END) {
 
1413
                ALX_MEM_R32(hw, reg, &data);
 
1414
                *p++ += data;
 
1415
                reg += 4;
 
1416
        }
 
1417
}
 
1418
 
 
1419
static const struct alx_platform_patch plats[] = {
 
1420
{0x1091, 0x00, 0x1969, 0x0091, 0x1001},
 
1421
{0},
 
1422
};
 
1423
 
 
1424
void alx_patch_assign(struct alx_hw *hw)
 
1425
{
 
1426
        int i = 0;
 
1427
 
 
1428
        while (plats[i].pci_did != 0) {
 
1429
                if (plats[i].pci_did == ALX_DID(hw) &&
 
1430
                    plats[i].subsystem_vid == ALX_SUB_VID(hw) &&
 
1431
                    plats[i].subsystem_did == ALX_SUB_DID(hw) &&
 
1432
                    (plats[i].pflag & ALX_PF_ANY_REV ||
 
1433
                     plats[i].pci_rev == hw->revision)) {
 
1434
                        if (plats[i].pflag & ALX_PF_LINK)
 
1435
                                hw->lnk_patch = true;
 
1436
                        if (plats[i].pflag & ALX_PF_HIB)
 
1437
                                hw->hib_patch = true;
 
1438
                }
 
1439
                i++;
 
1440
        }
 
1441
}
 
1442
 
 
1443
bool alx_get_phy_info(struct alx_hw *hw)
 
1444
{
 
1445
        u16  devs1, devs2;
 
1446
 
 
1447
        if (alx_read_phy_reg(hw, MII_PHYSID1, &hw->phy_id[0]) ||
 
1448
            alx_read_phy_reg(hw, MII_PHYSID2, &hw->phy_id[1]))
 
1449
                return false;
 
1450
 
 
1451
        /* since we haven't PMA/PMD status2 register, we can't
 
1452
         * use mdio45_probe function for prtad and mmds.
 
1453
         * use fixed MMD3 to get mmds.
 
1454
         */
 
1455
        if (alx_read_phy_ext(hw, 3, MDIO_DEVS1, &devs1) ||
 
1456
            alx_read_phy_ext(hw, 3, MDIO_DEVS2, &devs2))
 
1457
                return false;
 
1458
        hw->mdio.mmds = devs1 | devs2 << 16;
 
1459
 
 
1460
        return true;
 
1461
}