projects / openwrt / svn-archive / archive.git / blob
? search:


292785701063d890158a3ffae45dc0ce3f0efd8c
[openwrt/svn-archive/archive.git] / target / linux / ar71xx / files / drivers / net / phy / rtl8366_smi.c
1 /*
2 * Platform driver for the Realtek RTL8366 ethernet switch
3 *
4 * Copyright (C) 2009 Gabor Juhos <juhosg@openwrt.org>
5 * Copyright (C) 2010 Antti Seppälä <a.seppala@gmail.com>
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License version 2 as published
9 * by the Free Software Foundation.
10 */
11
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/platform_device.h>
16 #include <linux/delay.h>
17 #include <linux/gpio.h>
18 #include <linux/spinlock.h>
19 #include <linux/skbuff.h>
20 #include <linux/switch.h>
21 #include <linux/phy.h>
22 #include <linux/rtl8366_smi.h>
23
24 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
25 #include <linux/debugfs.h>
26 #endif
27
28 #define RTL8366_SMI_DRIVER_NAME "rtl8366-smi"
29 #define RTL8366_SMI_DRIVER_DESC "Realtek RTL8366 switch driver"
30 #define RTL8366_SMI_DRIVER_VER "0.1.1"
31
32 #define RTL8366S_PHY_NO_MAX 4
33 #define RTL8366S_PHY_PAGE_MAX 7
34 #define RTL8366S_PHY_ADDR_MAX 31
35
36 #define RTL8366_CHIP_GLOBAL_CTRL_REG 0x0000
37 #define RTL8366_CHIP_CTRL_VLAN (1 << 13)
38
39 #define RTL8366_RESET_CTRL_REG 0x0100
40 #define RTL8366_CHIP_CTRL_RESET_HW 1
41 #define RTL8366_CHIP_CTRL_RESET_SW (1 << 1)
42
43 #define RTL8366S_CHIP_VERSION_CTRL_REG 0x0104
44 #define RTL8366S_CHIP_VERSION_MASK 0xf
45 #define RTL8366S_CHIP_ID_REG 0x0105
46 #define RTL8366S_CHIP_ID_8366 0x8366
47
48 /* PHY registers control */
49 #define RTL8366S_PHY_ACCESS_CTRL_REG 0x8028
50 #define RTL8366S_PHY_ACCESS_DATA_REG 0x8029
51
52 #define RTL8366S_PHY_CTRL_READ 1
53 #define RTL8366S_PHY_CTRL_WRITE 0
54
55 #define RTL8366S_PHY_REG_MASK 0x1f
56 #define RTL8366S_PHY_PAGE_OFFSET 5
57 #define RTL8366S_PHY_PAGE_MASK (0x7 << 5)
58 #define RTL8366S_PHY_NO_OFFSET 9
59 #define RTL8366S_PHY_NO_MASK (0x1f << 9)
60
61 #define RTL8366_SMI_ACK_RETRY_COUNT 5
62 #define RTL8366_SMI_CLK_DELAY 10 /* nsec */
63
64 /* LED control registers */
65 #define RTL8366_LED_BLINKRATE_REG 0x0420
66 #define RTL8366_LED_BLINKRATE_BIT 0
67 #define RTL8366_LED_BLINKRATE_MASK 0x0007
68
69 #define RTL8366_LED_CTRL_REG 0x0421
70 #define RTL8366_LED_0_1_CTRL_REG 0x0422
71 #define RTL8366_LED_2_3_CTRL_REG 0x0423
72
73 #define RTL8366S_MIB_COUNT 33
74 #define RTL8366S_GLOBAL_MIB_COUNT 1
75 #define RTL8366S_MIB_COUNTER_PORT_OFFSET 0x0040
76 #define RTL8366S_MIB_COUNTER_BASE 0x1000
77 #define RTL8366S_MIB_CTRL_REG 0x11F0
78 #define RTL8366S_MIB_CTRL_USER_MASK 0x01FF
79 #define RTL8366S_MIB_CTRL_BUSY_MASK 0x0001
80 #define RTL8366S_MIB_CTRL_RESET_MASK 0x0002
81
82 #define RTL8366S_MIB_CTRL_GLOBAL_RESET_MASK 0x0004
83 #define RTL8366S_MIB_CTRL_PORT_RESET_BIT 0x0003
84 #define RTL8366S_MIB_CTRL_PORT_RESET_MASK 0x01FC
85
86
87 #define RTL8366S_PORT_VLAN_CTRL_BASE 0x0058
88 #define RTL8366S_PORT_VLAN_CTRL_REG(_p) \
89 (RTL8366S_PORT_VLAN_CTRL_BASE + (_p) / 4)
90 #define RTL8366S_PORT_VLAN_CTRL_MASK 0xf
91 #define RTL8366S_PORT_VLAN_CTRL_SHIFT(_p) (4 * ((_p) % 4))
92
93
94 #define RTL8366S_VLAN_TABLE_READ_BASE 0x018B
95 #define RTL8366S_VLAN_TABLE_WRITE_BASE 0x0185
96
97 #define RTL8366S_VLAN_TB_CTRL_REG 0x010F
98
99 #define RTL8366S_TABLE_ACCESS_CTRL_REG 0x0180
100 #define RTL8366S_TABLE_VLAN_READ_CTRL 0x0E01
101 #define RTL8366S_TABLE_VLAN_WRITE_CTRL 0x0F01
102
103 #define RTL8366S_VLAN_MEMCONF_BASE 0x0016
104
105
106 #define RTL8366S_PORT_LINK_STATUS_BASE 0x0060
107 #define RTL8366S_PORT_STATUS_SPEED_MASK 0x0003
108 #define RTL8366S_PORT_STATUS_DUPLEX_MASK 0x0004
109 #define RTL8366S_PORT_STATUS_LINK_MASK 0x0010
110 #define RTL8366S_PORT_STATUS_TXPAUSE_MASK 0x0020
111 #define RTL8366S_PORT_STATUS_RXPAUSE_MASK 0x0040
112 #define RTL8366S_PORT_STATUS_AN_MASK 0x0080
113
114
115 #define RTL8366_PORT_NUM_CPU 5
116 #define RTL8366_NUM_PORTS 6
117 #define RTL8366_NUM_VLANS 16
118 #define RTL8366_NUM_LEDGROUPS 4
119 #define RTL8366_NUM_VIDS 4096
120 #define RTL8366S_PRIORITYMAX 7
121 #define RTL8366S_FIDMAX 7
122
123
124 #define RTL8366_PORT_1 (1 << 0) /* In userspace port 0 */
125 #define RTL8366_PORT_2 (1 << 1) /* In userspace port 1 */
126 #define RTL8366_PORT_3 (1 << 2) /* In userspace port 2 */
127 #define RTL8366_PORT_4 (1 << 3) /* In userspace port 3 */
128
129 #define RTL8366_PORT_UNKNOWN (1 << 4) /* No known connection */
130 #define RTL8366_PORT_CPU (1 << 5) /* CPU port */
131
132 #define RTL8366_PORT_ALL (RTL8366_PORT_1 | \
133 RTL8366_PORT_2 | \
134 RTL8366_PORT_3 | \
135 RTL8366_PORT_4 | \
136 RTL8366_PORT_UNKNOWN | \
137 RTL8366_PORT_CPU)
138
139 #define RTL8366_PORT_ALL_BUT_CPU (RTL8366_PORT_1 | \
140 RTL8366_PORT_2 | \
141 RTL8366_PORT_3 | \
142 RTL8366_PORT_4 | \
143 RTL8366_PORT_UNKNOWN)
144
145 #define RTL8366_PORT_ALL_EXTERNAL (RTL8366_PORT_1 | \
146 RTL8366_PORT_2 | \
147 RTL8366_PORT_3 | \
148 RTL8366_PORT_4)
149
150 #define RTL8366_PORT_ALL_INTERNAL (RTL8366_PORT_UNKNOWN | \
151 RTL8366_PORT_CPU)
152
153 struct rtl8366s_vlanconfig {
154 u16 reserved2:1;
155 u16 priority:3;
156 u16 vid:12;
157
158 u16 reserved1:1;
159 u16 fid:3;
160 u16 untag:6;
161 u16 member:6;
162 };
163
164 struct rtl8366s_vlan4kentry {
165 u16 reserved1:4;
166 u16 vid:12;
167
168 u16 reserved2:1;
169 u16 fid:3;
170 u16 untag:6;
171 u16 member:6;
172 };
173
174 static const char *MIBCOUNTERS[] = {
175 "IfInOctets ",
176 "EtherStatsOctets ",
177 "EtherStatsUnderSizePkts ",
178 "EtherFregament ",
179 "EtherStatsPkts64Octets ",
180 "EtherStatsPkts65to127Octets ",
181 "EtherStatsPkts128to255Octets ",
182 "EtherStatsPkts256to511Octets ",
183 "EtherStatsPkts512to1023Octets ",
184 "EtherStatsPkts1024to1518Octets ",
185 "EtherOversizeStats ",
186 "EtherStatsJabbers ",
187 "IfInUcastPkts ",
188 "EtherStatsMulticastPkts ",
189 "EtherStatsBroadcastPkts ",
190 "EtherStatsDropEvents ",
191 "Dot3StatsFCSErrors ",
192 "Dot3StatsSymbolErrors ",
193 "Dot3InPauseFrames ",
194 "Dot3ControlInUnknownOpcodes ",
195 "IfOutOctets ",
196 "Dot3StatsSingleCollisionFrames ",
197 "Dot3StatMultipleCollisionFrames ",
198 "Dot3sDeferredTransmissions ",
199 "Dot3StatsLateCollisions ",
200 "EtherStatsCollisions ",
201 "Dot3StatsExcessiveCollisions ",
202 "Dot3OutPauseFrames ",
203 "Dot1dBasePortDelayExceededDiscards",
204 "Dot1dTpPortInDiscards ",
205 "IfOutUcastPkts ",
206 "IfOutMulticastPkts ",
207 "IfOutBroadcastPkts ",
208 NULL,
209 };
210
211 struct rtl8366_smi {
212 struct platform_device *pdev;
213 struct rtl8366_smi_platform_data *pdata;
214 spinlock_t lock;
215 struct mii_bus *mii_bus;
216 struct switch_dev dev;
217 int mii_irq[PHY_MAX_ADDR];
218 char buf[4096];
219 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
220 struct dentry *debugfs_root;
221 #endif
222 };
223
224 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
225 u16 g_dbg_reg;
226 #endif
227
228 static inline struct rtl8366_smi *sw_to_rtl8366(struct switch_dev *sw)
229 {
230 return container_of(sw, struct rtl8366_smi, dev);
231 }
232
233 static inline void rtl8366_smi_clk_delay(struct rtl8366_smi *smi)
234 {
235 ndelay(RTL8366_SMI_CLK_DELAY);
236 }
237
238 static void rtl8366_smi_start(struct rtl8366_smi *smi)
239 {
240 unsigned int sda = smi->pdata->gpio_sda;
241 unsigned int sck = smi->pdata->gpio_sck;
242
243 /*
244 * Set GPIO pins to output mode, with initial state:
245 * SCK = 0, SDA = 1
246 */
247 gpio_direction_output(sck, 0);
248 gpio_direction_output(sda, 1);
249 rtl8366_smi_clk_delay(smi);
250
251 /* CLK 1: 0 -> 1, 1 -> 0 */
252 gpio_set_value(sck, 1);
253 rtl8366_smi_clk_delay(smi);
254 gpio_set_value(sck, 0);
255 rtl8366_smi_clk_delay(smi);
256
257 /* CLK 2: */
258 gpio_set_value(sck, 1);
259 rtl8366_smi_clk_delay(smi);
260 gpio_set_value(sda, 0);
261 rtl8366_smi_clk_delay(smi);
262 gpio_set_value(sck, 0);
263 rtl8366_smi_clk_delay(smi);
264 gpio_set_value(sda, 1);
265 }
266
267 static void rtl8366_smi_stop(struct rtl8366_smi *smi)
268 {
269 unsigned int sda = smi->pdata->gpio_sda;
270 unsigned int sck = smi->pdata->gpio_sck;
271
272 rtl8366_smi_clk_delay(smi);
273 gpio_set_value(sda, 0);
274 gpio_set_value(sck, 1);
275 rtl8366_smi_clk_delay(smi);
276 gpio_set_value(sda, 1);
277 rtl8366_smi_clk_delay(smi);
278 gpio_set_value(sck, 1);
279 rtl8366_smi_clk_delay(smi);
280 gpio_set_value(sck, 0);
281 rtl8366_smi_clk_delay(smi);
282 gpio_set_value(sck, 1);
283
284 /* add a click */
285 rtl8366_smi_clk_delay(smi);
286 gpio_set_value(sck, 0);
287 rtl8366_smi_clk_delay(smi);
288 gpio_set_value(sck, 1);
289
290 /* set GPIO pins to input mode */
291 gpio_direction_input(sda);
292 gpio_direction_input(sck);
293 }
294
295 static void rtl8366_smi_write_bits(struct rtl8366_smi *smi, u32 data, u32 len)
296 {
297 unsigned int sda = smi->pdata->gpio_sda;
298 unsigned int sck = smi->pdata->gpio_sck;
299
300 for (; len > 0; len--) {
301 rtl8366_smi_clk_delay(smi);
302
303 /* prepare data */
304 if ( data & ( 1 << (len - 1)) )
305 gpio_set_value(sda, 1);
306 else
307 gpio_set_value(sda, 0);
308 rtl8366_smi_clk_delay(smi);
309
310 /* clocking */
311 gpio_set_value(sck, 1);
312 rtl8366_smi_clk_delay(smi);
313 gpio_set_value(sck, 0);
314 }
315 }
316
317 static void rtl8366_smi_read_bits(struct rtl8366_smi *smi, u32 len, u32 *data)
318 {
319 unsigned int sda = smi->pdata->gpio_sda;
320 unsigned int sck = smi->pdata->gpio_sck;
321
322 gpio_direction_input(sda);
323
324 for (*data = 0; len > 0; len--) {
325 u32 u;
326
327 rtl8366_smi_clk_delay(smi);
328
329 /* clocking */
330 gpio_set_value(sck, 1);
331 rtl8366_smi_clk_delay(smi);
332 u = gpio_get_value(sda);
333 gpio_set_value(sck, 0);
334
335 *data |= (u << (len - 1));
336 }
337
338 gpio_direction_output(sda, 0);
339 }
340
341 static int rtl8366_smi_wait_for_ack(struct rtl8366_smi *smi)
342 {
343 int retry_cnt;
344
345 retry_cnt = 0;
346 do {
347 u32 ack;
348
349 rtl8366_smi_read_bits(smi, 1, &ack);
350 if (ack == 0)
351 break;
352
353 if (++retry_cnt > RTL8366_SMI_ACK_RETRY_COUNT)
354 return -EIO;
355 } while (1);
356
357 return 0;
358 }
359
360 static int rtl8366_smi_write_byte(struct rtl8366_smi *smi, u8 data)
361 {
362 rtl8366_smi_write_bits(smi, data, 8);
363 return rtl8366_smi_wait_for_ack(smi);
364 }
365
366 static int rtl8366_smi_read_byte0(struct rtl8366_smi *smi, u8 *data)
367 {
368 u32 t;
369
370 /* read data */
371 rtl8366_smi_read_bits(smi, 8, &t);
372 *data = (t & 0xff);
373
374 /* send an ACK */
375 rtl8366_smi_write_bits(smi, 0x00, 1);
376
377 return 0;
378 }
379
380 static int rtl8366_smi_read_byte1(struct rtl8366_smi *smi, u8 *data)
381 {
382 u32 t;
383
384 /* read data */
385 rtl8366_smi_read_bits(smi, 8, &t);
386 *data = (t & 0xff);
387
388 /* send an ACK */
389 rtl8366_smi_write_bits(smi, 0x01, 1);
390
391 return 0;
392 }
393
394 static int rtl8366_smi_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data)
395 {
396 unsigned long flags;
397 u8 lo = 0;
398 u8 hi = 0;
399 int ret;
400
401 spin_lock_irqsave(&smi->lock, flags);
402
403 rtl8366_smi_start(smi);
404
405 /* send READ command */
406 ret = rtl8366_smi_write_byte(smi, 0x0a << 4 | 0x04 << 1 | 0x01);
407 if (ret)
408 goto out;
409
410 /* set ADDR[7:0] */
411 ret = rtl8366_smi_write_byte(smi, addr & 0xff);
412 if (ret)
413 goto out;
414
415 /* set ADDR[15:8] */
416 ret = rtl8366_smi_write_byte(smi, addr >> 8);
417 if (ret)
418 goto out;
419
420 /* read DATA[7:0] */
421 rtl8366_smi_read_byte0(smi, &lo);
422 /* read DATA[15:8] */
423 rtl8366_smi_read_byte1(smi, &hi);
424
425 *data = ((u32) lo) | (((u32) hi) << 8);
426
427 ret = 0;
428
429 out:
430 rtl8366_smi_stop(smi);
431 spin_unlock_irqrestore(&smi->lock, flags);
432
433 return ret;
434 }
435
436 static int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
437 {
438 unsigned long flags;
439 int ret;
440
441 spin_lock_irqsave(&smi->lock, flags);
442
443 rtl8366_smi_start(smi);
444
445 /* send WRITE command */
446 ret = rtl8366_smi_write_byte(smi, 0x0a << 4 | 0x04 << 1 | 0x00);
447 if (ret)
448 goto out;
449
450 /* set ADDR[7:0] */
451 ret = rtl8366_smi_write_byte(smi, addr & 0xff);
452 if (ret)
453 goto out;
454
455 /* set ADDR[15:8] */
456 ret = rtl8366_smi_write_byte(smi, addr >> 8);
457 if (ret)
458 goto out;
459
460 /* write DATA[7:0] */
461 ret = rtl8366_smi_write_byte(smi, data & 0xff);
462 if (ret)
463 goto out;
464
465 /* write DATA[15:8] */
466 ret = rtl8366_smi_write_byte(smi, data >> 8);
467 if (ret)
468 goto out;
469
470 ret = 0;
471
472 out:
473 rtl8366_smi_stop(smi);
474 spin_unlock_irqrestore(&smi->lock, flags);
475
476 return ret;
477 }
478
479 static int rtl8366_smi_read_phy_reg(struct rtl8366_smi *smi,
480 u32 phy_no, u32 page, u32 addr, u32 *data)
481 {
482 u32 reg;
483 int ret;
484
485 if (phy_no > RTL8366S_PHY_NO_MAX)
486 return -EINVAL;
487
488 if (page > RTL8366S_PHY_PAGE_MAX)
489 return -EINVAL;
490
491 if (addr > RTL8366S_PHY_ADDR_MAX)
492 return -EINVAL;
493
494 ret = rtl8366_smi_write_reg(smi, RTL8366S_PHY_ACCESS_CTRL_REG,
495 RTL8366S_PHY_CTRL_READ);
496 if (ret)
497 return ret;
498
499 reg = 0x8000 | (1 << (phy_no + RTL8366S_PHY_NO_OFFSET)) |
500 ((page << RTL8366S_PHY_PAGE_OFFSET) & RTL8366S_PHY_PAGE_MASK) |
501 (addr & RTL8366S_PHY_REG_MASK);
502
503 ret = rtl8366_smi_write_reg(smi, reg, 0);
504 if (ret)
505 return ret;
506
507 ret = rtl8366_smi_read_reg(smi, RTL8366S_PHY_ACCESS_DATA_REG, data);
508 if (ret)
509 return ret;
510
511 return 0;
512 }
513
514 static int rtl8366_smi_write_phy_reg(struct rtl8366_smi *smi,
515 u32 phy_no, u32 page, u32 addr, u32 data)
516 {
517 u32 reg;
518 int ret;
519
520 if (phy_no > RTL8366S_PHY_NO_MAX)
521 return -EINVAL;
522
523 if (page > RTL8366S_PHY_PAGE_MAX)
524 return -EINVAL;
525
526 if (addr > RTL8366S_PHY_ADDR_MAX)
527 return -EINVAL;
528
529 ret = rtl8366_smi_write_reg(smi, RTL8366S_PHY_ACCESS_CTRL_REG,
530 RTL8366S_PHY_CTRL_WRITE);
531 if (ret)
532 return ret;
533
534 reg = 0x8000 | (1 << (phy_no + RTL8366S_PHY_NO_OFFSET)) |
535 ((page << RTL8366S_PHY_PAGE_OFFSET) & RTL8366S_PHY_PAGE_MASK) |
536 (addr & RTL8366S_PHY_REG_MASK);
537
538 ret = rtl8366_smi_write_reg(smi, reg, data);
539 if (ret)
540 return ret;
541
542 return 0;
543 }
544
545 static int rtl8366_get_mib_counter(struct rtl8366_smi *smi, int counter,
546 int port, unsigned long long *val)
547 {
548 int i;
549 int err;
550 u32 addr, data, regoffset;
551 u64 mibvalue;
552
553 /* address offset to MIBs counter */
554 const u16 mibLength[RTL8366S_MIB_COUNT] = {4, 4, 2, 2, 2, 2, 2, 2, 2,
555 2, 2, 2, 2, 2, 2, 2, 2, 2,
556 2, 2, 4, 2, 2, 2, 2, 2, 2,
557 2, 2, 2, 2, 2, 2};
558
559 if (port > RTL8366_NUM_PORTS || counter >= RTL8366S_MIB_COUNT)
560 return -EINVAL;
561
562 regoffset = RTL8366S_MIB_COUNTER_PORT_OFFSET * (port);
563
564 for (i = 0; i < counter; i++)
565 regoffset += mibLength[i];
566
567 addr = RTL8366S_MIB_COUNTER_BASE + regoffset;
568
569 /*
570 * Writing access counter address first
571 * then ASIC will prepare 64bits counter wait for being retrived
572 */
573 data = 0; /* writing data will be discard by ASIC */
574 err = rtl8366_smi_write_reg(smi, addr, data);
575 if (err)
576 return err;
577
578 /* read MIB control register */
579 err = rtl8366_smi_read_reg(smi, RTL8366S_MIB_CTRL_REG, &data);
580 if (err)
581 return err;
582
583 if (data & RTL8366S_MIB_CTRL_BUSY_MASK)
584 return -EBUSY;
585
586 if (data & RTL8366S_MIB_CTRL_RESET_MASK)
587 return -EIO;
588
589 mibvalue = 0;
590 addr = addr + mibLength[counter] - 1;
591 i = mibLength[counter];
592
593 while (i) {
594 err = rtl8366_smi_read_reg(smi, addr, &data);
595 if (err)
596 return err;
597
598 mibvalue = (mibvalue << 16) | (data & 0xFFFF);
599
600 addr--;
601 i--;
602 }
603
604 *val = mibvalue;
605 return 0;
606 }
607
608 static int rtl8366s_get_vlan_4k_entry(struct rtl8366_smi *smi, u32 vid,
609 struct rtl8366s_vlan4kentry *vlan4k)
610 {
611 int err;
612 u32 data;
613 u16 *tableaddr;
614
615 memset(vlan4k, '\0', sizeof(struct rtl8366s_vlan4kentry));
616 vlan4k->vid = vid;
617
618 if (vid >= RTL8366_NUM_VIDS)
619 return -EINVAL;
620
621 tableaddr = (u16 *)vlan4k;
622
623 /* write VID */
624 data = *tableaddr;
625 err = rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TABLE_WRITE_BASE, data);
626 if (err)
627 return err;
628
629 /* write table access control word */
630 err = rtl8366_smi_write_reg(smi, RTL8366S_TABLE_ACCESS_CTRL_REG,
631 RTL8366S_TABLE_VLAN_READ_CTRL);
632 if (err)
633 return err;
634
635 err = rtl8366_smi_read_reg(smi, RTL8366S_VLAN_TABLE_READ_BASE, &data);
636 if (err)
637 return err;
638
639 *tableaddr = data;
640 tableaddr++;
641
642 err = rtl8366_smi_read_reg(smi, RTL8366S_VLAN_TABLE_READ_BASE + 1,
643 &data);
644 if (err)
645 return err;
646
647 *tableaddr = data;
648 vlan4k->vid = vid;
649
650 return 0;
651 }
652
653 static int rtl8366s_set_vlan_4k_entry(struct rtl8366_smi *smi,
654 const struct rtl8366s_vlan4kentry *vlan4k)
655 {
656 int err;
657 u32 data;
658 u16 *tableaddr;
659
660 if (vlan4k->vid >= RTL8366_NUM_VIDS ||
661 vlan4k->member > RTL8366_PORT_ALL ||
662 vlan4k->untag > RTL8366_PORT_ALL ||
663 vlan4k->fid > RTL8366S_FIDMAX)
664 return -EINVAL;
665
666 tableaddr = (u16 *)vlan4k;
667
668 data = *tableaddr;
669
670 err = rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TABLE_WRITE_BASE, data);
671 if (err)
672 return err;
673
674 tableaddr++;
675
676 data = *tableaddr;
677
678 err = rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TABLE_WRITE_BASE + 1,
679 data);
680 if (err)
681 return err;
682
683 /* write table access control word */
684 err = rtl8366_smi_write_reg(smi, RTL8366S_TABLE_ACCESS_CTRL_REG,
685 RTL8366S_TABLE_VLAN_WRITE_CTRL);
686
687 return err;
688 }
689
690 static int rtl8366s_get_vlan_member_config(struct rtl8366_smi *smi, u32 index,
691 struct rtl8366s_vlanconfig *vlanmc)
692 {
693 int err;
694 u32 addr;
695 u32 data;
696 u16 *tableaddr;
697
698 memset(vlanmc, '\0', sizeof(struct rtl8366s_vlanconfig));
699
700 if (index >= RTL8366_NUM_VLANS)
701 return -EINVAL;
702
703 tableaddr = (u16 *)vlanmc;
704
705 addr = RTL8366S_VLAN_MEMCONF_BASE + (index << 1);
706 err = rtl8366_smi_read_reg(smi, addr, &data);
707 if (err)
708 return err;
709
710 *tableaddr = data;
711 tableaddr++;
712
713 addr = RTL8366S_VLAN_MEMCONF_BASE + 1 + (index << 1);
714 err = rtl8366_smi_read_reg(smi, addr, &data);
715 if (err)
716 return err;
717
718 *tableaddr = data;
719
720 return 0;
721 }
722
723 static int rtl8366s_set_vlan_member_config(struct rtl8366_smi *smi, u32 index,
724 const struct rtl8366s_vlanconfig
725 *vlanmc)
726 {
727 int err;
728 u32 addr;
729 u32 data;
730 u16 *tableaddr;
731
732 if (index >= RTL8366_NUM_VLANS ||
733 vlanmc->vid >= RTL8366_NUM_VIDS ||
734 vlanmc->priority > RTL8366S_PRIORITYMAX ||
735 vlanmc->member > RTL8366_PORT_ALL ||
736 vlanmc->untag > RTL8366_PORT_ALL ||
737 vlanmc->fid > RTL8366S_FIDMAX)
738 return -EINVAL;
739
740 addr = RTL8366S_VLAN_MEMCONF_BASE + (index << 1);
741
742 tableaddr = (u16 *)vlanmc;
743 data = *tableaddr;
744
745 err = rtl8366_smi_write_reg(smi, addr, data);
746 if (err)
747 return err;
748
749 addr = RTL8366S_VLAN_MEMCONF_BASE + 1 + (index << 1);
750
751 tableaddr++;
752 data = *tableaddr;
753
754 err = rtl8366_smi_write_reg(smi, addr, data);
755 if (err)
756 return err;
757
758 return 0;
759 }
760
761 static int rtl8366_get_port_vlan_index(struct rtl8366_smi *smi, int port,
762 int *val)
763 {
764 u32 data;
765 int err;
766
767 if (port >= RTL8366_NUM_PORTS)
768 return -EINVAL;
769
770 err = rtl8366_smi_read_reg(smi, RTL8366S_PORT_VLAN_CTRL_REG(port),
771 &data);
772 if (err)
773 return err;
774
775 *val = (data >> RTL8366S_PORT_VLAN_CTRL_SHIFT(port)) &
776 RTL8366S_PORT_VLAN_CTRL_MASK;
777
778 return 0;
779
780 }
781
782 static int rtl8366_get_vlan_port_pvid(struct rtl8366_smi *smi, int port,
783 int *val)
784 {
785 struct rtl8366s_vlanconfig vlanmc;
786 int err;
787 int index;
788
789 err = rtl8366_get_port_vlan_index(smi, port, &index);
790 if (err)
791 return err;
792
793 err = rtl8366s_get_vlan_member_config(smi, index, &vlanmc);
794 if (err)
795 return err;
796
797 *val = vlanmc.vid;
798 return 0;
799 }
800
801 static int rtl8366_set_port_vlan_index(struct rtl8366_smi *smi, int port,
802 int index)
803 {
804 u32 data;
805 int err;
806
807 if (port >= RTL8366_NUM_PORTS || index >= RTL8366_NUM_VLANS)
808 return -EINVAL;
809
810 err = rtl8366_smi_read_reg(smi, RTL8366S_PORT_VLAN_CTRL_REG(port),
811 &data);
812 if (err)
813 return err;
814
815 data &= ~(RTL8366S_PORT_VLAN_CTRL_MASK <<
816 RTL8366S_PORT_VLAN_CTRL_SHIFT(port));
817 data |= (index & RTL8366S_PORT_VLAN_CTRL_MASK) <<
818 RTL8366S_PORT_VLAN_CTRL_SHIFT(port);
819
820 err = rtl8366_smi_write_reg(smi, RTL8366S_PORT_VLAN_CTRL_REG(port),
821 data);
822 return err;
823 }
824
825 static int rtl8366_set_vlan_port_pvid(struct rtl8366_smi *smi, int port,
826 int val)
827 {
828 int i;
829 struct rtl8366s_vlanconfig vlanmc;
830 struct rtl8366s_vlan4kentry vlan4k;
831
832 if (port >= RTL8366_NUM_PORTS || val >= RTL8366_NUM_VIDS)
833 return -EINVAL;
834
835 /* Updating the 4K entry; lookup it and change the port member set */
836 rtl8366s_get_vlan_4k_entry(smi, val, &vlan4k);
837 vlan4k.member |= ((1 << port) | RTL8366_PORT_CPU);
838 vlan4k.untag = RTL8366_PORT_ALL_BUT_CPU;
839 rtl8366s_set_vlan_4k_entry(smi, &vlan4k);
840
841 /*
842 * For the 16 entries more work needs to be done. First see if such
843 * VID is already there and change it
844 */
845 for (i = 0; i < RTL8366_NUM_VLANS; ++i) {
846 rtl8366s_get_vlan_member_config(smi, i, &vlanmc);
847
848 /* Try to find an existing vid and update port member set */
849 if (val == vlanmc.vid) {
850 vlanmc.member |= ((1 << port) | RTL8366_PORT_CPU);
851 rtl8366s_set_vlan_member_config(smi, i, &vlanmc);
852
853 /* Now update PVID register settings */
854 rtl8366_set_port_vlan_index(smi, port, i);
855
856 return 0;
857 }
858 }
859
860 /*
861 * PVID could not be found from vlan table. Replace unused (one that
862 * has no member ports) with new one
863 */
864 for (i = 0; i < RTL8366_NUM_VLANS; ++i) {
865 rtl8366s_get_vlan_member_config(smi, i, &vlanmc);
866
867 /*
868 * See if this vlan member configuration is unused. It is
869 * unused if member set contains no ports or CPU port only
870 */
871 if (!vlanmc.member || vlanmc.member == RTL8366_PORT_CPU) {
872 vlanmc.vid = val;
873 vlanmc.priority = 0;
874 vlanmc.untag = RTL8366_PORT_ALL_BUT_CPU;
875 vlanmc.member = ((1 << port) | RTL8366_PORT_CPU);
876 vlanmc.fid = 0;
877
878 rtl8366s_set_vlan_member_config(smi, i, &vlanmc);
879
880 /* Now update PVID register settings */
881 rtl8366_set_port_vlan_index(smi, port, i);
882
883 return 0;
884 }
885 }
886
887 dev_err(&smi->pdev->dev,
888 "All 16 vlan member configurations are in use\n");
889
890 return -EINVAL;
891 }
892
893
894 static int rtl8366_vlan_set_vlan(struct rtl8366_smi *smi, int enable)
895 {
896 u32 data = 0;
897
898 rtl8366_smi_read_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, &data);
899
900 if (enable)
901 data |= RTL8366_CHIP_CTRL_VLAN;
902 else
903 data &= ~RTL8366_CHIP_CTRL_VLAN;
904
905 return rtl8366_smi_write_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, data);
906 }
907
908 static int rtl8366_vlan_set_4ktable(struct rtl8366_smi *smi, int enable)
909 {
910 u32 data = 0;
911
912 rtl8366_smi_read_reg(smi, RTL8366S_VLAN_TB_CTRL_REG, &data);
913
914 if (enable)
915 data |= 1;
916 else
917 data &= ~1;
918
919 return rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TB_CTRL_REG, data);
920 }
921
922 static int rtl8366s_reset_vlan(struct rtl8366_smi *smi)
923 {
924 struct rtl8366s_vlan4kentry vlan4k;
925 struct rtl8366s_vlanconfig vlanmc;
926 int err;
927 int i;
928
929 /* clear 16 VLAN member configuration */
930 vlanmc.vid = 0;
931 vlanmc.priority = 0;
932 vlanmc.member = 0;
933 vlanmc.untag = 0;
934 vlanmc.fid = 0;
935 for (i = 0; i < RTL8366_NUM_VLANS; i++) {
936 err = rtl8366s_set_vlan_member_config(smi, i, &vlanmc);
937 if (err)
938 return err;
939 }
940
941 /* Set a default VLAN with vid 1 to 4K table for all ports */
942 vlan4k.vid = 1;
943 vlan4k.member = RTL8366_PORT_ALL;
944 vlan4k.untag = RTL8366_PORT_ALL;
945 vlan4k.fid = 0;
946 err = rtl8366s_set_vlan_4k_entry(smi, &vlan4k);
947 if (err)
948 return err;
949
950 /* Set all ports PVID to default VLAN */
951 for (i = 0; i < RTL8366_NUM_PORTS; i++) {
952 err = rtl8366_set_vlan_port_pvid(smi, i, 0);
953 if (err)
954 return err;
955 }
956
957 return 0;
958 }
959
960 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
961 static int rtl8366_debugfs_open(struct inode *inode, struct file *file)
962 {
963 file->private_data = inode->i_private;
964 return 0;
965 }
966
967 static ssize_t rtl8366_read_debugfs_mibs(struct file *file,
968 char __user *user_buf,
969 size_t count, loff_t *ppos)
970 {
971 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
972 int i, j, len = 0;
973 char *buf = smi->buf;
974
975 len += snprintf(buf + len, sizeof(smi->buf) - len, "MIB Counters:\n");
976 len += snprintf(buf + len, sizeof(smi->buf) - len, "Counter"
977 " "
978 "Port 0 \t\t Port 1 \t\t Port 2 \t\t Port 3 \t\t "
979 "Port 4\n");
980
981 for (i = 0; i < 33; ++i) {
982 len += snprintf(buf + len, sizeof(smi->buf) - len, "%d:%s ",
983 i, MIBCOUNTERS[i]);
984 for (j = 0; j < RTL8366_NUM_PORTS; ++j) {
985 unsigned long long counter = 0;
986
987 if (!rtl8366_get_mib_counter(smi, i, j, &counter))
988 len += snprintf(buf + len,
989 sizeof(smi->buf) - len,
990 "[%llu]", counter);
991 else
992 len += snprintf(buf + len,
993 sizeof(smi->buf) - len,
994 "[error]");
995
996 if (j != RTL8366_NUM_PORTS - 1) {
997 if (counter < 100000)
998 len += snprintf(buf + len,
999 sizeof(smi->buf) - len,
1000 "\t");
1001
1002 len += snprintf(buf + len,
1003 sizeof(smi->buf) - len,
1004 "\t");
1005 }
1006 }
1007 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
1008 }
1009
1010 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
1011
1012 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1013 }
1014
1015 static ssize_t rtl8366_read_debugfs_vlan(struct file *file,
1016 char __user *user_buf,
1017 size_t count, loff_t *ppos)
1018 {
1019 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
1020 int i, j, len = 0;
1021 char *buf = smi->buf;
1022
1023 len += snprintf(buf + len, sizeof(smi->buf) - len,
1024 "VLAN Member Config:\n");
1025 len += snprintf(buf + len, sizeof(smi->buf) - len,
1026 "\t id \t vid \t prio \t member \t untag \t fid "
1027 "\tports\n");
1028
1029 for (i = 0; i < RTL8366_NUM_VLANS; ++i) {
1030 struct rtl8366s_vlanconfig vlanmc;
1031
1032 rtl8366s_get_vlan_member_config(smi, i, &vlanmc);
1033
1034 len += snprintf(buf + len, sizeof(smi->buf) - len,
1035 "\t[%d] \t %d \t %d \t 0x%04x \t 0x%04x \t %d "
1036 "\t", i, vlanmc.vid, vlanmc.priority,
1037 vlanmc.member, vlanmc.untag, vlanmc.fid);
1038
1039 for (j = 0; j < RTL8366_NUM_PORTS; ++j) {
1040 int index = 0;
1041 if (!rtl8366_get_port_vlan_index(smi, j, &index)) {
1042 if (index == i)
1043 len += snprintf(buf + len,
1044 sizeof(smi->buf) - len,
1045 "%d", j);
1046 }
1047 }
1048 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
1049 }
1050
1051 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1052 }
1053
1054 static ssize_t rtl8366_read_debugfs_reg(struct file *file,
1055 char __user *user_buf,
1056 size_t count, loff_t *ppos)
1057 {
1058 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
1059 u32 t, reg = g_dbg_reg;
1060 int err, len = 0;
1061 char *buf = smi->buf;
1062
1063 memset(buf, '\0', sizeof(smi->buf));
1064
1065 err = rtl8366_smi_read_reg(smi, reg, &t);
1066 if (err) {
1067 len += snprintf(buf, sizeof(smi->buf),
1068 "Read failed (reg: 0x%04x)\n", reg);
1069 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1070 }
1071
1072 len += snprintf(buf, sizeof(smi->buf), "reg = 0x%04x, val = 0x%04x\n",
1073 reg, t);
1074
1075 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1076 }
1077
1078 static ssize_t rtl8366_write_debugfs_reg(struct file *file,
1079 const char __user *user_buf,
1080 size_t count, loff_t *ppos)
1081 {
1082 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
1083 unsigned long data;
1084 u32 reg = g_dbg_reg;
1085 int err;
1086 size_t len;
1087 char *buf = smi->buf;
1088
1089 len = min(count, sizeof(smi->buf) - 1);
1090 if (copy_from_user(buf, user_buf, len)) {
1091 dev_err(&smi->pdev->dev, "copy from user failed\n");
1092 return -EFAULT;
1093 }
1094
1095 buf[len] = '\0';
1096 if (len > 0 && buf[len - 1] == '\n')
1097 buf[len - 1] = '\0';
1098
1099
1100 if (strict_strtoul(buf, 16, &data)) {
1101 dev_err(&smi->pdev->dev, "Invalid reg value %s\n", buf);
1102 } else {
1103 err = rtl8366_smi_write_reg(smi, reg, data);
1104 if (err) {
1105 dev_err(&smi->pdev->dev,
1106 "writing reg 0x%04x val 0x%04lx failed\n",
1107 reg, data);
1108 }
1109 }
1110
1111 return count;
1112 }
1113
1114 static const struct file_operations fops_rtl8366_regs = {
1115 .read = rtl8366_read_debugfs_reg,
1116 .write = rtl8366_write_debugfs_reg,
1117 .open = rtl8366_debugfs_open,
1118 .owner = THIS_MODULE
1119 };
1120
1121 static const struct file_operations fops_rtl8366_vlan = {
1122 .read = rtl8366_read_debugfs_vlan,
1123 .open = rtl8366_debugfs_open,
1124 .owner = THIS_MODULE
1125 };
1126
1127 static const struct file_operations fops_rtl8366_mibs = {
1128 .read = rtl8366_read_debugfs_mibs,
1129 .open = rtl8366_debugfs_open,
1130 .owner = THIS_MODULE
1131 };
1132
1133 static void rtl8366_debugfs_init(struct rtl8366_smi *smi)
1134 {
1135 struct dentry *node;
1136 struct dentry *root;
1137
1138 if (!smi->debugfs_root)
1139 smi->debugfs_root = debugfs_create_dir("rtl8366s", NULL);
1140
1141 if (!smi->debugfs_root) {
1142 dev_err(&smi->pdev->dev, "Unable to create debugfs dir\n");
1143 return;
1144 }
1145 root = smi->debugfs_root;
1146
1147 node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root, &g_dbg_reg);
1148 if (!node) {
1149 dev_err(&smi->pdev->dev, "Creating debugfs file reg failed\n");
1150 return;
1151 }
1152
1153 node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, smi,
1154 &fops_rtl8366_regs);
1155 if (!node) {
1156 dev_err(&smi->pdev->dev, "Creating debugfs file val failed\n");
1157 return;
1158 }
1159
1160 node = debugfs_create_file("vlan", S_IRUSR, root, smi,
1161 &fops_rtl8366_vlan);
1162 if (!node) {
1163 dev_err(&smi->pdev->dev,
1164 "Creating debugfs file vlan failed\n");
1165 return;
1166 }
1167
1168 node = debugfs_create_file("mibs", S_IRUSR, root, smi,
1169 &fops_rtl8366_mibs);
1170 if (!node) {
1171 dev_err(&smi->pdev->dev,
1172 "Creating debugfs file mibs failed\n");
1173 return;
1174 }
1175 }
1176
1177 static void rtl8366_debugfs_remove(struct rtl8366_smi *smi)
1178 {
1179 if (smi->debugfs_root) {
1180 debugfs_remove_recursive(smi->debugfs_root);
1181 smi->debugfs_root = NULL;
1182 }
1183 }
1184
1185 #else
1186 static inline void rtl8366_debugfs_init(struct rtl8366_smi *smi) {}
1187 static inline void rtl8366_debugfs_remove(struct rtl8366_smi *smi) {}
1188 #endif /* CONFIG_RTL8366_SMI_DEBUG_FS */
1189
1190 static int rtl8366_global_reset_mibs(struct switch_dev *dev,
1191 const struct switch_attr *attr,
1192 struct switch_val *val)
1193 {
1194 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1195 u32 data = 0;
1196
1197 if (val->value.i == 1) {
1198 rtl8366_smi_read_reg(smi, RTL8366S_MIB_CTRL_REG, &data);
1199 data |= (1 << 2);
1200 rtl8366_smi_write_reg(smi, RTL8366S_MIB_CTRL_REG, data);
1201 }
1202
1203 return 0;
1204 }
1205
1206 static int rtl8366_get_vlan(struct switch_dev *dev,
1207 const struct switch_attr *attr,
1208 struct switch_val *val)
1209 {
1210 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1211 u32 data;
1212
1213 if (attr->ofs == 1) {
1214 rtl8366_smi_read_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, &data);
1215
1216 if (data & RTL8366_CHIP_CTRL_VLAN)
1217 val->value.i = 1;
1218 else
1219 val->value.i = 0;
1220 } else if (attr->ofs == 2) {
1221 rtl8366_smi_read_reg(smi, RTL8366S_VLAN_TB_CTRL_REG, &data);
1222
1223 if (data & 0x0001)
1224 val->value.i = 1;
1225 else
1226 val->value.i = 0;
1227 }
1228
1229 return 0;
1230 }
1231
1232 static int rtl8366_global_get_blinkrate(struct switch_dev *dev,
1233 const struct switch_attr *attr,
1234 struct switch_val *val)
1235 {
1236 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1237 u32 data;
1238
1239 rtl8366_smi_read_reg(smi, RTL8366_LED_BLINKRATE_REG, &data);
1240
1241 val->value.i = (data & (RTL8366_LED_BLINKRATE_MASK));
1242
1243 return 0;
1244 }
1245
1246 static int rtl8366_global_set_blinkrate(struct switch_dev *dev,
1247 const struct switch_attr *attr,
1248 struct switch_val *val)
1249 {
1250 u32 data;
1251 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1252
1253 if (val->value.i >= 6)
1254 return -EINVAL;
1255
1256 rtl8366_smi_read_reg(smi, RTL8366_LED_BLINKRATE_REG, &data);
1257
1258 data &= ~RTL8366_LED_BLINKRATE_MASK;
1259 data |= val->value.i;
1260
1261 rtl8366_smi_write_reg(smi, RTL8366_LED_BLINKRATE_REG, data);
1262
1263 return 0;
1264 }
1265
1266 static int rtl8366_set_vlan(struct switch_dev *dev,
1267 const struct switch_attr *attr,
1268 struct switch_val *val)
1269 {
1270 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1271
1272 if (attr->ofs == 1)
1273 return rtl8366_vlan_set_vlan(smi, val->value.i);
1274 else
1275 return rtl8366_vlan_set_4ktable(smi, val->value.i);
1276 }
1277
1278 static int rtl8366_attr_get_port_link(struct switch_dev *dev,
1279 const struct switch_attr *attr,
1280 struct switch_val *val)
1281 {
1282 u32 len = 0, data = 0;
1283 int speed, duplex, link, txpause, rxpause, nway;
1284 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1285 char *buf = smi->buf;
1286
1287 if (val->port_vlan >= RTL8366_NUM_PORTS)
1288 return -EINVAL;
1289
1290 memset(buf, '\0', sizeof(smi->buf));
1291 rtl8366_smi_read_reg(smi, RTL8366S_PORT_LINK_STATUS_BASE +
1292 (val->port_vlan >> 1),
1293 &data);
1294
1295 if (val->port_vlan & 0x1)
1296 data = data >> 8;
1297
1298 speed = (data & RTL8366S_PORT_STATUS_SPEED_MASK);
1299 duplex = (data & RTL8366S_PORT_STATUS_DUPLEX_MASK) >> 2;
1300 link = (data & RTL8366S_PORT_STATUS_LINK_MASK) >> 4;
1301 txpause = (data & RTL8366S_PORT_STATUS_TXPAUSE_MASK) >> 5;
1302 rxpause = (data & RTL8366S_PORT_STATUS_RXPAUSE_MASK) >> 6;
1303 nway = (data & RTL8366S_PORT_STATUS_AN_MASK) >> 7;
1304
1305 len += snprintf(buf + len, sizeof(smi->buf) - len, "Port %d: ",
1306 val->port_vlan);
1307
1308 if (link)
1309 len += snprintf(buf + len, sizeof(smi->buf) - len,
1310 "Link UP, Speed: ");
1311 else
1312 len += snprintf(buf + len, sizeof(smi->buf) - len,
1313 "Link DOWN, Speed: ");
1314
1315 if (speed == 0)
1316 len += snprintf(buf + len, sizeof(smi->buf) - len,
1317 "10Base-TX ");
1318 else if (speed == 1)
1319 len += snprintf(buf + len, sizeof(smi->buf) - len,
1320 "100Base-TX ");
1321 else if (speed == 2)
1322 len += snprintf(buf + len, sizeof(smi->buf) - len,
1323 "1000Base-TX ");
1324
1325 if (duplex)
1326 len += snprintf(buf + len, sizeof(smi->buf) - len,
1327 "Full-Duplex, ");
1328 else
1329 len += snprintf(buf + len, sizeof(smi->buf) - len,
1330 "Half-Duplex, ");
1331
1332 if (txpause)
1333 len += snprintf(buf + len, sizeof(smi->buf) - len,
1334 "TX-Pause ");
1335 if (rxpause)
1336 len += snprintf(buf + len, sizeof(smi->buf) - len,
1337 "RX-Pause ");
1338 if (nway)
1339 len += snprintf(buf + len, sizeof(smi->buf) - len,
1340 "nway ");
1341
1342 val->value.s = buf;
1343 val->len = len;
1344
1345 return 0;
1346 }
1347
1348 static int rtl8366_attr_get_vlan_info(struct switch_dev *dev,
1349 const struct switch_attr *attr,
1350 struct switch_val *val)
1351 {
1352 int i;
1353 u32 len = 0;
1354 struct rtl8366s_vlanconfig vlanmc;
1355 struct rtl8366s_vlan4kentry vlan4k;
1356 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1357 char *buf = smi->buf;
1358
1359 if (val->port_vlan >= RTL8366_NUM_VLANS)
1360 return -EINVAL;
1361
1362 memset(buf, '\0', sizeof(smi->buf));
1363
1364 rtl8366s_get_vlan_member_config(smi, val->port_vlan, &vlanmc);
1365 rtl8366s_get_vlan_4k_entry(smi, vlanmc.vid, &vlan4k);
1366
1367 len += snprintf(buf + len, sizeof(smi->buf) - len, "VLAN %d: Ports: ",
1368 val->port_vlan);
1369
1370 for (i = 0; i < RTL8366_NUM_PORTS; ++i) {
1371 int index = 0;
1372 if (!rtl8366_get_port_vlan_index(smi, i, &index) &&
1373 index == val->port_vlan)
1374 len += snprintf(buf + len, sizeof(smi->buf) - len,
1375 "%d", i);
1376 }
1377 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
1378
1379 len += snprintf(buf + len, sizeof(smi->buf) - len,
1380 "\t\t vid \t prio \t member \t untag \t fid\n");
1381 len += snprintf(buf + len, sizeof(smi->buf) - len, "\tMC:\t");
1382 len += snprintf(buf + len, sizeof(smi->buf) - len,
1383 "%d \t %d \t 0x%04x \t 0x%04x \t %d\n",
1384 vlanmc.vid, vlanmc.priority, vlanmc.member,
1385 vlanmc.untag, vlanmc.fid);
1386 len += snprintf(buf + len, sizeof(smi->buf) - len, "\t4K:\t");
1387 len += snprintf(buf + len, sizeof(smi->buf) - len,
1388 "%d \t \t 0x%04x \t 0x%04x \t %d",
1389 vlan4k.vid, vlan4k.member, vlan4k.untag, vlan4k.fid);
1390
1391 val->value.s = buf;
1392 val->len = len;
1393
1394 return 0;
1395 }
1396
1397 static int rtl8366_set_port_led(struct switch_dev *dev,
1398 const struct switch_attr *attr,
1399 struct switch_val *val)
1400 {
1401 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1402 u32 data = 0;
1403
1404 if (val->port_vlan >= RTL8366_NUM_PORTS ||
1405 (1 << val->port_vlan) == RTL8366_PORT_UNKNOWN)
1406 return -EINVAL;
1407
1408 if (val->port_vlan == RTL8366_PORT_NUM_CPU) {
1409 rtl8366_smi_read_reg(smi, RTL8366_LED_BLINKRATE_REG, &data);
1410 data = (data & (~(0xF << 4))) | (val->value.i << 4);
1411 rtl8366_smi_write_reg(smi, RTL8366_LED_BLINKRATE_REG, data);
1412 } else {
1413 rtl8366_smi_read_reg(smi, RTL8366_LED_CTRL_REG, &data);
1414 data = (data & (~(0xF << (val->port_vlan * 4)))) |
1415 (val->value.i << (val->port_vlan * 4));
1416 rtl8366_smi_write_reg(smi, RTL8366_LED_CTRL_REG, data);
1417 }
1418
1419 return 0;
1420 }
1421
1422 static int rtl8366_get_port_led(struct switch_dev *dev,
1423 const struct switch_attr *attr,
1424 struct switch_val *val)
1425 {
1426 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1427 u32 data = 0;
1428
1429 if (val->port_vlan >= RTL8366_NUM_LEDGROUPS)
1430 return -EINVAL;
1431
1432 rtl8366_smi_read_reg(smi, RTL8366_LED_CTRL_REG, &data);
1433 val->value.i = (data >> (val->port_vlan * 4)) & 0x000F;
1434
1435 return 0;
1436 }
1437
1438 static int rtl8366_reset_port_mibs(struct switch_dev *dev,
1439 const struct switch_attr *attr,
1440 struct switch_val *val)
1441 {
1442 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1443 u32 data = 0;
1444
1445 if (val->port_vlan >= RTL8366_NUM_PORTS)
1446 return -EINVAL;
1447
1448 rtl8366_smi_read_reg(smi, RTL8366S_MIB_CTRL_REG, &data);
1449 data |= (1 << (val->port_vlan + 3));
1450 rtl8366_smi_write_reg(smi, RTL8366S_MIB_CTRL_REG, data);
1451
1452 return 0;
1453 }
1454
1455 static int rtl8366_get_port_mib(struct switch_dev *dev,
1456 const struct switch_attr *attr,
1457 struct switch_val *val)
1458 {
1459 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1460 int i, len = 0;
1461 unsigned long long counter = 0;
1462 char *buf = smi->buf;
1463
1464 if (val->port_vlan >= RTL8366_NUM_PORTS)
1465 return -EINVAL;
1466
1467 len += snprintf(buf + len, sizeof(smi->buf) - len,
1468 "Port %d MIB counters\n",
1469 val->port_vlan);
1470
1471 for (i = 0; i < RTL8366S_MIB_COUNT; ++i) {
1472 len += snprintf(buf + len, sizeof(smi->buf) - len,
1473 "%d:%s\t", i, MIBCOUNTERS[i]);
1474 if (!rtl8366_get_mib_counter(smi, i, val->port_vlan, &counter))
1475 len += snprintf(buf + len, sizeof(smi->buf) - len,
1476 "[%llu]\n", counter);
1477 else
1478 len += snprintf(buf + len, sizeof(smi->buf) - len,
1479 "[error]\n");
1480 }
1481
1482 val->value.s = buf;
1483 val->len = len;
1484 return 0;
1485 }
1486
1487 static int rtl8366_get_ports(struct switch_dev *dev,
1488 struct switch_val *val)
1489 {
1490 struct rtl8366s_vlanconfig vlanmc;
1491 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1492 struct switch_port *port;
1493 int i;
1494
1495 if (val->port_vlan >= RTL8366_NUM_VLANS)
1496 return -EINVAL;
1497
1498 rtl8366s_get_vlan_member_config(smi, val->port_vlan, &vlanmc);
1499
1500 port = &val->value.ports[0];
1501 val->len = 0;
1502 for (i = 0; i < RTL8366_NUM_PORTS; i++) {
1503 if (!(vlanmc.member & BIT(i)))
1504 continue;
1505
1506 port->id = i;
1507 port->flags = (vlanmc.untag & BIT(i)) ?
1508 0 : BIT(SWITCH_PORT_FLAG_TAGGED);
1509 val->len++;
1510 port++;
1511 }
1512 return 0;
1513 }
1514
1515 static int rtl8366_set_ports(struct switch_dev *dev,
1516 struct switch_val *val)
1517 {
1518 struct rtl8366s_vlanconfig vlanmc;
1519 struct rtl8366s_vlan4kentry vlan4k;
1520 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1521 struct switch_port *port;
1522 int i;
1523
1524 if (val->port_vlan >= RTL8366_NUM_VLANS)
1525 return -EINVAL;
1526
1527 rtl8366s_get_vlan_member_config(smi, val->port_vlan, &vlanmc);
1528 rtl8366s_get_vlan_4k_entry(smi, vlanmc.vid, &vlan4k);
1529
1530 vlanmc.untag = 0;
1531 vlanmc.member = 0;
1532
1533 port = &val->value.ports[0];
1534 for (i = 0; i < val->len; i++, port++) {
1535 vlanmc.member |= BIT(port->id);
1536
1537 if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED)))
1538 vlanmc.untag |= BIT(port->id);
1539 }
1540
1541 vlan4k.member = vlanmc.member;
1542 vlan4k.untag = vlanmc.untag;
1543
1544 rtl8366s_set_vlan_member_config(smi, val->port_vlan, &vlanmc);
1545 rtl8366s_set_vlan_4k_entry(smi, &vlan4k);
1546 return 0;
1547 }
1548
1549 static int rtl8366_get_port_pvid(struct switch_dev *dev, int port, int *val)
1550 {
1551 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1552 return rtl8366_get_vlan_port_pvid(smi, port, val);
1553 }
1554
1555 static int rtl8366_set_port_pvid(struct switch_dev *dev, int port, int val)
1556 {
1557 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1558 return rtl8366_set_vlan_port_pvid(smi, port, val);
1559 }
1560
1561 static int rtl8366_reset_switch(struct switch_dev *dev)
1562 {
1563 struct rtl8366_smi *smi = sw_to_rtl8366(dev);
1564 int timeout = 10;
1565 u32 data;
1566
1567 rtl8366_smi_write_reg(smi, RTL8366_RESET_CTRL_REG,
1568 RTL8366_CHIP_CTRL_RESET_HW);
1569 do {
1570 msleep(1);
1571 if (rtl8366_smi_read_reg(smi, RTL8366_RESET_CTRL_REG, &data))
1572 return -EIO;
1573
1574 if (!(data & RTL8366_CHIP_CTRL_RESET_HW))
1575 break;
1576 } while (--timeout);
1577
1578 if (!timeout) {
1579 printk("Timeout waiting for the switch to reset\n");
1580 return -EIO;
1581 }
1582
1583 return rtl8366s_reset_vlan(smi);
1584 }
1585
1586 static struct switch_attr rtl8366_globals[] = {
1587 {
1588 .type = SWITCH_TYPE_INT,
1589 .name = "enable_vlan",
1590 .description = "Enable VLAN mode",
1591 .set = rtl8366_set_vlan,
1592 .get = rtl8366_get_vlan,
1593 .max = 1,
1594 .ofs = 1
1595 }, {
1596 .type = SWITCH_TYPE_INT,
1597 .name = "enable_vlan4k",
1598 .description = "Enable VLAN 4K mode",
1599 .set = rtl8366_set_vlan,
1600 .get = rtl8366_get_vlan,
1601 .max = 1,
1602 .ofs = 2
1603 }, {
1604 .type = SWITCH_TYPE_INT,
1605 .name = "reset_mibs",
1606 .description = "Reset all MIB counters",
1607 .set = rtl8366_global_reset_mibs,
1608 .get = NULL,
1609 .max = 1
1610 }, {
1611 .type = SWITCH_TYPE_INT,
1612 .name = "blinkrate",
1613 .description = "Get/Set LED blinking rate (0 = 43ms, 1 = 84ms,"
1614 " 2 = 120ms, 3 = 170ms, 4 = 340ms, 5 = 670ms)",
1615 .set = rtl8366_global_set_blinkrate,
1616 .get = rtl8366_global_get_blinkrate,
1617 .max = 5
1618 },
1619 };
1620
1621 static struct switch_attr rtl8366_port[] = {
1622 {
1623 .type = SWITCH_TYPE_STRING,
1624 .name = "link",
1625 .description = "Get port link information",
1626 .max = 1,
1627 .set = NULL,
1628 .get = rtl8366_attr_get_port_link
1629 }, {
1630 .type = SWITCH_TYPE_INT,
1631 .name = "reset_mib",
1632 .description = "Reset single port MIB counters",
1633 .max = 1,
1634 .set = rtl8366_reset_port_mibs,
1635 .get = NULL
1636 }, {
1637 .type = SWITCH_TYPE_STRING,
1638 .name = "mib",
1639 .description = "Get MIB counters for port",
1640 .max = 33,
1641 .set = NULL,
1642 .get = rtl8366_get_port_mib
1643 }, {
1644 .type = SWITCH_TYPE_INT,
1645 .name = "led",
1646 .description = "Get/Set port group (0 - 3) led mode (0 - 15)",
1647 .max = 15,
1648 .set = rtl8366_set_port_led,
1649 .get = rtl8366_get_port_led
1650 },
1651 };
1652
1653 static struct switch_attr rtl8366_vlan[] = {
1654 {
1655 .type = SWITCH_TYPE_STRING,
1656 .name = "info",
1657 .description = "Get vlan information",
1658 .max = 1,
1659 .set = NULL,
1660 .get = rtl8366_attr_get_vlan_info
1661 },
1662 };
1663
1664
1665 /* template */
1666 static struct switch_dev rtldev = {
1667 .name = "RTL8366S",
1668 .cpu_port = RTL8366_PORT_NUM_CPU,
1669 .ports = RTL8366_NUM_PORTS,
1670 .vlans = RTL8366_NUM_VLANS,
1671 .attr_global = {
1672 .attr = rtl8366_globals,
1673 .n_attr = ARRAY_SIZE(rtl8366_globals),
1674 },
1675 .attr_port = {
1676 .attr = rtl8366_port,
1677 .n_attr = ARRAY_SIZE(rtl8366_port),
1678 },
1679 .attr_vlan = {
1680 .attr = rtl8366_vlan,
1681 .n_attr = ARRAY_SIZE(rtl8366_vlan),
1682 },
1683
1684 .get_vlan_ports = rtl8366_get_ports,
1685 .set_vlan_ports = rtl8366_set_ports,
1686 .get_port_pvid = rtl8366_get_port_pvid,
1687 .set_port_pvid = rtl8366_set_port_pvid,
1688 .reset_switch = rtl8366_reset_switch,
1689 };
1690
1691 static int rtl8366_smi_switch_init(struct rtl8366_smi *smi)
1692 {
1693 struct switch_dev *dev = &smi->dev;
1694 int err;
1695
1696 memcpy(dev, &rtldev, sizeof(struct switch_dev));
1697 dev->priv = smi;
1698 dev->devname = dev_name(&smi->pdev->dev);
1699
1700 err = register_switch(dev, NULL);
1701 if (err)
1702 dev_err(&smi->pdev->dev, "switch registration failed\n");
1703
1704 return err;
1705 }
1706
1707 static void rtl8366_smi_switch_cleanup(struct rtl8366_smi *smi)
1708 {
1709 unregister_switch(&smi->dev);
1710 }
1711
1712 static int rtl8366_smi_mii_read(struct mii_bus *bus, int addr, int reg)
1713 {
1714 struct rtl8366_smi *smi = bus->priv;
1715 u32 val = 0;
1716 int err;
1717
1718 err = rtl8366_smi_read_phy_reg(smi, addr, 0, reg, &val);
1719 if (err)
1720 return 0xffff;
1721
1722 return val;
1723 }
1724
1725 static int rtl8366_smi_mii_write(struct mii_bus *bus, int addr, int reg,
1726 u16 val)
1727 {
1728 struct rtl8366_smi *smi = bus->priv;
1729 u32 t;
1730 int err;
1731
1732 err = rtl8366_smi_write_phy_reg(smi, addr, 0, reg, val);
1733 /* flush write */
1734 (void) rtl8366_smi_read_phy_reg(smi, addr, 0, reg, &t);
1735
1736 return err;
1737 }
1738
1739 static int rtl8366_smi_mii_init(struct rtl8366_smi *smi)
1740 {
1741 int ret;
1742 int i;
1743
1744 smi->mii_bus = mdiobus_alloc();
1745 if (smi->mii_bus == NULL) {
1746 ret = -ENOMEM;
1747 goto err;
1748 }
1749
1750 spin_lock_init(&smi->lock);
1751 smi->mii_bus->priv = (void *) smi;
1752 smi->mii_bus->name = "rtl8366-smi";
1753 smi->mii_bus->read = rtl8366_smi_mii_read;
1754 smi->mii_bus->write = rtl8366_smi_mii_write;
1755 snprintf(smi->mii_bus->id, MII_BUS_ID_SIZE, "%s",
1756 dev_name(&smi->pdev->dev));
1757 smi->mii_bus->parent = &smi->pdev->dev;
1758 smi->mii_bus->phy_mask = ~(0x1f);
1759 smi->mii_bus->irq = smi->mii_irq;
1760 for (i = 0; i < PHY_MAX_ADDR; i++)
1761 smi->mii_irq[i] = PHY_POLL;
1762
1763 ret = mdiobus_register(smi->mii_bus);
1764 if (ret)
1765 goto err_free;
1766
1767 return 0;
1768
1769 err_free:
1770 mdiobus_free(smi->mii_bus);
1771 err:
1772 return ret;
1773 }
1774
1775 static void rtl8366_smi_mii_cleanup(struct rtl8366_smi *smi)
1776 {
1777 mdiobus_unregister(smi->mii_bus);
1778 mdiobus_free(smi->mii_bus);
1779 }
1780
1781 static int rtl8366_smi_mii_bus_match(struct mii_bus *bus)
1782 {
1783 return (bus->read == rtl8366_smi_mii_read &&
1784 bus->write == rtl8366_smi_mii_write);
1785 }
1786
1787 static int rtl8366_smi_setup(struct rtl8366_smi *smi)
1788 {
1789 u32 chip_id = 0;
1790 u32 chip_ver = 0;
1791 int ret;
1792
1793 ret = rtl8366_smi_read_reg(smi, RTL8366S_CHIP_ID_REG, &chip_id);
1794 if (ret) {
1795 dev_err(&smi->pdev->dev, "unable to read chip id\n");
1796 return ret;
1797 }
1798
1799 switch (chip_id) {
1800 case RTL8366S_CHIP_ID_8366:
1801 break;
1802 default:
1803 dev_err(&smi->pdev->dev, "unknown chip id (%04x)\n", chip_id);
1804 return -ENODEV;
1805 }
1806
1807 ret = rtl8366_smi_read_reg(smi, RTL8366S_CHIP_VERSION_CTRL_REG,
1808 &chip_ver);
1809 if (ret) {
1810 dev_err(&smi->pdev->dev, "unable to read chip version\n");
1811 return ret;
1812 }
1813
1814 dev_info(&smi->pdev->dev, "RTL%04x ver. %u chip found\n",
1815 chip_id, chip_ver & RTL8366S_CHIP_VERSION_MASK);
1816
1817 rtl8366_debugfs_init(smi);
1818
1819 return 0;
1820 }
1821
1822 static int __init rtl8366_smi_probe(struct platform_device *pdev)
1823 {
1824 static int rtl8366_smi_version_printed;
1825 struct rtl8366_smi_platform_data *pdata;
1826 struct rtl8366_smi *smi;
1827 int err;
1828
1829 if (!rtl8366_smi_version_printed++)
1830 printk(KERN_NOTICE RTL8366_SMI_DRIVER_DESC
1831 " version " RTL8366_SMI_DRIVER_VER"\n");
1832
1833 pdata = pdev->dev.platform_data;
1834 if (!pdata) {
1835 dev_err(&pdev->dev, "no platform data specified\n");
1836 err = -EINVAL;
1837 goto err_out;
1838 }
1839
1840 smi = kzalloc(sizeof(struct rtl8366_smi), GFP_KERNEL);
1841 if (!smi) {
1842 dev_err(&pdev->dev, "no memory for private data\n");
1843 err = -ENOMEM;
1844 goto err_out;
1845 }
1846
1847 err = gpio_request(pdata->gpio_sda, dev_name(&pdev->dev));
1848 if (err) {
1849 dev_err(&pdev->dev, "gpio_request failed for %u, err=%d\n",
1850 pdata->gpio_sda, err);
1851 goto err_free_smi;
1852 }
1853
1854 err = gpio_request(pdata->gpio_sck, dev_name(&pdev->dev));
1855 if (err) {
1856 dev_err(&pdev->dev, "gpio_request failed for %u, err=%d\n",
1857 pdata->gpio_sck, err);
1858 goto err_free_sda;
1859 }
1860
1861 smi->pdev = pdev;
1862 smi->pdata = pdata;
1863 spin_lock_init(&smi->lock);
1864
1865 platform_set_drvdata(pdev, smi);
1866
1867 dev_info(&pdev->dev, "using GPIO pins %u (SDA) and %u (SCK)\n",
1868 pdata->gpio_sda, pdata->gpio_sck);
1869
1870 err = rtl8366_smi_setup(smi);
1871 if (err)
1872 goto err_clear_drvdata;
1873
1874 err = rtl8366_smi_mii_init(smi);
1875 if (err)
1876 goto err_clear_drvdata;
1877
1878 err = rtl8366_smi_switch_init(smi);
1879 if (err)
1880 goto err_mii_cleanup;
1881
1882 return 0;
1883
1884 err_mii_cleanup:
1885 rtl8366_smi_mii_cleanup(smi);
1886 err_clear_drvdata:
1887 platform_set_drvdata(pdev, NULL);
1888 gpio_free(pdata->gpio_sck);
1889 err_free_sda:
1890 gpio_free(pdata->gpio_sda);
1891 err_free_smi:
1892 kfree(smi);
1893 err_out:
1894 return err;
1895 }
1896
1897 int rtl8366_phy_config_init(struct phy_device *phydev)
1898 {
1899 if (!rtl8366_smi_mii_bus_match(phydev->bus))
1900 return -EINVAL;
1901
1902 return 0;
1903 }
1904
1905 int rtl8366_phy_config_aneg(struct phy_device *phydev)
1906 {
1907 return 0;
1908 }
1909
1910 static struct phy_driver rtl8366_smi_phy_driver = {
1911 .phy_id = 0x001cc960,
1912 .name = "Realtek RTL8366",
1913 .phy_id_mask = 0x1ffffff0,
1914 .features = PHY_GBIT_FEATURES,
1915 .config_aneg = rtl8366_phy_config_aneg,
1916 .config_init = rtl8366_phy_config_init,
1917 .read_status = genphy_read_status,
1918 .driver = {
1919 .owner = THIS_MODULE,
1920 },
1921 };
1922
1923 static int __devexit rtl8366_smi_remove(struct platform_device *pdev)
1924 {
1925 struct rtl8366_smi *smi = platform_get_drvdata(pdev);
1926
1927 if (smi) {
1928 struct rtl8366_smi_platform_data *pdata;
1929
1930 pdata = pdev->dev.platform_data;
1931
1932 rtl8366_smi_switch_cleanup(smi);
1933 rtl8366_debugfs_remove(smi);
1934 rtl8366_smi_mii_cleanup(smi);
1935 platform_set_drvdata(pdev, NULL);
1936 gpio_free(pdata->gpio_sck);
1937 gpio_free(pdata->gpio_sda);
1938 kfree(smi);
1939 }
1940
1941 return 0;
1942 }
1943
1944 static struct platform_driver rtl8366_smi_driver = {
1945 .driver = {
1946 .name = RTL8366_SMI_DRIVER_NAME,
1947 .owner = THIS_MODULE,
1948 },
1949 .probe = rtl8366_smi_probe,
1950 .remove = __devexit_p(rtl8366_smi_remove),
1951 };
1952
1953 static int __init rtl8366_smi_init(void)
1954 {
1955 int ret;
1956 ret = platform_driver_register(&rtl8366_smi_driver);
1957 if (ret)
1958 return ret;
1959
1960 ret = phy_driver_register(&rtl8366_smi_phy_driver);
1961 if (ret)
1962 goto err_platform_unregister;
1963
1964 return 0;
1965
1966 err_platform_unregister:
1967 platform_driver_unregister(&rtl8366_smi_driver);
1968 return ret;
1969 }
1970 module_init(rtl8366_smi_init);
1971
1972 static void __exit rtl8366_smi_exit(void)
1973 {
1974 phy_driver_unregister(&rtl8366_smi_phy_driver);
1975 platform_driver_unregister(&rtl8366_smi_driver);
1976 }
1977 module_exit(rtl8366_smi_exit);
1978
1979 MODULE_DESCRIPTION(RTL8366_SMI_DRIVER_DESC);
1980 MODULE_VERSION(RTL8366_SMI_DRIVER_VER);
1981 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
1982 MODULE_AUTHOR("Antti Seppälä <a.seppala@gmail.com>");
1983 MODULE_LICENSE("GPL v2");
1984 MODULE_ALIAS("platform:" RTL8366_SMI_DRIVER_NAME);
OpenWrt SVN history