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