b843bf7d8c17477dabb6216dfd390121a83b7c56
[linux-2.6.git] / drivers / net / ksz884x.c
1 /**
2  * drivers/net/ksx884x.c - Micrel KSZ8841/2 PCI Ethernet driver
3  *
4  * Copyright (c) 2009-2010 Micrel, Inc.
5  *      Tristram Ha <Tristram.Ha@micrel.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  */
16
17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
18
19 #include <linux/init.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/ioport.h>
23 #include <linux/pci.h>
24 #include <linux/proc_fs.h>
25 #include <linux/mii.h>
26 #include <linux/platform_device.h>
27 #include <linux/ethtool.h>
28 #include <linux/etherdevice.h>
29 #include <linux/in.h>
30 #include <linux/ip.h>
31 #include <linux/if_vlan.h>
32 #include <linux/crc32.h>
33 #include <linux/sched.h>
34
35
36 /* DMA Registers */
37
38 #define KS_DMA_TX_CTRL                  0x0000
39 #define DMA_TX_ENABLE                   0x00000001
40 #define DMA_TX_CRC_ENABLE               0x00000002
41 #define DMA_TX_PAD_ENABLE               0x00000004
42 #define DMA_TX_LOOPBACK                 0x00000100
43 #define DMA_TX_FLOW_ENABLE              0x00000200
44 #define DMA_TX_CSUM_IP                  0x00010000
45 #define DMA_TX_CSUM_TCP                 0x00020000
46 #define DMA_TX_CSUM_UDP                 0x00040000
47 #define DMA_TX_BURST_SIZE               0x3F000000
48
49 #define KS_DMA_RX_CTRL                  0x0004
50 #define DMA_RX_ENABLE                   0x00000001
51 #define KS884X_DMA_RX_MULTICAST         0x00000002
52 #define DMA_RX_PROMISCUOUS              0x00000004
53 #define DMA_RX_ERROR                    0x00000008
54 #define DMA_RX_UNICAST                  0x00000010
55 #define DMA_RX_ALL_MULTICAST            0x00000020
56 #define DMA_RX_BROADCAST                0x00000040
57 #define DMA_RX_FLOW_ENABLE              0x00000200
58 #define DMA_RX_CSUM_IP                  0x00010000
59 #define DMA_RX_CSUM_TCP                 0x00020000
60 #define DMA_RX_CSUM_UDP                 0x00040000
61 #define DMA_RX_BURST_SIZE               0x3F000000
62
63 #define DMA_BURST_SHIFT                 24
64 #define DMA_BURST_DEFAULT               8
65
66 #define KS_DMA_TX_START                 0x0008
67 #define KS_DMA_RX_START                 0x000C
68 #define DMA_START                       0x00000001
69
70 #define KS_DMA_TX_ADDR                  0x0010
71 #define KS_DMA_RX_ADDR                  0x0014
72
73 #define DMA_ADDR_LIST_MASK              0xFFFFFFFC
74 #define DMA_ADDR_LIST_SHIFT             2
75
76 /* MTR0 */
77 #define KS884X_MULTICAST_0_OFFSET       0x0020
78 #define KS884X_MULTICAST_1_OFFSET       0x0021
79 #define KS884X_MULTICAST_2_OFFSET       0x0022
80 #define KS884x_MULTICAST_3_OFFSET       0x0023
81 /* MTR1 */
82 #define KS884X_MULTICAST_4_OFFSET       0x0024
83 #define KS884X_MULTICAST_5_OFFSET       0x0025
84 #define KS884X_MULTICAST_6_OFFSET       0x0026
85 #define KS884X_MULTICAST_7_OFFSET       0x0027
86
87 /* Interrupt Registers */
88
89 /* INTEN */
90 #define KS884X_INTERRUPTS_ENABLE        0x0028
91 /* INTST */
92 #define KS884X_INTERRUPTS_STATUS        0x002C
93
94 #define KS884X_INT_RX_STOPPED           0x02000000
95 #define KS884X_INT_TX_STOPPED           0x04000000
96 #define KS884X_INT_RX_OVERRUN           0x08000000
97 #define KS884X_INT_TX_EMPTY             0x10000000
98 #define KS884X_INT_RX                   0x20000000
99 #define KS884X_INT_TX                   0x40000000
100 #define KS884X_INT_PHY                  0x80000000
101
102 #define KS884X_INT_RX_MASK              \
103         (KS884X_INT_RX | KS884X_INT_RX_OVERRUN)
104 #define KS884X_INT_TX_MASK              \
105         (KS884X_INT_TX | KS884X_INT_TX_EMPTY)
106 #define KS884X_INT_MASK (KS884X_INT_RX | KS884X_INT_TX | KS884X_INT_PHY)
107
108 /* MAC Additional Station Address */
109
110 /* MAAL0 */
111 #define KS_ADD_ADDR_0_LO                0x0080
112 /* MAAH0 */
113 #define KS_ADD_ADDR_0_HI                0x0084
114 /* MAAL1 */
115 #define KS_ADD_ADDR_1_LO                0x0088
116 /* MAAH1 */
117 #define KS_ADD_ADDR_1_HI                0x008C
118 /* MAAL2 */
119 #define KS_ADD_ADDR_2_LO                0x0090
120 /* MAAH2 */
121 #define KS_ADD_ADDR_2_HI                0x0094
122 /* MAAL3 */
123 #define KS_ADD_ADDR_3_LO                0x0098
124 /* MAAH3 */
125 #define KS_ADD_ADDR_3_HI                0x009C
126 /* MAAL4 */
127 #define KS_ADD_ADDR_4_LO                0x00A0
128 /* MAAH4 */
129 #define KS_ADD_ADDR_4_HI                0x00A4
130 /* MAAL5 */
131 #define KS_ADD_ADDR_5_LO                0x00A8
132 /* MAAH5 */
133 #define KS_ADD_ADDR_5_HI                0x00AC
134 /* MAAL6 */
135 #define KS_ADD_ADDR_6_LO                0x00B0
136 /* MAAH6 */
137 #define KS_ADD_ADDR_6_HI                0x00B4
138 /* MAAL7 */
139 #define KS_ADD_ADDR_7_LO                0x00B8
140 /* MAAH7 */
141 #define KS_ADD_ADDR_7_HI                0x00BC
142 /* MAAL8 */
143 #define KS_ADD_ADDR_8_LO                0x00C0
144 /* MAAH8 */
145 #define KS_ADD_ADDR_8_HI                0x00C4
146 /* MAAL9 */
147 #define KS_ADD_ADDR_9_LO                0x00C8
148 /* MAAH9 */
149 #define KS_ADD_ADDR_9_HI                0x00CC
150 /* MAAL10 */
151 #define KS_ADD_ADDR_A_LO                0x00D0
152 /* MAAH10 */
153 #define KS_ADD_ADDR_A_HI                0x00D4
154 /* MAAL11 */
155 #define KS_ADD_ADDR_B_LO                0x00D8
156 /* MAAH11 */
157 #define KS_ADD_ADDR_B_HI                0x00DC
158 /* MAAL12 */
159 #define KS_ADD_ADDR_C_LO                0x00E0
160 /* MAAH12 */
161 #define KS_ADD_ADDR_C_HI                0x00E4
162 /* MAAL13 */
163 #define KS_ADD_ADDR_D_LO                0x00E8
164 /* MAAH13 */
165 #define KS_ADD_ADDR_D_HI                0x00EC
166 /* MAAL14 */
167 #define KS_ADD_ADDR_E_LO                0x00F0
168 /* MAAH14 */
169 #define KS_ADD_ADDR_E_HI                0x00F4
170 /* MAAL15 */
171 #define KS_ADD_ADDR_F_LO                0x00F8
172 /* MAAH15 */
173 #define KS_ADD_ADDR_F_HI                0x00FC
174
175 #define ADD_ADDR_HI_MASK                0x0000FFFF
176 #define ADD_ADDR_ENABLE                 0x80000000
177 #define ADD_ADDR_INCR                   8
178
179 /* Miscellaneous Registers */
180
181 /* MARL */
182 #define KS884X_ADDR_0_OFFSET            0x0200
183 #define KS884X_ADDR_1_OFFSET            0x0201
184 /* MARM */
185 #define KS884X_ADDR_2_OFFSET            0x0202
186 #define KS884X_ADDR_3_OFFSET            0x0203
187 /* MARH */
188 #define KS884X_ADDR_4_OFFSET            0x0204
189 #define KS884X_ADDR_5_OFFSET            0x0205
190
191 /* OBCR */
192 #define KS884X_BUS_CTRL_OFFSET          0x0210
193
194 #define BUS_SPEED_125_MHZ               0x0000
195 #define BUS_SPEED_62_5_MHZ              0x0001
196 #define BUS_SPEED_41_66_MHZ             0x0002
197 #define BUS_SPEED_25_MHZ                0x0003
198
199 /* EEPCR */
200 #define KS884X_EEPROM_CTRL_OFFSET       0x0212
201
202 #define EEPROM_CHIP_SELECT              0x0001
203 #define EEPROM_SERIAL_CLOCK             0x0002
204 #define EEPROM_DATA_OUT                 0x0004
205 #define EEPROM_DATA_IN                  0x0008
206 #define EEPROM_ACCESS_ENABLE            0x0010
207
208 /* MBIR */
209 #define KS884X_MEM_INFO_OFFSET          0x0214
210
211 #define RX_MEM_TEST_FAILED              0x0008
212 #define RX_MEM_TEST_FINISHED            0x0010
213 #define TX_MEM_TEST_FAILED              0x0800
214 #define TX_MEM_TEST_FINISHED            0x1000
215
216 /* GCR */
217 #define KS884X_GLOBAL_CTRL_OFFSET       0x0216
218 #define GLOBAL_SOFTWARE_RESET           0x0001
219
220 #define KS8841_POWER_MANAGE_OFFSET      0x0218
221
222 /* WFCR */
223 #define KS8841_WOL_CTRL_OFFSET          0x021A
224 #define KS8841_WOL_MAGIC_ENABLE         0x0080
225 #define KS8841_WOL_FRAME3_ENABLE        0x0008
226 #define KS8841_WOL_FRAME2_ENABLE        0x0004
227 #define KS8841_WOL_FRAME1_ENABLE        0x0002
228 #define KS8841_WOL_FRAME0_ENABLE        0x0001
229
230 /* WF0 */
231 #define KS8841_WOL_FRAME_CRC_OFFSET     0x0220
232 #define KS8841_WOL_FRAME_BYTE0_OFFSET   0x0224
233 #define KS8841_WOL_FRAME_BYTE2_OFFSET   0x0228
234
235 /* IACR */
236 #define KS884X_IACR_P                   0x04A0
237 #define KS884X_IACR_OFFSET              KS884X_IACR_P
238
239 /* IADR1 */
240 #define KS884X_IADR1_P                  0x04A2
241 #define KS884X_IADR2_P                  0x04A4
242 #define KS884X_IADR3_P                  0x04A6
243 #define KS884X_IADR4_P                  0x04A8
244 #define KS884X_IADR5_P                  0x04AA
245
246 #define KS884X_ACC_CTRL_SEL_OFFSET      KS884X_IACR_P
247 #define KS884X_ACC_CTRL_INDEX_OFFSET    (KS884X_ACC_CTRL_SEL_OFFSET + 1)
248
249 #define KS884X_ACC_DATA_0_OFFSET        KS884X_IADR4_P
250 #define KS884X_ACC_DATA_1_OFFSET        (KS884X_ACC_DATA_0_OFFSET + 1)
251 #define KS884X_ACC_DATA_2_OFFSET        KS884X_IADR5_P
252 #define KS884X_ACC_DATA_3_OFFSET        (KS884X_ACC_DATA_2_OFFSET + 1)
253 #define KS884X_ACC_DATA_4_OFFSET        KS884X_IADR2_P
254 #define KS884X_ACC_DATA_5_OFFSET        (KS884X_ACC_DATA_4_OFFSET + 1)
255 #define KS884X_ACC_DATA_6_OFFSET        KS884X_IADR3_P
256 #define KS884X_ACC_DATA_7_OFFSET        (KS884X_ACC_DATA_6_OFFSET + 1)
257 #define KS884X_ACC_DATA_8_OFFSET        KS884X_IADR1_P
258
259 /* P1MBCR */
260 #define KS884X_P1MBCR_P                 0x04D0
261 #define KS884X_P1MBSR_P                 0x04D2
262 #define KS884X_PHY1ILR_P                0x04D4
263 #define KS884X_PHY1IHR_P                0x04D6
264 #define KS884X_P1ANAR_P                 0x04D8
265 #define KS884X_P1ANLPR_P                0x04DA
266
267 /* P2MBCR */
268 #define KS884X_P2MBCR_P                 0x04E0
269 #define KS884X_P2MBSR_P                 0x04E2
270 #define KS884X_PHY2ILR_P                0x04E4
271 #define KS884X_PHY2IHR_P                0x04E6
272 #define KS884X_P2ANAR_P                 0x04E8
273 #define KS884X_P2ANLPR_P                0x04EA
274
275 #define KS884X_PHY_1_CTRL_OFFSET        KS884X_P1MBCR_P
276 #define PHY_CTRL_INTERVAL               (KS884X_P2MBCR_P - KS884X_P1MBCR_P)
277
278 #define KS884X_PHY_CTRL_OFFSET          0x00
279
280 /* Mode Control Register */
281 #define PHY_REG_CTRL                    0
282
283 #define PHY_RESET                       0x8000
284 #define PHY_LOOPBACK                    0x4000
285 #define PHY_SPEED_100MBIT               0x2000
286 #define PHY_AUTO_NEG_ENABLE             0x1000
287 #define PHY_POWER_DOWN                  0x0800
288 #define PHY_MII_DISABLE                 0x0400
289 #define PHY_AUTO_NEG_RESTART            0x0200
290 #define PHY_FULL_DUPLEX                 0x0100
291 #define PHY_COLLISION_TEST              0x0080
292 #define PHY_HP_MDIX                     0x0020
293 #define PHY_FORCE_MDIX                  0x0010
294 #define PHY_AUTO_MDIX_DISABLE           0x0008
295 #define PHY_REMOTE_FAULT_DISABLE        0x0004
296 #define PHY_TRANSMIT_DISABLE            0x0002
297 #define PHY_LED_DISABLE                 0x0001
298
299 #define KS884X_PHY_STATUS_OFFSET        0x02
300
301 /* Mode Status Register */
302 #define PHY_REG_STATUS                  1
303
304 #define PHY_100BT4_CAPABLE              0x8000
305 #define PHY_100BTX_FD_CAPABLE           0x4000
306 #define PHY_100BTX_CAPABLE              0x2000
307 #define PHY_10BT_FD_CAPABLE             0x1000
308 #define PHY_10BT_CAPABLE                0x0800
309 #define PHY_MII_SUPPRESS_CAPABLE        0x0040
310 #define PHY_AUTO_NEG_ACKNOWLEDGE        0x0020
311 #define PHY_REMOTE_FAULT                0x0010
312 #define PHY_AUTO_NEG_CAPABLE            0x0008
313 #define PHY_LINK_STATUS                 0x0004
314 #define PHY_JABBER_DETECT               0x0002
315 #define PHY_EXTENDED_CAPABILITY         0x0001
316
317 #define KS884X_PHY_ID_1_OFFSET          0x04
318 #define KS884X_PHY_ID_2_OFFSET          0x06
319
320 /* PHY Identifier Registers */
321 #define PHY_REG_ID_1                    2
322 #define PHY_REG_ID_2                    3
323
324 #define KS884X_PHY_AUTO_NEG_OFFSET      0x08
325
326 /* Auto-Negotiation Advertisement Register */
327 #define PHY_REG_AUTO_NEGOTIATION        4
328
329 #define PHY_AUTO_NEG_NEXT_PAGE          0x8000
330 #define PHY_AUTO_NEG_REMOTE_FAULT       0x2000
331 /* Not supported. */
332 #define PHY_AUTO_NEG_ASYM_PAUSE         0x0800
333 #define PHY_AUTO_NEG_SYM_PAUSE          0x0400
334 #define PHY_AUTO_NEG_100BT4             0x0200
335 #define PHY_AUTO_NEG_100BTX_FD          0x0100
336 #define PHY_AUTO_NEG_100BTX             0x0080
337 #define PHY_AUTO_NEG_10BT_FD            0x0040
338 #define PHY_AUTO_NEG_10BT               0x0020
339 #define PHY_AUTO_NEG_SELECTOR           0x001F
340 #define PHY_AUTO_NEG_802_3              0x0001
341
342 #define PHY_AUTO_NEG_PAUSE  (PHY_AUTO_NEG_SYM_PAUSE | PHY_AUTO_NEG_ASYM_PAUSE)
343
344 #define KS884X_PHY_REMOTE_CAP_OFFSET    0x0A
345
346 /* Auto-Negotiation Link Partner Ability Register */
347 #define PHY_REG_REMOTE_CAPABILITY       5
348
349 #define PHY_REMOTE_NEXT_PAGE            0x8000
350 #define PHY_REMOTE_ACKNOWLEDGE          0x4000
351 #define PHY_REMOTE_REMOTE_FAULT         0x2000
352 #define PHY_REMOTE_SYM_PAUSE            0x0400
353 #define PHY_REMOTE_100BTX_FD            0x0100
354 #define PHY_REMOTE_100BTX               0x0080
355 #define PHY_REMOTE_10BT_FD              0x0040
356 #define PHY_REMOTE_10BT                 0x0020
357
358 /* P1VCT */
359 #define KS884X_P1VCT_P                  0x04F0
360 #define KS884X_P1PHYCTRL_P              0x04F2
361
362 /* P2VCT */
363 #define KS884X_P2VCT_P                  0x04F4
364 #define KS884X_P2PHYCTRL_P              0x04F6
365
366 #define KS884X_PHY_SPECIAL_OFFSET       KS884X_P1VCT_P
367 #define PHY_SPECIAL_INTERVAL            (KS884X_P2VCT_P - KS884X_P1VCT_P)
368
369 #define KS884X_PHY_LINK_MD_OFFSET       0x00
370
371 #define PHY_START_CABLE_DIAG            0x8000
372 #define PHY_CABLE_DIAG_RESULT           0x6000
373 #define PHY_CABLE_STAT_NORMAL           0x0000
374 #define PHY_CABLE_STAT_OPEN             0x2000
375 #define PHY_CABLE_STAT_SHORT            0x4000
376 #define PHY_CABLE_STAT_FAILED           0x6000
377 #define PHY_CABLE_10M_SHORT             0x1000
378 #define PHY_CABLE_FAULT_COUNTER         0x01FF
379
380 #define KS884X_PHY_PHY_CTRL_OFFSET      0x02
381
382 #define PHY_STAT_REVERSED_POLARITY      0x0020
383 #define PHY_STAT_MDIX                   0x0010
384 #define PHY_FORCE_LINK                  0x0008
385 #define PHY_POWER_SAVING_DISABLE        0x0004
386 #define PHY_REMOTE_LOOPBACK             0x0002
387
388 /* SIDER */
389 #define KS884X_SIDER_P                  0x0400
390 #define KS884X_CHIP_ID_OFFSET           KS884X_SIDER_P
391 #define KS884X_FAMILY_ID_OFFSET         (KS884X_CHIP_ID_OFFSET + 1)
392
393 #define REG_FAMILY_ID                   0x88
394
395 #define REG_CHIP_ID_41                  0x8810
396 #define REG_CHIP_ID_42                  0x8800
397
398 #define KS884X_CHIP_ID_MASK_41          0xFF10
399 #define KS884X_CHIP_ID_MASK             0xFFF0
400 #define KS884X_CHIP_ID_SHIFT            4
401 #define KS884X_REVISION_MASK            0x000E
402 #define KS884X_REVISION_SHIFT           1
403 #define KS8842_START                    0x0001
404
405 #define CHIP_IP_41_M                    0x8810
406 #define CHIP_IP_42_M                    0x8800
407 #define CHIP_IP_61_M                    0x8890
408 #define CHIP_IP_62_M                    0x8880
409
410 #define CHIP_IP_41_P                    0x8850
411 #define CHIP_IP_42_P                    0x8840
412 #define CHIP_IP_61_P                    0x88D0
413 #define CHIP_IP_62_P                    0x88C0
414
415 /* SGCR1 */
416 #define KS8842_SGCR1_P                  0x0402
417 #define KS8842_SWITCH_CTRL_1_OFFSET     KS8842_SGCR1_P
418
419 #define SWITCH_PASS_ALL                 0x8000
420 #define SWITCH_TX_FLOW_CTRL             0x2000
421 #define SWITCH_RX_FLOW_CTRL             0x1000
422 #define SWITCH_CHECK_LENGTH             0x0800
423 #define SWITCH_AGING_ENABLE             0x0400
424 #define SWITCH_FAST_AGING               0x0200
425 #define SWITCH_AGGR_BACKOFF             0x0100
426 #define SWITCH_PASS_PAUSE               0x0008
427 #define SWITCH_LINK_AUTO_AGING          0x0001
428
429 /* SGCR2 */
430 #define KS8842_SGCR2_P                  0x0404
431 #define KS8842_SWITCH_CTRL_2_OFFSET     KS8842_SGCR2_P
432
433 #define SWITCH_VLAN_ENABLE              0x8000
434 #define SWITCH_IGMP_SNOOP               0x4000
435 #define IPV6_MLD_SNOOP_ENABLE           0x2000
436 #define IPV6_MLD_SNOOP_OPTION           0x1000
437 #define PRIORITY_SCHEME_SELECT          0x0800
438 #define SWITCH_MIRROR_RX_TX             0x0100
439 #define UNICAST_VLAN_BOUNDARY           0x0080
440 #define MULTICAST_STORM_DISABLE         0x0040
441 #define SWITCH_BACK_PRESSURE            0x0020
442 #define FAIR_FLOW_CTRL                  0x0010
443 #define NO_EXC_COLLISION_DROP           0x0008
444 #define SWITCH_HUGE_PACKET              0x0004
445 #define SWITCH_LEGAL_PACKET             0x0002
446 #define SWITCH_BUF_RESERVE              0x0001
447
448 /* SGCR3 */
449 #define KS8842_SGCR3_P                  0x0406
450 #define KS8842_SWITCH_CTRL_3_OFFSET     KS8842_SGCR3_P
451
452 #define BROADCAST_STORM_RATE_LO         0xFF00
453 #define SWITCH_REPEATER                 0x0080
454 #define SWITCH_HALF_DUPLEX              0x0040
455 #define SWITCH_FLOW_CTRL                0x0020
456 #define SWITCH_10_MBIT                  0x0010
457 #define SWITCH_REPLACE_NULL_VID         0x0008
458 #define BROADCAST_STORM_RATE_HI         0x0007
459
460 #define BROADCAST_STORM_RATE            0x07FF
461
462 /* SGCR4 */
463 #define KS8842_SGCR4_P                  0x0408
464
465 /* SGCR5 */
466 #define KS8842_SGCR5_P                  0x040A
467 #define KS8842_SWITCH_CTRL_5_OFFSET     KS8842_SGCR5_P
468
469 #define LED_MODE                        0x8200
470 #define LED_SPEED_DUPLEX_ACT            0x0000
471 #define LED_SPEED_DUPLEX_LINK_ACT       0x8000
472 #define LED_DUPLEX_10_100               0x0200
473
474 /* SGCR6 */
475 #define KS8842_SGCR6_P                  0x0410
476 #define KS8842_SWITCH_CTRL_6_OFFSET     KS8842_SGCR6_P
477
478 #define KS8842_PRIORITY_MASK            3
479 #define KS8842_PRIORITY_SHIFT           2
480
481 /* SGCR7 */
482 #define KS8842_SGCR7_P                  0x0412
483 #define KS8842_SWITCH_CTRL_7_OFFSET     KS8842_SGCR7_P
484
485 #define SWITCH_UNK_DEF_PORT_ENABLE      0x0008
486 #define SWITCH_UNK_DEF_PORT_3           0x0004
487 #define SWITCH_UNK_DEF_PORT_2           0x0002
488 #define SWITCH_UNK_DEF_PORT_1           0x0001
489
490 /* MACAR1 */
491 #define KS8842_MACAR1_P                 0x0470
492 #define KS8842_MACAR2_P                 0x0472
493 #define KS8842_MACAR3_P                 0x0474
494 #define KS8842_MAC_ADDR_1_OFFSET        KS8842_MACAR1_P
495 #define KS8842_MAC_ADDR_0_OFFSET        (KS8842_MAC_ADDR_1_OFFSET + 1)
496 #define KS8842_MAC_ADDR_3_OFFSET        KS8842_MACAR2_P
497 #define KS8842_MAC_ADDR_2_OFFSET        (KS8842_MAC_ADDR_3_OFFSET + 1)
498 #define KS8842_MAC_ADDR_5_OFFSET        KS8842_MACAR3_P
499 #define KS8842_MAC_ADDR_4_OFFSET        (KS8842_MAC_ADDR_5_OFFSET + 1)
500
501 /* TOSR1 */
502 #define KS8842_TOSR1_P                  0x0480
503 #define KS8842_TOSR2_P                  0x0482
504 #define KS8842_TOSR3_P                  0x0484
505 #define KS8842_TOSR4_P                  0x0486
506 #define KS8842_TOSR5_P                  0x0488
507 #define KS8842_TOSR6_P                  0x048A
508 #define KS8842_TOSR7_P                  0x0490
509 #define KS8842_TOSR8_P                  0x0492
510 #define KS8842_TOS_1_OFFSET             KS8842_TOSR1_P
511 #define KS8842_TOS_2_OFFSET             KS8842_TOSR2_P
512 #define KS8842_TOS_3_OFFSET             KS8842_TOSR3_P
513 #define KS8842_TOS_4_OFFSET             KS8842_TOSR4_P
514 #define KS8842_TOS_5_OFFSET             KS8842_TOSR5_P
515 #define KS8842_TOS_6_OFFSET             KS8842_TOSR6_P
516
517 #define KS8842_TOS_7_OFFSET             KS8842_TOSR7_P
518 #define KS8842_TOS_8_OFFSET             KS8842_TOSR8_P
519
520 /* P1CR1 */
521 #define KS8842_P1CR1_P                  0x0500
522 #define KS8842_P1CR2_P                  0x0502
523 #define KS8842_P1VIDR_P                 0x0504
524 #define KS8842_P1CR3_P                  0x0506
525 #define KS8842_P1IRCR_P                 0x0508
526 #define KS8842_P1ERCR_P                 0x050A
527 #define KS884X_P1SCSLMD_P               0x0510
528 #define KS884X_P1CR4_P                  0x0512
529 #define KS884X_P1SR_P                   0x0514
530
531 /* P2CR1 */
532 #define KS8842_P2CR1_P                  0x0520
533 #define KS8842_P2CR2_P                  0x0522
534 #define KS8842_P2VIDR_P                 0x0524
535 #define KS8842_P2CR3_P                  0x0526
536 #define KS8842_P2IRCR_P                 0x0528
537 #define KS8842_P2ERCR_P                 0x052A
538 #define KS884X_P2SCSLMD_P               0x0530
539 #define KS884X_P2CR4_P                  0x0532
540 #define KS884X_P2SR_P                   0x0534
541
542 /* P3CR1 */
543 #define KS8842_P3CR1_P                  0x0540
544 #define KS8842_P3CR2_P                  0x0542
545 #define KS8842_P3VIDR_P                 0x0544
546 #define KS8842_P3CR3_P                  0x0546
547 #define KS8842_P3IRCR_P                 0x0548
548 #define KS8842_P3ERCR_P                 0x054A
549
550 #define KS8842_PORT_1_CTRL_1            KS8842_P1CR1_P
551 #define KS8842_PORT_2_CTRL_1            KS8842_P2CR1_P
552 #define KS8842_PORT_3_CTRL_1            KS8842_P3CR1_P
553
554 #define PORT_CTRL_ADDR(port, addr)              \
555         (addr = KS8842_PORT_1_CTRL_1 + (port) * \
556                 (KS8842_PORT_2_CTRL_1 - KS8842_PORT_1_CTRL_1))
557
558 #define KS8842_PORT_CTRL_1_OFFSET       0x00
559
560 #define PORT_BROADCAST_STORM            0x0080
561 #define PORT_DIFFSERV_ENABLE            0x0040
562 #define PORT_802_1P_ENABLE              0x0020
563 #define PORT_BASED_PRIORITY_MASK        0x0018
564 #define PORT_BASED_PRIORITY_BASE        0x0003
565 #define PORT_BASED_PRIORITY_SHIFT       3
566 #define PORT_BASED_PRIORITY_0           0x0000
567 #define PORT_BASED_PRIORITY_1           0x0008
568 #define PORT_BASED_PRIORITY_2           0x0010
569 #define PORT_BASED_PRIORITY_3           0x0018
570 #define PORT_INSERT_TAG                 0x0004
571 #define PORT_REMOVE_TAG                 0x0002
572 #define PORT_PRIO_QUEUE_ENABLE          0x0001
573
574 #define KS8842_PORT_CTRL_2_OFFSET       0x02
575
576 #define PORT_INGRESS_VLAN_FILTER        0x4000
577 #define PORT_DISCARD_NON_VID            0x2000
578 #define PORT_FORCE_FLOW_CTRL            0x1000
579 #define PORT_BACK_PRESSURE              0x0800
580 #define PORT_TX_ENABLE                  0x0400
581 #define PORT_RX_ENABLE                  0x0200
582 #define PORT_LEARN_DISABLE              0x0100
583 #define PORT_MIRROR_SNIFFER             0x0080
584 #define PORT_MIRROR_RX                  0x0040
585 #define PORT_MIRROR_TX                  0x0020
586 #define PORT_USER_PRIORITY_CEILING      0x0008
587 #define PORT_VLAN_MEMBERSHIP            0x0007
588
589 #define KS8842_PORT_CTRL_VID_OFFSET     0x04
590
591 #define PORT_DEFAULT_VID                0x0001
592
593 #define KS8842_PORT_CTRL_3_OFFSET       0x06
594
595 #define PORT_INGRESS_LIMIT_MODE         0x000C
596 #define PORT_INGRESS_ALL                0x0000
597 #define PORT_INGRESS_UNICAST            0x0004
598 #define PORT_INGRESS_MULTICAST          0x0008
599 #define PORT_INGRESS_BROADCAST          0x000C
600 #define PORT_COUNT_IFG                  0x0002
601 #define PORT_COUNT_PREAMBLE             0x0001
602
603 #define KS8842_PORT_IN_RATE_OFFSET      0x08
604 #define KS8842_PORT_OUT_RATE_OFFSET     0x0A
605
606 #define PORT_PRIORITY_RATE              0x0F
607 #define PORT_PRIORITY_RATE_SHIFT        4
608
609 #define KS884X_PORT_LINK_MD             0x10
610
611 #define PORT_CABLE_10M_SHORT            0x8000
612 #define PORT_CABLE_DIAG_RESULT          0x6000
613 #define PORT_CABLE_STAT_NORMAL          0x0000
614 #define PORT_CABLE_STAT_OPEN            0x2000
615 #define PORT_CABLE_STAT_SHORT           0x4000
616 #define PORT_CABLE_STAT_FAILED          0x6000
617 #define PORT_START_CABLE_DIAG           0x1000
618 #define PORT_FORCE_LINK                 0x0800
619 #define PORT_POWER_SAVING_DISABLE       0x0400
620 #define PORT_PHY_REMOTE_LOOPBACK        0x0200
621 #define PORT_CABLE_FAULT_COUNTER        0x01FF
622
623 #define KS884X_PORT_CTRL_4_OFFSET       0x12
624
625 #define PORT_LED_OFF                    0x8000
626 #define PORT_TX_DISABLE                 0x4000
627 #define PORT_AUTO_NEG_RESTART           0x2000
628 #define PORT_REMOTE_FAULT_DISABLE       0x1000
629 #define PORT_POWER_DOWN                 0x0800
630 #define PORT_AUTO_MDIX_DISABLE          0x0400
631 #define PORT_FORCE_MDIX                 0x0200
632 #define PORT_LOOPBACK                   0x0100
633 #define PORT_AUTO_NEG_ENABLE            0x0080
634 #define PORT_FORCE_100_MBIT             0x0040
635 #define PORT_FORCE_FULL_DUPLEX          0x0020
636 #define PORT_AUTO_NEG_SYM_PAUSE         0x0010
637 #define PORT_AUTO_NEG_100BTX_FD         0x0008
638 #define PORT_AUTO_NEG_100BTX            0x0004
639 #define PORT_AUTO_NEG_10BT_FD           0x0002
640 #define PORT_AUTO_NEG_10BT              0x0001
641
642 #define KS884X_PORT_STATUS_OFFSET       0x14
643
644 #define PORT_HP_MDIX                    0x8000
645 #define PORT_REVERSED_POLARITY          0x2000
646 #define PORT_RX_FLOW_CTRL               0x0800
647 #define PORT_TX_FLOW_CTRL               0x1000
648 #define PORT_STATUS_SPEED_100MBIT       0x0400
649 #define PORT_STATUS_FULL_DUPLEX         0x0200
650 #define PORT_REMOTE_FAULT               0x0100
651 #define PORT_MDIX_STATUS                0x0080
652 #define PORT_AUTO_NEG_COMPLETE          0x0040
653 #define PORT_STATUS_LINK_GOOD           0x0020
654 #define PORT_REMOTE_SYM_PAUSE           0x0010
655 #define PORT_REMOTE_100BTX_FD           0x0008
656 #define PORT_REMOTE_100BTX              0x0004
657 #define PORT_REMOTE_10BT_FD             0x0002
658 #define PORT_REMOTE_10BT                0x0001
659
660 /*
661 #define STATIC_MAC_TABLE_ADDR           00-0000FFFF-FFFFFFFF
662 #define STATIC_MAC_TABLE_FWD_PORTS      00-00070000-00000000
663 #define STATIC_MAC_TABLE_VALID          00-00080000-00000000
664 #define STATIC_MAC_TABLE_OVERRIDE       00-00100000-00000000
665 #define STATIC_MAC_TABLE_USE_FID        00-00200000-00000000
666 #define STATIC_MAC_TABLE_FID            00-03C00000-00000000
667 */
668
669 #define STATIC_MAC_TABLE_ADDR           0x0000FFFF
670 #define STATIC_MAC_TABLE_FWD_PORTS      0x00070000
671 #define STATIC_MAC_TABLE_VALID          0x00080000
672 #define STATIC_MAC_TABLE_OVERRIDE       0x00100000
673 #define STATIC_MAC_TABLE_USE_FID        0x00200000
674 #define STATIC_MAC_TABLE_FID            0x03C00000
675
676 #define STATIC_MAC_FWD_PORTS_SHIFT      16
677 #define STATIC_MAC_FID_SHIFT            22
678
679 /*
680 #define VLAN_TABLE_VID                  00-00000000-00000FFF
681 #define VLAN_TABLE_FID                  00-00000000-0000F000
682 #define VLAN_TABLE_MEMBERSHIP           00-00000000-00070000
683 #define VLAN_TABLE_VALID                00-00000000-00080000
684 */
685
686 #define VLAN_TABLE_VID                  0x00000FFF
687 #define VLAN_TABLE_FID                  0x0000F000
688 #define VLAN_TABLE_MEMBERSHIP           0x00070000
689 #define VLAN_TABLE_VALID                0x00080000
690
691 #define VLAN_TABLE_FID_SHIFT            12
692 #define VLAN_TABLE_MEMBERSHIP_SHIFT     16
693
694 /*
695 #define DYNAMIC_MAC_TABLE_ADDR          00-0000FFFF-FFFFFFFF
696 #define DYNAMIC_MAC_TABLE_FID           00-000F0000-00000000
697 #define DYNAMIC_MAC_TABLE_SRC_PORT      00-00300000-00000000
698 #define DYNAMIC_MAC_TABLE_TIMESTAMP     00-00C00000-00000000
699 #define DYNAMIC_MAC_TABLE_ENTRIES       03-FF000000-00000000
700 #define DYNAMIC_MAC_TABLE_MAC_EMPTY     04-00000000-00000000
701 #define DYNAMIC_MAC_TABLE_RESERVED      78-00000000-00000000
702 #define DYNAMIC_MAC_TABLE_NOT_READY     80-00000000-00000000
703 */
704
705 #define DYNAMIC_MAC_TABLE_ADDR          0x0000FFFF
706 #define DYNAMIC_MAC_TABLE_FID           0x000F0000
707 #define DYNAMIC_MAC_TABLE_SRC_PORT      0x00300000
708 #define DYNAMIC_MAC_TABLE_TIMESTAMP     0x00C00000
709 #define DYNAMIC_MAC_TABLE_ENTRIES       0xFF000000
710
711 #define DYNAMIC_MAC_TABLE_ENTRIES_H     0x03
712 #define DYNAMIC_MAC_TABLE_MAC_EMPTY     0x04
713 #define DYNAMIC_MAC_TABLE_RESERVED      0x78
714 #define DYNAMIC_MAC_TABLE_NOT_READY     0x80
715
716 #define DYNAMIC_MAC_FID_SHIFT           16
717 #define DYNAMIC_MAC_SRC_PORT_SHIFT      20
718 #define DYNAMIC_MAC_TIMESTAMP_SHIFT     22
719 #define DYNAMIC_MAC_ENTRIES_SHIFT       24
720 #define DYNAMIC_MAC_ENTRIES_H_SHIFT     8
721
722 /*
723 #define MIB_COUNTER_VALUE               00-00000000-3FFFFFFF
724 #define MIB_COUNTER_VALID               00-00000000-40000000
725 #define MIB_COUNTER_OVERFLOW            00-00000000-80000000
726 */
727
728 #define MIB_COUNTER_VALUE               0x3FFFFFFF
729 #define MIB_COUNTER_VALID               0x40000000
730 #define MIB_COUNTER_OVERFLOW            0x80000000
731
732 #define MIB_PACKET_DROPPED              0x0000FFFF
733
734 #define KS_MIB_PACKET_DROPPED_TX_0      0x100
735 #define KS_MIB_PACKET_DROPPED_TX_1      0x101
736 #define KS_MIB_PACKET_DROPPED_TX        0x102
737 #define KS_MIB_PACKET_DROPPED_RX_0      0x103
738 #define KS_MIB_PACKET_DROPPED_RX_1      0x104
739 #define KS_MIB_PACKET_DROPPED_RX        0x105
740
741 /* Change default LED mode. */
742 #define SET_DEFAULT_LED                 LED_SPEED_DUPLEX_ACT
743
744 #define MAC_ADDR_LEN                    6
745 #define MAC_ADDR_ORDER(i)               (MAC_ADDR_LEN - 1 - (i))
746
747 #define MAX_ETHERNET_BODY_SIZE          1500
748 #define ETHERNET_HEADER_SIZE            14
749
750 #define MAX_ETHERNET_PACKET_SIZE        \
751         (MAX_ETHERNET_BODY_SIZE + ETHERNET_HEADER_SIZE)
752
753 #define REGULAR_RX_BUF_SIZE             (MAX_ETHERNET_PACKET_SIZE + 4)
754 #define MAX_RX_BUF_SIZE                 (1912 + 4)
755
756 #define ADDITIONAL_ENTRIES              16
757 #define MAX_MULTICAST_LIST              32
758
759 #define HW_MULTICAST_SIZE               8
760
761 #define HW_TO_DEV_PORT(port)            (port - 1)
762
763 enum {
764         media_connected,
765         media_disconnected
766 };
767
768 enum {
769         OID_COUNTER_UNKOWN,
770
771         OID_COUNTER_FIRST,
772
773         /* total transmit errors */
774         OID_COUNTER_XMIT_ERROR,
775
776         /* total receive errors */
777         OID_COUNTER_RCV_ERROR,
778
779         OID_COUNTER_LAST
780 };
781
782 /*
783  * Hardware descriptor definitions
784  */
785
786 #define DESC_ALIGNMENT                  16
787 #define BUFFER_ALIGNMENT                8
788
789 #define NUM_OF_RX_DESC                  64
790 #define NUM_OF_TX_DESC                  64
791
792 #define KS_DESC_RX_FRAME_LEN            0x000007FF
793 #define KS_DESC_RX_FRAME_TYPE           0x00008000
794 #define KS_DESC_RX_ERROR_CRC            0x00010000
795 #define KS_DESC_RX_ERROR_RUNT           0x00020000
796 #define KS_DESC_RX_ERROR_TOO_LONG       0x00040000
797 #define KS_DESC_RX_ERROR_PHY            0x00080000
798 #define KS884X_DESC_RX_PORT_MASK        0x00300000
799 #define KS_DESC_RX_MULTICAST            0x01000000
800 #define KS_DESC_RX_ERROR                0x02000000
801 #define KS_DESC_RX_ERROR_CSUM_UDP       0x04000000
802 #define KS_DESC_RX_ERROR_CSUM_TCP       0x08000000
803 #define KS_DESC_RX_ERROR_CSUM_IP        0x10000000
804 #define KS_DESC_RX_LAST                 0x20000000
805 #define KS_DESC_RX_FIRST                0x40000000
806 #define KS_DESC_RX_ERROR_COND           \
807         (KS_DESC_RX_ERROR_CRC |         \
808         KS_DESC_RX_ERROR_RUNT |         \
809         KS_DESC_RX_ERROR_PHY |          \
810         KS_DESC_RX_ERROR_TOO_LONG)
811
812 #define KS_DESC_HW_OWNED                0x80000000
813
814 #define KS_DESC_BUF_SIZE                0x000007FF
815 #define KS884X_DESC_TX_PORT_MASK        0x00300000
816 #define KS_DESC_END_OF_RING             0x02000000
817 #define KS_DESC_TX_CSUM_GEN_UDP         0x04000000
818 #define KS_DESC_TX_CSUM_GEN_TCP         0x08000000
819 #define KS_DESC_TX_CSUM_GEN_IP          0x10000000
820 #define KS_DESC_TX_LAST                 0x20000000
821 #define KS_DESC_TX_FIRST                0x40000000
822 #define KS_DESC_TX_INTERRUPT            0x80000000
823
824 #define KS_DESC_PORT_SHIFT              20
825
826 #define KS_DESC_RX_MASK                 (KS_DESC_BUF_SIZE)
827
828 #define KS_DESC_TX_MASK                 \
829         (KS_DESC_TX_INTERRUPT |         \
830         KS_DESC_TX_FIRST |              \
831         KS_DESC_TX_LAST |               \
832         KS_DESC_TX_CSUM_GEN_IP |        \
833         KS_DESC_TX_CSUM_GEN_TCP |       \
834         KS_DESC_TX_CSUM_GEN_UDP |       \
835         KS_DESC_BUF_SIZE)
836
837 struct ksz_desc_rx_stat {
838 #ifdef __BIG_ENDIAN_BITFIELD
839         u32 hw_owned:1;
840         u32 first_desc:1;
841         u32 last_desc:1;
842         u32 csum_err_ip:1;
843         u32 csum_err_tcp:1;
844         u32 csum_err_udp:1;
845         u32 error:1;
846         u32 multicast:1;
847         u32 src_port:4;
848         u32 err_phy:1;
849         u32 err_too_long:1;
850         u32 err_runt:1;
851         u32 err_crc:1;
852         u32 frame_type:1;
853         u32 reserved1:4;
854         u32 frame_len:11;
855 #else
856         u32 frame_len:11;
857         u32 reserved1:4;
858         u32 frame_type:1;
859         u32 err_crc:1;
860         u32 err_runt:1;
861         u32 err_too_long:1;
862         u32 err_phy:1;
863         u32 src_port:4;
864         u32 multicast:1;
865         u32 error:1;
866         u32 csum_err_udp:1;
867         u32 csum_err_tcp:1;
868         u32 csum_err_ip:1;
869         u32 last_desc:1;
870         u32 first_desc:1;
871         u32 hw_owned:1;
872 #endif
873 };
874
875 struct ksz_desc_tx_stat {
876 #ifdef __BIG_ENDIAN_BITFIELD
877         u32 hw_owned:1;
878         u32 reserved1:31;
879 #else
880         u32 reserved1:31;
881         u32 hw_owned:1;
882 #endif
883 };
884
885 struct ksz_desc_rx_buf {
886 #ifdef __BIG_ENDIAN_BITFIELD
887         u32 reserved4:6;
888         u32 end_of_ring:1;
889         u32 reserved3:14;
890         u32 buf_size:11;
891 #else
892         u32 buf_size:11;
893         u32 reserved3:14;
894         u32 end_of_ring:1;
895         u32 reserved4:6;
896 #endif
897 };
898
899 struct ksz_desc_tx_buf {
900 #ifdef __BIG_ENDIAN_BITFIELD
901         u32 intr:1;
902         u32 first_seg:1;
903         u32 last_seg:1;
904         u32 csum_gen_ip:1;
905         u32 csum_gen_tcp:1;
906         u32 csum_gen_udp:1;
907         u32 end_of_ring:1;
908         u32 reserved4:1;
909         u32 dest_port:4;
910         u32 reserved3:9;
911         u32 buf_size:11;
912 #else
913         u32 buf_size:11;
914         u32 reserved3:9;
915         u32 dest_port:4;
916         u32 reserved4:1;
917         u32 end_of_ring:1;
918         u32 csum_gen_udp:1;
919         u32 csum_gen_tcp:1;
920         u32 csum_gen_ip:1;
921         u32 last_seg:1;
922         u32 first_seg:1;
923         u32 intr:1;
924 #endif
925 };
926
927 union desc_stat {
928         struct ksz_desc_rx_stat rx;
929         struct ksz_desc_tx_stat tx;
930         u32 data;
931 };
932
933 union desc_buf {
934         struct ksz_desc_rx_buf rx;
935         struct ksz_desc_tx_buf tx;
936         u32 data;
937 };
938
939 /**
940  * struct ksz_hw_desc - Hardware descriptor data structure
941  * @ctrl:       Descriptor control value.
942  * @buf:        Descriptor buffer value.
943  * @addr:       Physical address of memory buffer.
944  * @next:       Pointer to next hardware descriptor.
945  */
946 struct ksz_hw_desc {
947         union desc_stat ctrl;
948         union desc_buf buf;
949         u32 addr;
950         u32 next;
951 };
952
953 /**
954  * struct ksz_sw_desc - Software descriptor data structure
955  * @ctrl:       Descriptor control value.
956  * @buf:        Descriptor buffer value.
957  * @buf_size:   Current buffers size value in hardware descriptor.
958  */
959 struct ksz_sw_desc {
960         union desc_stat ctrl;
961         union desc_buf buf;
962         u32 buf_size;
963 };
964
965 /**
966  * struct ksz_dma_buf - OS dependent DMA buffer data structure
967  * @skb:        Associated socket buffer.
968  * @dma:        Associated physical DMA address.
969  * len:         Actual len used.
970  */
971 struct ksz_dma_buf {
972         struct sk_buff *skb;
973         dma_addr_t dma;
974         int len;
975 };
976
977 /**
978  * struct ksz_desc - Descriptor structure
979  * @phw:        Hardware descriptor pointer to uncached physical memory.
980  * @sw:         Cached memory to hold hardware descriptor values for
981  *              manipulation.
982  * @dma_buf:    Operating system dependent data structure to hold physical
983  *              memory buffer allocation information.
984  */
985 struct ksz_desc {
986         struct ksz_hw_desc *phw;
987         struct ksz_sw_desc sw;
988         struct ksz_dma_buf dma_buf;
989 };
990
991 #define DMA_BUFFER(desc)  ((struct ksz_dma_buf *)(&(desc)->dma_buf))
992
993 /**
994  * struct ksz_desc_info - Descriptor information data structure
995  * @ring:       First descriptor in the ring.
996  * @cur:        Current descriptor being manipulated.
997  * @ring_virt:  First hardware descriptor in the ring.
998  * @ring_phys:  The physical address of the first descriptor of the ring.
999  * @size:       Size of hardware descriptor.
1000  * @alloc:      Number of descriptors allocated.
1001  * @avail:      Number of descriptors available for use.
1002  * @last:       Index for last descriptor released to hardware.
1003  * @next:       Index for next descriptor available for use.
1004  * @mask:       Mask for index wrapping.
1005  */
1006 struct ksz_desc_info {
1007         struct ksz_desc *ring;
1008         struct ksz_desc *cur;
1009         struct ksz_hw_desc *ring_virt;
1010         u32 ring_phys;
1011         int size;
1012         int alloc;
1013         int avail;
1014         int last;
1015         int next;
1016         int mask;
1017 };
1018
1019 /*
1020  * KSZ8842 switch definitions
1021  */
1022
1023 enum {
1024         TABLE_STATIC_MAC = 0,
1025         TABLE_VLAN,
1026         TABLE_DYNAMIC_MAC,
1027         TABLE_MIB
1028 };
1029
1030 #define LEARNED_MAC_TABLE_ENTRIES       1024
1031 #define STATIC_MAC_TABLE_ENTRIES        8
1032
1033 /**
1034  * struct ksz_mac_table - Static MAC table data structure
1035  * @mac_addr:   MAC address to filter.
1036  * @vid:        VID value.
1037  * @fid:        FID value.
1038  * @ports:      Port membership.
1039  * @override:   Override setting.
1040  * @use_fid:    FID use setting.
1041  * @valid:      Valid setting indicating the entry is being used.
1042  */
1043 struct ksz_mac_table {
1044         u8 mac_addr[MAC_ADDR_LEN];
1045         u16 vid;
1046         u8 fid;
1047         u8 ports;
1048         u8 override:1;
1049         u8 use_fid:1;
1050         u8 valid:1;
1051 };
1052
1053 #define VLAN_TABLE_ENTRIES              16
1054
1055 /**
1056  * struct ksz_vlan_table - VLAN table data structure
1057  * @vid:        VID value.
1058  * @fid:        FID value.
1059  * @member:     Port membership.
1060  */
1061 struct ksz_vlan_table {
1062         u16 vid;
1063         u8 fid;
1064         u8 member;
1065 };
1066
1067 #define DIFFSERV_ENTRIES                64
1068 #define PRIO_802_1P_ENTRIES             8
1069 #define PRIO_QUEUES                     4
1070
1071 #define SWITCH_PORT_NUM                 2
1072 #define TOTAL_PORT_NUM                  (SWITCH_PORT_NUM + 1)
1073 #define HOST_MASK                       (1 << SWITCH_PORT_NUM)
1074 #define PORT_MASK                       7
1075
1076 #define MAIN_PORT                       0
1077 #define OTHER_PORT                      1
1078 #define HOST_PORT                       SWITCH_PORT_NUM
1079
1080 #define PORT_COUNTER_NUM                0x20
1081 #define TOTAL_PORT_COUNTER_NUM          (PORT_COUNTER_NUM + 2)
1082
1083 #define MIB_COUNTER_RX_LO_PRIORITY      0x00
1084 #define MIB_COUNTER_RX_HI_PRIORITY      0x01
1085 #define MIB_COUNTER_RX_UNDERSIZE        0x02
1086 #define MIB_COUNTER_RX_FRAGMENT         0x03
1087 #define MIB_COUNTER_RX_OVERSIZE         0x04
1088 #define MIB_COUNTER_RX_JABBER           0x05
1089 #define MIB_COUNTER_RX_SYMBOL_ERR       0x06
1090 #define MIB_COUNTER_RX_CRC_ERR          0x07
1091 #define MIB_COUNTER_RX_ALIGNMENT_ERR    0x08
1092 #define MIB_COUNTER_RX_CTRL_8808        0x09
1093 #define MIB_COUNTER_RX_PAUSE            0x0A
1094 #define MIB_COUNTER_RX_BROADCAST        0x0B
1095 #define MIB_COUNTER_RX_MULTICAST        0x0C
1096 #define MIB_COUNTER_RX_UNICAST          0x0D
1097 #define MIB_COUNTER_RX_OCTET_64         0x0E
1098 #define MIB_COUNTER_RX_OCTET_65_127     0x0F
1099 #define MIB_COUNTER_RX_OCTET_128_255    0x10
1100 #define MIB_COUNTER_RX_OCTET_256_511    0x11
1101 #define MIB_COUNTER_RX_OCTET_512_1023   0x12
1102 #define MIB_COUNTER_RX_OCTET_1024_1522  0x13
1103 #define MIB_COUNTER_TX_LO_PRIORITY      0x14
1104 #define MIB_COUNTER_TX_HI_PRIORITY      0x15
1105 #define MIB_COUNTER_TX_LATE_COLLISION   0x16
1106 #define MIB_COUNTER_TX_PAUSE            0x17
1107 #define MIB_COUNTER_TX_BROADCAST        0x18
1108 #define MIB_COUNTER_TX_MULTICAST        0x19
1109 #define MIB_COUNTER_TX_UNICAST          0x1A
1110 #define MIB_COUNTER_TX_DEFERRED         0x1B
1111 #define MIB_COUNTER_TX_TOTAL_COLLISION  0x1C
1112 #define MIB_COUNTER_TX_EXCESS_COLLISION 0x1D
1113 #define MIB_COUNTER_TX_SINGLE_COLLISION 0x1E
1114 #define MIB_COUNTER_TX_MULTI_COLLISION  0x1F
1115
1116 #define MIB_COUNTER_RX_DROPPED_PACKET   0x20
1117 #define MIB_COUNTER_TX_DROPPED_PACKET   0x21
1118
1119 /**
1120  * struct ksz_port_mib - Port MIB data structure
1121  * @cnt_ptr:    Current pointer to MIB counter index.
1122  * @link_down:  Indication the link has just gone down.
1123  * @state:      Connection status of the port.
1124  * @mib_start:  The starting counter index.  Some ports do not start at 0.
1125  * @counter:    64-bit MIB counter value.
1126  * @dropped:    Temporary buffer to remember last read packet dropped values.
1127  *
1128  * MIB counters needs to be read periodically so that counters do not get
1129  * overflowed and give incorrect values.  A right balance is needed to
1130  * satisfy this condition and not waste too much CPU time.
1131  *
1132  * It is pointless to read MIB counters when the port is disconnected.  The
1133  * @state provides the connection status so that MIB counters are read only
1134  * when the port is connected.  The @link_down indicates the port is just
1135  * disconnected so that all MIB counters are read one last time to update the
1136  * information.
1137  */
1138 struct ksz_port_mib {
1139         u8 cnt_ptr;
1140         u8 link_down;
1141         u8 state;
1142         u8 mib_start;
1143
1144         u64 counter[TOTAL_PORT_COUNTER_NUM];
1145         u32 dropped[2];
1146 };
1147
1148 /**
1149  * struct ksz_port_cfg - Port configuration data structure
1150  * @vid:        VID value.
1151  * @member:     Port membership.
1152  * @port_prio:  Port priority.
1153  * @rx_rate:    Receive priority rate.
1154  * @tx_rate:    Transmit priority rate.
1155  * @stp_state:  Current Spanning Tree Protocol state.
1156  */
1157 struct ksz_port_cfg {
1158         u16 vid;
1159         u8 member;
1160         u8 port_prio;
1161         u32 rx_rate[PRIO_QUEUES];
1162         u32 tx_rate[PRIO_QUEUES];
1163         int stp_state;
1164 };
1165
1166 /**
1167  * struct ksz_switch - KSZ8842 switch data structure
1168  * @mac_table:  MAC table entries information.
1169  * @vlan_table: VLAN table entries information.
1170  * @port_cfg:   Port configuration information.
1171  * @diffserv:   DiffServ priority settings.  Possible values from 6-bit of ToS
1172  *              (bit7 ~ bit2) field.
1173  * @p_802_1p:   802.1P priority settings.  Possible values from 3-bit of 802.1p
1174  *              Tag priority field.
1175  * @br_addr:    Bridge address.  Used for STP.
1176  * @other_addr: Other MAC address.  Used for multiple network device mode.
1177  * @broad_per:  Broadcast storm percentage.
1178  * @member:     Current port membership.  Used for STP.
1179  */
1180 struct ksz_switch {
1181         struct ksz_mac_table mac_table[STATIC_MAC_TABLE_ENTRIES];
1182         struct ksz_vlan_table vlan_table[VLAN_TABLE_ENTRIES];
1183         struct ksz_port_cfg port_cfg[TOTAL_PORT_NUM];
1184
1185         u8 diffserv[DIFFSERV_ENTRIES];
1186         u8 p_802_1p[PRIO_802_1P_ENTRIES];
1187
1188         u8 br_addr[MAC_ADDR_LEN];
1189         u8 other_addr[MAC_ADDR_LEN];
1190
1191         u8 broad_per;
1192         u8 member;
1193 };
1194
1195 #define TX_RATE_UNIT                    10000
1196
1197 /**
1198  * struct ksz_port_info - Port information data structure
1199  * @state:      Connection status of the port.
1200  * @tx_rate:    Transmit rate divided by 10000 to get Mbit.
1201  * @duplex:     Duplex mode.
1202  * @advertised: Advertised auto-negotiation setting.  Used to determine link.
1203  * @partner:    Auto-negotiation partner setting.  Used to determine link.
1204  * @port_id:    Port index to access actual hardware register.
1205  * @pdev:       Pointer to OS dependent network device.
1206  */
1207 struct ksz_port_info {
1208         uint state;
1209         uint tx_rate;
1210         u8 duplex;
1211         u8 advertised;
1212         u8 partner;
1213         u8 port_id;
1214         void *pdev;
1215 };
1216
1217 #define MAX_TX_HELD_SIZE                52000
1218
1219 /* Hardware features and bug fixes. */
1220 #define LINK_INT_WORKING                (1 << 0)
1221 #define SMALL_PACKET_TX_BUG             (1 << 1)
1222 #define HALF_DUPLEX_SIGNAL_BUG          (1 << 2)
1223 #define IPV6_CSUM_GEN_HACK              (1 << 3)
1224 #define RX_HUGE_FRAME                   (1 << 4)
1225 #define STP_SUPPORT                     (1 << 8)
1226
1227 /* Software overrides. */
1228 #define PAUSE_FLOW_CTRL                 (1 << 0)
1229 #define FAST_AGING                      (1 << 1)
1230
1231 /**
1232  * struct ksz_hw - KSZ884X hardware data structure
1233  * @io:                 Virtual address assigned.
1234  * @ksz_switch:         Pointer to KSZ8842 switch.
1235  * @port_info:          Port information.
1236  * @port_mib:           Port MIB information.
1237  * @dev_count:          Number of network devices this hardware supports.
1238  * @dst_ports:          Destination ports in switch for transmission.
1239  * @id:                 Hardware ID.  Used for display only.
1240  * @mib_cnt:            Number of MIB counters this hardware has.
1241  * @mib_port_cnt:       Number of ports with MIB counters.
1242  * @tx_cfg:             Cached transmit control settings.
1243  * @rx_cfg:             Cached receive control settings.
1244  * @intr_mask:          Current interrupt mask.
1245  * @intr_set:           Current interrup set.
1246  * @intr_blocked:       Interrupt blocked.
1247  * @rx_desc_info:       Receive descriptor information.
1248  * @tx_desc_info:       Transmit descriptor information.
1249  * @tx_int_cnt:         Transmit interrupt count.  Used for TX optimization.
1250  * @tx_int_mask:        Transmit interrupt mask.  Used for TX optimization.
1251  * @tx_size:            Transmit data size.  Used for TX optimization.
1252  *                      The maximum is defined by MAX_TX_HELD_SIZE.
1253  * @perm_addr:          Permanent MAC address.
1254  * @override_addr:      Overrided MAC address.
1255  * @address:            Additional MAC address entries.
1256  * @addr_list_size:     Additional MAC address list size.
1257  * @mac_override:       Indication of MAC address overrided.
1258  * @promiscuous:        Counter to keep track of promiscuous mode set.
1259  * @all_multi:          Counter to keep track of all multicast mode set.
1260  * @multi_list:         Multicast address entries.
1261  * @multi_bits:         Cached multicast hash table settings.
1262  * @multi_list_size:    Multicast address list size.
1263  * @enabled:            Indication of hardware enabled.
1264  * @rx_stop:            Indication of receive process stop.
1265  * @features:           Hardware features to enable.
1266  * @overrides:          Hardware features to override.
1267  * @parent:             Pointer to parent, network device private structure.
1268  */
1269 struct ksz_hw {
1270         void __iomem *io;
1271
1272         struct ksz_switch *ksz_switch;
1273         struct ksz_port_info port_info[SWITCH_PORT_NUM];
1274         struct ksz_port_mib port_mib[TOTAL_PORT_NUM];
1275         int dev_count;
1276         int dst_ports;
1277         int id;
1278         int mib_cnt;
1279         int mib_port_cnt;
1280
1281         u32 tx_cfg;
1282         u32 rx_cfg;
1283         u32 intr_mask;
1284         u32 intr_set;
1285         uint intr_blocked;
1286
1287         struct ksz_desc_info rx_desc_info;
1288         struct ksz_desc_info tx_desc_info;
1289
1290         int tx_int_cnt;
1291         int tx_int_mask;
1292         int tx_size;
1293
1294         u8 perm_addr[MAC_ADDR_LEN];
1295         u8 override_addr[MAC_ADDR_LEN];
1296         u8 address[ADDITIONAL_ENTRIES][MAC_ADDR_LEN];
1297         u8 addr_list_size;
1298         u8 mac_override;
1299         u8 promiscuous;
1300         u8 all_multi;
1301         u8 multi_list[MAX_MULTICAST_LIST][MAC_ADDR_LEN];
1302         u8 multi_bits[HW_MULTICAST_SIZE];
1303         u8 multi_list_size;
1304
1305         u8 enabled;
1306         u8 rx_stop;
1307         u8 reserved2[1];
1308
1309         uint features;
1310         uint overrides;
1311
1312         void *parent;
1313 };
1314
1315 enum {
1316         PHY_NO_FLOW_CTRL,
1317         PHY_FLOW_CTRL,
1318         PHY_TX_ONLY,
1319         PHY_RX_ONLY
1320 };
1321
1322 /**
1323  * struct ksz_port - Virtual port data structure
1324  * @duplex:             Duplex mode setting.  1 for half duplex, 2 for full
1325  *                      duplex, and 0 for auto, which normally results in full
1326  *                      duplex.
1327  * @speed:              Speed setting.  10 for 10 Mbit, 100 for 100 Mbit, and
1328  *                      0 for auto, which normally results in 100 Mbit.
1329  * @force_link:         Force link setting.  0 for auto-negotiation, and 1 for
1330  *                      force.
1331  * @flow_ctrl:          Flow control setting.  PHY_NO_FLOW_CTRL for no flow
1332  *                      control, and PHY_FLOW_CTRL for flow control.
1333  *                      PHY_TX_ONLY and PHY_RX_ONLY are not supported for 100
1334  *                      Mbit PHY.
1335  * @first_port:         Index of first port this port supports.
1336  * @mib_port_cnt:       Number of ports with MIB counters.
1337  * @port_cnt:           Number of ports this port supports.
1338  * @counter:            Port statistics counter.
1339  * @hw:                 Pointer to hardware structure.
1340  * @linked:             Pointer to port information linked to this port.
1341  */
1342 struct ksz_port {
1343         u8 duplex;
1344         u8 speed;
1345         u8 force_link;
1346         u8 flow_ctrl;
1347
1348         int first_port;
1349         int mib_port_cnt;
1350         int port_cnt;
1351         u64 counter[OID_COUNTER_LAST];
1352
1353         struct ksz_hw *hw;
1354         struct ksz_port_info *linked;
1355 };
1356
1357 /**
1358  * struct ksz_timer_info - Timer information data structure
1359  * @timer:      Kernel timer.
1360  * @cnt:        Running timer counter.
1361  * @max:        Number of times to run timer; -1 for infinity.
1362  * @period:     Timer period in jiffies.
1363  */
1364 struct ksz_timer_info {
1365         struct timer_list timer;
1366         int cnt;
1367         int max;
1368         int period;
1369 };
1370
1371 /**
1372  * struct ksz_shared_mem - OS dependent shared memory data structure
1373  * @dma_addr:   Physical DMA address allocated.
1374  * @alloc_size: Allocation size.
1375  * @phys:       Actual physical address used.
1376  * @alloc_virt: Virtual address allocated.
1377  * @virt:       Actual virtual address used.
1378  */
1379 struct ksz_shared_mem {
1380         dma_addr_t dma_addr;
1381         uint alloc_size;
1382         uint phys;
1383         u8 *alloc_virt;
1384         u8 *virt;
1385 };
1386
1387 /**
1388  * struct ksz_counter_info - OS dependent counter information data structure
1389  * @counter:    Wait queue to wakeup after counters are read.
1390  * @time:       Next time in jiffies to read counter.
1391  * @read:       Indication of counters read in full or not.
1392  */
1393 struct ksz_counter_info {
1394         wait_queue_head_t counter;
1395         unsigned long time;
1396         int read;
1397 };
1398
1399 /**
1400  * struct dev_info - Network device information data structure
1401  * @dev:                Pointer to network device.
1402  * @pdev:               Pointer to PCI device.
1403  * @hw:                 Hardware structure.
1404  * @desc_pool:          Physical memory used for descriptor pool.
1405  * @hwlock:             Spinlock to prevent hardware from accessing.
1406  * @lock:               Mutex lock to prevent device from accessing.
1407  * @dev_rcv:            Receive process function used.
1408  * @last_skb:           Socket buffer allocated for descriptor rx fragments.
1409  * @skb_index:          Buffer index for receiving fragments.
1410  * @skb_len:            Buffer length for receiving fragments.
1411  * @mib_read:           Workqueue to read MIB counters.
1412  * @mib_timer_info:     Timer to read MIB counters.
1413  * @counter:            Used for MIB reading.
1414  * @mtu:                Current MTU used.  The default is REGULAR_RX_BUF_SIZE;
1415  *                      the maximum is MAX_RX_BUF_SIZE.
1416  * @opened:             Counter to keep track of device open.
1417  * @rx_tasklet:         Receive processing tasklet.
1418  * @tx_tasklet:         Transmit processing tasklet.
1419  * @wol_enable:         Wake-on-LAN enable set by ethtool.
1420  * @wol_support:        Wake-on-LAN support used by ethtool.
1421  * @pme_wait:           Used for KSZ8841 power management.
1422  */
1423 struct dev_info {
1424         struct net_device *dev;
1425         struct pci_dev *pdev;
1426
1427         struct ksz_hw hw;
1428         struct ksz_shared_mem desc_pool;
1429
1430         spinlock_t hwlock;
1431         struct mutex lock;
1432
1433         int (*dev_rcv)(struct dev_info *);
1434
1435         struct sk_buff *last_skb;
1436         int skb_index;
1437         int skb_len;
1438
1439         struct work_struct mib_read;
1440         struct ksz_timer_info mib_timer_info;
1441         struct ksz_counter_info counter[TOTAL_PORT_NUM];
1442
1443         int mtu;
1444         int opened;
1445
1446         struct tasklet_struct rx_tasklet;
1447         struct tasklet_struct tx_tasklet;
1448
1449         int wol_enable;
1450         int wol_support;
1451         unsigned long pme_wait;
1452 };
1453
1454 /**
1455  * struct dev_priv - Network device private data structure
1456  * @adapter:            Adapter device information.
1457  * @port:               Port information.
1458  * @monitor_time_info:  Timer to monitor ports.
1459  * @stats:              Network statistics.
1460  * @proc_sem:           Semaphore for proc accessing.
1461  * @id:                 Device ID.
1462  * @mii_if:             MII interface information.
1463  * @advertising:        Temporary variable to store advertised settings.
1464  * @msg_enable:         The message flags controlling driver output.
1465  * @media_state:        The connection status of the device.
1466  * @multicast:          The all multicast state of the device.
1467  * @promiscuous:        The promiscuous state of the device.
1468  */
1469 struct dev_priv {
1470         struct dev_info *adapter;
1471         struct ksz_port port;
1472         struct ksz_timer_info monitor_timer_info;
1473         struct net_device_stats stats;
1474
1475         struct semaphore proc_sem;
1476         int id;
1477
1478         struct mii_if_info mii_if;
1479         u32 advertising;
1480
1481         u32 msg_enable;
1482         int media_state;
1483         int multicast;
1484         int promiscuous;
1485 };
1486
1487 #define DRV_NAME                "KSZ884X PCI"
1488 #define DEVICE_NAME             "KSZ884x PCI"
1489 #define DRV_VERSION             "1.0.0"
1490 #define DRV_RELDATE             "Feb 8, 2010"
1491
1492 static char version[] __devinitdata =
1493         "Micrel " DEVICE_NAME " " DRV_VERSION " (" DRV_RELDATE ")";
1494
1495 static u8 DEFAULT_MAC_ADDRESS[] = { 0x00, 0x10, 0xA1, 0x88, 0x42, 0x01 };
1496
1497 /*
1498  * Interrupt processing primary routines
1499  */
1500
1501 static inline void hw_ack_intr(struct ksz_hw *hw, uint interrupt)
1502 {
1503         writel(interrupt, hw->io + KS884X_INTERRUPTS_STATUS);
1504 }
1505
1506 static inline void hw_dis_intr(struct ksz_hw *hw)
1507 {
1508         hw->intr_blocked = hw->intr_mask;
1509         writel(0, hw->io + KS884X_INTERRUPTS_ENABLE);
1510         hw->intr_set = readl(hw->io + KS884X_INTERRUPTS_ENABLE);
1511 }
1512
1513 static inline void hw_set_intr(struct ksz_hw *hw, uint interrupt)
1514 {
1515         hw->intr_set = interrupt;
1516         writel(interrupt, hw->io + KS884X_INTERRUPTS_ENABLE);
1517 }
1518
1519 static inline void hw_ena_intr(struct ksz_hw *hw)
1520 {
1521         hw->intr_blocked = 0;
1522         hw_set_intr(hw, hw->intr_mask);
1523 }
1524
1525 static inline void hw_dis_intr_bit(struct ksz_hw *hw, uint bit)
1526 {
1527         hw->intr_mask &= ~(bit);
1528 }
1529
1530 static inline void hw_turn_off_intr(struct ksz_hw *hw, uint interrupt)
1531 {
1532         u32 read_intr;
1533
1534         read_intr = readl(hw->io + KS884X_INTERRUPTS_ENABLE);
1535         hw->intr_set = read_intr & ~interrupt;
1536         writel(hw->intr_set, hw->io + KS884X_INTERRUPTS_ENABLE);
1537         hw_dis_intr_bit(hw, interrupt);
1538 }
1539
1540 /**
1541  * hw_turn_on_intr - turn on specified interrupts
1542  * @hw:         The hardware instance.
1543  * @bit:        The interrupt bits to be on.
1544  *
1545  * This routine turns on the specified interrupts in the interrupt mask so that
1546  * those interrupts will be enabled.
1547  */
1548 static void hw_turn_on_intr(struct ksz_hw *hw, u32 bit)
1549 {
1550         hw->intr_mask |= bit;
1551
1552         if (!hw->intr_blocked)
1553                 hw_set_intr(hw, hw->intr_mask);
1554 }
1555
1556 static inline void hw_ena_intr_bit(struct ksz_hw *hw, uint interrupt)
1557 {
1558         u32 read_intr;
1559
1560         read_intr = readl(hw->io + KS884X_INTERRUPTS_ENABLE);
1561         hw->intr_set = read_intr | interrupt;
1562         writel(hw->intr_set, hw->io + KS884X_INTERRUPTS_ENABLE);
1563 }
1564
1565 static inline void hw_read_intr(struct ksz_hw *hw, uint *status)
1566 {
1567         *status = readl(hw->io + KS884X_INTERRUPTS_STATUS);
1568         *status = *status & hw->intr_set;
1569 }
1570
1571 static inline void hw_restore_intr(struct ksz_hw *hw, uint interrupt)
1572 {
1573         if (interrupt)
1574                 hw_ena_intr(hw);
1575 }
1576
1577 /**
1578  * hw_block_intr - block hardware interrupts
1579  *
1580  * This function blocks all interrupts of the hardware and returns the current
1581  * interrupt enable mask so that interrupts can be restored later.
1582  *
1583  * Return the current interrupt enable mask.
1584  */
1585 static uint hw_block_intr(struct ksz_hw *hw)
1586 {
1587         uint interrupt = 0;
1588
1589         if (!hw->intr_blocked) {
1590                 hw_dis_intr(hw);
1591                 interrupt = hw->intr_blocked;
1592         }
1593         return interrupt;
1594 }
1595
1596 /*
1597  * Hardware descriptor routines
1598  */
1599
1600 static inline void reset_desc(struct ksz_desc *desc, union desc_stat status)
1601 {
1602         status.rx.hw_owned = 0;
1603         desc->phw->ctrl.data = cpu_to_le32(status.data);
1604 }
1605
1606 static inline void release_desc(struct ksz_desc *desc)
1607 {
1608         desc->sw.ctrl.tx.hw_owned = 1;
1609         if (desc->sw.buf_size != desc->sw.buf.data) {
1610                 desc->sw.buf_size = desc->sw.buf.data;
1611                 desc->phw->buf.data = cpu_to_le32(desc->sw.buf.data);
1612         }
1613         desc->phw->ctrl.data = cpu_to_le32(desc->sw.ctrl.data);
1614 }
1615
1616 static void get_rx_pkt(struct ksz_desc_info *info, struct ksz_desc **desc)
1617 {
1618         *desc = &info->ring[info->last];
1619         info->last++;
1620         info->last &= info->mask;
1621         info->avail--;
1622         (*desc)->sw.buf.data &= ~KS_DESC_RX_MASK;
1623 }
1624
1625 static inline void set_rx_buf(struct ksz_desc *desc, u32 addr)
1626 {
1627         desc->phw->addr = cpu_to_le32(addr);
1628 }
1629
1630 static inline void set_rx_len(struct ksz_desc *desc, u32 len)
1631 {
1632         desc->sw.buf.rx.buf_size = len;
1633 }
1634
1635 static inline void get_tx_pkt(struct ksz_desc_info *info,
1636         struct ksz_desc **desc)
1637 {
1638         *desc = &info->ring[info->next];
1639         info->next++;
1640         info->next &= info->mask;
1641         info->avail--;
1642         (*desc)->sw.buf.data &= ~KS_DESC_TX_MASK;
1643 }
1644
1645 static inline void set_tx_buf(struct ksz_desc *desc, u32 addr)
1646 {
1647         desc->phw->addr = cpu_to_le32(addr);
1648 }
1649
1650 static inline void set_tx_len(struct ksz_desc *desc, u32 len)
1651 {
1652         desc->sw.buf.tx.buf_size = len;
1653 }
1654
1655 /* Switch functions */
1656
1657 #define TABLE_READ                      0x10
1658 #define TABLE_SEL_SHIFT                 2
1659
1660 #define HW_DELAY(hw, reg)                       \
1661         do {                                    \
1662                 u16 dummy;                      \
1663                 dummy = readw(hw->io + reg);    \
1664         } while (0)
1665
1666 /**
1667  * sw_r_table - read 4 bytes of data from switch table
1668  * @hw:         The hardware instance.
1669  * @table:      The table selector.
1670  * @addr:       The address of the table entry.
1671  * @data:       Buffer to store the read data.
1672  *
1673  * This routine reads 4 bytes of data from the table of the switch.
1674  * Hardware interrupts are disabled to minimize corruption of read data.
1675  */
1676 static void sw_r_table(struct ksz_hw *hw, int table, u16 addr, u32 *data)
1677 {
1678         u16 ctrl_addr;
1679         uint interrupt;
1680
1681         ctrl_addr = (((table << TABLE_SEL_SHIFT) | TABLE_READ) << 8) | addr;
1682
1683         interrupt = hw_block_intr(hw);
1684
1685         writew(ctrl_addr, hw->io + KS884X_IACR_OFFSET);
1686         HW_DELAY(hw, KS884X_IACR_OFFSET);
1687         *data = readl(hw->io + KS884X_ACC_DATA_0_OFFSET);
1688
1689         hw_restore_intr(hw, interrupt);
1690 }
1691
1692 /**
1693  * sw_w_table_64 - write 8 bytes of data to the switch table
1694  * @hw:         The hardware instance.
1695  * @table:      The table selector.
1696  * @addr:       The address of the table entry.
1697  * @data_hi:    The high part of data to be written (bit63 ~ bit32).
1698  * @data_lo:    The low part of data to be written (bit31 ~ bit0).
1699  *
1700  * This routine writes 8 bytes of data to the table of the switch.
1701  * Hardware interrupts are disabled to minimize corruption of written data.
1702  */
1703 static void sw_w_table_64(struct ksz_hw *hw, int table, u16 addr, u32 data_hi,
1704         u32 data_lo)
1705 {
1706         u16 ctrl_addr;
1707         uint interrupt;
1708
1709         ctrl_addr = ((table << TABLE_SEL_SHIFT) << 8) | addr;
1710
1711         interrupt = hw_block_intr(hw);
1712
1713         writel(data_hi, hw->io + KS884X_ACC_DATA_4_OFFSET);
1714         writel(data_lo, hw->io + KS884X_ACC_DATA_0_OFFSET);
1715
1716         writew(ctrl_addr, hw->io + KS884X_IACR_OFFSET);
1717         HW_DELAY(hw, KS884X_IACR_OFFSET);
1718
1719         hw_restore_intr(hw, interrupt);
1720 }
1721
1722 /**
1723  * sw_w_sta_mac_table - write to the static MAC table
1724  * @hw:         The hardware instance.
1725  * @addr:       The address of the table entry.
1726  * @mac_addr:   The MAC address.
1727  * @ports:      The port members.
1728  * @override:   The flag to override the port receive/transmit settings.
1729  * @valid:      The flag to indicate entry is valid.
1730  * @use_fid:    The flag to indicate the FID is valid.
1731  * @fid:        The FID value.
1732  *
1733  * This routine writes an entry of the static MAC table of the switch.  It
1734  * calls sw_w_table_64() to write the data.
1735  */
1736 static void sw_w_sta_mac_table(struct ksz_hw *hw, u16 addr, u8 *mac_addr,
1737         u8 ports, int override, int valid, int use_fid, u8 fid)
1738 {
1739         u32 data_hi;
1740         u32 data_lo;
1741
1742         data_lo = ((u32) mac_addr[2] << 24) |
1743                 ((u32) mac_addr[3] << 16) |
1744                 ((u32) mac_addr[4] << 8) | mac_addr[5];
1745         data_hi = ((u32) mac_addr[0] << 8) | mac_addr[1];
1746         data_hi |= (u32) ports << STATIC_MAC_FWD_PORTS_SHIFT;
1747
1748         if (override)
1749                 data_hi |= STATIC_MAC_TABLE_OVERRIDE;
1750         if (use_fid) {
1751                 data_hi |= STATIC_MAC_TABLE_USE_FID;
1752                 data_hi |= (u32) fid << STATIC_MAC_FID_SHIFT;
1753         }
1754         if (valid)
1755                 data_hi |= STATIC_MAC_TABLE_VALID;
1756
1757         sw_w_table_64(hw, TABLE_STATIC_MAC, addr, data_hi, data_lo);
1758 }
1759
1760 /**
1761  * sw_r_vlan_table - read from the VLAN table
1762  * @hw:         The hardware instance.
1763  * @addr:       The address of the table entry.
1764  * @vid:        Buffer to store the VID.
1765  * @fid:        Buffer to store the VID.
1766  * @member:     Buffer to store the port membership.
1767  *
1768  * This function reads an entry of the VLAN table of the switch.  It calls
1769  * sw_r_table() to get the data.
1770  *
1771  * Return 0 if the entry is valid; otherwise -1.
1772  */
1773 static int sw_r_vlan_table(struct ksz_hw *hw, u16 addr, u16 *vid, u8 *fid,
1774         u8 *member)
1775 {
1776         u32 data;
1777
1778         sw_r_table(hw, TABLE_VLAN, addr, &data);
1779         if (data & VLAN_TABLE_VALID) {
1780                 *vid = (u16)(data & VLAN_TABLE_VID);
1781                 *fid = (u8)((data & VLAN_TABLE_FID) >> VLAN_TABLE_FID_SHIFT);
1782                 *member = (u8)((data & VLAN_TABLE_MEMBERSHIP) >>
1783                         VLAN_TABLE_MEMBERSHIP_SHIFT);
1784                 return 0;
1785         }
1786         return -1;
1787 }
1788
1789 /**
1790  * port_r_mib_cnt - read MIB counter
1791  * @hw:         The hardware instance.
1792  * @port:       The port index.
1793  * @addr:       The address of the counter.
1794  * @cnt:        Buffer to store the counter.
1795  *
1796  * This routine reads a MIB counter of the port.
1797  * Hardware interrupts are disabled to minimize corruption of read data.
1798  */
1799 static void port_r_mib_cnt(struct ksz_hw *hw, int port, u16 addr, u64 *cnt)
1800 {
1801         u32 data;
1802         u16 ctrl_addr;
1803         uint interrupt;
1804         int timeout;
1805
1806         ctrl_addr = addr + PORT_COUNTER_NUM * port;
1807
1808         interrupt = hw_block_intr(hw);
1809
1810         ctrl_addr |= (((TABLE_MIB << TABLE_SEL_SHIFT) | TABLE_READ) << 8);
1811         writew(ctrl_addr, hw->io + KS884X_IACR_OFFSET);
1812         HW_DELAY(hw, KS884X_IACR_OFFSET);
1813
1814         for (timeout = 100; timeout > 0; timeout--) {
1815                 data = readl(hw->io + KS884X_ACC_DATA_0_OFFSET);
1816
1817                 if (data & MIB_COUNTER_VALID) {
1818                         if (data & MIB_COUNTER_OVERFLOW)
1819                                 *cnt += MIB_COUNTER_VALUE + 1;
1820                         *cnt += data & MIB_COUNTER_VALUE;
1821                         break;
1822                 }
1823         }
1824
1825         hw_restore_intr(hw, interrupt);
1826 }
1827
1828 /**
1829  * port_r_mib_pkt - read dropped packet counts
1830  * @hw:         The hardware instance.
1831  * @port:       The port index.
1832  * @cnt:        Buffer to store the receive and transmit dropped packet counts.
1833  *
1834  * This routine reads the dropped packet counts of the port.
1835  * Hardware interrupts are disabled to minimize corruption of read data.
1836  */
1837 static void port_r_mib_pkt(struct ksz_hw *hw, int port, u32 *last, u64 *cnt)
1838 {
1839         u32 cur;
1840         u32 data;
1841         u16 ctrl_addr;
1842         uint interrupt;
1843         int index;
1844
1845         index = KS_MIB_PACKET_DROPPED_RX_0 + port;
1846         do {
1847                 interrupt = hw_block_intr(hw);
1848
1849                 ctrl_addr = (u16) index;
1850                 ctrl_addr |= (((TABLE_MIB << TABLE_SEL_SHIFT) | TABLE_READ)
1851                         << 8);
1852                 writew(ctrl_addr, hw->io + KS884X_IACR_OFFSET);
1853                 HW_DELAY(hw, KS884X_IACR_OFFSET);
1854                 data = readl(hw->io + KS884X_ACC_DATA_0_OFFSET);
1855
1856                 hw_restore_intr(hw, interrupt);
1857
1858                 data &= MIB_PACKET_DROPPED;
1859                 cur = *last;
1860                 if (data != cur) {
1861                         *last = data;
1862                         if (data < cur)
1863                                 data += MIB_PACKET_DROPPED + 1;
1864                         data -= cur;
1865                         *cnt += data;
1866                 }
1867                 ++last;
1868                 ++cnt;
1869                 index -= KS_MIB_PACKET_DROPPED_TX -
1870                         KS_MIB_PACKET_DROPPED_TX_0 + 1;
1871         } while (index >= KS_MIB_PACKET_DROPPED_TX_0 + port);
1872 }
1873
1874 /**
1875  * port_r_cnt - read MIB counters periodically
1876  * @hw:         The hardware instance.
1877  * @port:       The port index.
1878  *
1879  * This routine is used to read the counters of the port periodically to avoid
1880  * counter overflow.  The hardware should be acquired first before calling this
1881  * routine.
1882  *
1883  * Return non-zero when not all counters not read.
1884  */
1885 static int port_r_cnt(struct ksz_hw *hw, int port)
1886 {
1887         struct ksz_port_mib *mib = &hw->port_mib[port];
1888
1889         if (mib->mib_start < PORT_COUNTER_NUM)
1890                 while (mib->cnt_ptr < PORT_COUNTER_NUM) {
1891                         port_r_mib_cnt(hw, port, mib->cnt_ptr,
1892                                 &mib->counter[mib->cnt_ptr]);
1893                         ++mib->cnt_ptr;
1894                 }
1895         if (hw->mib_cnt > PORT_COUNTER_NUM)
1896                 port_r_mib_pkt(hw, port, mib->dropped,
1897                         &mib->counter[PORT_COUNTER_NUM]);
1898         mib->cnt_ptr = 0;
1899         return 0;
1900 }
1901
1902 /**
1903  * port_init_cnt - initialize MIB counter values
1904  * @hw:         The hardware instance.
1905  * @port:       The port index.
1906  *
1907  * This routine is used to initialize all counters to zero if the hardware
1908  * cannot do it after reset.
1909  */
1910 static void port_init_cnt(struct ksz_hw *hw, int port)
1911 {
1912         struct ksz_port_mib *mib = &hw->port_mib[port];
1913
1914         mib->cnt_ptr = 0;
1915         if (mib->mib_start < PORT_COUNTER_NUM)
1916                 do {
1917                         port_r_mib_cnt(hw, port, mib->cnt_ptr,
1918                                 &mib->counter[mib->cnt_ptr]);
1919                         ++mib->cnt_ptr;
1920                 } while (mib->cnt_ptr < PORT_COUNTER_NUM);
1921         if (hw->mib_cnt > PORT_COUNTER_NUM)
1922                 port_r_mib_pkt(hw, port, mib->dropped,
1923                         &mib->counter[PORT_COUNTER_NUM]);
1924         memset((void *) mib->counter, 0, sizeof(u64) * TOTAL_PORT_COUNTER_NUM);
1925         mib->cnt_ptr = 0;
1926 }
1927
1928 /*
1929  * Port functions
1930  */
1931
1932 /**
1933  * port_chk - check port register bits
1934  * @hw:         The hardware instance.
1935  * @port:       The port index.
1936  * @offset:     The offset of the port register.
1937  * @bits:       The data bits to check.
1938  *
1939  * This function checks whether the specified bits of the port register are set
1940  * or not.
1941  *
1942  * Return 0 if the bits are not set.
1943  */
1944 static int port_chk(struct ksz_hw *hw, int port, int offset, u16 bits)
1945 {
1946         u32 addr;
1947         u16 data;
1948
1949         PORT_CTRL_ADDR(port, addr);
1950         addr += offset;
1951         data = readw(hw->io + addr);
1952         return (data & bits) == bits;
1953 }
1954
1955 /**
1956  * port_cfg - set port register bits
1957  * @hw:         The hardware instance.
1958  * @port:       The port index.
1959  * @offset:     The offset of the port register.
1960  * @bits:       The data bits to set.
1961  * @set:        The flag indicating whether the bits are to be set or not.
1962  *
1963  * This routine sets or resets the specified bits of the port register.
1964  */
1965 static void port_cfg(struct ksz_hw *hw, int port, int offset, u16 bits,
1966         int set)
1967 {
1968         u32 addr;
1969         u16 data;
1970
1971         PORT_CTRL_ADDR(port, addr);
1972         addr += offset;
1973         data = readw(hw->io + addr);
1974         if (set)
1975                 data |= bits;
1976         else
1977                 data &= ~bits;
1978         writew(data, hw->io + addr);
1979 }
1980
1981 /**
1982  * port_chk_shift - check port bit
1983  * @hw:         The hardware instance.
1984  * @port:       The port index.
1985  * @offset:     The offset of the register.
1986  * @shift:      Number of bits to shift.
1987  *
1988  * This function checks whether the specified port is set in the register or
1989  * not.
1990  *
1991  * Return 0 if the port is not set.
1992  */
1993 static int port_chk_shift(struct ksz_hw *hw, int port, u32 addr, int shift)
1994 {
1995         u16 data;
1996         u16 bit = 1 << port;
1997
1998         data = readw(hw->io + addr);
1999         data >>= shift;
2000         return (data & bit) == bit;
2001 }
2002
2003 /**
2004  * port_cfg_shift - set port bit
2005  * @hw:         The hardware instance.
2006  * @port:       The port index.
2007  * @offset:     The offset of the register.
2008  * @shift:      Number of bits to shift.
2009  * @set:        The flag indicating whether the port is to be set or not.
2010  *
2011  * This routine sets or resets the specified port in the register.
2012  */
2013 static void port_cfg_shift(struct ksz_hw *hw, int port, u32 addr, int shift,
2014         int set)
2015 {
2016         u16 data;
2017         u16 bits = 1 << port;
2018
2019         data = readw(hw->io + addr);
2020         bits <<= shift;
2021         if (set)
2022                 data |= bits;
2023         else
2024                 data &= ~bits;
2025         writew(data, hw->io + addr);
2026 }
2027
2028 /**
2029  * port_r8 - read byte from port register
2030  * @hw:         The hardware instance.
2031  * @port:       The port index.
2032  * @offset:     The offset of the port register.
2033  * @data:       Buffer to store the data.
2034  *
2035  * This routine reads a byte from the port register.
2036  */
2037 static void port_r8(struct ksz_hw *hw, int port, int offset, u8 *data)
2038 {
2039         u32 addr;
2040
2041         PORT_CTRL_ADDR(port, addr);
2042         addr += offset;
2043         *data = readb(hw->io + addr);
2044 }
2045
2046 /**
2047  * port_r16 - read word from port register.
2048  * @hw:         The hardware instance.
2049  * @port:       The port index.
2050  * @offset:     The offset of the port register.
2051  * @data:       Buffer to store the data.
2052  *
2053  * This routine reads a word from the port register.
2054  */
2055 static void port_r16(struct ksz_hw *hw, int port, int offset, u16 *data)
2056 {
2057         u32 addr;
2058
2059         PORT_CTRL_ADDR(port, addr);
2060         addr += offset;
2061         *data = readw(hw->io + addr);
2062 }
2063
2064 /**
2065  * port_w16 - write word to port register.
2066  * @hw:         The hardware instance.
2067  * @port:       The port index.
2068  * @offset:     The offset of the port register.
2069  * @data:       Data to write.
2070  *
2071  * This routine writes a word to the port register.
2072  */
2073 static void port_w16(struct ksz_hw *hw, int port, int offset, u16 data)
2074 {
2075         u32 addr;
2076
2077         PORT_CTRL_ADDR(port, addr);
2078         addr += offset;
2079         writew(data, hw->io + addr);
2080 }
2081
2082 /**
2083  * sw_chk - check switch register bits
2084  * @hw:         The hardware instance.
2085  * @addr:       The address of the switch register.
2086  * @bits:       The data bits to check.
2087  *
2088  * This function checks whether the specified bits of the switch register are
2089  * set or not.
2090  *
2091  * Return 0 if the bits are not set.
2092  */
2093 static int sw_chk(struct ksz_hw *hw, u32 addr, u16 bits)
2094 {
2095         u16 data;
2096
2097         data = readw(hw->io + addr);
2098         return (data & bits) == bits;
2099 }
2100
2101 /**
2102  * sw_cfg - set switch register bits
2103  * @hw:         The hardware instance.
2104  * @addr:       The address of the switch register.
2105  * @bits:       The data bits to set.
2106  * @set:        The flag indicating whether the bits are to be set or not.
2107  *
2108  * This function sets or resets the specified bits of the switch register.
2109  */
2110 static void sw_cfg(struct ksz_hw *hw, u32 addr, u16 bits, int set)
2111 {
2112         u16 data;
2113
2114         data = readw(hw->io + addr);
2115         if (set)
2116                 data |= bits;
2117         else
2118                 data &= ~bits;
2119         writew(data, hw->io + addr);
2120 }
2121
2122 /* Bandwidth */
2123
2124 static inline void port_cfg_broad_storm(struct ksz_hw *hw, int p, int set)
2125 {
2126         port_cfg(hw, p,
2127                 KS8842_PORT_CTRL_1_OFFSET, PORT_BROADCAST_STORM, set);
2128 }
2129
2130 static inline int port_chk_broad_storm(struct ksz_hw *hw, int p)
2131 {
2132         return port_chk(hw, p,
2133                 KS8842_PORT_CTRL_1_OFFSET, PORT_BROADCAST_STORM);
2134 }
2135
2136 /* Driver set switch broadcast storm protection at 10% rate. */
2137 #define BROADCAST_STORM_PROTECTION_RATE 10
2138
2139 /* 148,800 frames * 67 ms / 100 */
2140 #define BROADCAST_STORM_VALUE           9969
2141
2142 /**
2143  * sw_cfg_broad_storm - configure broadcast storm threshold
2144  * @hw:         The hardware instance.
2145  * @percent:    Broadcast storm threshold in percent of transmit rate.
2146  *
2147  * This routine configures the broadcast storm threshold of the switch.
2148  */
2149 static void sw_cfg_broad_storm(struct ksz_hw *hw, u8 percent)
2150 {
2151         u16 data;
2152         u32 value = ((u32) BROADCAST_STORM_VALUE * (u32) percent / 100);
2153
2154         if (value > BROADCAST_STORM_RATE)
2155                 value = BROADCAST_STORM_RATE;
2156
2157         data = readw(hw->io + KS8842_SWITCH_CTRL_3_OFFSET);
2158         data &= ~(BROADCAST_STORM_RATE_LO | BROADCAST_STORM_RATE_HI);
2159         data |= ((value & 0x00FF) << 8) | ((value & 0xFF00) >> 8);
2160         writew(data, hw->io + KS8842_SWITCH_CTRL_3_OFFSET);
2161 }
2162
2163 /**
2164  * sw_get_board_storm - get broadcast storm threshold
2165  * @hw:         The hardware instance.
2166  * @percent:    Buffer to store the broadcast storm threshold percentage.
2167  *
2168  * This routine retrieves the broadcast storm threshold of the switch.
2169  */
2170 static void sw_get_broad_storm(struct ksz_hw *hw, u8 *percent)
2171 {
2172         int num;
2173         u16 data;
2174
2175         data = readw(hw->io + KS8842_SWITCH_CTRL_3_OFFSET);
2176         num = (data & BROADCAST_STORM_RATE_HI);
2177         num <<= 8;
2178         num |= (data & BROADCAST_STORM_RATE_LO) >> 8;
2179         num = (num * 100 + BROADCAST_STORM_VALUE / 2) / BROADCAST_STORM_VALUE;
2180         *percent = (u8) num;
2181 }
2182
2183 /**
2184  * sw_dis_broad_storm - disable broadstorm
2185  * @hw:         The hardware instance.
2186  * @port:       The port index.
2187  *
2188  * This routine disables the broadcast storm limit function of the switch.
2189  */
2190 static void sw_dis_broad_storm(struct ksz_hw *hw, int port)
2191 {
2192         port_cfg_broad_storm(hw, port, 0);
2193 }
2194
2195 /**
2196  * sw_ena_broad_storm - enable broadcast storm
2197  * @hw:         The hardware instance.
2198  * @port:       The port index.
2199  *
2200  * This routine enables the broadcast storm limit function of the switch.
2201  */
2202 static void sw_ena_broad_storm(struct ksz_hw *hw, int port)
2203 {
2204         sw_cfg_broad_storm(hw, hw->ksz_switch->broad_per);
2205         port_cfg_broad_storm(hw, port, 1);
2206 }
2207
2208 /**
2209  * sw_init_broad_storm - initialize broadcast storm
2210  * @hw:         The hardware instance.
2211  *
2212  * This routine initializes the broadcast storm limit function of the switch.
2213  */
2214 static void sw_init_broad_storm(struct ksz_hw *hw)
2215 {
2216         int port;
2217
2218         hw->ksz_switch->broad_per = 1;
2219         sw_cfg_broad_storm(hw, hw->ksz_switch->broad_per);
2220         for (port = 0; port < TOTAL_PORT_NUM; port++)
2221                 sw_dis_broad_storm(hw, port);
2222         sw_cfg(hw, KS8842_SWITCH_CTRL_2_OFFSET, MULTICAST_STORM_DISABLE, 1);
2223 }
2224
2225 /**
2226  * hw_cfg_broad_storm - configure broadcast storm
2227  * @hw:         The hardware instance.
2228  * @percent:    Broadcast storm threshold in percent of transmit rate.
2229  *
2230  * This routine configures the broadcast storm threshold of the switch.
2231  * It is called by user functions.  The hardware should be acquired first.
2232  */
2233 static void hw_cfg_broad_storm(struct ksz_hw *hw, u8 percent)
2234 {
2235         if (percent > 100)
2236                 percent = 100;
2237
2238         sw_cfg_broad_storm(hw, percent);
2239         sw_get_broad_storm(hw, &percent);
2240         hw->ksz_switch->broad_per = percent;
2241 }
2242
2243 /**
2244  * sw_dis_prio_rate - disable switch priority rate
2245  * @hw:         The hardware instance.
2246  * @port:       The port index.
2247  *
2248  * This routine disables the priority rate function of the switch.
2249  */
2250 static void sw_dis_prio_rate(struct ksz_hw *hw, int port)
2251 {
2252         u32 addr;
2253
2254         PORT_CTRL_ADDR(port, addr);
2255         addr += KS8842_PORT_IN_RATE_OFFSET;
2256         writel(0, hw->io + addr);
2257 }
2258
2259 /**
2260  * sw_init_prio_rate - initialize switch prioirty rate
2261  * @hw:         The hardware instance.
2262  *
2263  * This routine initializes the priority rate function of the switch.
2264  */
2265 static void sw_init_prio_rate(struct ksz_hw *hw)
2266 {
2267         int port;
2268         int prio;
2269         struct ksz_switch *sw = hw->ksz_switch;
2270
2271         for (port = 0; port < TOTAL_PORT_NUM; port++) {
2272                 for (prio = 0; prio < PRIO_QUEUES; prio++) {
2273                         sw->port_cfg[port].rx_rate[prio] =
2274                         sw->port_cfg[port].tx_rate[prio] = 0;
2275                 }
2276                 sw_dis_prio_rate(hw, port);
2277         }
2278 }
2279
2280 /* Communication */
2281
2282 static inline void port_cfg_back_pressure(struct ksz_hw *hw, int p, int set)
2283 {
2284         port_cfg(hw, p,
2285                 KS8842_PORT_CTRL_2_OFFSET, PORT_BACK_PRESSURE, set);
2286 }
2287
2288 static inline void port_cfg_force_flow_ctrl(struct ksz_hw *hw, int p, int set)
2289 {
2290         port_cfg(hw, p,
2291                 KS8842_PORT_CTRL_2_OFFSET, PORT_FORCE_FLOW_CTRL, set);
2292 }
2293
2294 static inline int port_chk_back_pressure(struct ksz_hw *hw, int p)
2295 {
2296         return port_chk(hw, p,
2297                 KS8842_PORT_CTRL_2_OFFSET, PORT_BACK_PRESSURE);
2298 }
2299
2300 static inline int port_chk_force_flow_ctrl(struct ksz_hw *hw, int p)
2301 {
2302         return port_chk(hw, p,
2303                 KS8842_PORT_CTRL_2_OFFSET, PORT_FORCE_FLOW_CTRL);
2304 }
2305
2306 /* Spanning Tree */
2307
2308 static inline void port_cfg_dis_learn(struct ksz_hw *hw, int p, int set)
2309 {
2310         port_cfg(hw, p,
2311                 KS8842_PORT_CTRL_2_OFFSET, PORT_LEARN_DISABLE, set);
2312 }
2313
2314 static inline void port_cfg_rx(struct ksz_hw *hw, int p, int set)
2315 {
2316         port_cfg(hw, p,
2317                 KS8842_PORT_CTRL_2_OFFSET, PORT_RX_ENABLE, set);
2318 }
2319
2320 static inline void port_cfg_tx(struct ksz_hw *hw, int p, int set)
2321 {
2322         port_cfg(hw, p,
2323                 KS8842_PORT_CTRL_2_OFFSET, PORT_TX_ENABLE, set);
2324 }
2325
2326 static inline void sw_cfg_fast_aging(struct ksz_hw *hw, int set)
2327 {
2328         sw_cfg(hw, KS8842_SWITCH_CTRL_1_OFFSET, SWITCH_FAST_AGING, set);
2329 }
2330
2331 static inline void sw_flush_dyn_mac_table(struct ksz_hw *hw)
2332 {
2333         if (!(hw->overrides & FAST_AGING)) {
2334                 sw_cfg_fast_aging(hw, 1);
2335                 mdelay(1);
2336                 sw_cfg_fast_aging(hw, 0);
2337         }
2338 }
2339
2340 /* VLAN */
2341
2342 static inline void port_cfg_ins_tag(struct ksz_hw *hw, int p, int insert)
2343 {
2344         port_cfg(hw, p,
2345                 KS8842_PORT_CTRL_1_OFFSET, PORT_INSERT_TAG, insert);
2346 }
2347
2348 static inline void port_cfg_rmv_tag(struct ksz_hw *hw, int p, int remove)
2349 {
2350         port_cfg(hw, p,
2351                 KS8842_PORT_CTRL_1_OFFSET, PORT_REMOVE_TAG, remove);
2352 }
2353
2354 static inline int port_chk_ins_tag(struct ksz_hw *hw, int p)
2355 {
2356         return port_chk(hw, p,
2357                 KS8842_PORT_CTRL_1_OFFSET, PORT_INSERT_TAG);
2358 }
2359
2360 static inline int port_chk_rmv_tag(struct ksz_hw *hw, int p)
2361 {
2362         return port_chk(hw, p,
2363                 KS8842_PORT_CTRL_1_OFFSET, PORT_REMOVE_TAG);
2364 }
2365
2366 static inline void port_cfg_dis_non_vid(struct ksz_hw *hw, int p, int set)
2367 {
2368         port_cfg(hw, p,
2369                 KS8842_PORT_CTRL_2_OFFSET, PORT_DISCARD_NON_VID, set);
2370 }
2371
2372 static inline void port_cfg_in_filter(struct ksz_hw *hw, int p, int set)
2373 {
2374         port_cfg(hw, p,
2375                 KS8842_PORT_CTRL_2_OFFSET, PORT_INGRESS_VLAN_FILTER, set);
2376 }
2377
2378 static inline int port_chk_dis_non_vid(struct ksz_hw *hw, int p)
2379 {
2380         return port_chk(hw, p,
2381                 KS8842_PORT_CTRL_2_OFFSET, PORT_DISCARD_NON_VID);
2382 }
2383
2384 static inline int port_chk_in_filter(struct ksz_hw *hw, int p)
2385 {
2386         return port_chk(hw, p,
2387                 KS8842_PORT_CTRL_2_OFFSET, PORT_INGRESS_VLAN_FILTER);
2388 }
2389
2390 /* Mirroring */
2391
2392 static inline void port_cfg_mirror_sniffer(struct ksz_hw *hw, int p, int set)
2393 {
2394         port_cfg(hw, p,
2395                 KS8842_PORT_CTRL_2_OFFSET, PORT_MIRROR_SNIFFER, set);
2396 }
2397
2398 static inline void port_cfg_mirror_rx(struct ksz_hw *hw, int p, int set)
2399 {
2400         port_cfg(hw, p,
2401                 KS8842_PORT_CTRL_2_OFFSET, PORT_MIRROR_RX, set);
2402 }
2403
2404 static inline void port_cfg_mirror_tx(struct ksz_hw *hw, int p, int set)
2405 {
2406         port_cfg(hw, p,
2407                 KS8842_PORT_CTRL_2_OFFSET, PORT_MIRROR_TX, set);
2408 }
2409
2410 static inline void sw_cfg_mirror_rx_tx(struct ksz_hw *hw, int set)
2411 {
2412         sw_cfg(hw, KS8842_SWITCH_CTRL_2_OFFSET, SWITCH_MIRROR_RX_TX, set);
2413 }
2414
2415 static void sw_init_mirror(struct ksz_hw *hw)
2416 {
2417         int port;
2418
2419         for (port = 0; port < TOTAL_PORT_NUM; port++) {
2420                 port_cfg_mirror_sniffer(hw, port, 0);
2421                 port_cfg_mirror_rx(hw, port, 0);
2422                 port_cfg_mirror_tx(hw, port, 0);
2423         }
2424         sw_cfg_mirror_rx_tx(hw, 0);
2425 }
2426
2427 static inline void sw_cfg_unk_def_deliver(struct ksz_hw *hw, int set)
2428 {
2429         sw_cfg(hw, KS8842_SWITCH_CTRL_7_OFFSET,
2430                 SWITCH_UNK_DEF_PORT_ENABLE, set);
2431 }
2432
2433 static inline int sw_cfg_chk_unk_def_deliver(struct ksz_hw *hw)
2434 {
2435         return sw_chk(hw, KS8842_SWITCH_CTRL_7_OFFSET,
2436                 SWITCH_UNK_DEF_PORT_ENABLE);
2437 }
2438
2439 static inline void sw_cfg_unk_def_port(struct ksz_hw *hw, int port, int set)
2440 {
2441         port_cfg_shift(hw, port, KS8842_SWITCH_CTRL_7_OFFSET, 0, set);
2442 }
2443
2444 static inline int sw_chk_unk_def_port(struct ksz_hw *hw, int port)
2445 {
2446         return port_chk_shift(hw, port, KS8842_SWITCH_CTRL_7_OFFSET, 0);
2447 }
2448
2449 /* Priority */
2450
2451 static inline void port_cfg_diffserv(struct ksz_hw *hw, int p, int set)
2452 {
2453         port_cfg(hw, p,
2454                 KS8842_PORT_CTRL_1_OFFSET, PORT_DIFFSERV_ENABLE, set);
2455 }
2456
2457 static inline void port_cfg_802_1p(struct ksz_hw *hw, int p, int set)
2458 {
2459         port_cfg(hw, p,
2460                 KS8842_PORT_CTRL_1_OFFSET, PORT_802_1P_ENABLE, set);
2461 }
2462
2463 static inline void port_cfg_replace_vid(struct ksz_hw *hw, int p, int set)
2464 {
2465         port_cfg(hw, p,
2466                 KS8842_PORT_CTRL_2_OFFSET, PORT_USER_PRIORITY_CEILING, set);
2467 }
2468
2469 static inline void port_cfg_prio(struct ksz_hw *hw, int p, int set)
2470 {
2471         port_cfg(hw, p,
2472                 KS8842_PORT_CTRL_1_OFFSET, PORT_PRIO_QUEUE_ENABLE, set);
2473 }
2474
2475 static inline int port_chk_diffserv(struct ksz_hw *hw, int p)
2476 {
2477         return port_chk(hw, p,
2478                 KS8842_PORT_CTRL_1_OFFSET, PORT_DIFFSERV_ENABLE);
2479 }
2480
2481 static inline int port_chk_802_1p(struct ksz_hw *hw, int p)
2482 {
2483         return port_chk(hw, p,
2484                 KS8842_PORT_CTRL_1_OFFSET, PORT_802_1P_ENABLE);
2485 }
2486
2487 static inline int port_chk_replace_vid(struct ksz_hw *hw, int p)
2488 {
2489         return port_chk(hw, p,
2490                 KS8842_PORT_CTRL_2_OFFSET, PORT_USER_PRIORITY_CEILING);
2491 }
2492
2493 static inline int port_chk_prio(struct ksz_hw *hw, int p)
2494 {
2495         return port_chk(hw, p,
2496                 KS8842_PORT_CTRL_1_OFFSET, PORT_PRIO_QUEUE_ENABLE);
2497 }
2498
2499 /**
2500  * sw_dis_diffserv - disable switch DiffServ priority
2501  * @hw:         The hardware instance.
2502  * @port:       The port index.
2503  *
2504  * This routine disables the DiffServ priority function of the switch.
2505  */
2506 static void sw_dis_diffserv(struct ksz_hw *hw, int port)
2507 {
2508         port_cfg_diffserv(hw, port, 0);
2509 }
2510
2511 /**
2512  * sw_dis_802_1p - disable switch 802.1p priority
2513  * @hw:         The hardware instance.
2514  * @port:       The port index.
2515  *
2516  * This routine disables the 802.1p priority function of the switch.
2517  */
2518 static void sw_dis_802_1p(struct ksz_hw *hw, int port)
2519 {
2520         port_cfg_802_1p(hw, port, 0);
2521 }
2522
2523 /**
2524  * sw_cfg_replace_null_vid -
2525  * @hw:         The hardware instance.
2526  * @set:        The flag to disable or enable.
2527  *
2528  */
2529 static void sw_cfg_replace_null_vid(struct ksz_hw *hw, int set)
2530 {
2531         sw_cfg(hw, KS8842_SWITCH_CTRL_3_OFFSET, SWITCH_REPLACE_NULL_VID, set);
2532 }
2533
2534 /**
2535  * sw_cfg_replace_vid - enable switch 802.10 priority re-mapping
2536  * @hw:         The hardware instance.
2537  * @port:       The port index.
2538  * @set:        The flag to disable or enable.
2539  *
2540  * This routine enables the 802.1p priority re-mapping function of the switch.
2541  * That allows 802.1p priority field to be replaced with the port's default
2542  * tag's priority value if the ingress packet's 802.1p priority has a higher
2543  * priority than port's default tag's priority.
2544  */
2545 static void sw_cfg_replace_vid(struct ksz_hw *hw, int port, int set)
2546 {
2547         port_cfg_replace_vid(hw, port, set);
2548 }
2549
2550 /**
2551  * sw_cfg_port_based - configure switch port based priority
2552  * @hw:         The hardware instance.
2553  * @port:       The port index.
2554  * @prio:       The priority to set.
2555  *
2556  * This routine configures the port based priority of the switch.
2557  */
2558 static void sw_cfg_port_based(struct ksz_hw *hw, int port, u8 prio)
2559 {
2560         u16 data;
2561
2562         if (prio > PORT_BASED_PRIORITY_BASE)
2563                 prio = PORT_BASED_PRIORITY_BASE;
2564
2565         hw->ksz_switch->port_cfg[port].port_prio = prio;
2566
2567         port_r16(hw, port, KS8842_PORT_CTRL_1_OFFSET, &data);
2568         data &= ~PORT_BASED_PRIORITY_MASK;
2569         data |= prio << PORT_BASED_PRIORITY_SHIFT;
2570         port_w16(hw, port, KS8842_PORT_CTRL_1_OFFSET, data);
2571 }
2572
2573 /**
2574  * sw_dis_multi_queue - disable transmit multiple queues
2575  * @hw:         The hardware instance.
2576  * @port:       The port index.
2577  *
2578  * This routine disables the transmit multiple queues selection of the switch
2579  * port.  Only single transmit queue on the port.
2580  */
2581 static void sw_dis_multi_queue(struct ksz_hw *hw, int port)
2582 {
2583         port_cfg_prio(hw, port, 0);
2584 }
2585
2586 /**
2587  * sw_init_prio - initialize switch priority
2588  * @hw:         The hardware instance.
2589  *
2590  * This routine initializes the switch QoS priority functions.
2591  */
2592 static void sw_init_prio(struct ksz_hw *hw)
2593 {
2594         int port;
2595         int tos;
2596         struct ksz_switch *sw = hw->ksz_switch;
2597
2598         /*
2599          * Init all the 802.1p tag priority value to be assigned to different
2600          * priority queue.
2601          */
2602         sw->p_802_1p[0] = 0;
2603         sw->p_802_1p[1] = 0;
2604         sw->p_802_1p[2] = 1;
2605         sw->p_802_1p[3] = 1;
2606         sw->p_802_1p[4] = 2;
2607         sw->p_802_1p[5] = 2;
2608         sw->p_802_1p[6] = 3;
2609         sw->p_802_1p[7] = 3;
2610
2611         /*
2612          * Init all the DiffServ priority value to be assigned to priority
2613          * queue 0.
2614          */
2615         for (tos = 0; tos < DIFFSERV_ENTRIES; tos++)
2616                 sw->diffserv[tos] = 0;
2617
2618         /* All QoS functions disabled. */
2619         for (port = 0; port < TOTAL_PORT_NUM; port++) {
2620                 sw_dis_multi_queue(hw, port);
2621                 sw_dis_diffserv(hw, port);
2622                 sw_dis_802_1p(hw, port);
2623                 sw_cfg_replace_vid(hw, port, 0);
2624
2625                 sw->port_cfg[port].port_prio = 0;
2626                 sw_cfg_port_based(hw, port, sw->port_cfg[port].port_prio);
2627         }
2628         sw_cfg_replace_null_vid(hw, 0);
2629 }
2630
2631 /**
2632  * port_get_def_vid - get port default VID.
2633  * @hw:         The hardware instance.
2634  * @port:       The port index.
2635  * @vid:        Buffer to store the VID.
2636  *
2637  * This routine retrieves the default VID of the port.
2638  */
2639 static void port_get_def_vid(struct ksz_hw *hw, int port, u16 *vid)
2640 {
2641         u32 addr;
2642
2643         PORT_CTRL_ADDR(port, addr);
2644         addr += KS8842_PORT_CTRL_VID_OFFSET;
2645         *vid = readw(hw->io + addr);
2646 }
2647
2648 /**
2649  * sw_init_vlan - initialize switch VLAN
2650  * @hw:         The hardware instance.
2651  *
2652  * This routine initializes the VLAN function of the switch.
2653  */
2654 static void sw_init_vlan(struct ksz_hw *hw)
2655 {
2656         int port;
2657         int entry;
2658         struct ksz_switch *sw = hw->ksz_switch;
2659
2660         /* Read 16 VLAN entries from device's VLAN table. */
2661         for (entry = 0; entry < VLAN_TABLE_ENTRIES; entry++) {
2662                 sw_r_vlan_table(hw, entry,
2663                         &sw->vlan_table[entry].vid,
2664                         &sw->vlan_table[entry].fid,
2665                         &sw->vlan_table[entry].member);
2666         }
2667
2668         for (port = 0; port < TOTAL_PORT_NUM; port++) {
2669                 port_get_def_vid(hw, port, &sw->port_cfg[port].vid);
2670                 sw->port_cfg[port].member = PORT_MASK;
2671         }
2672 }
2673
2674 /**
2675  * sw_cfg_port_base_vlan - configure port-based VLAN membership
2676  * @hw:         The hardware instance.
2677  * @port:       The port index.
2678  * @member:     The port-based VLAN membership.
2679  *
2680  * This routine configures the port-based VLAN membership of the port.
2681  */
2682 static void sw_cfg_port_base_vlan(struct ksz_hw *hw, int port, u8 member)
2683 {
2684         u32 addr;
2685         u8 data;
2686
2687         PORT_CTRL_ADDR(port, addr);
2688         addr += KS8842_PORT_CTRL_2_OFFSET;
2689
2690         data = readb(hw->io + addr);
2691         data &= ~PORT_VLAN_MEMBERSHIP;
2692         data |= (member & PORT_MASK);
2693         writeb(data, hw->io + addr);
2694
2695         hw->ksz_switch->port_cfg[port].member = member;
2696 }
2697
2698 /**
2699  * sw_get_addr - get the switch MAC address.
2700  * @hw:         The hardware instance.
2701  * @mac_addr:   Buffer to store the MAC address.
2702  *
2703  * This function retrieves the MAC address of the switch.
2704  */
2705 static inline void sw_get_addr(struct ksz_hw *hw, u8 *mac_addr)
2706 {
2707         int i;
2708
2709         for (i = 0; i < 6; i += 2) {
2710                 mac_addr[i] = readb(hw->io + KS8842_MAC_ADDR_0_OFFSET + i);
2711                 mac_addr[1 + i] = readb(hw->io + KS8842_MAC_ADDR_1_OFFSET + i);
2712         }
2713 }
2714
2715 /**
2716  * sw_set_addr - configure switch MAC address
2717  * @hw:         The hardware instance.
2718  * @mac_addr:   The MAC address.
2719  *
2720  * This function configures the MAC address of the switch.
2721  */
2722 static void sw_set_addr(struct ksz_hw *hw, u8 *mac_addr)
2723 {
2724         int i;
2725
2726         for (i = 0; i < 6; i += 2) {
2727                 writeb(mac_addr[i], hw->io + KS8842_MAC_ADDR_0_OFFSET + i);
2728                 writeb(mac_addr[1 + i], hw->io + KS8842_MAC_ADDR_1_OFFSET + i);
2729         }
2730 }
2731
2732 /**
2733  * sw_set_global_ctrl - set switch global control
2734  * @hw:         The hardware instance.
2735  *
2736  * This routine sets the global control of the switch function.
2737  */
2738 static void sw_set_global_ctrl(struct ksz_hw *hw)
2739 {
2740         u16 data;
2741
2742         /* Enable switch MII flow control. */
2743         data = readw(hw->io + KS8842_SWITCH_CTRL_3_OFFSET);
2744         data |= SWITCH_FLOW_CTRL;
2745         writew(data, hw->io + KS8842_SWITCH_CTRL_3_OFFSET);
2746
2747         data = readw(hw->io + KS8842_SWITCH_CTRL_1_OFFSET);
2748
2749         /* Enable aggressive back off algorithm in half duplex mode. */
2750         data |= SWITCH_AGGR_BACKOFF;
2751
2752         /* Enable automatic fast aging when link changed detected. */
2753         data |= SWITCH_AGING_ENABLE;
2754         data |= SWITCH_LINK_AUTO_AGING;
2755
2756         if (hw->overrides & FAST_AGING)
2757                 data |= SWITCH_FAST_AGING;
2758         else
2759                 data &= ~SWITCH_FAST_AGING;
2760         writew(data, hw->io + KS8842_SWITCH_CTRL_1_OFFSET);
2761
2762         data = readw(hw->io + KS8842_SWITCH_CTRL_2_OFFSET);
2763
2764         /* Enable no excessive collision drop. */
2765         data |= NO_EXC_COLLISION_DROP;
2766         writew(data, hw->io + KS8842_SWITCH_CTRL_2_OFFSET);
2767 }
2768
2769 enum {
2770         STP_STATE_DISABLED = 0,
2771         STP_STATE_LISTENING,
2772         STP_STATE_LEARNING,
2773         STP_STATE_FORWARDING,
2774         STP_STATE_BLOCKED,
2775         STP_STATE_SIMPLE
2776 };
2777
2778 /**
2779  * port_set_stp_state - configure port spanning tree state
2780  * @hw:         The hardware instance.
2781  * @port:       The port index.
2782  * @state:      The spanning tree state.
2783  *
2784  * This routine configures the spanning tree state of the port.
2785  */
2786 static void port_set_stp_state(struct ksz_hw *hw, int port, int state)
2787 {
2788         u16 data;
2789
2790         port_r16(hw, port, KS8842_PORT_CTRL_2_OFFSET, &data);
2791         switch (state) {
2792         case STP_STATE_DISABLED:
2793                 data &= ~(PORT_TX_ENABLE | PORT_RX_ENABLE);
2794                 data |= PORT_LEARN_DISABLE;
2795                 break;
2796         case STP_STATE_LISTENING:
2797 /*
2798  * No need to turn on transmit because of port direct mode.
2799  * Turning on receive is required if static MAC table is not setup.
2800  */
2801                 data &= ~PORT_TX_ENABLE;
2802                 data |= PORT_RX_ENABLE;
2803                 data |= PORT_LEARN_DISABLE;
2804                 break;
2805         case STP_STATE_LEARNING:
2806                 data &= ~PORT_TX_ENABLE;
2807                 data |= PORT_RX_ENABLE;
2808                 data &= ~PORT_LEARN_DISABLE;
2809                 break;
2810         case STP_STATE_FORWARDING:
2811                 data |= (PORT_TX_ENABLE | PORT_RX_ENABLE);
2812                 data &= ~PORT_LEARN_DISABLE;
2813                 break;
2814         case STP_STATE_BLOCKED:
2815 /*
2816  * Need to setup static MAC table with override to keep receiving BPDU
2817  * messages.  See sw_init_stp routine.
2818  */
2819                 data &= ~(PORT_TX_ENABLE | PORT_RX_ENABLE);
2820                 data |= PORT_LEARN_DISABLE;
2821                 break;
2822         case STP_STATE_SIMPLE:
2823                 data |= (PORT_TX_ENABLE | PORT_RX_ENABLE);
2824                 data |= PORT_LEARN_DISABLE;
2825                 break;
2826         }
2827         port_w16(hw, port, KS8842_PORT_CTRL_2_OFFSET, data);
2828         hw->ksz_switch->port_cfg[port].stp_state = state;
2829 }
2830
2831 #define STP_ENTRY                       0
2832 #define BROADCAST_ENTRY                 1
2833 #define BRIDGE_ADDR_ENTRY               2
2834 #define IPV6_ADDR_ENTRY                 3
2835
2836 /**
2837  * sw_clr_sta_mac_table - clear static MAC table
2838  * @hw:         The hardware instance.
2839  *
2840  * This routine clears the static MAC table.
2841  */
2842 static void sw_clr_sta_mac_table(struct ksz_hw *hw)
2843 {
2844         struct ksz_mac_table *entry;
2845         int i;
2846
2847         for (i = 0; i < STATIC_MAC_TABLE_ENTRIES; i++) {
2848                 entry = &hw->ksz_switch->mac_table[i];
2849                 sw_w_sta_mac_table(hw, i,
2850                         entry->mac_addr, entry->ports,
2851                         entry->override, 0,
2852                         entry->use_fid, entry->fid);
2853         }
2854 }
2855
2856 /**
2857  * sw_init_stp - initialize switch spanning tree support
2858  * @hw:         The hardware instance.
2859  *
2860  * This routine initializes the spanning tree support of the switch.
2861  */
2862 static void sw_init_stp(struct ksz_hw *hw)
2863 {
2864         struct ksz_mac_table *entry;
2865
2866         entry = &hw->ksz_switch->mac_table[STP_ENTRY];
2867         entry->mac_addr[0] = 0x01;
2868         entry->mac_addr[1] = 0x80;
2869         entry->mac_addr[2] = 0xC2;
2870         entry->mac_addr[3] = 0x00;
2871         entry->mac_addr[4] = 0x00;
2872         entry->mac_addr[5] = 0x00;
2873         entry->ports = HOST_MASK;
2874         entry->override = 1;
2875         entry->valid = 1;
2876         sw_w_sta_mac_table(hw, STP_ENTRY,
2877                 entry->mac_addr, entry->ports,
2878                 entry->override, entry->valid,
2879                 entry->use_fid, entry->fid);
2880 }
2881
2882 /**
2883  * sw_block_addr - block certain packets from the host port
2884  * @hw:         The hardware instance.
2885  *
2886  * This routine blocks certain packets from reaching to the host port.
2887  */
2888 static void sw_block_addr(struct ksz_hw *hw)
2889 {
2890         struct ksz_mac_table *entry;
2891         int i;
2892
2893         for (i = BROADCAST_ENTRY; i <= IPV6_ADDR_ENTRY; i++) {
2894                 entry = &hw->ksz_switch->mac_table[i];
2895                 entry->valid = 0;
2896                 sw_w_sta_mac_table(hw, i,
2897                         entry->mac_addr, entry->ports,
2898                         entry->override, entry->valid,
2899                         entry->use_fid, entry->fid);
2900         }
2901 }
2902
2903 #define PHY_LINK_SUPPORT                \
2904         (PHY_AUTO_NEG_ASYM_PAUSE |      \
2905         PHY_AUTO_NEG_SYM_PAUSE |        \
2906         PHY_AUTO_NEG_100BT4 |           \
2907         PHY_AUTO_NEG_100BTX_FD |        \
2908         PHY_AUTO_NEG_100BTX |           \
2909         PHY_AUTO_NEG_10BT_FD |          \
2910         PHY_AUTO_NEG_10BT)
2911
2912 static inline void hw_r_phy_ctrl(struct ksz_hw *hw, int phy, u16 *data)
2913 {
2914         *data = readw(hw->io + phy + KS884X_PHY_CTRL_OFFSET);
2915 }
2916
2917 static inline void hw_w_phy_ctrl(struct ksz_hw *hw, int phy, u16 data)
2918 {
2919         writew(data, hw->io + phy + KS884X_PHY_CTRL_OFFSET);
2920 }
2921
2922 static inline void hw_r_phy_link_stat(struct ksz_hw *hw, int phy, u16 *data)
2923 {
2924         *data = readw(hw->io + phy + KS884X_PHY_STATUS_OFFSET);
2925 }
2926
2927 static inline void hw_r_phy_auto_neg(struct ksz_hw *hw, int phy, u16 *data)
2928 {
2929         *data = readw(hw->io + phy + KS884X_PHY_AUTO_NEG_OFFSET);
2930 }
2931
2932 static inline void hw_w_phy_auto_neg(struct ksz_hw *hw, int phy, u16 data)
2933 {
2934         writew(data, hw->io + phy + KS884X_PHY_AUTO_NEG_OFFSET);
2935 }
2936
2937 static inline void hw_r_phy_rem_cap(struct ksz_hw *hw, int phy, u16 *data)
2938 {
2939         *data = readw(hw->io + phy + KS884X_PHY_REMOTE_CAP_OFFSET);
2940 }
2941
2942 static inline void hw_r_phy_crossover(struct ksz_hw *hw, int phy, u16 *data)
2943 {
2944         *data = readw(hw->io + phy + KS884X_PHY_CTRL_OFFSET);
2945 }
2946
2947 static inline void hw_w_phy_crossover(struct ksz_hw *hw, int phy, u16 data)
2948 {
2949         writew(data, hw->io + phy + KS884X_PHY_CTRL_OFFSET);
2950 }
2951
2952 static inline void hw_r_phy_polarity(struct ksz_hw *hw, int phy, u16 *data)
2953 {
2954         *data = readw(hw->io + phy + KS884X_PHY_PHY_CTRL_OFFSET);
2955 }
2956
2957 static inline void hw_w_phy_polarity(struct ksz_hw *hw, int phy, u16 data)
2958 {
2959         writew(data, hw->io + phy + KS884X_PHY_PHY_CTRL_OFFSET);
2960 }
2961
2962 static inline void hw_r_phy_link_md(struct ksz_hw *hw, int phy, u16 *data)
2963 {
2964         *data = readw(hw->io + phy + KS884X_PHY_LINK_MD_OFFSET);
2965 }
2966
2967 static inline void hw_w_phy_link_md(struct ksz_hw *hw, int phy, u16 data)
2968 {
2969         writew(data, hw->io + phy + KS884X_PHY_LINK_MD_OFFSET);
2970 }
2971
2972 /**
2973  * hw_r_phy - read data from PHY register
2974  * @hw:         The hardware instance.
2975  * @port:       Port to read.
2976  * @reg:        PHY register to read.
2977  * @val:        Buffer to store the read data.
2978  *
2979  * This routine reads data from the PHY register.
2980  */
2981 static void hw_r_phy(struct ksz_hw *hw, int port, u16 reg, u16 *val)
2982 {
2983         int phy;
2984
2985         phy = KS884X_PHY_1_CTRL_OFFSET + port * PHY_CTRL_INTERVAL + reg;
2986         *val = readw(hw->io + phy);
2987 }
2988
2989 /**
2990  * port_w_phy - write data to PHY register
2991  * @hw:         The hardware instance.
2992  * @port:       Port to write.
2993  * @reg:        PHY register to write.
2994  * @val:        Word data to write.
2995  *
2996  * This routine writes data to the PHY register.
2997  */
2998 static void hw_w_phy(struct ksz_hw *hw, int port, u16 reg, u16 val)
2999 {
3000         int phy;
3001
3002         phy = KS884X_PHY_1_CTRL_OFFSET + port * PHY_CTRL_INTERVAL + reg;
3003         writew(val, hw->io + phy);
3004 }
3005
3006 /*
3007  * EEPROM access functions
3008  */
3009
3010 #define AT93C_CODE                      0
3011 #define AT93C_WR_OFF                    0x00
3012 #define AT93C_WR_ALL                    0x10
3013 #define AT93C_ER_ALL                    0x20
3014 #define AT93C_WR_ON                     0x30
3015
3016 #define AT93C_WRITE                     1
3017 #define AT93C_READ                      2
3018 #define AT93C_ERASE                     3
3019
3020 #define EEPROM_DELAY                    4
3021
3022 static inline void drop_gpio(struct ksz_hw *hw, u8 gpio)
3023 {
3024         u16 data;
3025
3026         data = readw(hw->io + KS884X_EEPROM_CTRL_OFFSET);
3027         data &= ~gpio;
3028         writew(data, hw->io + KS884X_EEPROM_CTRL_OFFSET);
3029 }
3030
3031 static inline void raise_gpio(struct ksz_hw *hw, u8 gpio)
3032 {
3033         u16 data;
3034
3035         data = readw(hw->io + KS884X_EEPROM_CTRL_OFFSET);
3036         data |= gpio;
3037         writew(data, hw->io + KS884X_EEPROM_CTRL_OFFSET);
3038 }
3039
3040 static inline u8 state_gpio(struct ksz_hw *hw, u8 gpio)
3041 {
3042         u16 data;
3043
3044         data = readw(hw->io + KS884X_EEPROM_CTRL_OFFSET);
3045         return (u8)(data & gpio);
3046 }
3047
3048 static void eeprom_clk(struct ksz_hw *hw)
3049 {
3050         raise_gpio(hw, EEPROM_SERIAL_CLOCK);
3051         udelay(EEPROM_DELAY);
3052         drop_gpio(hw, EEPROM_SERIAL_CLOCK);
3053         udelay(EEPROM_DELAY);
3054 }
3055
3056 static u16 spi_r(struct ksz_hw *hw)
3057 {
3058         int i;
3059         u16 temp = 0;
3060
3061         for (i = 15; i >= 0; i--) {
3062                 raise_gpio(hw, EEPROM_SERIAL_CLOCK);
3063                 udelay(EEPROM_DELAY);
3064
3065                 temp |= (state_gpio(hw, EEPROM_DATA_IN)) ? 1 << i : 0;
3066
3067                 drop_gpio(hw, EEPROM_SERIAL_CLOCK);
3068                 udelay(EEPROM_DELAY);
3069         }
3070         return temp;
3071 }
3072
3073 static void spi_w(struct ksz_hw *hw, u16 data)
3074 {
3075         int i;
3076
3077         for (i = 15; i >= 0; i--) {
3078                 (data & (0x01 << i)) ? raise_gpio(hw, EEPROM_DATA_OUT) :
3079                         drop_gpio(hw, EEPROM_DATA_OUT);
3080                 eeprom_clk(hw);
3081         }
3082 }
3083
3084 static void spi_reg(struct ksz_hw *hw, u8 data, u8 reg)
3085 {
3086         int i;
3087
3088         /* Initial start bit */
3089         raise_gpio(hw, EEPROM_DATA_OUT);
3090         eeprom_clk(hw);
3091
3092         /* AT93C operation */
3093         for (i = 1; i >= 0; i--) {
3094                 (data & (0x01 << i)) ? raise_gpio(hw, EEPROM_DATA_OUT) :
3095                         drop_gpio(hw, EEPROM_DATA_OUT);
3096                 eeprom_clk(hw);
3097         }
3098
3099         /* Address location */
3100         for (i = 5; i >= 0; i--) {
3101                 (reg & (0x01 << i)) ? raise_gpio(hw, EEPROM_DATA_OUT) :
3102                         drop_gpio(hw, EEPROM_DATA_OUT);
3103                 eeprom_clk(hw);
3104         }
3105 }
3106
3107 #define EEPROM_DATA_RESERVED            0
3108 #define EEPROM_DATA_MAC_ADDR_0          1
3109 #define EEPROM_DATA_MAC_ADDR_1          2
3110 #define EEPROM_DATA_MAC_ADDR_2          3
3111 #define EEPROM_DATA_SUBSYS_ID           4
3112 #define EEPROM_DATA_SUBSYS_VEN_ID       5
3113 #define EEPROM_DATA_PM_CAP              6
3114
3115 /* User defined EEPROM data */
3116 #define EEPROM_DATA_OTHER_MAC_ADDR      9
3117
3118 /**
3119  * eeprom_read - read from AT93C46 EEPROM
3120  * @hw:         The hardware instance.
3121  * @reg:        The register offset.
3122  *
3123  * This function reads a word from the AT93C46 EEPROM.
3124  *
3125  * Return the data value.
3126  */
3127 static u16 eeprom_read(struct ksz_hw *hw, u8 reg)
3128 {
3129         u16 data;
3130
3131         raise_gpio(hw, EEPROM_ACCESS_ENABLE | EEPROM_CHIP_SELECT);
3132
3133         spi_reg(hw, AT93C_READ, reg);
3134         data = spi_r(hw);
3135
3136         drop_gpio(hw, EEPROM_ACCESS_ENABLE | EEPROM_CHIP_SELECT);
3137
3138         return data;
3139 }
3140
3141 /**
3142  * eeprom_write - write to AT93C46 EEPROM
3143  * @hw:         The hardware instance.
3144  * @reg:        The register offset.
3145  * @data:       The data value.
3146  *
3147  * This procedure writes a word to the AT93C46 EEPROM.
3148  */
3149 static void eeprom_write(struct ksz_hw *hw, u8 reg, u16 data)
3150 {
3151         int timeout;
3152
3153         raise_gpio(hw, EEPROM_ACCESS_ENABLE | EEPROM_CHIP_SELECT);
3154
3155         /* Enable write. */
3156         spi_reg(hw, AT93C_CODE, AT93C_WR_ON);
3157         drop_gpio(hw, EEPROM_CHIP_SELECT);
3158         udelay(1);
3159
3160         /* Erase the register. */
3161         raise_gpio(hw, EEPROM_CHIP_SELECT);
3162         spi_reg(hw, AT93C_ERASE, reg);
3163         drop_gpio(hw, EEPROM_CHIP_SELECT);
3164         udelay(1);
3165
3166         /* Check operation complete. */
3167         raise_gpio(hw, EEPROM_CHIP_SELECT);
3168         timeout = 8;
3169         mdelay(2);
3170         do {
3171                 mdelay(1);
3172         } while (!state_gpio(hw, EEPROM_DATA_IN) && --timeout);
3173         drop_gpio(hw, EEPROM_CHIP_SELECT);
3174         udelay(1);
3175
3176         /* Write the register. */
3177         raise_gpio(hw, EEPROM_CHIP_SELECT);
3178         spi_reg(hw, AT93C_WRITE, reg);
3179         spi_w(hw, data);
3180         drop_gpio(hw, EEPROM_CHIP_SELECT);
3181         udelay(1);
3182
3183         /* Check operation complete. */
3184         raise_gpio(hw, EEPROM_CHIP_SELECT);
3185         timeout = 8;
3186         mdelay(2);
3187         do {
3188                 mdelay(1);
3189         } while (!state_gpio(hw, EEPROM_DATA_IN) && --timeout);
3190         drop_gpio(hw, EEPROM_CHIP_SELECT);
3191         udelay(1);
3192
3193         /* Disable write. */
3194         raise_gpio(hw, EEPROM_CHIP_SELECT);
3195         spi_reg(hw, AT93C_CODE, AT93C_WR_OFF);
3196
3197         drop_gpio(hw, EEPROM_ACCESS_ENABLE | EEPROM_CHIP_SELECT);
3198 }
3199
3200 /*
3201  * Link detection routines
3202  */
3203
3204 static u16 advertised_flow_ctrl(struct ksz_port *port, u16 ctrl)
3205 {
3206         ctrl &= ~PORT_AUTO_NEG_SYM_PAUSE;
3207         switch (port->flow_ctrl) {
3208         case PHY_FLOW_CTRL:
3209                 ctrl |= PORT_AUTO_NEG_SYM_PAUSE;
3210                 break;
3211         /* Not supported. */
3212         case PHY_TX_ONLY:
3213         case PHY_RX_ONLY:
3214         default:
3215                 break;
3216         }
3217         return ctrl;
3218 }
3219
3220 static void set_flow_ctrl(struct ksz_hw *hw, int rx, int tx)
3221 {
3222         u32 rx_cfg;
3223         u32 tx_cfg;
3224
3225         rx_cfg = hw->rx_cfg;
3226         tx_cfg = hw->tx_cfg;
3227         if (rx)
3228                 hw->rx_cfg |= DMA_RX_FLOW_ENABLE;
3229         else
3230                 hw->rx_cfg &= ~DMA_RX_FLOW_ENABLE;
3231         if (tx)
3232                 hw->tx_cfg |= DMA_TX_FLOW_ENABLE;
3233         else
3234                 hw->tx_cfg &= ~DMA_TX_FLOW_ENABLE;
3235         if (hw->enabled) {
3236                 if (rx_cfg != hw->rx_cfg)
3237                         writel(hw->rx_cfg, hw->io + KS_DMA_RX_CTRL);
3238                 if (tx_cfg != hw->tx_cfg)
3239                         writel(hw->tx_cfg, hw->io + KS_DMA_TX_CTRL);
3240         }
3241 }
3242
3243 static void determine_flow_ctrl(struct ksz_hw *hw, struct ksz_port *port,
3244         u16 local, u16 remote)
3245 {
3246         int rx;
3247         int tx;
3248
3249         if (hw->overrides & PAUSE_FLOW_CTRL)
3250                 return;
3251
3252         rx = tx = 0;
3253         if (port->force_link)
3254                 rx = tx = 1;
3255         if (remote & PHY_AUTO_NEG_SYM_PAUSE) {
3256                 if (local & PHY_AUTO_NEG_SYM_PAUSE) {
3257                         rx = tx = 1;
3258                 } else if ((remote & PHY_AUTO_NEG_ASYM_PAUSE) &&
3259                                 (local & PHY_AUTO_NEG_PAUSE) ==
3260                                 PHY_AUTO_NEG_ASYM_PAUSE) {
3261                         tx = 1;
3262                 }
3263         } else if (remote & PHY_AUTO_NEG_ASYM_PAUSE) {
3264                 if ((local & PHY_AUTO_NEG_PAUSE) == PHY_AUTO_NEG_PAUSE)
3265                         rx = 1;
3266         }
3267         if (!hw->ksz_switch)
3268                 set_flow_ctrl(hw, rx, tx);
3269 }
3270
3271 static inline void port_cfg_change(struct ksz_hw *hw, struct ksz_port *port,
3272         struct ksz_port_info *info, u16 link_status)
3273 {
3274         if ((hw->features & HALF_DUPLEX_SIGNAL_BUG) &&
3275                         !(hw->overrides & PAUSE_FLOW_CTRL)) {
3276                 u32 cfg = hw->tx_cfg;
3277
3278                 /* Disable flow control in the half duplex mode. */
3279                 if (1 == info->duplex)
3280                         hw->tx_cfg &= ~DMA_TX_FLOW_ENABLE;
3281                 if (hw->enabled && cfg != hw->tx_cfg)
3282                         writel(hw->tx_cfg, hw->io + KS_DMA_TX_CTRL);
3283         }
3284 }
3285
3286 /**
3287  * port_get_link_speed - get current link status
3288  * @port:       The port instance.
3289  *
3290  * This routine reads PHY registers to determine the current link status of the
3291  * switch ports.
3292  */
3293 static void port_get_link_speed(struct ksz_port *port)
3294 {
3295         uint interrupt;
3296         struct ksz_port_info *info;
3297         struct ksz_port_info *linked = NULL;
3298         struct ksz_hw *hw = port->hw;
3299         u16 data;
3300         u16 status;
3301         u8 local;
3302         u8 remote;
3303         int i;
3304         int p;
3305         int change = 0;
3306
3307         interrupt = hw_block_intr(hw);
3308
3309         for (i = 0, p = port->first_port; i < port->port_cnt; i++, p++) {
3310                 info = &hw->port_info[p];
3311                 port_r16(hw, p, KS884X_PORT_CTRL_4_OFFSET, &data);
3312                 port_r16(hw, p, KS884X_PORT_STATUS_OFFSET, &status);
3313
3314                 /*
3315                  * Link status is changing all the time even when there is no
3316                  * cable connection!
3317                  */
3318                 remote = status & (PORT_AUTO_NEG_COMPLETE |
3319                         PORT_STATUS_LINK_GOOD);
3320                 local = (u8) data;
3321
3322                 /* No change to status. */
3323                 if (local == info->advertised && remote == info->partner)
3324                         continue;
3325
3326                 info->advertised = local;
3327                 info->partner = remote;
3328                 if (status & PORT_STATUS_LINK_GOOD) {
3329
3330                         /* Remember the first linked port. */
3331                         if (!linked)
3332                                 linked = info;
3333
3334                         info->tx_rate = 10 * TX_RATE_UNIT;
3335                         if (status & PORT_STATUS_SPEED_100MBIT)
3336                                 info->tx_rate = 100 * TX_RATE_UNIT;
3337
3338                         info->duplex = 1;
3339                         if (status & PORT_STATUS_FULL_DUPLEX)
3340                                 info->duplex = 2;
3341
3342                         if (media_connected != info->state) {
3343                                 hw_r_phy(hw, p, KS884X_PHY_AUTO_NEG_OFFSET,
3344                                         &data);
3345                                 hw_r_phy(hw, p, KS884X_PHY_REMOTE_CAP_OFFSET,
3346                                         &status);
3347                                 determine_flow_ctrl(hw, port, data, status);
3348                                 if (hw->ksz_switch) {
3349                                         port_cfg_back_pressure(hw, p,
3350                                                 (1 == info->duplex));
3351                                 }
3352                                 change |= 1 << i;
3353                                 port_cfg_change(hw, port, info, status);
3354                         }
3355                         info->state = media_connected;
3356                 } else {
3357                         if (media_disconnected != info->state) {
3358                                 change |= 1 << i;
3359
3360                                 /* Indicate the link just goes down. */
3361                                 hw->port_mib[p].link_down = 1;
3362                         }
3363                         info->state = media_disconnected;
3364                 }
3365                 hw->port_mib[p].state = (u8) info->state;
3366         }
3367
3368         if (linked && media_disconnected == port->linked->state)
3369                 port->linked = linked;
3370
3371         hw_restore_intr(hw, interrupt);
3372 }
3373
3374 #define PHY_RESET_TIMEOUT               10
3375
3376 /**
3377  * port_set_link_speed - set port speed
3378  * @port:       The port instance.
3379  *
3380  * This routine sets the link speed of the switch ports.
3381  */
3382 static void port_set_link_speed(struct ksz_port *port)
3383 {
3384         struct ksz_port_info *info;
3385         struct ksz_hw *hw = port->hw;
3386         u16 data;
3387         u16 cfg;
3388         u8 status;
3389         int i;
3390         int p;
3391
3392         for (i = 0, p = port->first_port; i < port->port_cnt; i++, p++) {
3393                 info = &hw->port_info[p];
3394
3395                 port_r16(hw, p, KS884X_PORT_CTRL_4_OFFSET, &data);
3396                 port_r8(hw, p, KS884X_PORT_STATUS_OFFSET, &status);
3397
3398                 cfg = 0;
3399                 if (status & PORT_STATUS_LINK_GOOD)
3400                         cfg = data;
3401
3402                 data |= PORT_AUTO_NEG_ENABLE;
3403                 data = advertised_flow_ctrl(port, data);
3404
3405                 data |= PORT_AUTO_NEG_100BTX_FD | PORT_AUTO_NEG_100BTX |
3406                         PORT_AUTO_NEG_10BT_FD | PORT_AUTO_NEG_10BT;
3407
3408                 /* Check if manual configuration is specified by the user. */
3409                 if (port->speed || port->duplex) {
3410                         if (10 == port->speed)
3411                                 data &= ~(PORT_AUTO_NEG_100BTX_FD |
3412                                         PORT_AUTO_NEG_100BTX);
3413                         else if (100 == port->speed)
3414                                 data &= ~(PORT_AUTO_NEG_10BT_FD |
3415                                         PORT_AUTO_NEG_10BT);
3416                         if (1 == port->duplex)
3417                                 data &= ~(PORT_AUTO_NEG_100BTX_FD |
3418                                         PORT_AUTO_NEG_10BT_FD);
3419                         else if (2 == port->duplex)
3420                                 data &= ~(PORT_AUTO_NEG_100BTX |
3421                                         PORT_AUTO_NEG_10BT);
3422                 }
3423                 if (data != cfg) {
3424                         data |= PORT_AUTO_NEG_RESTART;
3425                         port_w16(hw, p, KS884X_PORT_CTRL_4_OFFSET, data);
3426                 }
3427         }
3428 }
3429
3430 /**
3431  * port_force_link_speed - force port speed
3432  * @port:       The port instance.
3433  *
3434  * This routine forces the link speed of the switch ports.
3435  */
3436 static void port_force_link_speed(struct ksz_port *port)
3437 {
3438         struct ksz_hw *hw = port->hw;
3439         u16 data;
3440         int i;
3441         int phy;
3442         int p;
3443
3444         for (i = 0, p = port->first_port; i < port->port_cnt; i++, p++) {
3445                 phy = KS884X_PHY_1_CTRL_OFFSET + p * PHY_CTRL_INTERVAL;
3446                 hw_r_phy_ctrl(hw, phy, &data);
3447
3448                 data &= ~PHY_AUTO_NEG_ENABLE;
3449
3450                 if (10 == port->speed)
3451                         data &= ~PHY_SPEED_100MBIT;
3452                 else if (100 == port->speed)
3453                         data |= PHY_SPEED_100MBIT;
3454                 if (1 == port->duplex)
3455                         data &= ~PHY_FULL_DUPLEX;
3456                 else if (2 == port->duplex)
3457                         data |= PHY_FULL_DUPLEX;
3458                 hw_w_phy_ctrl(hw, phy, data);
3459         }
3460 }
3461
3462 static void port_set_power_saving(struct ksz_port *port, int enable)
3463 {
3464         struct ksz_hw *hw = port->hw;
3465         int i;
3466         int p;
3467
3468         for (i = 0, p = port->first_port; i < port->port_cnt; i++, p++)
3469                 port_cfg(hw, p,
3470                         KS884X_PORT_CTRL_4_OFFSET, PORT_POWER_DOWN, enable);
3471 }
3472
3473 /*
3474  * KSZ8841 power management functions
3475  */
3476
3477 /**
3478  * hw_chk_wol_pme_status - check PMEN pin
3479  * @hw:         The hardware instance.
3480  *
3481  * This function is used to check PMEN pin is asserted.
3482  *
3483  * Return 1 if PMEN pin is asserted; otherwise, 0.
3484  */
3485 static int hw_chk_wol_pme_status(struct ksz_hw *hw)
3486 {
3487         struct dev_info *hw_priv = container_of(hw, struct dev_info, hw);
3488         struct pci_dev *pdev = hw_priv->pdev;
3489         u16 data;
3490
3491         if (!pdev->pm_cap)
3492                 return 0;
3493         pci_read_config_word(pdev, pdev->pm_cap + PCI_PM_CTRL, &data);
3494         return (data & PCI_PM_CTRL_PME_STATUS) == PCI_PM_CTRL_PME_STATUS;
3495 }
3496
3497 /**
3498  * hw_clr_wol_pme_status - clear PMEN pin
3499  * @hw:         The hardware instance.
3500  *
3501  * This routine is used to clear PME_Status to deassert PMEN pin.
3502  */
3503 static void hw_clr_wol_pme_status(struct ksz_hw *hw)
3504 {
3505         struct dev_info *hw_priv = container_of(hw, struct dev_info, hw);
3506         struct pci_dev *pdev = hw_priv->pdev;
3507         u16 data;
3508
3509         if (!pdev->pm_cap)
3510                 return;
3511
3512         /* Clear PME_Status to deassert PMEN pin. */
3513         pci_read_config_word(pdev, pdev->pm_cap + PCI_PM_CTRL, &data);
3514         data |= PCI_PM_CTRL_PME_STATUS;
3515         pci_write_config_word(pdev, pdev->pm_cap + PCI_PM_CTRL, data);
3516 }
3517
3518 /**
3519  * hw_cfg_wol_pme - enable or disable Wake-on-LAN
3520  * @hw:         The hardware instance.
3521  * @set:        The flag indicating whether to enable or disable.
3522  *
3523  * This routine is used to enable or disable Wake-on-LAN.
3524  */
3525 static void hw_cfg_wol_pme(struct ksz_hw *hw, int set)
3526 {
3527         struct dev_info *hw_priv = container_of(hw, struct dev_info, hw);
3528         struct pci_dev *pdev = hw_priv->pdev;
3529         u16 data;
3530
3531         if (!pdev->pm_cap)
3532                 return;
3533         pci_read_config_word(pdev, pdev->pm_cap + PCI_PM_CTRL, &data);
3534         data &= ~PCI_PM_CTRL_STATE_MASK;
3535         if (set)
3536                 data |= PCI_PM_CTRL_PME_ENABLE | PCI_D3hot;
3537         else
3538                 data &= ~PCI_PM_CTRL_PME_ENABLE;
3539         pci_write_config_word(pdev, pdev->pm_cap + PCI_PM_CTRL, data);
3540 }
3541
3542 /**
3543  * hw_cfg_wol - configure Wake-on-LAN features
3544  * @hw:         The hardware instance.
3545  * @frame:      The pattern frame bit.
3546  * @set:        The flag indicating whether to enable or disable.
3547  *
3548  * This routine is used to enable or disable certain Wake-on-LAN features.
3549  */
3550 static void hw_cfg_wol(struct ksz_hw *hw, u16 frame, int set)
3551 {
3552         u16 data;
3553
3554         data = readw(hw->io + KS8841_WOL_CTRL_OFFSET);
3555         if (set)
3556                 data |= frame;
3557         else
3558                 data &= ~frame;
3559         writew(data, hw->io + KS8841_WOL_CTRL_OFFSET);
3560 }
3561
3562 /**
3563  * hw_set_wol_frame - program Wake-on-LAN pattern
3564  * @hw:         The hardware instance.
3565  * @i:          The frame index.
3566  * @mask_size:  The size of the mask.
3567  * @mask:       Mask to ignore certain bytes in the pattern.
3568  * @frame_size: The size of the frame.
3569  * @pattern:    The frame data.
3570  *
3571  * This routine is used to program Wake-on-LAN pattern.
3572  */
3573 static void hw_set_wol_frame(struct ksz_hw *hw, int i, uint mask_size,
3574         u8 *mask, uint frame_size, u8 *pattern)
3575 {
3576         int bits;
3577         int from;
3578         int len;
3579         int to;
3580         u32 crc;
3581         u8 data[64];
3582         u8 val = 0;
3583
3584         if (frame_size > mask_size * 8)
3585                 frame_size = mask_size * 8;
3586         if (frame_size > 64)
3587                 frame_size = 64;
3588
3589         i *= 0x10;
3590         writel(0, hw->io + KS8841_WOL_FRAME_BYTE0_OFFSET + i);
3591         writel(0, hw->io + KS8841_WOL_FRAME_BYTE2_OFFSET + i);
3592
3593         bits = len = from = to = 0;
3594         do {
3595                 if (bits) {
3596                         if ((val & 1))
3597                                 data[to++] = pattern[from];
3598                         val >>= 1;
3599                         ++from;
3600                         --bits;
3601                 } else {
3602                         val = mask[len];
3603                         writeb(val, hw->io + KS8841_WOL_FRAME_BYTE0_OFFSET + i
3604                                 + len);
3605                         ++len;
3606                         if (val)
3607                                 bits = 8;
3608                         else
3609                                 from += 8;
3610                 }
3611         } while (from < (int) frame_size);
3612         if (val) {
3613                 bits = mask[len - 1];
3614                 val <<= (from % 8);
3615                 bits &= ~val;
3616                 writeb(bits, hw->io + KS8841_WOL_FRAME_BYTE0_OFFSET + i + len -
3617                         1);
3618         }
3619         crc = ether_crc(to, data);
3620         writel(crc, hw->io + KS8841_WOL_FRAME_CRC_OFFSET + i);
3621 }
3622
3623 /**
3624  * hw_add_wol_arp - add ARP pattern
3625  * @hw:         The hardware instance.
3626  * @ip_addr:    The IPv4 address assigned to the device.
3627  *
3628  * This routine is used to add ARP pattern for waking up the host.
3629  */
3630 static void hw_add_wol_arp(struct ksz_hw *hw, u8 *ip_addr)
3631 {
3632         u8 mask[6] = { 0x3F, 0xF0, 0x3F, 0x00, 0xC0, 0x03 };
3633         u8 pattern[42] = {
3634                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
3635                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3636                 0x08, 0x06,
3637                 0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01,
3638                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3639                 0x00, 0x00, 0x00, 0x00,
3640                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3641                 0x00, 0x00, 0x00, 0x00 };
3642
3643         memcpy(&pattern[38], ip_addr, 4);
3644         hw_set_wol_frame(hw, 3, 6, mask, 42, pattern);
3645 }
3646
3647 /**
3648  * hw_add_wol_bcast - add broadcast pattern
3649  * @hw:         The hardware instance.
3650  *
3651  * This routine is used to add broadcast pattern for waking up the host.
3652  */
3653 static void hw_add_wol_bcast(struct ksz_hw *hw)
3654 {
3655         u8 mask[] = { 0x3F };
3656         u8 pattern[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
3657
3658         hw_set_wol_frame(hw, 2, 1, mask, MAC_ADDR_LEN, pattern);
3659 }
3660
3661 /**
3662  * hw_add_wol_mcast - add multicast pattern
3663  * @hw:         The hardware instance.
3664  *
3665  * This routine is used to add multicast pattern for waking up the host.
3666  *
3667  * It is assumed the multicast packet is the ICMPv6 neighbor solicitation used
3668  * by IPv6 ping command.  Note that multicast packets are filtred through the
3669  * multicast hash table, so not all multicast packets can wake up the host.
3670  */
3671 static void hw_add_wol_mcast(struct ksz_hw *hw)
3672 {
3673         u8 mask[] = { 0x3F };
3674         u8 pattern[] = { 0x33, 0x33, 0xFF, 0x00, 0x00, 0x00 };
3675
3676         memcpy(&pattern[3], &hw->override_addr[3], 3);
3677         hw_set_wol_frame(hw, 1, 1, mask, 6, pattern);
3678 }
3679
3680 /**
3681  * hw_add_wol_ucast - add unicast pattern
3682  * @hw:         The hardware instance.
3683  *
3684  * This routine is used to add unicast pattern to wakeup the host.
3685  *
3686  * It is assumed the unicast packet is directed to the device, as the hardware
3687  * can only receive them in normal case.
3688  */
3689 static void hw_add_wol_ucast(struct ksz_hw *hw)
3690 {
3691         u8 mask[] = { 0x3F };
3692
3693         hw_set_wol_frame(hw, 0, 1, mask, MAC_ADDR_LEN, hw->override_addr);
3694 }
3695
3696 /**
3697  * hw_enable_wol - enable Wake-on-LAN
3698  * @hw:         The hardware instance.
3699  * @wol_enable: The Wake-on-LAN settings.
3700  * @net_addr:   The IPv4 address assigned to the device.
3701  *
3702  * This routine is used to enable Wake-on-LAN depending on driver settings.
3703  */
3704 static void hw_enable_wol(struct ksz_hw *hw, u32 wol_enable, u8 *net_addr)
3705 {
3706         hw_cfg_wol(hw, KS8841_WOL_MAGIC_ENABLE, (wol_enable & WAKE_MAGIC));
3707         hw_cfg_wol(hw, KS8841_WOL_FRAME0_ENABLE, (wol_enable & WAKE_UCAST));
3708         hw_add_wol_ucast(hw);
3709         hw_cfg_wol(hw, KS8841_WOL_FRAME1_ENABLE, (wol_enable & WAKE_MCAST));
3710         hw_add_wol_mcast(hw);
3711         hw_cfg_wol(hw, KS8841_WOL_FRAME2_ENABLE, (wol_enable & WAKE_BCAST));
3712         hw_cfg_wol(hw, KS8841_WOL_FRAME3_ENABLE, (wol_enable & WAKE_ARP));
3713         hw_add_wol_arp(hw, net_addr);
3714 }
3715
3716 /**
3717  * hw_init - check driver is correct for the hardware
3718  * @hw:         The hardware instance.
3719  *
3720  * This function checks the hardware is correct for this driver and sets the
3721  * hardware up for proper initialization.
3722  *
3723  * Return number of ports or 0 if not right.
3724  */
3725 static int hw_init(struct ksz_hw *hw)
3726 {
3727         int rc = 0;
3728         u16 data;
3729         u16 revision;
3730
3731         /* Set bus speed to 125MHz. */
3732         writew(BUS_SPEED_125_MHZ, hw->io + KS884X_BUS_CTRL_OFFSET);
3733
3734         /* Check KSZ884x chip ID. */
3735         data = readw(hw->io + KS884X_CHIP_ID_OFFSET);
3736
3737         revision = (data & KS884X_REVISION_MASK) >> KS884X_REVISION_SHIFT;
3738         data &= KS884X_CHIP_ID_MASK_41;
3739         if (REG_CHIP_ID_41 == data)
3740                 rc = 1;
3741         else if (REG_CHIP_ID_42 == data)
3742                 rc = 2;
3743         else
3744                 return 0;
3745
3746         /* Setup hardware features or bug workarounds. */
3747         if (revision <= 1) {
3748                 hw->features |= SMALL_PACKET_TX_BUG;
3749                 if (1 == rc)
3750                         hw->features |= HALF_DUPLEX_SIGNAL_BUG;
3751         }
3752         hw->features |= IPV6_CSUM_GEN_HACK;
3753         return rc;
3754 }
3755
3756 /**
3757  * hw_reset - reset the hardware
3758  * @hw:         The hardware instance.
3759  *
3760  * This routine resets the hardware.
3761  */
3762 static void hw_reset(struct ksz_hw *hw)
3763 {
3764         writew(GLOBAL_SOFTWARE_RESET, hw->io + KS884X_GLOBAL_CTRL_OFFSET);
3765
3766         /* Wait for device to reset. */
3767         mdelay(10);
3768
3769         /* Write 0 to clear device reset. */
3770         writew(0, hw->io + KS884X_GLOBAL_CTRL_OFFSET);
3771 }
3772
3773 /**
3774  * hw_setup - setup the hardware
3775  * @hw:         The hardware instance.
3776  *
3777  * This routine setup the hardware for proper operation.
3778  */
3779 static void hw_setup(struct ksz_hw *hw)
3780 {
3781 #if SET_DEFAULT_LED
3782         u16 data;
3783
3784         /* Change default LED mode. */
3785         data = readw(hw->io + KS8842_SWITCH_CTRL_5_OFFSET);
3786         data &= ~LED_MODE;
3787         data |= SET_DEFAULT_LED;
3788         writew(data, hw->io + KS8842_SWITCH_CTRL_5_OFFSET);
3789 #endif
3790
3791         /* Setup transmit control. */
3792         hw->tx_cfg = (DMA_TX_PAD_ENABLE | DMA_TX_CRC_ENABLE |
3793                 (DMA_BURST_DEFAULT << DMA_BURST_SHIFT) | DMA_TX_ENABLE);
3794
3795         /* Setup receive control. */
3796         hw->rx_cfg = (DMA_RX_BROADCAST | DMA_RX_UNICAST |
3797                 (DMA_BURST_DEFAULT << DMA_BURST_SHIFT) | DMA_RX_ENABLE);
3798         hw->rx_cfg |= KS884X_DMA_RX_MULTICAST;
3799
3800         /* Hardware cannot handle UDP packet in IP fragments. */
3801         hw->rx_cfg |= (DMA_RX_CSUM_TCP | DMA_RX_CSUM_IP);
3802
3803         if (hw->all_multi)
3804                 hw->rx_cfg |= DMA_RX_ALL_MULTICAST;
3805         if (hw->promiscuous)
3806                 hw->rx_cfg |= DMA_RX_PROMISCUOUS;
3807 }
3808
3809 /**
3810  * hw_setup_intr - setup interrupt mask
3811  * @hw:         The hardware instance.
3812  *
3813  * This routine setup the interrupt mask for proper operation.
3814  */
3815 static void hw_setup_intr(struct ksz_hw *hw)
3816 {
3817         hw->intr_mask = KS884X_INT_MASK | KS884X_INT_RX_OVERRUN;
3818 }
3819
3820 static void ksz_check_desc_num(struct ksz_desc_info *info)
3821 {
3822 #define MIN_DESC_SHIFT  2
3823
3824         int alloc = info->alloc;
3825         int shift;
3826
3827         shift = 0;
3828         while (!(alloc & 1)) {
3829                 shift++;
3830                 alloc >>= 1;
3831         }
3832         if (alloc != 1 || shift < MIN_DESC_SHIFT) {
3833                 pr_alert("Hardware descriptor numbers not right!\n");
3834                 while (alloc) {
3835                         shift++;
3836                         alloc >>= 1;
3837                 }
3838                 if (shift < MIN_DESC_SHIFT)
3839                         shift = MIN_DESC_SHIFT;
3840                 alloc = 1 << shift;
3841                 info->alloc = alloc;
3842         }
3843         info->mask = info->alloc - 1;
3844 }
3845
3846 static void hw_init_desc(struct ksz_desc_info *desc_info, int transmit)
3847 {
3848         int i;
3849         u32 phys = desc_info->ring_phys;
3850         struct ksz_hw_desc *desc = desc_info->ring_virt;
3851         struct ksz_desc *cur = desc_info->ring;
3852         struct ksz_desc *previous = NULL;
3853
3854         for (i = 0; i < desc_info->alloc; i++) {
3855                 cur->phw = desc++;
3856                 phys += desc_info->size;
3857                 previous = cur++;
3858                 previous->phw->next = cpu_to_le32(phys);
3859         }
3860         previous->phw->next = cpu_to_le32(desc_info->ring_phys);
3861         previous->sw.buf.rx.end_of_ring = 1;
3862         previous->phw->buf.data = cpu_to_le32(previous->sw.buf.data);
3863
3864         desc_info->avail = desc_info->alloc;
3865         desc_info->last = desc_info->next = 0;
3866
3867         desc_info->cur = desc_info->ring;
3868 }
3869
3870 /**
3871  * hw_set_desc_base - set descriptor base addresses
3872  * @hw:         The hardware instance.
3873  * @tx_addr:    The transmit descriptor base.
3874  * @rx_addr:    The receive descriptor base.
3875  *
3876  * This routine programs the descriptor base addresses after reset.
3877  */
3878 static void hw_set_desc_base(struct ksz_hw *hw, u32 tx_addr, u32 rx_addr)
3879 {
3880         /* Set base address of Tx/Rx descriptors. */
3881         writel(tx_addr, hw->io + KS_DMA_TX_ADDR);
3882         writel(rx_addr, hw->io + KS_DMA_RX_ADDR);
3883 }
3884
3885 static void hw_reset_pkts(struct ksz_desc_info *info)
3886 {
3887         info->cur = info->ring;
3888         info->avail = info->alloc;
3889         info->last = info->next = 0;
3890 }
3891
3892 static inline void hw_resume_rx(struct ksz_hw *hw)
3893 {
3894         writel(DMA_START, hw->io + KS_DMA_RX_START);
3895 }
3896
3897 /**
3898  * hw_start_rx - start receiving
3899  * @hw:         The hardware instance.
3900  *
3901  * This routine starts the receive function of the hardware.
3902  */
3903 static void hw_start_rx(struct ksz_hw *hw)
3904 {
3905         writel(hw->rx_cfg, hw->io + KS_DMA_RX_CTRL);
3906
3907         /* Notify when the receive stops. */
3908         hw->intr_mask |= KS884X_INT_RX_STOPPED;
3909
3910         writel(DMA_START, hw->io + KS_DMA_RX_START);
3911         hw_ack_intr(hw, KS884X_INT_RX_STOPPED);
3912         hw->rx_stop++;
3913
3914         /* Variable overflows. */
3915         if (0 == hw->rx_stop)
3916                 hw->rx_stop = 2;
3917 }
3918
3919 /*
3920  * hw_stop_rx - stop receiving
3921  * @hw:         The hardware instance.
3922  *
3923  * This routine stops the receive function of the hardware.
3924  */
3925 static void hw_stop_rx(struct ksz_hw *hw)
3926 {
3927         hw->rx_stop = 0;
3928         hw_turn_off_intr(hw, KS884X_INT_RX_STOPPED);
3929         writel((hw->rx_cfg & ~DMA_RX_ENABLE), hw->io + KS_DMA_RX_CTRL);
3930 }
3931
3932 /**
3933  * hw_start_tx - start transmitting
3934  * @hw:         The hardware instance.
3935  *
3936  * This routine starts the transmit function of the hardware.
3937  */
3938 static void hw_start_tx(struct ksz_hw *hw)
3939 {
3940         writel(hw->tx_cfg, hw->io + KS_DMA_TX_CTRL);
3941 }
3942
3943 /**
3944  * hw_stop_tx - stop transmitting
3945  * @hw:         The hardware instance.
3946  *
3947  * This routine stops the transmit function of the hardware.
3948  */
3949 static void hw_stop_tx(struct ksz_hw *hw)
3950 {
3951         writel((hw->tx_cfg & ~DMA_TX_ENABLE), hw->io + KS_DMA_TX_CTRL);
3952 }
3953
3954 /**
3955  * hw_disable - disable hardware
3956  * @hw:         The hardware instance.
3957  *
3958  * This routine disables the hardware.
3959  */
3960 static void hw_disable(struct ksz_hw *hw)
3961 {
3962         hw_stop_rx(hw);
3963         hw_stop_tx(hw);
3964         hw->enabled = 0;
3965 }
3966
3967 /**
3968  * hw_enable - enable hardware
3969  * @hw:         The hardware instance.
3970  *
3971  * This routine enables the hardware.
3972  */
3973 static void hw_enable(struct ksz_hw *hw)
3974 {
3975         hw_start_tx(hw);
3976         hw_start_rx(hw);
3977         hw->enabled = 1;
3978 }
3979
3980 /**
3981  * hw_alloc_pkt - allocate enough descriptors for transmission
3982  * @hw:         The hardware instance.
3983  * @length:     The length of the packet.
3984  * @physical:   Number of descriptors required.
3985  *
3986  * This function allocates descriptors for transmission.
3987  *
3988  * Return 0 if not successful; 1 for buffer copy; or number of descriptors.
3989  */
3990 static int hw_alloc_pkt(struct ksz_hw *hw, int length, int physical)
3991 {
3992         /* Always leave one descriptor free. */
3993         if (hw->tx_desc_info.avail <= 1)
3994                 return 0;
3995
3996         /* Allocate a descriptor for transmission and mark it current. */
3997         get_tx_pkt(&hw->tx_desc_info, &hw->tx_desc_info.cur);
3998         hw->tx_desc_info.cur->sw.buf.tx.first_seg = 1;
3999
4000         /* Keep track of number of transmit descriptors used so far. */
4001         ++hw->tx_int_cnt;
4002         hw->tx_size += length;
4003
4004         /* Cannot hold on too much data. */
4005         if (hw->tx_size >= MAX_TX_HELD_SIZE)
4006                 hw->tx_int_cnt = hw->tx_int_mask + 1;
4007
4008         if (physical > hw->tx_desc_info.avail)
4009                 return 1;
4010
4011         return hw->tx_desc_info.avail;
4012 }
4013
4014 /**
4015  * hw_send_pkt - mark packet for transmission
4016  * @hw:         The hardware instance.
4017  *
4018  * This routine marks the packet for transmission in PCI version.
4019  */
4020 static void hw_send_pkt(struct ksz_hw *hw)
4021 {
4022         struct ksz_desc *cur = hw->tx_desc_info.cur;
4023
4024         cur->sw.buf.tx.last_seg = 1;
4025
4026         /* Interrupt only after specified number of descriptors used. */
4027         if (hw->tx_int_cnt > hw->tx_int_mask) {
4028                 cur->sw.buf.tx.intr = 1;
4029                 hw->tx_int_cnt = 0;
4030                 hw->tx_size = 0;
4031         }
4032
4033         /* KSZ8842 supports port directed transmission. */
4034         cur->sw.buf.tx.dest_port = hw->dst_ports;
4035
4036         release_desc(cur);
4037
4038         writel(0, hw->io + KS_DMA_TX_START);
4039 }
4040
4041 static int empty_addr(u8 *addr)
4042 {
4043         u32 *addr1 = (u32 *) addr;
4044         u16 *addr2 = (u16 *) &addr[4];
4045
4046         return 0 == *addr1 && 0 == *addr2;
4047 }
4048
4049 /**
4050  * hw_set_addr - set MAC address
4051  * @hw:         The hardware instance.
4052  *
4053  * This routine programs the MAC address of the hardware when the address is
4054  * overrided.
4055  */
4056 static void hw_set_addr(struct ksz_hw *hw)
4057 {
4058         int i;
4059
4060         for (i = 0; i < MAC_ADDR_LEN; i++)
4061                 writeb(hw->override_addr[MAC_ADDR_ORDER(i)],
4062                         hw->io + KS884X_ADDR_0_OFFSET + i);
4063
4064         sw_set_addr(hw, hw->override_addr);
4065 }
4066
4067 /**
4068  * hw_read_addr - read MAC address
4069  * @hw:         The hardware instance.
4070  *
4071  * This routine retrieves the MAC address of the hardware.
4072  */
4073 static void hw_read_addr(struct ksz_hw *hw)
4074 {
4075         int i;
4076
4077         for (i = 0; i < MAC_ADDR_LEN; i++)
4078                 hw->perm_addr[MAC_ADDR_ORDER(i)] = readb(hw->io +
4079                         KS884X_ADDR_0_OFFSET + i);
4080
4081         if (!hw->mac_override) {
4082                 memcpy(hw->override_addr, hw->perm_addr, MAC_ADDR_LEN);
4083                 if (empty_addr(hw->override_addr)) {
4084                         memcpy(hw->perm_addr, DEFAULT_MAC_ADDRESS,
4085                                 MAC_ADDR_LEN);
4086                         memcpy(hw->override_addr, DEFAULT_MAC_ADDRESS,
4087                                 MAC_ADDR_LEN);
4088                         hw->override_addr[5] += hw->id;
4089                         hw_set_addr(hw);
4090                 }
4091         }
4092 }
4093
4094 static void hw_ena_add_addr(struct ksz_hw *hw, int index, u8 *mac_addr)
4095 {
4096         int i;
4097         u32 mac_addr_lo;
4098         u32 mac_addr_hi;
4099
4100         mac_addr_hi = 0;
4101         for (i = 0; i < 2; i++) {
4102                 mac_addr_hi <<= 8;
4103                 mac_addr_hi |= mac_addr[i];
4104         }
4105         mac_addr_hi |= ADD_ADDR_ENABLE;
4106         mac_addr_lo = 0;
4107         for (i = 2; i < 6; i++) {
4108                 mac_addr_lo <<= 8;
4109                 mac_addr_lo |= mac_addr[i];
4110         }
4111         index *= ADD_ADDR_INCR;
4112
4113         writel(mac_addr_lo, hw->io + index + KS_ADD_ADDR_0_LO);
4114         writel(mac_addr_hi, hw->io + index + KS_ADD_ADDR_0_HI);
4115 }
4116
4117 static void hw_set_add_addr(struct ksz_hw *hw)
4118 {
4119         int i;
4120
4121         for (i = 0; i < ADDITIONAL_ENTRIES; i++) {
4122                 if (empty_addr(hw->address[i]))
4123                         writel(0, hw->io + ADD_ADDR_INCR * i +
4124                                 KS_ADD_ADDR_0_HI);
4125                 else
4126                         hw_ena_add_addr(hw, i, hw->address[i]);
4127         }
4128 }
4129
4130 static int hw_add_addr(struct ksz_hw *hw, u8 *mac_addr)
4131 {
4132         int i;
4133         int j = ADDITIONAL_ENTRIES;
4134
4135         if (!memcmp(hw->override_addr, mac_addr, MAC_ADDR_LEN))
4136                 return 0;
4137         for (i = 0; i < hw->addr_list_size; i++) {
4138                 if (!memcmp(hw->address[i], mac_addr, MAC_ADDR_LEN))
4139                         return 0;
4140                 if (ADDITIONAL_ENTRIES == j && empty_addr(hw->address[i]))
4141                         j = i;
4142         }
4143         if (j < ADDITIONAL_ENTRIES) {
4144                 memcpy(hw->address[j], mac_addr, MAC_ADDR_LEN);
4145                 hw_ena_add_addr(hw, j, hw->address[j]);
4146                 return 0;
4147         }
4148         return -1;
4149 }
4150
4151 static int hw_del_addr(struct ksz_hw *hw, u8 *mac_addr)
4152 {
4153         int i;
4154
4155         for (i = 0; i < hw->addr_list_size; i++) {
4156                 if (!memcmp(hw->address[i], mac_addr, MAC_ADDR_LEN)) {
4157                         memset(hw->address[i], 0, MAC_ADDR_LEN);
4158                         writel(0, hw->io + ADD_ADDR_INCR * i +
4159                                 KS_ADD_ADDR_0_HI);
4160                         return 0;
4161                 }
4162         }
4163         return -1;
4164 }
4165
4166 /**
4167  * hw_clr_multicast - clear multicast addresses
4168  * @hw:         The hardware instance.
4169  *
4170  * This routine removes all multicast addresses set in the hardware.
4171  */
4172 static void hw_clr_multicast(struct ksz_hw *hw)
4173 {
4174         int i;
4175
4176         for (i = 0; i < HW_MULTICAST_SIZE; i++) {
4177                 hw->multi_bits[i] = 0;
4178
4179                 writeb(0, hw->io + KS884X_MULTICAST_0_OFFSET + i);
4180         }
4181 }
4182
4183 /**
4184  * hw_set_grp_addr - set multicast addresses
4185  * @hw:         The hardware instance.
4186  *
4187  * This routine programs multicast addresses for the hardware to accept those
4188  * addresses.
4189  */
4190 static void hw_set_grp_addr(struct ksz_hw *hw)
4191 {
4192         int i;
4193         int index;
4194         int position;
4195         int value;
4196
4197         memset(hw->multi_bits, 0, sizeof(u8) * HW_MULTICAST_SIZE);
4198
4199         for (i = 0; i < hw->multi_list_size; i++) {
4200                 position = (ether_crc(6, hw->multi_list[i]) >> 26) & 0x3f;
4201                 index = position >> 3;
4202                 value = 1 << (position & 7);
4203                 hw->multi_bits[index] |= (u8) value;
4204         }
4205
4206         for (i = 0; i < HW_MULTICAST_SIZE; i++)
4207                 writeb(hw->multi_bits[i], hw->io + KS884X_MULTICAST_0_OFFSET +
4208                         i);
4209 }
4210
4211 /**
4212  * hw_set_multicast - enable or disable all multicast receiving
4213  * @hw:         The hardware instance.
4214  * @multicast:  To turn on or off the all multicast feature.
4215  *
4216  * This routine enables/disables the hardware to accept all multicast packets.
4217  */
4218 static void hw_set_multicast(struct ksz_hw *hw, u8 multicast)
4219 {
4220         /* Stop receiving for reconfiguration. */
4221         hw_stop_rx(hw);
4222
4223         if (multicast)
4224                 hw->rx_cfg |= DMA_RX_ALL_MULTICAST;
4225         else
4226                 hw->rx_cfg &= ~DMA_RX_ALL_MULTICAST;
4227
4228         if (hw->enabled)
4229                 hw_start_rx(hw);
4230 }
4231
4232 /**
4233  * hw_set_promiscuous - enable or disable promiscuous receiving
4234  * @hw:         The hardware instance.
4235  * @prom:       To turn on or off the promiscuous feature.
4236  *
4237  * This routine enables/disables the hardware to accept all packets.
4238  */
4239 static void hw_set_promiscuous(struct ksz_hw *hw, u8 prom)
4240 {
4241         /* Stop receiving for reconfiguration. */
4242         hw_stop_rx(hw);
4243
4244         if (prom)
4245                 hw->rx_cfg |= DMA_RX_PROMISCUOUS;
4246         else
4247                 hw->rx_cfg &= ~DMA_RX_PROMISCUOUS;
4248
4249         if (hw->enabled)
4250                 hw_start_rx(hw);
4251 }
4252
4253 /**
4254  * sw_enable - enable the switch
4255  * @hw:         The hardware instance.
4256  * @enable:     The flag to enable or disable the switch
4257  *
4258  * This routine is used to enable/disable the switch in KSZ8842.
4259  */
4260 static void sw_enable(struct ksz_hw *hw, int enable)
4261 {
4262         int port;
4263
4264         for (port = 0; port < SWITCH_PORT_NUM; port++) {
4265                 if (hw->dev_count > 1) {
4266                         /* Set port-base vlan membership with host port. */
4267                         sw_cfg_port_base_vlan(hw, port,
4268                                 HOST_MASK | (1 << port));
4269                         port_set_stp_state(hw, port, STP_STATE_DISABLED);
4270                 } else {
4271                         sw_cfg_port_base_vlan(hw, port, PORT_MASK);
4272                         port_set_stp_state(hw, port, STP_STATE_FORWARDING);
4273                 }
4274         }
4275         if (hw->dev_count > 1)
4276                 port_set_stp_state(hw, SWITCH_PORT_NUM, STP_STATE_SIMPLE);
4277         else
4278                 port_set_stp_state(hw, SWITCH_PORT_NUM, STP_STATE_FORWARDING);
4279
4280         if (enable)
4281                 enable = KS8842_START;
4282         writew(enable, hw->io + KS884X_CHIP_ID_OFFSET);
4283 }
4284
4285 /**
4286  * sw_setup - setup the switch
4287  * @hw:         The hardware instance.
4288  *
4289  * This routine setup the hardware switch engine for default operation.
4290  */
4291 static void sw_setup(struct ksz_hw *hw)
4292 {
4293         int port;
4294
4295         sw_set_global_ctrl(hw);
4296
4297         /* Enable switch broadcast storm protection at 10% percent rate. */
4298         sw_init_broad_storm(hw);
4299         hw_cfg_broad_storm(hw, BROADCAST_STORM_PROTECTION_RATE);
4300         for (port = 0; port < SWITCH_PORT_NUM; port++)
4301                 sw_ena_broad_storm(hw, port);
4302
4303         sw_init_prio(hw);
4304
4305         sw_init_mirror(hw);
4306
4307         sw_init_prio_rate(hw);
4308
4309         sw_init_vlan(hw);
4310
4311         if (hw->features & STP_SUPPORT)
4312                 sw_init_stp(hw);
4313         if (!sw_chk(hw, KS8842_SWITCH_CTRL_1_OFFSET,
4314                         SWITCH_TX_FLOW_CTRL | SWITCH_RX_FLOW_CTRL))
4315                 hw->overrides |= PAUSE_FLOW_CTRL;
4316         sw_enable(hw, 1);
4317 }
4318
4319 /**
4320  * ksz_start_timer - start kernel timer
4321  * @info:       Kernel timer information.
4322  * @time:       The time tick.
4323  *
4324  * This routine starts the kernel timer after the specified time tick.
4325  */
4326 static void ksz_start_timer(struct ksz_timer_info *info, int time)
4327 {
4328         info->cnt = 0;
4329         info->timer.expires = jiffies + time;
4330         add_timer(&info->timer);
4331
4332         /* infinity */
4333         info->max = -1;
4334 }
4335
4336 /**
4337  * ksz_stop_timer - stop kernel timer
4338  * @info:       Kernel timer information.
4339  *
4340  * This routine stops the kernel timer.
4341  */
4342 static void ksz_stop_timer(struct ksz_timer_info *info)
4343 {
4344         if (info->max) {
4345                 info->max = 0;
4346                 del_timer_sync(&info->timer);
4347         }
4348 }
4349
4350 static void ksz_init_timer(struct ksz_timer_info *info, int period,
4351         void (*function)(unsigned long), void *data)
4352 {
4353         info->max = 0;
4354         info->period = period;
4355         init_timer(&info->timer);
4356         info->timer.function = function;
4357         info->timer.data = (unsigned long) data;
4358 }
4359
4360 static void ksz_update_timer(struct ksz_timer_info *info)
4361 {
4362         ++info->cnt;
4363         if (info->max > 0) {
4364                 if (info->cnt < info->max) {
4365                         info->timer.expires = jiffies + info->period;
4366                         add_timer(&info->timer);
4367                 } else
4368                         info->max = 0;
4369         } else if (info->max < 0) {
4370                 info->timer.expires = jiffies + info->period;
4371                 add_timer(&info->timer);
4372         }
4373 }
4374
4375 /**
4376  * ksz_alloc_soft_desc - allocate software descriptors
4377  * @desc_info:  Descriptor information structure.
4378  * @transmit:   Indication that descriptors are for transmit.
4379  *
4380  * This local function allocates software descriptors for manipulation in
4381  * memory.
4382  *
4383  * Return 0 if successful.
4384  */
4385 static int ksz_alloc_soft_desc(struct ksz_desc_info *desc_info, int transmit)
4386 {
4387         desc_info->ring = kmalloc(sizeof(struct ksz_desc) * desc_info->alloc,
4388                 GFP_KERNEL);
4389         if (!desc_info->ring)
4390                 return 1;
4391         memset((void *) desc_info->ring, 0,
4392                 sizeof(struct ksz_desc) * desc_info->alloc);
4393         hw_init_desc(desc_info, transmit);
4394         return 0;
4395 }
4396
4397 /**
4398  * ksz_alloc_desc - allocate hardware descriptors
4399  * @adapter:    Adapter information structure.
4400  *
4401  * This local function allocates hardware descriptors for receiving and
4402  * transmitting.
4403  *
4404  * Return 0 if successful.
4405  */
4406 static int ksz_alloc_desc(struct dev_info *adapter)
4407 {
4408         struct ksz_hw *hw = &adapter->hw;
4409         int offset;
4410
4411         /* Allocate memory for RX & TX descriptors. */
4412         adapter->desc_pool.alloc_size =
4413                 hw->rx_desc_info.size * hw->rx_desc_info.alloc +
4414                 hw->tx_desc_info.size * hw->tx_desc_info.alloc +
4415                 DESC_ALIGNMENT;
4416
4417         adapter->desc_pool.alloc_virt =
4418                 pci_alloc_consistent(
4419                         adapter->pdev, adapter->desc_pool.alloc_size,
4420                         &adapter->desc_pool.dma_addr);
4421         if (adapter->desc_pool.alloc_virt == NULL) {
4422                 adapter->desc_pool.alloc_size = 0;
4423                 return 1;
4424         }
4425         memset(adapter->desc_pool.alloc_virt, 0, adapter->desc_pool.alloc_size);
4426
4427         /* Align to the next cache line boundary. */
4428         offset = (((ulong) adapter->desc_pool.alloc_virt % DESC_ALIGNMENT) ?
4429                 (DESC_ALIGNMENT -
4430                 ((ulong) adapter->desc_pool.alloc_virt % DESC_ALIGNMENT)) : 0);
4431         adapter->desc_pool.virt = adapter->desc_pool.alloc_virt + offset;
4432         adapter->desc_pool.phys = adapter->desc_pool.dma_addr + offset;
4433
4434         /* Allocate receive/transmit descriptors. */
4435         hw->rx_desc_info.ring_virt = (struct ksz_hw_desc *)
4436                 adapter->desc_pool.virt;
4437         hw->rx_desc_info.ring_phys = adapter->desc_pool.phys;
4438         offset = hw->rx_desc_info.alloc * hw->rx_desc_info.size;
4439         hw->tx_desc_info.ring_virt = (struct ksz_hw_desc *)
4440                 (adapter->desc_pool.virt + offset);
4441         hw->tx_desc_info.ring_phys = adapter->desc_pool.phys + offset;
4442
4443         if (ksz_alloc_soft_desc(&hw->rx_desc_info, 0))
4444                 return 1;
4445         if (ksz_alloc_soft_desc(&hw->tx_desc_info, 1))
4446                 return 1;
4447
4448         return 0;
4449 }
4450
4451 /**
4452  * free_dma_buf - release DMA buffer resources
4453  * @adapter:    Adapter information structure.
4454  *
4455  * This routine is just a helper function to release the DMA buffer resources.
4456  */
4457 static void free_dma_buf(struct dev_info *adapter, struct ksz_dma_buf *dma_buf,
4458         int direction)
4459 {
4460         pci_unmap_single(adapter->pdev, dma_buf->dma, dma_buf->len, direction);
4461         dev_kfree_skb(dma_buf->skb);
4462         dma_buf->skb = NULL;
4463         dma_buf->dma = 0;
4464 }
4465
4466 /**
4467  * ksz_init_rx_buffers - initialize receive descriptors
4468  * @adapter:    Adapter information structure.
4469  *
4470  * This routine initializes DMA buffers for receiving.
4471  */
4472 static void ksz_init_rx_buffers(struct dev_info *adapter)
4473 {
4474         int i;
4475         struct ksz_desc *desc;
4476         struct ksz_dma_buf *dma_buf;
4477         struct ksz_hw *hw = &adapter->hw;
4478         struct ksz_desc_info *info = &hw->rx_desc_info;
4479
4480         for (i = 0; i < hw->rx_desc_info.alloc; i++) {
4481                 get_rx_pkt(info, &desc);
4482
4483                 dma_buf = DMA_BUFFER(desc);
4484                 if (dma_buf->skb && dma_buf->len != adapter->mtu)
4485                         free_dma_buf(adapter, dma_buf, PCI_DMA_FROMDEVICE);
4486                 dma_buf->len = adapter->mtu;
4487                 if (!dma_buf->skb)
4488                         dma_buf->skb = alloc_skb(dma_buf->len, GFP_ATOMIC);
4489                 if (dma_buf->skb && !dma_buf->dma) {
4490                         dma_buf->skb->dev = adapter->dev;
4491                         dma_buf->dma = pci_map_single(
4492                                 adapter->pdev,
4493                                 skb_tail_pointer(dma_buf->skb),
4494                                 dma_buf->len,
4495                                 PCI_DMA_FROMDEVICE);
4496                 }
4497
4498                 /* Set descriptor. */
4499                 set_rx_buf(desc, dma_buf->dma);
4500                 set_rx_len(desc, dma_buf->len);
4501                 release_desc(desc);
4502         }
4503 }
4504
4505 /**
4506  * ksz_alloc_mem - allocate memory for hardware descriptors
4507  * @adapter:    Adapter information structure.
4508  *
4509  * This function allocates memory for use by hardware descriptors for receiving
4510  * and transmitting.
4511  *
4512  * Return 0 if successful.
4513  */
4514 static int ksz_alloc_mem(struct dev_info *adapter)
4515 {
4516         struct ksz_hw *hw = &adapter->hw;
4517
4518         /* Determine the number of receive and transmit descriptors. */
4519         hw->rx_desc_info.alloc = NUM_OF_RX_DESC;
4520         hw->tx_desc_info.alloc = NUM_OF_TX_DESC;
4521
4522         /* Determine how many descriptors to skip transmit interrupt. */
4523         hw->tx_int_cnt = 0;
4524         hw->tx_int_mask = NUM_OF_TX_DESC / 4;
4525         if (hw->tx_int_mask > 8)
4526                 hw->tx_int_mask = 8;
4527         while (hw->tx_int_mask) {
4528                 hw->tx_int_cnt++;
4529                 hw->tx_int_mask >>= 1;
4530         }
4531         if (hw->tx_int_cnt) {
4532                 hw->tx_int_mask = (1 << (hw->tx_int_cnt - 1)) - 1;
4533                 hw->tx_int_cnt = 0;
4534         }
4535
4536         /* Determine the descriptor size. */
4537         hw->rx_desc_info.size =
4538                 (((sizeof(struct ksz_hw_desc) + DESC_ALIGNMENT - 1) /
4539                 DESC_ALIGNMENT) * DESC_ALIGNMENT);
4540         hw->tx_desc_info.size =
4541                 (((sizeof(struct ksz_hw_desc) + DESC_ALIGNMENT - 1) /
4542                 DESC_ALIGNMENT) * DESC_ALIGNMENT);
4543         if (hw->rx_desc_info.size != sizeof(struct ksz_hw_desc))
4544                 pr_alert("Hardware descriptor size not right!\n");
4545         ksz_check_desc_num(&hw->rx_desc_info);
4546         ksz_check_desc_num(&hw->tx_desc_info);
4547
4548         /* Allocate descriptors. */
4549         if (ksz_alloc_desc(adapter))
4550                 return 1;
4551
4552         return 0;
4553 }
4554
4555 /**
4556  * ksz_free_desc - free software and hardware descriptors
4557  * @adapter:    Adapter information structure.
4558  *
4559  * This local routine frees the software and hardware descriptors allocated by
4560  * ksz_alloc_desc().
4561  */
4562 static void ksz_free_desc(struct dev_info *adapter)
4563 {
4564         struct ksz_hw *hw = &adapter->hw;
4565
4566         /* Reset descriptor. */
4567         hw->rx_desc_info.ring_virt = NULL;
4568         hw->tx_desc_info.ring_virt = NULL;
4569         hw->rx_desc_info.ring_phys = 0;
4570         hw->tx_desc_info.ring_phys = 0;
4571
4572         /* Free memory. */
4573         if (adapter->desc_pool.alloc_virt)
4574                 pci_free_consistent(
4575                         adapter->pdev,
4576                         adapter->desc_pool.alloc_size,
4577                         adapter->desc_pool.alloc_virt,
4578                         adapter->desc_pool.dma_addr);
4579
4580         /* Reset resource pool. */
4581         adapter->desc_pool.alloc_size = 0;
4582         adapter->desc_pool.alloc_virt = NULL;
4583
4584         kfree(hw->rx_desc_info.ring);
4585         hw->rx_desc_info.ring = NULL;
4586         kfree(hw->tx_desc_info.ring);
4587         hw->tx_desc_info.ring = NULL;
4588 }
4589
4590 /**
4591  * ksz_free_buffers - free buffers used in the descriptors
4592  * @adapter:    Adapter information structure.
4593  * @desc_info:  Descriptor information structure.
4594  *
4595  * This local routine frees buffers used in the DMA buffers.
4596  */
4597 static void ksz_free_buffers(struct dev_info *adapter,
4598         struct ksz_desc_info *desc_info, int direction)
4599 {
4600         int i;
4601         struct ksz_dma_buf *dma_buf;
4602         struct ksz_desc *desc = desc_info->ring;
4603
4604         for (i = 0; i < desc_info->alloc; i++) {
4605                 dma_buf = DMA_BUFFER(desc);
4606                 if (dma_buf->skb)
4607                         free_dma_buf(adapter, dma_buf, direction);
4608                 desc++;
4609         }
4610 }
4611
4612 /**
4613  * ksz_free_mem - free all resources used by descriptors
4614  * @adapter:    Adapter information structure.
4615  *
4616  * This local routine frees all the resources allocated by ksz_alloc_mem().
4617  */
4618 static void ksz_free_mem(struct dev_info *adapter)
4619 {
4620         /* Free transmit buffers. */
4621         ksz_free_buffers(adapter, &adapter->hw.tx_desc_info,
4622                 PCI_DMA_TODEVICE);
4623
4624         /* Free receive buffers. */
4625         ksz_free_buffers(adapter, &adapter->hw.rx_desc_info,
4626                 PCI_DMA_FROMDEVICE);
4627
4628         /* Free descriptors. */
4629         ksz_free_desc(adapter);
4630 }
4631
4632 static void get_mib_counters(struct ksz_hw *hw, int first, int cnt,
4633         u64 *counter)
4634 {
4635         int i;
4636         int mib;
4637         int port;
4638         struct ksz_port_mib *port_mib;
4639
4640         memset(counter, 0, sizeof(u64) * TOTAL_PORT_COUNTER_NUM);
4641         for (i = 0, port = first; i < cnt; i++, port++) {
4642                 port_mib = &hw->port_mib[port];
4643                 for (mib = port_mib->mib_start; mib < hw->mib_cnt; mib++)
4644                         counter[mib] += port_mib->counter[mib];
4645         }
4646 }
4647
4648 /**
4649  * send_packet - send packet
4650  * @skb:        Socket buffer.
4651  * @dev:        Network device.
4652  *
4653  * This routine is used to send a packet out to the network.
4654  */
4655 static void send_packet(struct sk_buff *skb, struct net_device *dev)
4656 {
4657         struct ksz_desc *desc;
4658         struct ksz_desc *first;
4659         struct dev_priv *priv = netdev_priv(dev);
4660         struct dev_info *hw_priv = priv->adapter;
4661         struct ksz_hw *hw = &hw_priv->hw;
4662         struct ksz_desc_info *info = &hw->tx_desc_info;
4663         struct ksz_dma_buf *dma_buf;
4664         int len;
4665         int last_frag = skb_shinfo(skb)->nr_frags;
4666
4667         /*
4668          * KSZ8842 with multiple device interfaces needs to be told which port
4669          * to send.
4670          */
4671         if (hw->dev_count > 1)
4672                 hw->dst_ports = 1 << priv->port.first_port;
4673
4674         /* Hardware will pad the length to 60. */
4675         len = skb->len;
4676
4677         /* Remember the very first descriptor. */
4678         first = info->cur;
4679         desc = first;
4680
4681         dma_buf = DMA_BUFFER(desc);
4682         if (last_frag) {
4683                 int frag;
4684                 skb_frag_t *this_frag;
4685
4686                 dma_buf->len = skb->len - skb->data_len;
4687
4688                 dma_buf->dma = pci_map_single(
4689                         hw_priv->pdev, skb->data, dma_buf->len,
4690                         PCI_DMA_TODEVICE);
4691                 set_tx_buf(desc, dma_buf->dma);
4692                 set_tx_len(desc, dma_buf->len);
4693
4694                 frag = 0;
4695                 do {
4696                         this_frag = &skb_shinfo(skb)->frags[frag];
4697
4698                         /* Get a new descriptor. */
4699                         get_tx_pkt(info, &desc);
4700
4701                         /* Keep track of descriptors used so far. */
4702                         ++hw->tx_int_cnt;
4703
4704                         dma_buf = DMA_BUFFER(desc);
4705                         dma_buf->len = this_frag->size;
4706
4707                         dma_buf->dma = pci_map_single(
4708                                 hw_priv->pdev,
4709                                 page_address(this_frag->page) +
4710                                 this_frag->page_offset,
4711                                 dma_buf->len,
4712                                 PCI_DMA_TODEVICE);
4713                         set_tx_buf(desc, dma_buf->dma);
4714                         set_tx_len(desc, dma_buf->len);
4715
4716                         frag++;
4717                         if (frag == last_frag)
4718                                 break;
4719
4720                         /* Do not release the last descriptor here. */
4721                         release_desc(desc);
4722                 } while (1);
4723
4724                 /* current points to the last descriptor. */
4725                 info->cur = desc;
4726
4727                 /* Release the first descriptor. */
4728                 release_desc(first);
4729         } else {
4730                 dma_buf->len = len;
4731
4732                 dma_buf->dma = pci_map_single(
4733                         hw_priv->pdev, skb->data, dma_buf->len,
4734                         PCI_DMA_TODEVICE);
4735                 set_tx_buf(desc, dma_buf->dma);
4736                 set_tx_len(desc, dma_buf->len);
4737         }
4738
4739         if (skb->ip_summed == CHECKSUM_PARTIAL) {
4740                 (desc)->sw.buf.tx.csum_gen_tcp = 1;
4741                 (desc)->sw.buf.tx.csum_gen_udp = 1;
4742         }
4743
4744         /*
4745          * The last descriptor holds the packet so that it can be returned to
4746          * network subsystem after all descriptors are transmitted.
4747          */
4748         dma_buf->skb = skb;
4749
4750         hw_send_pkt(hw);
4751
4752         /* Update transmit statistics. */
4753         priv->stats.tx_packets++;
4754         priv->stats.tx_bytes += len;
4755 }
4756
4757 /**
4758  * transmit_cleanup - clean up transmit descriptors
4759  * @dev:        Network device.
4760  *
4761  * This routine is called to clean up the transmitted buffers.
4762  */
4763 static void transmit_cleanup(struct dev_info *hw_priv, int normal)
4764 {
4765         int last;
4766         union desc_stat status;
4767         struct ksz_hw *hw = &hw_priv->hw;
4768         struct ksz_desc_info *info = &hw->tx_desc_info;
4769         struct ksz_desc *desc;
4770         struct ksz_dma_buf *dma_buf;
4771         struct net_device *dev = NULL;
4772
4773         spin_lock(&hw_priv->hwlock);
4774         last = info->last;
4775
4776         while (info->avail < info->alloc) {
4777                 /* Get next descriptor which is not hardware owned. */
4778                 desc = &info->ring[last];
4779                 status.data = le32_to_cpu(desc->phw->ctrl.data);
4780                 if (status.tx.hw_owned) {
4781                         if (normal)
4782                                 break;
4783                         else
4784                                 reset_desc(desc, status);
4785                 }
4786
4787                 dma_buf = DMA_BUFFER(desc);
4788                 pci_unmap_single(
4789                         hw_priv->pdev, dma_buf->dma, dma_buf->len,
4790                         PCI_DMA_TODEVICE);
4791
4792                 /* This descriptor contains the last buffer in the packet. */
4793                 if (dma_buf->skb) {
4794                         dev = dma_buf->skb->dev;
4795
4796                         /* Release the packet back to network subsystem. */
4797                         dev_kfree_skb_irq(dma_buf->skb);
4798                         dma_buf->skb = NULL;
4799                 }
4800
4801                 /* Free the transmitted descriptor. */
4802                 last++;
4803                 last &= info->mask;
4804                 info->avail++;
4805         }
4806         info->last = last;
4807         spin_unlock(&hw_priv->hwlock);
4808
4809         /* Notify the network subsystem that the packet has been sent. */
4810         if (dev)
4811                 dev->trans_start = jiffies;
4812 }
4813
4814 /**
4815  * transmit_done - transmit done processing
4816  * @dev:        Network device.
4817  *
4818  * This routine is called when the transmit interrupt is triggered, indicating
4819  * either a packet is sent successfully or there are transmit errors.
4820  */
4821 static void tx_done(struct dev_info *hw_priv)
4822 {
4823         struct ksz_hw *hw = &hw_priv->hw;
4824         int port;
4825
4826         transmit_cleanup(hw_priv, 1);
4827
4828         for (port = 0; port < hw->dev_count; port++) {
4829                 struct net_device *dev = hw->port_info[port].pdev;
4830
4831                 if (netif_running(dev) && netif_queue_stopped(dev))
4832                         netif_wake_queue(dev);
4833         }
4834 }
4835
4836 static inline void copy_old_skb(struct sk_buff *old, struct sk_buff *skb)
4837 {
4838         skb->dev = old->dev;
4839         skb->protocol = old->protocol;
4840         skb->ip_summed = old->ip_summed;
4841         skb->csum = old->csum;
4842         skb_set_network_header(skb, ETH_HLEN);
4843
4844         dev_kfree_skb(old);
4845 }
4846
4847 /**
4848  * netdev_tx - send out packet
4849  * @skb:        Socket buffer.
4850  * @dev:        Network device.
4851  *
4852  * This function is used by the upper network layer to send out a packet.
4853  *
4854  * Return 0 if successful; otherwise an error code indicating failure.
4855  */
4856 static int netdev_tx(struct sk_buff *skb, struct net_device *dev)
4857 {
4858         struct dev_priv *priv = netdev_priv(dev);
4859         struct dev_info *hw_priv = priv->adapter;
4860         struct ksz_hw *hw = &hw_priv->hw;
4861         int left;
4862         int num = 1;
4863         int rc = 0;
4864
4865         if (hw->features & SMALL_PACKET_TX_BUG) {
4866                 struct sk_buff *org_skb = skb;
4867
4868                 if (skb->len <= 48) {
4869                         if (skb_end_pointer(skb) - skb->data >= 50) {
4870                                 memset(&skb->data[skb->len], 0, 50 - skb->len);
4871                                 skb->len = 50;
4872                         } else {
4873                                 skb = dev_alloc_skb(50);
4874                                 if (!skb)
4875                                         return NETDEV_TX_BUSY;
4876                                 memcpy(skb->data, org_skb->data, org_skb->len);
4877                                 memset(&skb->data[org_skb->len], 0,
4878                                         50 - org_skb->len);
4879                                 skb->len = 50;
4880                                 copy_old_skb(org_skb, skb);
4881                         }
4882                 }
4883         }
4884
4885         spin_lock_irq(&hw_priv->hwlock);
4886
4887         num = skb_shinfo(skb)->nr_frags + 1;
4888         left = hw_alloc_pkt(hw, skb->len, num);
4889         if (left) {
4890                 if (left < num ||
4891                                 ((hw->features & IPV6_CSUM_GEN_HACK) &&
4892                                 (CHECKSUM_PARTIAL == skb->ip_summed) &&
4893                                 (ETH_P_IPV6 == htons(skb->protocol)))) {
4894                         struct sk_buff *org_skb = skb;
4895
4896                         skb = dev_alloc_skb(org_skb->len);
4897                         if (!skb) {
4898                                 rc = NETDEV_TX_BUSY;
4899                                 goto unlock;
4900                         }
4901                         skb_copy_and_csum_dev(org_skb, skb->data);
4902                         org_skb->ip_summed = 0;
4903                         skb->len = org_skb->len;
4904                         copy_old_skb(org_skb, skb);
4905                 }
4906                 send_packet(skb, dev);
4907                 if (left <= num)
4908                         netif_stop_queue(dev);
4909         } else {
4910                 /* Stop the transmit queue until packet is allocated. */
4911                 netif_stop_queue(dev);
4912                 rc = NETDEV_TX_BUSY;
4913         }
4914 unlock:
4915         spin_unlock_irq(&hw_priv->hwlock);
4916
4917         return rc;
4918 }
4919
4920 /**
4921  * netdev_tx_timeout - transmit timeout processing
4922  * @dev:        Network device.
4923  *
4924  * This routine is called when the transmit timer expires.  That indicates the
4925  * hardware is not running correctly because transmit interrupts are not
4926  * triggered to free up resources so that the transmit routine can continue
4927  * sending out packets.  The hardware is reset to correct the problem.
4928  */
4929 static void netdev_tx_timeout(struct net_device *dev)
4930 {
4931         static unsigned long last_reset;
4932
4933         struct dev_priv *priv = netdev_priv(dev);
4934         struct dev_info *hw_priv = priv->adapter;
4935         struct ksz_hw *hw = &hw_priv->hw;
4936         int port;
4937
4938         if (hw->dev_count > 1) {
4939                 /*
4940                  * Only reset the hardware if time between calls is long
4941                  * enough.
4942                  */
4943                 if (jiffies - last_reset <= dev->watchdog_timeo)
4944                         hw_priv = NULL;
4945         }
4946
4947         last_reset = jiffies;
4948         if (hw_priv) {
4949                 hw_dis_intr(hw);
4950                 hw_disable(hw);
4951
4952                 transmit_cleanup(hw_priv, 0);
4953                 hw_reset_pkts(&hw->rx_desc_info);
4954                 hw_reset_pkts(&hw->tx_desc_info);
4955                 ksz_init_rx_buffers(hw_priv);
4956
4957                 hw_reset(hw);
4958
4959                 hw_set_desc_base(hw,
4960                         hw->tx_desc_info.ring_phys,
4961                         hw->rx_desc_info.ring_phys);
4962                 hw_set_addr(hw);
4963                 if (hw->all_multi)
4964                         hw_set_multicast(hw, hw->all_multi);
4965                 else if (hw->multi_list_size)
4966                         hw_set_grp_addr(hw);
4967
4968                 if (hw->dev_count > 1) {
4969                         hw_set_add_addr(hw);
4970                         for (port = 0; port < SWITCH_PORT_NUM; port++) {
4971                                 struct net_device *port_dev;
4972
4973                                 port_set_stp_state(hw, port,
4974                                         STP_STATE_DISABLED);
4975
4976                                 port_dev = hw->port_info[port].pdev;
4977                                 if (netif_running(port_dev))
4978                                         port_set_stp_state(hw, port,
4979                                                 STP_STATE_SIMPLE);
4980                         }
4981                 }
4982
4983                 hw_enable(hw);
4984                 hw_ena_intr(hw);
4985         }
4986
4987         dev->trans_start = jiffies;
4988         netif_wake_queue(dev);
4989 }
4990
4991 static inline void csum_verified(struct sk_buff *skb)
4992 {
4993         unsigned short protocol;
4994         struct iphdr *iph;
4995
4996         protocol = skb->protocol;
4997         skb_reset_network_header(skb);
4998         iph = (struct iphdr *) skb_network_header(skb);
4999         if (protocol == htons(ETH_P_8021Q)) {
5000                 protocol = iph->tot_len;
5001                 skb_set_network_header(skb, VLAN_HLEN);
5002                 iph = (struct iphdr *) skb_network_header(skb);
5003         }
5004         if (protocol == htons(ETH_P_IP)) {
5005                 if (iph->protocol == IPPROTO_TCP)
5006                         skb->ip_summed = CHECKSUM_UNNECESSARY;
5007         }
5008 }
5009
5010 static inline int rx_proc(struct net_device *dev, struct ksz_hw* hw,
5011         struct ksz_desc *desc, union desc_stat status)
5012 {
5013         int packet_len;
5014         struct dev_priv *priv = netdev_priv(dev);
5015         struct dev_info *hw_priv = priv->adapter;
5016         struct ksz_dma_buf *dma_buf;
5017         struct sk_buff *skb;
5018         int rx_status;
5019
5020         /* Received length includes 4-byte CRC. */
5021         packet_len = status.rx.frame_len - 4;
5022
5023         dma_buf = DMA_BUFFER(desc);
5024         pci_dma_sync_single_for_cpu(
5025                 hw_priv->pdev, dma_buf->dma, packet_len + 4,
5026                 PCI_DMA_FROMDEVICE);
5027
5028         do {
5029                 /* skb->data != skb->head */
5030                 skb = dev_alloc_skb(packet_len + 2);
5031                 if (!skb) {
5032                         priv->stats.rx_dropped++;
5033                         return -ENOMEM;
5034                 }
5035
5036                 /*
5037                  * Align socket buffer in 4-byte boundary for better
5038                  * performance.
5039                  */
5040                 skb_reserve(skb, 2);
5041
5042                 memcpy(skb_put(skb, packet_len),
5043                         dma_buf->skb->data, packet_len);
5044         } while (0);
5045
5046         skb->protocol = eth_type_trans(skb, dev);
5047
5048         if (hw->rx_cfg & (DMA_RX_CSUM_UDP | DMA_RX_CSUM_TCP))
5049                 csum_verified(skb);
5050
5051         /* Update receive statistics. */
5052         priv->stats.rx_packets++;
5053         priv->stats.rx_bytes += packet_len;
5054
5055         /* Notify upper layer for received packet. */
5056         dev->last_rx = jiffies;
5057
5058         rx_status = netif_rx(skb);
5059
5060         return 0;
5061 }
5062
5063 static int dev_rcv_packets(struct dev_info *hw_priv)
5064 {
5065         int next;
5066         union desc_stat status;
5067         struct ksz_hw *hw = &hw_priv->hw;
5068         struct net_device *dev = hw->port_info[0].pdev;
5069         struct ksz_desc_info *info = &hw->rx_desc_info;
5070         int left = info->alloc;
5071         struct ksz_desc *desc;
5072         int received = 0;
5073
5074         next = info->next;
5075         while (left--) {
5076                 /* Get next descriptor which is not hardware owned. */
5077                 desc = &info->ring[next];
5078                 status.data = le32_to_cpu(desc->phw->ctrl.data);
5079                 if (status.rx.hw_owned)
5080                         break;
5081
5082                 /* Status valid only when last descriptor bit is set. */
5083                 if (status.rx.last_desc && status.rx.first_desc) {
5084                         if (rx_proc(dev, hw, desc, status))
5085                                 goto release_packet;
5086                         received++;
5087                 }
5088
5089 release_packet:
5090                 release_desc(desc);
5091                 next++;
5092                 next &= info->mask;
5093         }
5094         info->next = next;
5095
5096         return received;
5097 }
5098
5099 static int port_rcv_packets(struct dev_info *hw_priv)
5100 {
5101         int next;
5102         union desc_stat status;
5103         struct ksz_hw *hw = &hw_priv->hw;
5104         struct net_device *dev = hw->port_info[0].pdev;
5105         struct ksz_desc_info *info = &hw->rx_desc_info;
5106         int left = info->alloc;
5107         struct ksz_desc *desc;
5108         int received = 0;
5109
5110         next = info->next;
5111         while (left--) {
5112                 /* Get next descriptor which is not hardware owned. */
5113                 desc = &info->ring[next];
5114                 status.data = le32_to_cpu(desc->phw->ctrl.data);
5115                 if (status.rx.hw_owned)
5116                         break;
5117
5118                 if (hw->dev_count > 1) {
5119                         /* Get received port number. */
5120                         int p = HW_TO_DEV_PORT(status.rx.src_port);
5121
5122                         dev = hw->port_info[p].pdev;
5123                         if (!netif_running(dev))
5124                                 goto release_packet;
5125                 }
5126
5127                 /* Status valid only when last descriptor bit is set. */
5128                 if (status.rx.last_desc && status.rx.first_desc) {
5129                         if (rx_proc(dev, hw, desc, status))
5130                                 goto release_packet;
5131                         received++;
5132                 }
5133
5134 release_packet:
5135                 release_desc(desc);
5136                 next++;
5137                 next &= info->mask;
5138         }
5139         info->next = next;
5140
5141         return received;
5142 }
5143
5144 static int dev_rcv_special(struct dev_info *hw_priv)
5145 {
5146         int next;
5147         union desc_stat status;
5148         struct ksz_hw *hw = &hw_priv->hw;
5149         struct net_device *dev = hw->port_info[0].pdev;
5150         struct ksz_desc_info *info = &hw->rx_desc_info;
5151         int left = info->alloc;
5152         struct ksz_desc *desc;
5153         int received = 0;
5154
5155         next = info->next;
5156         while (left--) {
5157                 /* Get next descriptor which is not hardware owned. */
5158                 desc = &info->ring[next];
5159                 status.data = le32_to_cpu(desc->phw->ctrl.data);
5160                 if (status.rx.hw_owned)
5161                         break;
5162
5163                 if (hw->dev_count > 1) {
5164                         /* Get received port number. */
5165                         int p = HW_TO_DEV_PORT(status.rx.src_port);
5166
5167                         dev = hw->port_info[p].pdev;
5168                         if (!netif_running(dev))
5169                                 goto release_packet;
5170                 }
5171
5172                 /* Status valid only when last descriptor bit is set. */
5173                 if (status.rx.last_desc && status.rx.first_desc) {
5174                         /*
5175                          * Receive without error.  With receive errors
5176                          * disabled, packets with receive errors will be
5177                          * dropped, so no need to check the error bit.
5178                          */
5179                         if (!status.rx.error || (status.data &
5180                                         KS_DESC_RX_ERROR_COND) ==
5181                                         KS_DESC_RX_ERROR_TOO_LONG) {
5182                                 if (rx_proc(dev, hw, desc, status))
5183                                         goto release_packet;
5184                                 received++;
5185                         } else {
5186                                 struct dev_priv *priv = netdev_priv(dev);
5187
5188                                 /* Update receive error statistics. */
5189                                 priv->port.counter[OID_COUNTER_RCV_ERROR]++;
5190                         }
5191                 }
5192
5193 release_packet:
5194                 release_desc(desc);
5195                 next++;
5196                 next &= info->mask;
5197         }
5198         info->next = next;
5199
5200         return received;
5201 }
5202
5203 static void rx_proc_task(unsigned long data)
5204 {
5205         struct dev_info *hw_priv = (struct dev_info *) data;
5206         struct ksz_hw *hw = &hw_priv->hw;
5207
5208         if (!hw->enabled)
5209                 return;
5210         if (unlikely(!hw_priv->dev_rcv(hw_priv))) {
5211
5212                 /* In case receive process is suspended because of overrun. */
5213                 hw_resume_rx(hw);
5214
5215                 /* tasklets are interruptible. */
5216                 spin_lock_irq(&hw_priv->hwlock);
5217                 hw_turn_on_intr(hw, KS884X_INT_RX_MASK);
5218                 spin_unlock_irq(&hw_priv->hwlock);
5219         } else {
5220                 hw_ack_intr(hw, KS884X_INT_RX);
5221                 tasklet_schedule(&hw_priv->rx_tasklet);
5222         }
5223 }
5224
5225 static void tx_proc_task(unsigned long data)
5226 {
5227         struct dev_info *hw_priv = (struct dev_info *) data;
5228         struct ksz_hw *hw = &hw_priv->hw;
5229
5230         hw_ack_intr(hw, KS884X_INT_TX_MASK);
5231
5232         tx_done(hw_priv);
5233
5234         /* tasklets are interruptible. */
5235         spin_lock_irq(&hw_priv->hwlock);
5236         hw_turn_on_intr(hw, KS884X_INT_TX);
5237         spin_unlock_irq(&hw_priv->hwlock);
5238 }
5239
5240 static inline void handle_rx_stop(struct ksz_hw *hw)
5241 {
5242         /* Receive just has been stopped. */
5243         if (0 == hw->rx_stop)
5244                 hw->intr_mask &= ~KS884X_INT_RX_STOPPED;
5245         else if (hw->rx_stop > 1) {
5246                 if (hw->enabled && (hw->rx_cfg & DMA_RX_ENABLE)) {
5247                         hw_start_rx(hw);
5248                 } else {
5249                         hw->intr_mask &= ~KS884X_INT_RX_STOPPED;
5250                         hw->rx_stop = 0;
5251                 }
5252         } else
5253                 /* Receive just has been started. */
5254                 hw->rx_stop++;
5255 }
5256
5257 /**
5258  * netdev_intr - interrupt handling
5259  * @irq:        Interrupt number.
5260  * @dev_id:     Network device.
5261  *
5262  * This function is called by upper network layer to signal interrupt.
5263  *
5264  * Return IRQ_HANDLED if interrupt is handled.
5265  */
5266 static irqreturn_t netdev_intr(int irq, void *dev_id)
5267 {
5268         uint int_enable = 0;
5269         struct net_device *dev = (struct net_device *) dev_id;
5270         struct dev_priv *priv = netdev_priv(dev);
5271         struct dev_info *hw_priv = priv->adapter;
5272         struct ksz_hw *hw = &hw_priv->hw;
5273
5274         hw_read_intr(hw, &int_enable);
5275
5276         /* Not our interrupt! */
5277         if (!int_enable)
5278                 return IRQ_NONE;
5279
5280         do {
5281                 hw_ack_intr(hw, int_enable);
5282                 int_enable &= hw->intr_mask;
5283
5284                 if (unlikely(int_enable & KS884X_INT_TX_MASK)) {
5285                         hw_dis_intr_bit(hw, KS884X_INT_TX_MASK);
5286                         tasklet_schedule(&hw_priv->tx_tasklet);
5287                 }
5288
5289                 if (likely(int_enable & KS884X_INT_RX)) {
5290                         hw_dis_intr_bit(hw, KS884X_INT_RX);
5291                         tasklet_schedule(&hw_priv->rx_tasklet);
5292                 }
5293
5294                 if (unlikely(int_enable & KS884X_INT_RX_OVERRUN)) {
5295                         priv->stats.rx_fifo_errors++;
5296                         hw_resume_rx(hw);
5297                 }
5298
5299                 if (unlikely(int_enable & KS884X_INT_PHY)) {
5300                         struct ksz_port *port = &priv->port;
5301
5302                         hw->features |= LINK_INT_WORKING;
5303                         port_get_link_speed(port);
5304                 }
5305
5306                 if (unlikely(int_enable & KS884X_INT_RX_STOPPED)) {
5307                         handle_rx_stop(hw);
5308                         break;
5309                 }
5310
5311                 if (unlikely(int_enable & KS884X_INT_TX_STOPPED)) {
5312                         u32 data;
5313
5314                         hw->intr_mask &= ~KS884X_INT_TX_STOPPED;
5315                         pr_info("Tx stopped\n");
5316                         data = readl(hw->io + KS_DMA_TX_CTRL);
5317                         if (!(data & DMA_TX_ENABLE))
5318                                 pr_info("Tx disabled\n");
5319                         break;
5320                 }
5321         } while (0);
5322
5323         hw_ena_intr(hw);
5324
5325         return IRQ_HANDLED;
5326 }
5327
5328 /*
5329  * Linux network device functions
5330  */
5331
5332 static unsigned long next_jiffies;
5333
5334 #ifdef CONFIG_NET_POLL_CONTROLLER
5335 static void netdev_netpoll(struct net_device *dev)
5336 {
5337         struct dev_priv *priv = netdev_priv(dev);
5338         struct dev_info *hw_priv = priv->adapter;
5339
5340         hw_dis_intr(&hw_priv->hw);
5341         netdev_intr(dev->irq, dev);
5342 }
5343 #endif
5344
5345 static void bridge_change(struct ksz_hw *hw)
5346 {
5347         int port;
5348         u8  member;
5349         struct ksz_switch *sw = hw->ksz_switch;
5350
5351         /* No ports in forwarding state. */
5352         if (!sw->member) {
5353                 port_set_stp_state(hw, SWITCH_PORT_NUM, STP_STATE_SIMPLE);
5354                 sw_block_addr(hw);
5355         }
5356         for (port = 0; port < SWITCH_PORT_NUM; port++) {
5357                 if (STP_STATE_FORWARDING == sw->port_cfg[port].stp_state)
5358                         member = HOST_MASK | sw->member;
5359                 else
5360                         member = HOST_MASK | (1 << port);
5361                 if (member != sw->port_cfg[port].member)
5362                         sw_cfg_port_base_vlan(hw, port, member);
5363         }
5364 }
5365
5366 /**
5367  * netdev_close - close network device
5368  * @dev:        Network device.
5369  *
5370  * This function process the close operation of network device.  This is caused
5371  * by the user command "ifconfig ethX down."
5372  *
5373  * Return 0 if successful; otherwise an error code indicating failure.
5374  */
5375 static int netdev_close(struct net_device *dev)
5376 {
5377         struct dev_priv *priv = netdev_priv(dev);
5378         struct dev_info *hw_priv = priv->adapter;
5379         struct ksz_port *port = &priv->port;
5380         struct ksz_hw *hw = &hw_priv->hw;
5381         int pi;
5382
5383         netif_stop_queue(dev);
5384
5385         ksz_stop_timer(&priv->monitor_timer_info);
5386
5387         /* Need to shut the port manually in multiple device interfaces mode. */
5388         if (hw->dev_count > 1) {
5389                 port_set_stp_state(hw, port->first_port, STP_STATE_DISABLED);
5390
5391                 /* Port is closed.  Need to change bridge setting. */
5392                 if (hw->features & STP_SUPPORT) {
5393                         pi = 1 << port->first_port;
5394                         if (hw->ksz_switch->member & pi) {
5395                                 hw->ksz_switch->member &= ~pi;
5396                                 bridge_change(hw);
5397                         }
5398                 }
5399         }
5400         if (port->first_port > 0)
5401                 hw_del_addr(hw, dev->dev_addr);
5402         if (!hw_priv->wol_enable)
5403                 port_set_power_saving(port, true);
5404
5405         if (priv->multicast)
5406                 --hw->all_multi;
5407         if (priv->promiscuous)
5408                 --hw->promiscuous;
5409
5410         hw_priv->opened--;
5411         if (!(hw_priv->opened)) {
5412                 ksz_stop_timer(&hw_priv->mib_timer_info);
5413                 flush_work(&hw_priv->mib_read);
5414
5415                 hw_dis_intr(hw);
5416                 hw_disable(hw);
5417                 hw_clr_multicast(hw);
5418
5419                 /* Delay for receive task to stop scheduling itself. */
5420                 msleep(2000 / HZ);
5421
5422                 tasklet_disable(&hw_priv->rx_tasklet);
5423                 tasklet_disable(&hw_priv->tx_tasklet);
5424                 free_irq(dev->irq, hw_priv->dev);
5425
5426                 transmit_cleanup(hw_priv, 0);
5427                 hw_reset_pkts(&hw->rx_desc_info);
5428                 hw_reset_pkts(&hw->tx_desc_info);
5429
5430                 /* Clean out static MAC table when the switch is shutdown. */
5431                 if (hw->features & STP_SUPPORT)
5432                         sw_clr_sta_mac_table(hw);
5433         }
5434
5435         return 0;
5436 }
5437
5438 static void hw_cfg_huge_frame(struct dev_info *hw_priv, struct ksz_hw *hw)
5439 {
5440         if (hw->ksz_switch) {
5441                 u32 data;
5442
5443                 data = readw(hw->io + KS8842_SWITCH_CTRL_2_OFFSET);
5444                 if (hw->features & RX_HUGE_FRAME)
5445                         data |= SWITCH_HUGE_PACKET;
5446                 else
5447                         data &= ~SWITCH_HUGE_PACKET;
5448                 writew(data, hw->io + KS8842_SWITCH_CTRL_2_OFFSET);
5449         }
5450         if (hw->features & RX_HUGE_FRAME) {
5451                 hw->rx_cfg |= DMA_RX_ERROR;
5452                 hw_priv->dev_rcv = dev_rcv_special;
5453         } else {
5454                 hw->rx_cfg &= ~DMA_RX_ERROR;
5455                 if (hw->dev_count > 1)
5456                         hw_priv->dev_rcv = port_rcv_packets;
5457                 else
5458                         hw_priv->dev_rcv = dev_rcv_packets;
5459         }
5460 }
5461
5462 static int prepare_hardware(struct net_device *dev)
5463 {
5464         struct dev_priv *priv = netdev_priv(dev);
5465         struct dev_info *hw_priv = priv->adapter;
5466         struct ksz_hw *hw = &hw_priv->hw;
5467         int rc = 0;
5468
5469         /* Remember the network device that requests interrupts. */
5470         hw_priv->dev = dev;
5471         rc = request_irq(dev->irq, netdev_intr, IRQF_SHARED, dev->name, dev);
5472         if (rc)
5473                 return rc;
5474         tasklet_enable(&hw_priv->rx_tasklet);
5475         tasklet_enable(&hw_priv->tx_tasklet);
5476
5477         hw->promiscuous = 0;
5478         hw->all_multi = 0;
5479         hw->multi_list_size = 0;
5480
5481         hw_reset(hw);
5482
5483         hw_set_desc_base(hw,
5484                 hw->tx_desc_info.ring_phys, hw->rx_desc_info.ring_phys);
5485         hw_set_addr(hw);
5486         hw_cfg_huge_frame(hw_priv, hw);
5487         ksz_init_rx_buffers(hw_priv);
5488         return 0;
5489 }
5490
5491 static void set_media_state(struct net_device *dev, int media_state)
5492 {
5493         struct dev_priv *priv = netdev_priv(dev);
5494
5495         if (media_state == priv->media_state)
5496                 netif_carrier_on(dev);
5497         else
5498                 netif_carrier_off(dev);
5499         netif_info(priv, link, dev, "link %s\n",
5500                    media_state == priv->media_state ? "on" : "off");
5501 }
5502
5503 /**
5504  * netdev_open - open network device
5505  * @dev:        Network device.
5506  *
5507  * This function process the open operation of network device.  This is caused
5508  * by the user command "ifconfig ethX up."
5509  *
5510  * Return 0 if successful; otherwise an error code indicating failure.
5511  */
5512 static int netdev_open(struct net_device *dev)
5513 {
5514         struct dev_priv *priv = netdev_priv(dev);
5515         struct dev_info *hw_priv = priv->adapter;
5516         struct ksz_hw *hw = &hw_priv->hw;
5517         struct ksz_port *port = &priv->port;
5518         int i;
5519         int p;
5520         int rc = 0;
5521
5522         priv->multicast = 0;
5523         priv->promiscuous = 0;
5524
5525         /* Reset device statistics. */
5526         memset(&priv->stats, 0, sizeof(struct net_device_stats));
5527         memset((void *) port->counter, 0,
5528                 (sizeof(u64) * OID_COUNTER_LAST));
5529
5530         if (!(hw_priv->opened)) {
5531                 rc = prepare_hardware(dev);
5532                 if (rc)
5533                         return rc;
5534                 for (i = 0; i < hw->mib_port_cnt; i++) {
5535                         if (next_jiffies < jiffies)
5536                                 next_jiffies = jiffies + HZ * 2;
5537                         else
5538                                 next_jiffies += HZ * 1;
5539                         hw_priv->counter[i].time = next_jiffies;
5540                         hw->port_mib[i].state = media_disconnected;
5541                         port_init_cnt(hw, i);
5542                 }
5543                 if (hw->ksz_switch)
5544                         hw->port_mib[HOST_PORT].state = media_connected;
5545                 else {
5546                         hw_add_wol_bcast(hw);
5547                         hw_cfg_wol_pme(hw, 0);
5548                         hw_clr_wol_pme_status(&hw_priv->hw);
5549                 }
5550         }
5551         port_set_power_saving(port, false);
5552
5553         for (i = 0, p = port->first_port; i < port->port_cnt; i++, p++) {
5554                 /*
5555                  * Initialize to invalid value so that link detection
5556                  * is done.
5557                  */
5558                 hw->port_info[p].partner = 0xFF;
5559                 hw->port_info[p].state = media_disconnected;
5560         }
5561
5562         /* Need to open the port in multiple device interfaces mode. */
5563         if (hw->dev_count > 1) {
5564                 port_set_stp_state(hw, port->first_port, STP_STATE_SIMPLE);
5565                 if (port->first_port > 0)
5566                         hw_add_addr(hw, dev->dev_addr);
5567         }
5568
5569         port_get_link_speed(port);
5570         if (port->force_link)
5571                 port_force_link_speed(port);
5572         else
5573                 port_set_link_speed(port);
5574
5575         if (!(hw_priv->opened)) {
5576                 hw_setup_intr(hw);
5577                 hw_enable(hw);
5578                 hw_ena_intr(hw);
5579
5580                 if (hw->mib_port_cnt)
5581                         ksz_start_timer(&hw_priv->mib_timer_info,
5582                                 hw_priv->mib_timer_info.period);
5583         }
5584
5585         hw_priv->opened++;
5586
5587         ksz_start_timer(&priv->monitor_timer_info,
5588                 priv->monitor_timer_info.period);
5589
5590         priv->media_state = port->linked->state;
5591
5592         set_media_state(dev, media_connected);
5593         netif_start_queue(dev);
5594
5595         return 0;
5596 }
5597
5598 /* RX errors = rx_errors */
5599 /* RX dropped = rx_dropped */
5600 /* RX overruns = rx_fifo_errors */
5601 /* RX frame = rx_crc_errors + rx_frame_errors + rx_length_errors */
5602 /* TX errors = tx_errors */
5603 /* TX dropped = tx_dropped */
5604 /* TX overruns = tx_fifo_errors */
5605 /* TX carrier = tx_aborted_errors + tx_carrier_errors + tx_window_errors */
5606 /* collisions = collisions */
5607
5608 /**
5609  * netdev_query_statistics - query network device statistics
5610  * @dev:        Network device.
5611  *
5612  * This function returns the statistics of the network device.  The device
5613  * needs not be opened.
5614  *
5615  * Return network device statistics.
5616  */
5617 static struct net_device_stats *netdev_query_statistics(struct net_device *dev)
5618 {
5619         struct dev_priv *priv = netdev_priv(dev);
5620         struct ksz_port *port = &priv->port;
5621         struct ksz_hw *hw = &priv->adapter->hw;
5622         struct ksz_port_mib *mib;
5623         int i;
5624         int p;
5625
5626         priv->stats.rx_errors = port->counter[OID_COUNTER_RCV_ERROR];
5627         priv->stats.tx_errors = port->counter[OID_COUNTER_XMIT_ERROR];
5628
5629         /* Reset to zero to add count later. */
5630         priv->stats.multicast = 0;
5631         priv->stats.collisions = 0;
5632         priv->stats.rx_length_errors = 0;
5633         priv->stats.rx_crc_errors = 0;
5634         priv->stats.rx_frame_errors = 0;
5635         priv->stats.tx_window_errors = 0;
5636
5637         for (i = 0, p = port->first_port; i < port->mib_port_cnt; i++, p++) {
5638                 mib = &hw->port_mib[p];
5639
5640                 priv->stats.multicast += (unsigned long)
5641                         mib->counter[MIB_COUNTER_RX_MULTICAST];
5642
5643                 priv->stats.collisions += (unsigned long)
5644                         mib->counter[MIB_COUNTER_TX_TOTAL_COLLISION];
5645
5646                 priv->stats.rx_length_errors += (unsigned long)(
5647                         mib->counter[MIB_COUNTER_RX_UNDERSIZE] +
5648                         mib->counter[MIB_COUNTER_RX_FRAGMENT] +
5649                         mib->counter[MIB_COUNTER_RX_OVERSIZE] +
5650                         mib->counter[MIB_COUNTER_RX_JABBER]);
5651                 priv->stats.rx_crc_errors += (unsigned long)
5652                         mib->counter[MIB_COUNTER_RX_CRC_ERR];
5653                 priv->stats.rx_frame_errors += (unsigned long)(
5654                         mib->counter[MIB_COUNTER_RX_ALIGNMENT_ERR] +
5655                         mib->counter[MIB_COUNTER_RX_SYMBOL_ERR]);
5656
5657                 priv->stats.tx_window_errors += (unsigned long)
5658                         mib->counter[MIB_COUNTER_TX_LATE_COLLISION];
5659         }
5660
5661         return &priv->stats;
5662 }
5663
5664 /**
5665  * netdev_set_mac_address - set network device MAC address
5666  * @dev:        Network device.
5667  * @addr:       Buffer of MAC address.
5668  *
5669  * This function is used to set the MAC address of the network device.
5670  *
5671  * Return 0 to indicate success.
5672  */
5673 static int netdev_set_mac_address(struct net_device *dev, void *addr)
5674 {
5675         struct dev_priv *priv = netdev_priv(dev);
5676         struct dev_info *hw_priv = priv->adapter;
5677         struct ksz_hw *hw = &hw_priv->hw;
5678         struct sockaddr *mac = addr;
5679         uint interrupt;
5680
5681         if (priv->port.first_port > 0)
5682                 hw_del_addr(hw, dev->dev_addr);
5683         else {
5684                 hw->mac_override = 1;
5685                 memcpy(hw->override_addr, mac->sa_data, MAC_ADDR_LEN);
5686         }
5687
5688         memcpy(dev->dev_addr, mac->sa_data, MAX_ADDR_LEN);
5689
5690         interrupt = hw_block_intr(hw);
5691
5692         if (priv->port.first_port > 0)
5693                 hw_add_addr(hw, dev->dev_addr);
5694         else
5695                 hw_set_addr(hw);
5696         hw_restore_intr(hw, interrupt);
5697
5698         return 0;
5699 }
5700
5701 static void dev_set_promiscuous(struct net_device *dev, struct dev_priv *priv,
5702         struct ksz_hw *hw, int promiscuous)
5703 {
5704         if (promiscuous != priv->promiscuous) {
5705                 u8 prev_state = hw->promiscuous;
5706
5707                 if (promiscuous)
5708                         ++hw->promiscuous;
5709                 else
5710                         --hw->promiscuous;
5711                 priv->promiscuous = promiscuous;
5712
5713                 /* Turn on/off promiscuous mode. */
5714                 if (hw->promiscuous <= 1 && prev_state <= 1)
5715                         hw_set_promiscuous(hw, hw->promiscuous);
5716
5717                 /*
5718                  * Port is not in promiscuous mode, meaning it is released
5719                  * from the bridge.
5720                  */
5721                 if ((hw->features & STP_SUPPORT) && !promiscuous &&
5722                                 dev->br_port) {
5723                         struct ksz_switch *sw = hw->ksz_switch;
5724                         int port = priv->port.first_port;
5725
5726                         port_set_stp_state(hw, port, STP_STATE_DISABLED);
5727                         port = 1 << port;
5728                         if (sw->member & port) {
5729                                 sw->member &= ~port;
5730                                 bridge_change(hw);
5731                         }
5732                 }
5733         }
5734 }
5735
5736 static void dev_set_multicast(struct dev_priv *priv, struct ksz_hw *hw,
5737         int multicast)
5738 {
5739         if (multicast != priv->multicast) {
5740                 u8 all_multi = hw->all_multi;
5741
5742                 if (multicast)
5743                         ++hw->all_multi;
5744                 else
5745                         --hw->all_multi;
5746                 priv->multicast = multicast;
5747
5748                 /* Turn on/off all multicast mode. */
5749                 if (hw->all_multi <= 1 && all_multi <= 1)
5750                         hw_set_multicast(hw, hw->all_multi);
5751         }
5752 }
5753
5754 /**
5755  * netdev_set_rx_mode
5756  * @dev:        Network device.
5757  *
5758  * This routine is used to set multicast addresses or put the network device
5759  * into promiscuous mode.
5760  */
5761 static void netdev_set_rx_mode(struct net_device *dev)
5762 {
5763         struct dev_priv *priv = netdev_priv(dev);
5764         struct dev_info *hw_priv = priv->adapter;
5765         struct ksz_hw *hw = &hw_priv->hw;
5766         struct dev_mc_list *mc_ptr;
5767         int multicast = (dev->flags & IFF_ALLMULTI);
5768
5769         dev_set_promiscuous(dev, priv, hw, (dev->flags & IFF_PROMISC));
5770
5771         if (hw_priv->hw.dev_count > 1)
5772                 multicast |= (dev->flags & IFF_MULTICAST);
5773         dev_set_multicast(priv, hw, multicast);
5774
5775         /* Cannot use different hashes in multiple device interfaces mode. */
5776         if (hw_priv->hw.dev_count > 1)
5777                 return;
5778
5779         if ((dev->flags & IFF_MULTICAST) && !netdev_mc_empty(dev)) {
5780                 int i = 0;
5781
5782                 /* List too big to support so turn on all multicast mode. */
5783                 if (dev->mc_count > MAX_MULTICAST_LIST) {
5784                         if (MAX_MULTICAST_LIST != hw->multi_list_size) {
5785                                 hw->multi_list_size = MAX_MULTICAST_LIST;
5786                                 ++hw->all_multi;
5787                                 hw_set_multicast(hw, hw->all_multi);
5788                         }
5789                         return;
5790                 }
5791
5792                 netdev_for_each_mc_addr(mc_ptr, dev) {
5793                         if (!(*mc_ptr->dmi_addr & 1))
5794                                 continue;
5795                         if (i >= MAX_MULTICAST_LIST)
5796                                 break;
5797                         memcpy(hw->multi_list[i++], mc_ptr->dmi_addr,
5798                                 MAC_ADDR_LEN);
5799                 }
5800                 hw->multi_list_size = (u8) i;
5801                 hw_set_grp_addr(hw);
5802         } else {
5803                 if (MAX_MULTICAST_LIST == hw->multi_list_size) {
5804                         --hw->all_multi;
5805                         hw_set_multicast(hw, hw->all_multi);
5806                 }
5807                 hw->multi_list_size = 0;
5808                 hw_clr_multicast(hw);
5809         }
5810 }
5811
5812 static int netdev_change_mtu(struct net_device *dev, int new_mtu)
5813 {
5814         struct dev_priv *priv = netdev_priv(dev);
5815         struct dev_info *hw_priv = priv->adapter;
5816         struct ksz_hw *hw = &hw_priv->hw;
5817         int hw_mtu;
5818
5819         if (netif_running(dev))
5820                 return -EBUSY;
5821
5822         /* Cannot use different MTU in multiple device interfaces mode. */
5823         if (hw->dev_count > 1)
5824                 if (dev != hw_priv->dev)
5825                         return 0;
5826         if (new_mtu < 60)
5827                 return -EINVAL;
5828
5829         if (dev->mtu != new_mtu) {
5830                 hw_mtu = new_mtu + ETHERNET_HEADER_SIZE + 4;
5831                 if (hw_mtu > MAX_RX_BUF_SIZE)
5832                         return -EINVAL;
5833                 if (hw_mtu > REGULAR_RX_BUF_SIZE) {
5834                         hw->features |= RX_HUGE_FRAME;
5835                         hw_mtu = MAX_RX_BUF_SIZE;
5836                 } else {
5837                         hw->features &= ~RX_HUGE_FRAME;
5838                         hw_mtu = REGULAR_RX_BUF_SIZE;
5839                 }
5840                 hw_mtu = (hw_mtu + 3) & ~3;
5841                 hw_priv->mtu = hw_mtu;
5842                 dev->mtu = new_mtu;
5843         }
5844         return 0;
5845 }
5846
5847 /**
5848  * netdev_ioctl - I/O control processing
5849  * @dev:        Network device.
5850  * @ifr:        Interface request structure.
5851  * @cmd:        I/O control code.
5852  *
5853  * This function is used to process I/O control calls.
5854  *
5855  * Return 0 to indicate success.
5856  */
5857 static int netdev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
5858 {
5859         struct dev_priv *priv = netdev_priv(dev);
5860         struct dev_info *hw_priv = priv->adapter;
5861         struct ksz_hw *hw = &hw_priv->hw;
5862         struct ksz_port *port = &priv->port;
5863         int rc;
5864         int result = 0;
5865         struct mii_ioctl_data *data = if_mii(ifr);
5866
5867         if (down_interruptible(&priv->proc_sem))
5868                 return -ERESTARTSYS;
5869
5870         /* assume success */
5871         rc = 0;
5872         switch (cmd) {
5873         /* Get address of MII PHY in use. */
5874         case SIOCGMIIPHY:
5875                 data->phy_id = priv->id;
5876
5877                 /* Fallthrough... */
5878
5879         /* Read MII PHY register. */
5880         case SIOCGMIIREG:
5881                 if (data->phy_id != priv->id || data->reg_num >= 6)
5882                         result = -EIO;
5883                 else
5884                         hw_r_phy(hw, port->linked->port_id, data->reg_num,
5885                                 &data->val_out);
5886                 break;
5887
5888         /* Write MII PHY register. */
5889         case SIOCSMIIREG:
5890                 if (!capable(CAP_NET_ADMIN))
5891                         result = -EPERM;
5892                 else if (data->phy_id != priv->id || data->reg_num >= 6)
5893                         result = -EIO;
5894                 else
5895                         hw_w_phy(hw, port->linked->port_id, data->reg_num,
5896                                 data->val_in);
5897                 break;
5898
5899         default:
5900                 result = -EOPNOTSUPP;
5901         }
5902
5903         up(&priv->proc_sem);
5904
5905         return result;
5906 }
5907
5908 /*
5909  * MII support
5910  */
5911
5912 /**
5913  * mdio_read - read PHY register
5914  * @dev:        Network device.
5915  * @phy_id:     The PHY id.
5916  * @reg_num:    The register number.
5917  *
5918  * This function returns the PHY register value.
5919  *
5920  * Return the register value.
5921  */
5922 static int mdio_read(struct net_device *dev, int phy_id, int reg_num)
5923 {
5924         struct dev_priv *priv = netdev_priv(dev);
5925         struct ksz_port *port = &priv->port;
5926         struct ksz_hw *hw = port->hw;
5927         u16 val_out;
5928
5929         hw_r_phy(hw, port->linked->port_id, reg_num << 1, &val_out);
5930         return val_out;
5931 }
5932
5933 /**
5934  * mdio_write - set PHY register
5935  * @dev:        Network device.
5936  * @phy_id:     The PHY id.
5937  * @reg_num:    The register number.
5938  * @val:        The register value.
5939  *
5940  * This procedure sets the PHY register value.
5941  */
5942 static void mdio_write(struct net_device *dev, int phy_id, int reg_num, int val)
5943 {
5944         struct dev_priv *priv = netdev_priv(dev);
5945         struct ksz_port *port = &priv->port;
5946         struct ksz_hw *hw = port->hw;
5947         int i;
5948         int pi;
5949
5950         for (i = 0, pi = port->first_port; i < port->port_cnt; i++, pi++)
5951                 hw_w_phy(hw, pi, reg_num << 1, val);
5952 }
5953
5954 /*
5955  * ethtool support
5956  */
5957
5958 #define EEPROM_SIZE                     0x40
5959
5960 static u16 eeprom_data[EEPROM_SIZE] = { 0 };
5961
5962 #define ADVERTISED_ALL                  \
5963         (ADVERTISED_10baseT_Half |      \
5964         ADVERTISED_10baseT_Full |       \
5965         ADVERTISED_100baseT_Half |      \
5966         ADVERTISED_100baseT_Full)
5967
5968 /* These functions use the MII functions in mii.c. */
5969
5970 /**
5971  * netdev_get_settings - get network device settings
5972  * @dev:        Network device.
5973  * @cmd:        Ethtool command.
5974  *
5975  * This function queries the PHY and returns its state in the ethtool command.
5976  *
5977  * Return 0 if successful; otherwise an error code.
5978  */
5979 static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
5980 {
5981         struct dev_priv *priv = netdev_priv(dev);
5982         struct dev_info *hw_priv = priv->adapter;
5983
5984         mutex_lock(&hw_priv->lock);
5985         mii_ethtool_gset(&priv->mii_if, cmd);
5986         cmd->advertising |= SUPPORTED_TP;
5987         mutex_unlock(&hw_priv->lock);
5988
5989         /* Save advertised settings for workaround in next function. */
5990         priv->advertising = cmd->advertising;
5991         return 0;
5992 }
5993
5994 /**
5995  * netdev_set_settings - set network device settings
5996  * @dev:        Network device.
5997  * @cmd:        Ethtool command.
5998  *
5999  * This function sets the PHY according to the ethtool command.
6000  *
6001  * Return 0 if successful; otherwise an error code.
6002  */
6003 static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
6004 {
6005         struct dev_priv *priv = netdev_priv(dev);
6006         struct dev_info *hw_priv = priv->adapter;
6007         struct ksz_port *port = &priv->port;
6008         int rc;
6009
6010         /*
6011          * ethtool utility does not change advertised setting if auto
6012          * negotiation is not specified explicitly.
6013          */
6014         if (cmd->autoneg && priv->advertising == cmd->advertising) {
6015                 cmd->advertising |= ADVERTISED_ALL;
6016                 if (10 == cmd->speed)
6017                         cmd->advertising &=
6018                                 ~(ADVERTISED_100baseT_Full |
6019                                 ADVERTISED_100baseT_Half);
6020                 else if (100 == cmd->speed)
6021                         cmd->advertising &=
6022                                 ~(ADVERTISED_10baseT_Full |
6023                                 ADVERTISED_10baseT_Half);
6024                 if (0 == cmd->duplex)
6025                         cmd->advertising &=
6026                                 ~(ADVERTISED_100baseT_Full |
6027                                 ADVERTISED_10baseT_Full);
6028                 else if (1 == cmd->duplex)
6029                         cmd->advertising &=
6030                                 ~(ADVERTISED_100baseT_Half |
6031                                 ADVERTISED_10baseT_Half);
6032         }
6033         mutex_lock(&hw_priv->lock);
6034         if (cmd->autoneg &&
6035                         (cmd->advertising & ADVERTISED_ALL) ==
6036                         ADVERTISED_ALL) {
6037                 port->duplex = 0;
6038                 port->speed = 0;
6039                 port->force_link = 0;
6040         } else {
6041                 port->duplex = cmd->duplex + 1;
6042                 if (cmd->speed != 1000)
6043                         port->speed = cmd->speed;
6044                 if (cmd->autoneg)
6045                         port->force_link = 0;
6046                 else
6047                         port->force_link = 1;
6048         }
6049         rc = mii_ethtool_sset(&priv->mii_if, cmd);
6050         mutex_unlock(&hw_priv->lock);
6051         return rc;
6052 }
6053
6054 /**
6055  * netdev_nway_reset - restart auto-negotiation
6056  * @dev:        Network device.
6057  *
6058  * This function restarts the PHY for auto-negotiation.
6059  *
6060  * Return 0 if successful; otherwise an error code.
6061  */
6062 static int netdev_nway_reset(struct net_device *dev)
6063 {
6064         struct dev_priv *priv = netdev_priv(dev);
6065         struct dev_info *hw_priv = priv->adapter;
6066         int rc;
6067
6068         mutex_lock(&hw_priv->lock);
6069         rc = mii_nway_restart(&priv->mii_if);
6070         mutex_unlock(&hw_priv->lock);
6071         return rc;
6072 }
6073
6074 /**
6075  * netdev_get_link - get network device link status
6076  * @dev:        Network device.
6077  *
6078  * This function gets the link status from the PHY.
6079  *
6080  * Return true if PHY is linked and false otherwise.
6081  */
6082 static u32 netdev_get_link(struct net_device *dev)
6083 {
6084         struct dev_priv *priv = netdev_priv(dev);
6085         int rc;
6086
6087         rc = mii_link_ok(&priv->mii_if);
6088         return rc;
6089 }
6090
6091 /**
6092  * netdev_get_drvinfo - get network driver information
6093  * @dev:        Network device.
6094  * @info:       Ethtool driver info data structure.
6095  *
6096  * This procedure returns the driver information.
6097  */
6098 static void netdev_get_drvinfo(struct net_device *dev,
6099         struct ethtool_drvinfo *info)
6100 {
6101         struct dev_priv *priv = netdev_priv(dev);
6102         struct dev_info *hw_priv = priv->adapter;
6103
6104         strcpy(info->driver, DRV_NAME);
6105         strcpy(info->version, DRV_VERSION);
6106         strcpy(info->bus_info, pci_name(hw_priv->pdev));
6107 }
6108
6109 /**
6110  * netdev_get_regs_len - get length of register dump
6111  * @dev:        Network device.
6112  *
6113  * This function returns the length of the register dump.
6114  *
6115  * Return length of the register dump.
6116  */
6117 static struct hw_regs {
6118         int start;
6119         int end;
6120 } hw_regs_range[] = {
6121         { KS_DMA_TX_CTRL,       KS884X_INTERRUPTS_STATUS },
6122         { KS_ADD_ADDR_0_LO,     KS_ADD_ADDR_F_HI },
6123         { KS884X_ADDR_0_OFFSET, KS8841_WOL_FRAME_BYTE2_OFFSET },
6124         { KS884X_SIDER_P,       KS8842_SGCR7_P },
6125         { KS8842_MACAR1_P,      KS8842_TOSR8_P },
6126         { KS884X_P1MBCR_P,      KS8842_P3ERCR_P },
6127         { 0, 0 }
6128 };
6129
6130 static int netdev_get_regs_len(struct net_device *dev)
6131 {
6132         struct hw_regs *range = hw_regs_range;
6133         int regs_len = 0x10 * sizeof(u32);
6134
6135         while (range->end > range->start) {
6136                 regs_len += (range->end - range->start + 3) / 4 * 4;
6137                 range++;
6138         }
6139         return regs_len;
6140 }
6141
6142 /**
6143  * netdev_get_regs - get register dump
6144  * @dev:        Network device.
6145  * @regs:       Ethtool registers data structure.
6146  * @ptr:        Buffer to store the register values.
6147  *
6148  * This procedure dumps the register values in the provided buffer.
6149  */
6150 static void netdev_get_regs(struct net_device *dev, struct ethtool_regs *regs,
6151         void *ptr)
6152 {
6153         struct dev_priv *priv = netdev_priv(dev);
6154         struct dev_info *hw_priv = priv->adapter;
6155         struct ksz_hw *hw = &hw_priv->hw;
6156         int *buf = (int *) ptr;
6157         struct hw_regs *range = hw_regs_range;
6158         int len;
6159
6160         mutex_lock(&hw_priv->lock);
6161         regs->version = 0;
6162         for (len = 0; len < 0x40; len += 4) {
6163                 pci_read_config_dword(hw_priv->pdev, len, buf);
6164                 buf++;
6165         }
6166         while (range->end > range->start) {
6167                 for (len = range->start; len < range->end; len += 4) {
6168                         *buf = readl(hw->io + len);
6169                         buf++;
6170                 }
6171                 range++;
6172         }
6173         mutex_unlock(&hw_priv->lock);
6174 }
6175
6176 #define WOL_SUPPORT                     \
6177         (WAKE_PHY | WAKE_MAGIC |        \
6178         WAKE_UCAST | WAKE_MCAST |       \
6179         WAKE_BCAST | WAKE_ARP)
6180
6181 /**
6182  * netdev_get_wol - get Wake-on-LAN support
6183  * @dev:        Network device.
6184  * @wol:        Ethtool Wake-on-LAN data structure.
6185  *
6186  * This procedure returns Wake-on-LAN support.
6187  */
6188 static void netdev_get_wol(struct net_device *dev,
6189         struct ethtool_wolinfo *wol)
6190 {
6191         struct dev_priv *priv = netdev_priv(dev);
6192         struct dev_info *hw_priv = priv->adapter;
6193
6194         wol->supported = hw_priv->wol_support;
6195         wol->wolopts = hw_priv->wol_enable;
6196         memset(&wol->sopass, 0, sizeof(wol->sopass));
6197 }
6198
6199 /**
6200  * netdev_set_wol - set Wake-on-LAN support
6201  * @dev:        Network device.
6202  * @wol:        Ethtool Wake-on-LAN data structure.
6203  *
6204  * This function sets Wake-on-LAN support.
6205  *
6206  * Return 0 if successful; otherwise an error code.
6207  */
6208 static int netdev_set_wol(struct net_device *dev,
6209         struct ethtool_wolinfo *wol)
6210 {
6211         struct dev_priv *priv = netdev_priv(dev);
6212         struct dev_info *hw_priv = priv->adapter;
6213
6214         /* Need to find a way to retrieve the device IP address. */
6215         u8 net_addr[] = { 192, 168, 1, 1 };
6216
6217         if (wol->wolopts & ~hw_priv->wol_support)
6218                 return -EINVAL;
6219
6220         hw_priv->wol_enable = wol->wolopts;
6221
6222         /* Link wakeup cannot really be disabled. */
6223         if (wol->wolopts)
6224                 hw_priv->wol_enable |= WAKE_PHY;
6225         hw_enable_wol(&hw_priv->hw, hw_priv->wol_enable, net_addr);
6226         return 0;
6227 }
6228
6229 /**
6230  * netdev_get_msglevel - get debug message level
6231  * @dev:        Network device.
6232  *
6233  * This function returns current debug message level.
6234  *
6235  * Return current debug message flags.
6236  */
6237 static u32 netdev_get_msglevel(struct net_device *dev)
6238 {
6239         struct dev_priv *priv = netdev_priv(dev);
6240
6241         return priv->msg_enable;
6242 }
6243
6244 /**
6245  * netdev_set_msglevel - set debug message level
6246  * @dev:        Network device.
6247  * @value:      Debug message flags.
6248  *
6249  * This procedure sets debug message level.
6250  */
6251 static void netdev_set_msglevel(struct net_device *dev, u32 value)
6252 {
6253         struct dev_priv *priv = netdev_priv(dev);
6254
6255         priv->msg_enable = value;
6256 }
6257
6258 /**
6259  * netdev_get_eeprom_len - get EEPROM length
6260  * @dev:        Network device.
6261  *
6262  * This function returns the length of the EEPROM.
6263  *
6264  * Return length of the EEPROM.
6265  */
6266 static int netdev_get_eeprom_len(struct net_device *dev)
6267 {
6268         return EEPROM_SIZE * 2;
6269 }
6270
6271 /**
6272  * netdev_get_eeprom - get EEPROM data
6273  * @dev:        Network device.
6274  * @eeprom:     Ethtool EEPROM data structure.
6275  * @data:       Buffer to store the EEPROM data.
6276  *
6277  * This function dumps the EEPROM data in the provided buffer.
6278  *
6279  * Return 0 if successful; otherwise an error code.
6280  */
6281 #define EEPROM_MAGIC                    0x10A18842
6282
6283 static int netdev_get_eeprom(struct net_device *dev,
6284         struct ethtool_eeprom *eeprom, u8 *data)
6285 {
6286         struct dev_priv *priv = netdev_priv(dev);
6287         struct dev_info *hw_priv = priv->adapter;
6288         u8 *eeprom_byte = (u8 *) eeprom_data;
6289         int i;
6290         int len;
6291
6292         len = (eeprom->offset + eeprom->len + 1) / 2;
6293         for (i = eeprom->offset / 2; i < len; i++)
6294                 eeprom_data[i] = eeprom_read(&hw_priv->hw, i);
6295         eeprom->magic = EEPROM_MAGIC;
6296         memcpy(data, &eeprom_byte[eeprom->offset], eeprom->len);
6297
6298         return 0;
6299 }
6300
6301 /**
6302  * netdev_set_eeprom - write EEPROM data
6303  * @dev:        Network device.
6304  * @eeprom:     Ethtool EEPROM data structure.
6305  * @data:       Data buffer.
6306  *
6307  * This function modifies the EEPROM data one byte at a time.
6308  *
6309  * Return 0 if successful; otherwise an error code.
6310  */
6311 static int netdev_set_eeprom(struct net_device *dev,
6312         struct ethtool_eeprom *eeprom, u8 *data)
6313 {
6314         struct dev_priv *priv = netdev_priv(dev);
6315         struct dev_info *hw_priv = priv->adapter;
6316         u16 eeprom_word[EEPROM_SIZE];
6317         u8 *eeprom_byte = (u8 *) eeprom_word;
6318         int i;
6319         int len;
6320
6321         if (eeprom->magic != EEPROM_MAGIC)
6322                 return 1;
6323
6324         len = (eeprom->offset + eeprom->len + 1) / 2;
6325         for (i = eeprom->offset / 2; i < len; i++)
6326                 eeprom_data[i] = eeprom_read(&hw_priv->hw, i);
6327         memcpy(eeprom_word, eeprom_data, EEPROM_SIZE * 2);
6328         memcpy(&eeprom_byte[eeprom->offset], data, eeprom->len);
6329         for (i = 0; i < EEPROM_SIZE; i++)
6330                 if (eeprom_word[i] != eeprom_data[i]) {
6331                         eeprom_data[i] = eeprom_word[i];
6332                         eeprom_write(&hw_priv->hw, i, eeprom_data[i]);
6333         }
6334
6335         return 0;
6336 }
6337
6338 /**
6339  * netdev_get_pauseparam - get flow control parameters
6340  * @dev:        Network device.
6341  * @pause:      Ethtool PAUSE settings data structure.
6342  *
6343  * This procedure returns the PAUSE control flow settings.
6344  */
6345 static void netdev_get_pauseparam(struct net_device *dev,
6346         struct ethtool_pauseparam *pause)
6347 {
6348         struct dev_priv *priv = netdev_priv(dev);
6349         struct dev_info *hw_priv = priv->adapter;
6350         struct ksz_hw *hw = &hw_priv->hw;
6351
6352         pause->autoneg = (hw->overrides & PAUSE_FLOW_CTRL) ? 0 : 1;
6353         if (!hw->ksz_switch) {
6354                 pause->rx_pause =
6355                         (hw->rx_cfg & DMA_RX_FLOW_ENABLE) ? 1 : 0;
6356                 pause->tx_pause =
6357                         (hw->tx_cfg & DMA_TX_FLOW_ENABLE) ? 1 : 0;
6358         } else {
6359                 pause->rx_pause =
6360                         (sw_chk(hw, KS8842_SWITCH_CTRL_1_OFFSET,
6361                                 SWITCH_RX_FLOW_CTRL)) ? 1 : 0;
6362                 pause->tx_pause =
6363                         (sw_chk(hw, KS8842_SWITCH_CTRL_1_OFFSET,
6364                                 SWITCH_TX_FLOW_CTRL)) ? 1 : 0;
6365         }
6366 }
6367
6368 /**
6369  * netdev_set_pauseparam - set flow control parameters
6370  * @dev:        Network device.
6371  * @pause:      Ethtool PAUSE settings data structure.
6372  *
6373  * This function sets the PAUSE control flow settings.
6374  * Not implemented yet.
6375  *
6376  * Return 0 if successful; otherwise an error code.
6377  */
6378 static int netdev_set_pauseparam(struct net_device *dev,
6379         struct ethtool_pauseparam *pause)
6380 {
6381         struct dev_priv *priv = netdev_priv(dev);
6382         struct dev_info *hw_priv = priv->adapter;
6383         struct ksz_hw *hw = &hw_priv->hw;
6384         struct ksz_port *port = &priv->port;
6385
6386         mutex_lock(&hw_priv->lock);
6387         if (pause->autoneg) {
6388                 if (!pause->rx_pause && !pause->tx_pause)
6389                         port->flow_ctrl = PHY_NO_FLOW_CTRL;
6390                 else
6391                         port->flow_ctrl = PHY_FLOW_CTRL;
6392                 hw->overrides &= ~PAUSE_FLOW_CTRL;
6393                 port->force_link = 0;
6394                 if (hw->ksz_switch) {
6395                         sw_cfg(hw, KS8842_SWITCH_CTRL_1_OFFSET,
6396                                 SWITCH_RX_FLOW_CTRL, 1);
6397                         sw_cfg(hw, KS8842_SWITCH_CTRL_1_OFFSET,
6398                                 SWITCH_TX_FLOW_CTRL, 1);
6399                 }
6400                 port_set_link_speed(port);
6401         } else {
6402                 hw->overrides |= PAUSE_FLOW_CTRL;
6403                 if (hw->ksz_switch) {
6404                         sw_cfg(hw, KS8842_SWITCH_CTRL_1_OFFSET,
6405                                 SWITCH_RX_FLOW_CTRL, pause->rx_pause);
6406                         sw_cfg(hw, KS8842_SWITCH_CTRL_1_OFFSET,
6407                                 SWITCH_TX_FLOW_CTRL, pause->tx_pause);
6408                 } else
6409                         set_flow_ctrl(hw, pause->rx_pause, pause->tx_pause);
6410         }
6411         mutex_unlock(&hw_priv->lock);
6412
6413         return 0;
6414 }
6415
6416 /**
6417  * netdev_get_ringparam - get tx/rx ring parameters
6418  * @dev:        Network device.
6419  * @pause:      Ethtool RING settings data structure.
6420  *
6421  * This procedure returns the TX/RX ring settings.
6422  */
6423 static void netdev_get_ringparam(struct net_device *dev,
6424         struct ethtool_ringparam *ring)
6425 {
6426         struct dev_priv *priv = netdev_priv(dev);
6427         struct dev_info *hw_priv = priv->adapter;
6428         struct ksz_hw *hw = &hw_priv->hw;
6429
6430         ring->tx_max_pending = (1 << 9);
6431         ring->tx_pending = hw->tx_desc_info.alloc;
6432         ring->rx_max_pending = (1 << 9);
6433         ring->rx_pending = hw->rx_desc_info.alloc;
6434 }
6435
6436 #define STATS_LEN                       (TOTAL_PORT_COUNTER_NUM)
6437
6438 static struct {
6439         char string[ETH_GSTRING_LEN];
6440 } ethtool_stats_keys[STATS_LEN] = {
6441         { "rx_lo_priority_octets" },
6442         { "rx_hi_priority_octets" },
6443         { "rx_undersize_packets" },
6444         { "rx_fragments" },
6445         { "rx_oversize_packets" },
6446         { "rx_jabbers" },
6447         { "rx_symbol_errors" },
6448         { "rx_crc_errors" },
6449         { "rx_align_errors" },
6450         { "rx_mac_ctrl_packets" },
6451         { "rx_pause_packets" },
6452         { "rx_bcast_packets" },
6453         { "rx_mcast_packets" },
6454         { "rx_ucast_packets" },
6455         { "rx_64_or_less_octet_packets" },
6456         { "rx_65_to_127_octet_packets" },
6457         { "rx_128_to_255_octet_packets" },
6458         { "rx_256_to_511_octet_packets" },
6459         { "rx_512_to_1023_octet_packets" },
6460         { "rx_1024_to_1522_octet_packets" },
6461
6462         { "tx_lo_priority_octets" },
6463         { "tx_hi_priority_octets" },
6464         { "tx_late_collisions" },
6465         { "tx_pause_packets" },
6466         { "tx_bcast_packets" },
6467         { "tx_mcast_packets" },
6468         { "tx_ucast_packets" },
6469         { "tx_deferred" },
6470         { "tx_total_collisions" },
6471         { "tx_excessive_collisions" },
6472         { "tx_single_collisions" },
6473         { "tx_mult_collisions" },
6474
6475         { "rx_discards" },
6476         { "tx_discards" },
6477 };
6478
6479 /**
6480  * netdev_get_strings - get statistics identity strings
6481  * @dev:        Network device.
6482  * @stringset:  String set identifier.
6483  * @buf:        Buffer to store the strings.
6484  *
6485  * This procedure returns the strings used to identify the statistics.
6486  */
6487 static void netdev_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
6488 {
6489         struct dev_priv *priv = netdev_priv(dev);
6490         struct dev_info *hw_priv = priv->adapter;
6491         struct ksz_hw *hw = &hw_priv->hw;
6492
6493         if (ETH_SS_STATS == stringset)
6494                 memcpy(buf, &ethtool_stats_keys,
6495                         ETH_GSTRING_LEN * hw->mib_cnt);
6496 }
6497
6498 /**
6499  * netdev_get_sset_count - get statistics size
6500  * @dev:        Network device.
6501  * @sset:       The statistics set number.
6502  *
6503  * This function returns the size of the statistics to be reported.
6504  *
6505  * Return size of the statistics to be reported.
6506  */
6507 static int netdev_get_sset_count(struct net_device *dev, int sset)
6508 {
6509         struct dev_priv *priv = netdev_priv(dev);
6510         struct dev_info *hw_priv = priv->adapter;
6511         struct ksz_hw *hw = &hw_priv->hw;
6512
6513         switch (sset) {
6514         case ETH_SS_STATS:
6515                 return hw->mib_cnt;
6516         default:
6517                 return -EOPNOTSUPP;
6518         }
6519 }
6520
6521 /**
6522  * netdev_get_ethtool_stats - get network device statistics
6523  * @dev:        Network device.
6524  * @stats:      Ethtool statistics data structure.
6525  * @data:       Buffer to store the statistics.
6526  *
6527  * This procedure returns the statistics.
6528  */
6529 static void netdev_get_ethtool_stats(struct net_device *dev,
6530         struct ethtool_stats *stats, u64 *data)
6531 {
6532         struct dev_priv *priv = netdev_priv(dev);
6533         struct dev_info *hw_priv = priv->adapter;
6534         struct ksz_hw *hw = &hw_priv->hw;
6535         struct ksz_port *port = &priv->port;
6536         int n_stats = stats->n_stats;
6537         int i;
6538         int n;
6539         int p;
6540         int rc;
6541         u64 counter[TOTAL_PORT_COUNTER_NUM];
6542
6543         mutex_lock(&hw_priv->lock);
6544         n = SWITCH_PORT_NUM;
6545         for (i = 0, p = port->first_port; i < port->mib_port_cnt; i++, p++) {
6546                 if (media_connected == hw->port_mib[p].state) {
6547                         hw_priv->counter[p].read = 1;
6548
6549                         /* Remember first port that requests read. */
6550                         if (n == SWITCH_PORT_NUM)
6551                                 n = p;
6552                 }
6553         }
6554         mutex_unlock(&hw_priv->lock);
6555
6556         if (n < SWITCH_PORT_NUM)
6557                 schedule_work(&hw_priv->mib_read);
6558
6559         if (1 == port->mib_port_cnt && n < SWITCH_PORT_NUM) {
6560                 p = n;
6561                 rc = wait_event_interruptible_timeout(
6562                         hw_priv->counter[p].counter,
6563                         2 == hw_priv->counter[p].read,
6564                         HZ * 1);
6565         } else
6566                 for (i = 0, p = n; i < port->mib_port_cnt - n; i++, p++) {
6567                         if (0 == i) {
6568                                 rc = wait_event_interruptible_timeout(
6569                                         hw_priv->counter[p].counter,
6570                                         2 == hw_priv->counter[p].read,
6571                                         HZ * 2);
6572                         } else if (hw->port_mib[p].cnt_ptr) {
6573                                 rc = wait_event_interruptible_timeout(
6574                                         hw_priv->counter[p].counter,
6575                                         2 == hw_priv->counter[p].read,
6576                                         HZ * 1);
6577                         }
6578                 }
6579
6580         get_mib_counters(hw, port->first_port, port->mib_port_cnt, counter);
6581         n = hw->mib_cnt;
6582         if (n > n_stats)
6583                 n = n_stats;
6584         n_stats -= n;
6585         for (i = 0; i < n; i++)
6586                 *data++ = counter[i];
6587 }
6588
6589 /**
6590  * netdev_get_rx_csum - get receive checksum support
6591  * @dev:        Network device.
6592  *
6593  * This function gets receive checksum support setting.
6594  *
6595  * Return true if receive checksum is enabled; false otherwise.
6596  */
6597 static u32 netdev_get_rx_csum(struct net_device *dev)
6598 {
6599         struct dev_priv *priv = netdev_priv(dev);
6600         struct dev_info *hw_priv = priv->adapter;
6601         struct ksz_hw *hw = &hw_priv->hw;
6602
6603         return hw->rx_cfg &
6604                 (DMA_RX_CSUM_UDP |
6605                 DMA_RX_CSUM_TCP |
6606                 DMA_RX_CSUM_IP);
6607 }
6608
6609 /**
6610  * netdev_set_rx_csum - set receive checksum support
6611  * @dev:        Network device.
6612  * @data:       Zero to disable receive checksum support.
6613  *
6614  * This function sets receive checksum support setting.
6615  *
6616  * Return 0 if successful; otherwise an error code.
6617  */
6618 static int netdev_set_rx_csum(struct net_device *dev, u32 data)
6619 {
6620         struct dev_priv *priv = netdev_priv(dev);
6621         struct dev_info *hw_priv = priv->adapter;
6622         struct ksz_hw *hw = &hw_priv->hw;
6623         u32 new_setting = hw->rx_cfg;
6624
6625         if (data)
6626                 new_setting |=
6627                         (DMA_RX_CSUM_UDP | DMA_RX_CSUM_TCP |
6628                         DMA_RX_CSUM_IP);
6629         else
6630                 new_setting &=
6631                         ~(DMA_RX_CSUM_UDP | DMA_RX_CSUM_TCP |
6632                         DMA_RX_CSUM_IP);
6633         new_setting &= ~DMA_RX_CSUM_UDP;
6634         mutex_lock(&hw_priv->lock);
6635         if (new_setting != hw->rx_cfg) {
6636                 hw->rx_cfg = new_setting;
6637                 if (hw->enabled)
6638                         writel(hw->rx_cfg, hw->io + KS_DMA_RX_CTRL);
6639         }
6640         mutex_unlock(&hw_priv->lock);
6641         return 0;
6642 }
6643
6644 static struct ethtool_ops netdev_ethtool_ops = {
6645         .get_settings           = netdev_get_settings,
6646         .set_settings           = netdev_set_settings,
6647         .nway_reset             = netdev_nway_reset,
6648         .get_link               = netdev_get_link,
6649         .get_drvinfo            = netdev_get_drvinfo,
6650         .get_regs_len           = netdev_get_regs_len,
6651         .get_regs               = netdev_get_regs,
6652         .get_wol                = netdev_get_wol,
6653         .set_wol                = netdev_set_wol,
6654         .get_msglevel           = netdev_get_msglevel,
6655         .set_msglevel           = netdev_set_msglevel,
6656         .get_eeprom_len         = netdev_get_eeprom_len,
6657         .get_eeprom             = netdev_get_eeprom,
6658         .set_eeprom             = netdev_set_eeprom,
6659         .get_pauseparam         = netdev_get_pauseparam,
6660         .set_pauseparam         = netdev_set_pauseparam,
6661         .get_ringparam          = netdev_get_ringparam,
6662         .get_strings            = netdev_get_strings,
6663         .get_sset_count         = netdev_get_sset_count,
6664         .get_ethtool_stats      = netdev_get_ethtool_stats,
6665         .get_rx_csum            = netdev_get_rx_csum,
6666         .set_rx_csum            = netdev_set_rx_csum,
6667         .get_tx_csum            = ethtool_op_get_tx_csum,
6668         .set_tx_csum            = ethtool_op_set_tx_csum,
6669         .get_sg                 = ethtool_op_get_sg,
6670         .set_sg                 = ethtool_op_set_sg,
6671 };
6672
6673 /*
6674  * Hardware monitoring
6675  */
6676
6677 static void update_link(struct net_device *dev, struct dev_priv *priv,
6678         struct ksz_port *port)
6679 {
6680         if (priv->media_state != port->linked->state) {
6681                 priv->media_state = port->linked->state;
6682                 if (netif_running(dev))
6683                         set_media_state(dev, media_connected);
6684         }
6685 }
6686
6687 static void mib_read_work(struct work_struct *work)
6688 {
6689         struct dev_info *hw_priv =
6690                 container_of(work, struct dev_info, mib_read);
6691         struct ksz_hw *hw = &hw_priv->hw;
6692         struct ksz_port_mib *mib;
6693         int i;
6694
6695         next_jiffies = jiffies;
6696         for (i = 0; i < hw->mib_port_cnt; i++) {
6697                 mib = &hw->port_mib[i];
6698
6699                 /* Reading MIB counters or requested to read. */
6700                 if (mib->cnt_ptr || 1 == hw_priv->counter[i].read) {
6701
6702                         /* Need to process receive interrupt. */
6703                         if (port_r_cnt(hw, i))
6704                                 break;
6705                         hw_priv->counter[i].read = 0;
6706
6707                         /* Finish reading counters. */
6708                         if (0 == mib->cnt_ptr) {
6709                                 hw_priv->counter[i].read = 2;
6710                                 wake_up_interruptible(
6711                                         &hw_priv->counter[i].counter);
6712                         }
6713                 } else if (jiffies >= hw_priv->counter[i].time) {
6714                         /* Only read MIB counters when the port is connected. */
6715                         if (media_connected ==