1
2
3
4
5#include "gmac.h"
6#include "elmer0.h"
7#include "vsc7326_reg.h"
8
9
10#define STATS_TICK_SECS 15
11
12#define MAJOR_UPDATE_TICKS (1800 / STATS_TICK_SECS)
13
14#define MAX_MTU 9600
15
16
17
18
19
20
21#define WM_DISABLE 0x01a01fff
22#define WM_ENABLE 0x014a03F0
23
24struct init_table {
25 u32 addr;
26 u32 data;
27};
28
29struct _cmac_instance {
30 u32 index;
31 u32 ticks;
32};
33
34#define INITBLOCK_SLEEP 0xffffffff
35
36static void vsc_read(adapter_t *adapter, u32 addr, u32 *val)
37{
38 u32 status, vlo, vhi;
39 int i;
40
41 spin_lock_bh(&adapter->mac_lock);
42 t1_tpi_read(adapter, (addr << 2) + 4, &vlo);
43 i = 0;
44 do {
45 t1_tpi_read(adapter, (REG_LOCAL_STATUS << 2) + 4, &vlo);
46 t1_tpi_read(adapter, REG_LOCAL_STATUS << 2, &vhi);
47 status = (vhi << 16) | vlo;
48 i++;
49 } while (((status & 1) == 0) && (i < 50));
50 if (i == 50)
51 pr_err("Invalid tpi read from MAC, breaking loop.\n");
52
53 t1_tpi_read(adapter, (REG_LOCAL_DATA << 2) + 4, &vlo);
54 t1_tpi_read(adapter, REG_LOCAL_DATA << 2, &vhi);
55
56 *val = (vhi << 16) | vlo;
57
58
59
60
61 spin_unlock_bh(&adapter->mac_lock);
62}
63
64static void vsc_write(adapter_t *adapter, u32 addr, u32 data)
65{
66 spin_lock_bh(&adapter->mac_lock);
67 t1_tpi_write(adapter, (addr << 2) + 4, data & 0xFFFF);
68 t1_tpi_write(adapter, addr << 2, (data >> 16) & 0xFFFF);
69
70
71
72 spin_unlock_bh(&adapter->mac_lock);
73}
74
75
76static void vsc7326_full_reset(adapter_t* adapter)
77{
78 u32 val;
79 u32 result = 0xffff;
80
81 t1_tpi_read(adapter, A_ELMER0_GPO, &val);
82 val &= ~1;
83 t1_tpi_write(adapter, A_ELMER0_GPO, val);
84 udelay(2);
85 val |= 0x1;
86 val |= 0x800;
87 t1_tpi_write(adapter, A_ELMER0_GPO, val);
88 mdelay(1);
89 vsc_write(adapter, REG_SW_RESET, 0x80000001);
90 do {
91 mdelay(1);
92 vsc_read(adapter, REG_SW_RESET, &result);
93 } while (result != 0x0);
94}
95
96static struct init_table vsc7326_reset[] = {
97 { REG_IFACE_MODE, 0x00000000 },
98 { REG_CRC_CFG, 0x00000020 },
99 { REG_PLL_CLK_SPEED, 0x00050c00 },
100 { REG_PLL_CLK_SPEED, 0x00050c00 },
101 { REG_MSCH, 0x00002f14 },
102 { REG_SPI4_MISC, 0x00040409 },
103 { REG_SPI4_DESKEW, 0x00080000 },
104 { REG_SPI4_ING_SETUP2, 0x08080004 },
105 { REG_SPI4_ING_SETUP0, 0x04111004 },
106 { REG_SPI4_EGR_SETUP0, 0x80001a04 },
107 { REG_SPI4_ING_SETUP1, 0x02010000 },
108 { REG_AGE_INC(0), 0x00000000 },
109 { REG_AGE_INC(1), 0x00000000 },
110 { REG_ING_CONTROL, 0x0a200011 },
111 { REG_EGR_CONTROL, 0xa0010091 },
112};
113
114static struct init_table vsc7326_portinit[4][22] = {
115 {
116
117 { REG_DBG(0), 0x000004f0 },
118 { REG_HDX(0), 0x00073101 },
119 { REG_TEST(0,0), 0x00000022 },
120 { REG_TEST(1,0), 0x00000022 },
121 { REG_TOP_BOTTOM(0,0), 0x003f0000 },
122 { REG_TOP_BOTTOM(1,0), 0x00120000 },
123 { REG_HIGH_LOW_WM(0,0), 0x07460757 },
124 { REG_HIGH_LOW_WM(1,0), WM_DISABLE },
125 { REG_CT_THRHLD(0,0), 0x00000000 },
126 { REG_CT_THRHLD(1,0), 0x00000000 },
127 { REG_BUCKE(0), 0x0002ffff },
128 { REG_BUCKI(0), 0x0002ffff },
129 { REG_TEST(0,0), 0x00000020 },
130 { REG_TEST(1,0), 0x00000020 },
131
132 { REG_MAX_LEN(0), 0x00002710 },
133 { REG_PORT_FAIL(0), 0x00000002 },
134 { REG_NORMALIZER(0), 0x00000a64 },
135 { REG_DENORM(0), 0x00000010 },
136 { REG_STICK_BIT(0), 0x03baa370 },
137 { REG_DEV_SETUP(0), 0x00000083 },
138 { REG_DEV_SETUP(0), 0x00000082 },
139 { REG_MODE_CFG(0), 0x0200259f },
140 },
141 {
142
143 { REG_DBG(1), 0x000004f0 },
144 { REG_HDX(1), 0x00073101 },
145 { REG_TEST(0,1), 0x00000022 },
146 { REG_TEST(1,1), 0x00000022 },
147 { REG_TOP_BOTTOM(0,1), 0x007e003f },
148 { REG_TOP_BOTTOM(1,1), 0x00240012 },
149 { REG_HIGH_LOW_WM(0,1), 0x07460757 },
150 { REG_HIGH_LOW_WM(1,1), WM_DISABLE },
151 { REG_CT_THRHLD(0,1), 0x00000000 },
152 { REG_CT_THRHLD(1,1), 0x00000000 },
153 { REG_BUCKE(1), 0x0002ffff },
154 { REG_BUCKI(1), 0x0002ffff },
155 { REG_TEST(0,1), 0x00000020 },
156 { REG_TEST(1,1), 0x00000020 },
157
158 { REG_MAX_LEN(1), 0x00002710 },
159 { REG_PORT_FAIL(1), 0x00000002 },
160 { REG_NORMALIZER(1), 0x00000a64 },
161 { REG_DENORM(1), 0x00000010 },
162 { REG_STICK_BIT(1), 0x03baa370 },
163 { REG_DEV_SETUP(1), 0x00000083 },
164 { REG_DEV_SETUP(1), 0x00000082 },
165 { REG_MODE_CFG(1), 0x0200259f },
166 },
167 {
168
169 { REG_DBG(2), 0x000004f0 },
170 { REG_HDX(2), 0x00073101 },
171 { REG_TEST(0,2), 0x00000022 },
172 { REG_TEST(1,2), 0x00000022 },
173 { REG_TOP_BOTTOM(0,2), 0x00bd007e },
174 { REG_TOP_BOTTOM(1,2), 0x00360024 },
175 { REG_HIGH_LOW_WM(0,2), 0x07460757 },
176 { REG_HIGH_LOW_WM(1,2), WM_DISABLE },
177 { REG_CT_THRHLD(0,2), 0x00000000 },
178 { REG_CT_THRHLD(1,2), 0x00000000 },
179 { REG_BUCKE(2), 0x0002ffff },
180 { REG_BUCKI(2), 0x0002ffff },
181 { REG_TEST(0,2), 0x00000020 },
182 { REG_TEST(1,2), 0x00000020 },
183
184 { REG_MAX_LEN(2), 0x00002710 },
185 { REG_PORT_FAIL(2), 0x00000002 },
186 { REG_NORMALIZER(2), 0x00000a64 },
187 { REG_DENORM(2), 0x00000010 },
188 { REG_STICK_BIT(2), 0x03baa370 },
189 { REG_DEV_SETUP(2), 0x00000083 },
190 { REG_DEV_SETUP(2), 0x00000082 },
191 { REG_MODE_CFG(2), 0x0200259f },
192 },
193 {
194
195 { REG_DBG(3), 0x000004f0 },
196 { REG_HDX(3), 0x00073101 },
197 { REG_TEST(0,3), 0x00000022 },
198 { REG_TEST(1,3), 0x00000022 },
199 { REG_TOP_BOTTOM(0,3), 0x00fc00bd },
200 { REG_TOP_BOTTOM(1,3), 0x00480036 },
201 { REG_HIGH_LOW_WM(0,3), 0x07460757 },
202 { REG_HIGH_LOW_WM(1,3), WM_DISABLE },
203 { REG_CT_THRHLD(0,3), 0x00000000 },
204 { REG_CT_THRHLD(1,3), 0x00000000 },
205 { REG_BUCKE(3), 0x0002ffff },
206 { REG_BUCKI(3), 0x0002ffff },
207 { REG_TEST(0,3), 0x00000020 },
208 { REG_TEST(1,3), 0x00000020 },
209
210 { REG_MAX_LEN(3), 0x00002710 },
211 { REG_PORT_FAIL(3), 0x00000002 },
212 { REG_NORMALIZER(3), 0x00000a64 },
213 { REG_DENORM(3), 0x00000010 },
214 { REG_STICK_BIT(3), 0x03baa370 },
215 { REG_DEV_SETUP(3), 0x00000083 },
216 { REG_DEV_SETUP(3), 0x00000082 },
217 { REG_MODE_CFG(3), 0x0200259f },
218 },
219};
220
221static void run_table(adapter_t *adapter, struct init_table *ib, int len)
222{
223 int i;
224
225 for (i = 0; i < len; i++) {
226 if (ib[i].addr == INITBLOCK_SLEEP) {
227 udelay( ib[i].data );
228 pr_err("sleep %d us\n",ib[i].data);
229 } else
230 vsc_write( adapter, ib[i].addr, ib[i].data );
231 }
232}
233
234static int bist_rd(adapter_t *adapter, int moduleid, int address)
235{
236 int data = 0;
237 u32 result = 0;
238
239 if ((address != 0x0) &&
240 (address != 0x1) &&
241 (address != 0x2) &&
242 (address != 0xd) &&
243 (address != 0xe))
244 pr_err("No bist address: 0x%x\n", address);
245
246 data = ((0x00 << 24) | ((address & 0xff) << 16) | (0x00 << 8) |
247 ((moduleid & 0xff) << 0));
248 vsc_write(adapter, REG_RAM_BIST_CMD, data);
249
250 udelay(10);
251
252 vsc_read(adapter, REG_RAM_BIST_RESULT, &result);
253 if ((result & (1 << 9)) != 0x0)
254 pr_err("Still in bist read: 0x%x\n", result);
255 else if ((result & (1 << 8)) != 0x0)
256 pr_err("bist read error: 0x%x\n", result);
257
258 return result & 0xff;
259}
260
261static int bist_wr(adapter_t *adapter, int moduleid, int address, int value)
262{
263 int data = 0;
264 u32 result = 0;
265
266 if ((address != 0x0) &&
267 (address != 0x1) &&
268 (address != 0x2) &&
269 (address != 0xd) &&
270 (address != 0xe))
271 pr_err("No bist address: 0x%x\n", address);
272
273 if (value > 255)
274 pr_err("Suspicious write out of range value: 0x%x\n", value);
275
276 data = ((0x01 << 24) | ((address & 0xff) << 16) | (value << 8) |
277 ((moduleid & 0xff) << 0));
278 vsc_write(adapter, REG_RAM_BIST_CMD, data);
279
280 udelay(5);
281
282 vsc_read(adapter, REG_RAM_BIST_CMD, &result);
283 if ((result & (1 << 27)) != 0x0)
284 pr_err("Still in bist write: 0x%x\n", result);
285 else if ((result & (1 << 26)) != 0x0)
286 pr_err("bist write error: 0x%x\n", result);
287
288 return 0;
289}
290
291static int run_bist(adapter_t *adapter, int moduleid)
292{
293
294 (void) bist_wr(adapter,moduleid, 0x00, 0x02);
295 (void) bist_wr(adapter,moduleid, 0x01, 0x01);
296
297 return 0;
298}
299
300static int check_bist(adapter_t *adapter, int moduleid)
301{
302 int result=0;
303 int column=0;
304
305 result = bist_rd(adapter,moduleid, 0x02);
306 column = ((bist_rd(adapter,moduleid, 0x0e)<<8) +
307 (bist_rd(adapter,moduleid, 0x0d)));
308 if ((result & 3) != 0x3)
309 pr_err("Result: 0x%x BIST error in ram %d, column: 0x%04x\n",
310 result, moduleid, column);
311 return 0;
312}
313
314static int enable_mem(adapter_t *adapter, int moduleid)
315{
316
317 (void) bist_wr(adapter,moduleid, 0x00, 0x00);
318 return 0;
319}
320
321static int run_bist_all(adapter_t *adapter)
322{
323 int port = 0;
324 u32 val = 0;
325
326 vsc_write(adapter, REG_MEM_BIST, 0x5);
327 vsc_read(adapter, REG_MEM_BIST, &val);
328
329 for (port = 0; port < 12; port++)
330 vsc_write(adapter, REG_DEV_SETUP(port), 0x0);
331
332 udelay(300);
333 vsc_write(adapter, REG_SPI4_MISC, 0x00040409);
334 udelay(300);
335
336 (void) run_bist(adapter,13);
337 (void) run_bist(adapter,14);
338 (void) run_bist(adapter,20);
339 (void) run_bist(adapter,21);
340 mdelay(200);
341 (void) check_bist(adapter,13);
342 (void) check_bist(adapter,14);
343 (void) check_bist(adapter,20);
344 (void) check_bist(adapter,21);
345 udelay(100);
346 (void) enable_mem(adapter,13);
347 (void) enable_mem(adapter,14);
348 (void) enable_mem(adapter,20);
349 (void) enable_mem(adapter,21);
350 udelay(300);
351 vsc_write(adapter, REG_SPI4_MISC, 0x60040400);
352 udelay(300);
353 for (port = 0; port < 12; port++)
354 vsc_write(adapter, REG_DEV_SETUP(port), 0x1);
355
356 udelay(300);
357 vsc_write(adapter, REG_MEM_BIST, 0x0);
358 mdelay(10);
359 return 0;
360}
361
362static int mac_intr_handler(struct cmac *mac)
363{
364 return 0;
365}
366
367static int mac_intr_enable(struct cmac *mac)
368{
369 return 0;
370}
371
372static int mac_intr_disable(struct cmac *mac)
373{
374 return 0;
375}
376
377static int mac_intr_clear(struct cmac *mac)
378{
379 return 0;
380}
381
382
383static int mac_set_address(struct cmac* mac, u8 addr[6])
384{
385 u32 val;
386 int port = mac->instance->index;
387
388 vsc_write(mac->adapter, REG_MAC_LOW_ADDR(port),
389 (addr[3] << 16) | (addr[4] << 8) | addr[5]);
390 vsc_write(mac->adapter, REG_MAC_HIGH_ADDR(port),
391 (addr[0] << 16) | (addr[1] << 8) | addr[2]);
392
393 vsc_read(mac->adapter, REG_ING_FFILT_UM_EN, &val);
394 val &= ~0xf0000000;
395 vsc_write(mac->adapter, REG_ING_FFILT_UM_EN, val | (port << 28));
396
397 vsc_write(mac->adapter, REG_ING_FFILT_MASK0,
398 0xffff0000 | (addr[4] << 8) | addr[5]);
399 vsc_write(mac->adapter, REG_ING_FFILT_MASK1,
400 0xffff0000 | (addr[2] << 8) | addr[3]);
401 vsc_write(mac->adapter, REG_ING_FFILT_MASK2,
402 0xffff0000 | (addr[0] << 8) | addr[1]);
403 return 0;
404}
405
406static int mac_get_address(struct cmac *mac, u8 addr[6])
407{
408 u32 addr_lo, addr_hi;
409 int port = mac->instance->index;
410
411 vsc_read(mac->adapter, REG_MAC_LOW_ADDR(port), &addr_lo);
412 vsc_read(mac->adapter, REG_MAC_HIGH_ADDR(port), &addr_hi);
413
414 addr[0] = (u8) (addr_hi >> 16);
415 addr[1] = (u8) (addr_hi >> 8);
416 addr[2] = (u8) addr_hi;
417 addr[3] = (u8) (addr_lo >> 16);
418 addr[4] = (u8) (addr_lo >> 8);
419 addr[5] = (u8) addr_lo;
420 return 0;
421}
422
423
424static int mac_reset(struct cmac *mac)
425{
426 int index = mac->instance->index;
427
428 run_table(mac->adapter, vsc7326_portinit[index],
429 ARRAY_SIZE(vsc7326_portinit[index]));
430
431 return 0;
432}
433
434static int mac_set_rx_mode(struct cmac *mac, struct t1_rx_mode *rm)
435{
436 u32 v;
437 int port = mac->instance->index;
438
439 vsc_read(mac->adapter, REG_ING_FFILT_UM_EN, &v);
440 v |= 1 << 12;
441
442 if (t1_rx_mode_promisc(rm))
443 v &= ~(1 << (port + 16));
444 else
445 v |= 1 << (port + 16);
446
447 vsc_write(mac->adapter, REG_ING_FFILT_UM_EN, v);
448 return 0;
449}
450
451static int mac_set_mtu(struct cmac *mac, int mtu)
452{
453 int port = mac->instance->index;
454
455 if (mtu > MAX_MTU)
456 return -EINVAL;
457
458
459 vsc_write(mac->adapter, REG_MAX_LEN(port), mtu + 14 + 4);
460 return 0;
461}
462
463static int mac_set_speed_duplex_fc(struct cmac *mac, int speed, int duplex,
464 int fc)
465{
466 u32 v;
467 int enable, port = mac->instance->index;
468
469 if (speed >= 0 && speed != SPEED_10 && speed != SPEED_100 &&
470 speed != SPEED_1000)
471 return -1;
472 if (duplex > 0 && duplex != DUPLEX_FULL)
473 return -1;
474
475 if (speed >= 0) {
476 vsc_read(mac->adapter, REG_MODE_CFG(port), &v);
477 enable = v & 3;
478 v &= ~0xf;
479 v |= 4;
480 if (speed == SPEED_1000)
481 v |= 8;
482 enable |= v;
483 vsc_write(mac->adapter, REG_MODE_CFG(port), v);
484
485 if (speed == SPEED_1000)
486 v = 0x82;
487 else if (speed == SPEED_100)
488 v = 0x84;
489 else
490 v = 0x86;
491 vsc_write(mac->adapter, REG_DEV_SETUP(port), v | 1);
492 vsc_write(mac->adapter, REG_DEV_SETUP(port), v);
493 vsc_read(mac->adapter, REG_DBG(port), &v);
494 v &= ~0xff00;
495 if (speed == SPEED_1000)
496 v |= 0x400;
497 else if (speed == SPEED_100)
498 v |= 0x2000;
499 else
500 v |= 0xff00;
501 vsc_write(mac->adapter, REG_DBG(port), v);
502
503 vsc_write(mac->adapter, REG_TX_IFG(port),
504 speed == SPEED_1000 ? 5 : 0x11);
505 if (duplex == DUPLEX_HALF)
506 enable = 0x0;
507 else if (speed == SPEED_1000)
508 enable = 0xc;
509 else
510 enable = 0x4;
511 enable |= 0x9 << 10;
512 enable |= 0x6 << 6;
513 enable |= 0x1 << 4;
514 enable |= 0x3;
515 vsc_write(mac->adapter, REG_MODE_CFG(port), enable);
516
517 }
518
519 vsc_read(mac->adapter, REG_PAUSE_CFG(port), &v);
520 v &= 0xfff0ffff;
521 v |= 0x20000;
522 if (fc & PAUSE_RX)
523 v |= 0x40000;
524 if (fc & PAUSE_TX)
525 v |= 0x80000;
526 if (fc == (PAUSE_RX | PAUSE_TX))
527 v |= 0x10000;
528 vsc_write(mac->adapter, REG_PAUSE_CFG(port), v);
529 return 0;
530}
531
532static int mac_enable(struct cmac *mac, int which)
533{
534 u32 val;
535 int port = mac->instance->index;
536
537
538 vsc_write(mac->adapter, REG_HIGH_LOW_WM(1,port), WM_ENABLE);
539
540 vsc_read(mac->adapter, REG_MODE_CFG(port), &val);
541 if (which & MAC_DIRECTION_RX)
542 val |= 0x2;
543 if (which & MAC_DIRECTION_TX)
544 val |= 1;
545 vsc_write(mac->adapter, REG_MODE_CFG(port), val);
546 return 0;
547}
548
549static int mac_disable(struct cmac *mac, int which)
550{
551 u32 val;
552 int i, port = mac->instance->index;
553
554
555 mac_reset(mac);
556
557 vsc_read(mac->adapter, REG_MODE_CFG(port), &val);
558 if (which & MAC_DIRECTION_RX)
559 val &= ~0x2;
560 if (which & MAC_DIRECTION_TX)
561 val &= ~0x1;
562 vsc_write(mac->adapter, REG_MODE_CFG(port), val);
563 vsc_read(mac->adapter, REG_MODE_CFG(port), &val);
564
565
566 for (i = 0; i <= 0x3a; ++i)
567 vsc_write(mac->adapter, CRA(4, port, i), 0);
568
569
570 memset(&mac->stats, 0, sizeof(struct cmac_statistics));
571
572 return 0;
573}
574
575static void rmon_update(struct cmac *mac, unsigned int addr, u64 *stat)
576{
577 u32 v, lo;
578
579 vsc_read(mac->adapter, addr, &v);
580 lo = *stat;
581 *stat = *stat - lo + v;
582
583 if (v == 0)
584 return;
585
586 if (v < lo)
587 *stat += (1ULL << 32);
588}
589
590static void port_stats_update(struct cmac *mac)
591{
592 struct {
593 unsigned int reg;
594 unsigned int offset;
595 } hw_stats[] = {
596
597#define HW_STAT(reg, stat_name) \
598 { reg, (&((struct cmac_statistics *)NULL)->stat_name) - (u64 *)NULL }
599
600
601 HW_STAT(RxUnicast, RxUnicastFramesOK),
602 HW_STAT(RxMulticast, RxMulticastFramesOK),
603 HW_STAT(RxBroadcast, RxBroadcastFramesOK),
604 HW_STAT(Crc, RxFCSErrors),
605 HW_STAT(RxAlignment, RxAlignErrors),
606 HW_STAT(RxOversize, RxFrameTooLongErrors),
607 HW_STAT(RxPause, RxPauseFrames),
608 HW_STAT(RxJabbers, RxJabberErrors),
609 HW_STAT(RxFragments, RxRuntErrors),
610 HW_STAT(RxUndersize, RxRuntErrors),
611 HW_STAT(RxSymbolCarrier, RxSymbolErrors),
612 HW_STAT(RxSize1519ToMax, RxJumboFramesOK),
613
614
615 HW_STAT(TxUnicast, TxUnicastFramesOK),
616 HW_STAT(TxMulticast, TxMulticastFramesOK),
617 HW_STAT(TxBroadcast, TxBroadcastFramesOK),
618 HW_STAT(TxPause, TxPauseFrames),
619 HW_STAT(TxUnderrun, TxUnderrun),
620 HW_STAT(TxSize1519ToMax, TxJumboFramesOK),
621 }, *p = hw_stats;
622 unsigned int port = mac->instance->index;
623 u64 *stats = (u64 *)&mac->stats;
624 unsigned int i;
625
626 for (i = 0; i < ARRAY_SIZE(hw_stats); i++)
627 rmon_update(mac, CRA(0x4, port, p->reg), stats + p->offset);
628
629 rmon_update(mac, REG_TX_OK_BYTES(port), &mac->stats.TxOctetsOK);
630 rmon_update(mac, REG_RX_OK_BYTES(port), &mac->stats.RxOctetsOK);
631 rmon_update(mac, REG_RX_BAD_BYTES(port), &mac->stats.RxOctetsBad);
632}
633
634
635
636
637
638
639
640
641
642
643static const struct cmac_statistics *mac_update_statistics(struct cmac *mac,
644 int flag)
645{
646 if (flag == MAC_STATS_UPDATE_FULL ||
647 mac->instance->ticks >= MAJOR_UPDATE_TICKS) {
648 port_stats_update(mac);
649 mac->instance->ticks = 0;
650 } else {
651 int port = mac->instance->index;
652
653 rmon_update(mac, REG_RX_OK_BYTES(port),
654 &mac->stats.RxOctetsOK);
655 rmon_update(mac, REG_RX_BAD_BYTES(port),
656 &mac->stats.RxOctetsBad);
657 rmon_update(mac, REG_TX_OK_BYTES(port),
658 &mac->stats.TxOctetsOK);
659 mac->instance->ticks++;
660 }
661 return &mac->stats;
662}
663
664static void mac_destroy(struct cmac *mac)
665{
666 kfree(mac);
667}
668
669static const struct cmac_ops vsc7326_ops = {
670 .destroy = mac_destroy,
671 .reset = mac_reset,
672 .interrupt_handler = mac_intr_handler,
673 .interrupt_enable = mac_intr_enable,
674 .interrupt_disable = mac_intr_disable,
675 .interrupt_clear = mac_intr_clear,
676 .enable = mac_enable,
677 .disable = mac_disable,
678 .set_mtu = mac_set_mtu,
679 .set_rx_mode = mac_set_rx_mode,
680 .set_speed_duplex_fc = mac_set_speed_duplex_fc,
681 .statistics_update = mac_update_statistics,
682 .macaddress_get = mac_get_address,
683 .macaddress_set = mac_set_address,
684};
685
686static struct cmac *vsc7326_mac_create(adapter_t *adapter, int index)
687{
688 struct cmac *mac;
689 u32 val;
690 int i;
691
692 mac = kzalloc(sizeof(*mac) + sizeof(cmac_instance), GFP_KERNEL);
693 if (!mac)
694 return NULL;
695
696 mac->ops = &vsc7326_ops;
697 mac->instance = (cmac_instance *)(mac + 1);
698 mac->adapter = adapter;
699
700 mac->instance->index = index;
701 mac->instance->ticks = 0;
702
703 i = 0;
704 do {
705 u32 vhi, vlo;
706
707 vhi = vlo = 0;
708 t1_tpi_read(adapter, (REG_LOCAL_STATUS << 2) + 4, &vlo);
709 udelay(1);
710 t1_tpi_read(adapter, REG_LOCAL_STATUS << 2, &vhi);
711 udelay(5);
712 val = (vhi << 16) | vlo;
713 } while ((++i < 10000) && (val == 0xffffffff));
714
715 return mac;
716}
717
718static int vsc7326_mac_reset(adapter_t *adapter)
719{
720 vsc7326_full_reset(adapter);
721 (void) run_bist_all(adapter);
722 run_table(adapter, vsc7326_reset, ARRAY_SIZE(vsc7326_reset));
723 return 0;
724}
725
726const struct gmac t1_vsc7326_ops = {
727 .stats_update_period = STATS_TICK_SECS,
728 .create = vsc7326_mac_create,
729 .reset = vsc7326_mac_reset,
730};
731
