source: branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8366rb.c @ 21931

Last change on this file since 21931 was 21931, checked in by juhosg, 6 years ago

backfire: generic: rtl8366: use struct rtl8366_smi for phy_reg_{read,write} calls (backport of r21912)

File size: 42.2 KB
Line 
1/*
2 * Platform driver for the Realtek RTL8366S ethernet switch
3 *
4 * Copyright (C) 2009-2010 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/skbuff.h>
18#include <linux/switch.h>
19#include <linux/rtl8366rb.h>
20
21#include "rtl8366_smi.h"
22
23#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
24#include <linux/debugfs.h>
25#endif
26
27#define RTL8366S_DRIVER_DESC    "Realtek RTL8366RB ethernet switch driver"
28#define RTL8366S_DRIVER_VER     "0.2.2"
29
30#define RTL8366S_PHY_NO_MAX                 4
31#define RTL8366S_PHY_PAGE_MAX               7
32#define RTL8366S_PHY_ADDR_MAX               31
33
34#define RTL8366_CHIP_GLOBAL_CTRL_REG        0x0000
35#define RTL8366_CHIP_CTRL_VLAN              (1 << 13)
36#define RTL8366_CHIP_CTRL_VLAN_4KTB         (1 << 14)
37
38#define RTL8366_RESET_CTRL_REG              0x0100
39#define RTL8366_CHIP_CTRL_RESET_HW          1
40#define RTL8366_CHIP_CTRL_RESET_SW          (1 << 1)
41
42#define RTL8366S_CHIP_VERSION_CTRL_REG      0x050A
43#define RTL8366S_CHIP_VERSION_MASK          0xf
44#define RTL8366S_CHIP_ID_REG                0x0509
45#define RTL8366S_CHIP_ID_8366               0x5937
46
47/* PHY registers control */
48#define RTL8366S_PHY_ACCESS_CTRL_REG        0x8000
49#define RTL8366S_PHY_ACCESS_DATA_REG        0x8002
50
51#define RTL8366S_PHY_CTRL_READ              1
52#define RTL8366S_PHY_CTRL_WRITE             0
53
54#define RTL8366S_PHY_REG_MASK               0x1f
55#define RTL8366S_PHY_PAGE_OFFSET            5
56#define RTL8366S_PHY_PAGE_MASK              (0xf << 5)
57#define RTL8366S_PHY_NO_OFFSET              9
58#define RTL8366S_PHY_NO_MASK                (0x1f << 9)
59
60/* LED control registers */
61#define RTL8366_LED_BLINKRATE_REG           0x0430
62#define RTL8366_LED_BLINKRATE_BIT           0
63#define RTL8366_LED_BLINKRATE_MASK          0x0007
64
65#define RTL8366_LED_CTRL_REG                0x0431
66#define RTL8366_LED_0_1_CTRL_REG            0x0432
67#define RTL8366_LED_2_3_CTRL_REG            0x0433
68
69#define RTL8366S_MIB_COUNT                  33
70#define RTL8366S_GLOBAL_MIB_COUNT           1
71#define RTL8366S_MIB_COUNTER_PORT_OFFSET    0x0050
72#define RTL8366S_MIB_COUNTER_BASE           0x1000
73#define RTL8366S_MIB_CTRL_REG               0x13F0
74#define RTL8366S_MIB_CTRL_USER_MASK         0x0FFC
75#define RTL8366S_MIB_CTRL_BUSY_MASK         0x0001
76#define RTL8366S_MIB_CTRL_RESET_MASK        0x0001
77
78#define RTL8366S_MIB_CTRL_GLOBAL_RESET_MASK 0x0004
79#define RTL8366S_MIB_CTRL_PORT_RESET_BIT    0x0003
80#define RTL8366S_MIB_CTRL_PORT_RESET_MASK   0x01FC
81
82
83#define RTL8366S_PORT_VLAN_CTRL_BASE        0x0063
84#define RTL8366S_PORT_VLAN_CTRL_REG(_p)  \
85                (RTL8366S_PORT_VLAN_CTRL_BASE + (_p) / 4)
86#define RTL8366S_PORT_VLAN_CTRL_MASK        0xf
87#define RTL8366S_PORT_VLAN_CTRL_SHIFT(_p)   (4 * ((_p) % 4))
88
89
90#define RTL8366S_VLAN_TABLE_READ_BASE       0x018C
91#define RTL8366S_VLAN_TABLE_WRITE_BASE      0x0185
92
93
94#define RTL8366S_TABLE_ACCESS_CTRL_REG      0x0180
95#define RTL8366S_TABLE_VLAN_READ_CTRL       0x0E01
96#define RTL8366S_TABLE_VLAN_WRITE_CTRL      0x0F01
97
98#define RTL8366S_VLAN_MEMCONF_BASE          0x0020
99
100
101#define RTL8366S_PORT_LINK_STATUS_BASE      0x0014
102#define RTL8366S_PORT_STATUS_SPEED_MASK     0x0003
103#define RTL8366S_PORT_STATUS_DUPLEX_MASK    0x0004
104#define RTL8366S_PORT_STATUS_LINK_MASK      0x0010
105#define RTL8366S_PORT_STATUS_TXPAUSE_MASK   0x0020
106#define RTL8366S_PORT_STATUS_RXPAUSE_MASK   0x0040
107#define RTL8366S_PORT_STATUS_AN_MASK        0x0080
108
109
110#define RTL8366_PORT_NUM_CPU                5
111#define RTL8366_NUM_PORTS                   6
112#define RTL8366_NUM_VLANS                   16
113#define RTL8366_NUM_LEDGROUPS               4
114#define RTL8366_NUM_VIDS                    4096
115#define RTL8366S_PRIORITYMAX                7
116#define RTL8366S_FIDMAX                     7
117
118
119#define RTL8366_PORT_1                      (1 << 0) /* In userspace port 0 */
120#define RTL8366_PORT_2                      (1 << 1) /* In userspace port 1 */
121#define RTL8366_PORT_3                      (1 << 2) /* In userspace port 2 */
122#define RTL8366_PORT_4                      (1 << 3) /* In userspace port 3 */
123#define RTL8366_PORT_5                      (1 << 4) /* In userspace port 4 */
124
125#define RTL8366_PORT_CPU                    (1 << 5) /* CPU port */
126
127#define RTL8366_PORT_ALL                    (RTL8366_PORT_1 |       \
128                                             RTL8366_PORT_2 |       \
129                                             RTL8366_PORT_3 |       \
130                                             RTL8366_PORT_4 |       \
131                                             RTL8366_PORT_5 |       \
132                                             RTL8366_PORT_CPU)
133
134#define RTL8366_PORT_ALL_BUT_CPU            (RTL8366_PORT_1 |       \
135                                             RTL8366_PORT_2 |       \
136                                             RTL8366_PORT_3 |       \
137                                             RTL8366_PORT_4 |       \
138                                             RTL8366_PORT_5)
139
140#define RTL8366_PORT_ALL_EXTERNAL           (RTL8366_PORT_1 |       \
141                                             RTL8366_PORT_2 |       \
142                                             RTL8366_PORT_3 |       \
143                                             RTL8366_PORT_4)
144
145#define RTL8366_PORT_ALL_INTERNAL            RTL8366_PORT_CPU
146
147struct rtl8366rb {
148        struct device           *parent;
149        struct rtl8366_smi      smi;
150        struct switch_dev       dev;
151        char                    buf[4096];
152#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
153        struct dentry           *debugfs_root;
154#endif
155};
156
157struct rtl8366rb_vlanconfig {
158        u16     reserved2:1;
159        u16     priority:3;
160        u16     vid:12;
161        u16     untag:8;
162        u16     member:8;
163        u16     stag_mbr:8;
164        u16     stag_idx:3;
165        u16     reserved1:2;
166        u16     fid:3;
167};
168
169struct rtl8366rb_vlan4kentry {
170        u16     reserved1:4;
171        u16     vid:12;
172        u16     untag:8;
173        u16     member:8;
174        u16     reserved2:13;
175        u16     fid:3;
176};
177
178
179#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
180u16 gl_dbg_reg;
181#endif
182
183struct mib_counter {
184        unsigned        offset;
185        unsigned        length;
186        const char      *name;
187};
188
189static struct mib_counter rtl8366rb_mib_counters[RTL8366S_MIB_COUNT] = {
190        {  0, 4, "IfInOctets                        " },
191        {  4, 4, "EtherStatsOctets                  " },
192        {  8, 2, "EtherStatsUnderSizePkts           " },
193        { 10, 2, "EtherFregament                    " },
194        { 12, 2, "EtherStatsPkts64Octets            " },
195        { 14, 2, "EtherStatsPkts65to127Octets       " },
196        { 16, 2, "EtherStatsPkts128to255Octets      " },
197        { 18, 2, "EtherStatsPkts256to511Octets      " },
198        { 20, 2, "EtherStatsPkts512to1023Octets     " },
199        { 22, 2, "EtherStatsPkts1024to1518Octets    " },
200        { 24, 2, "EtherOversizeStats                " },
201        { 26, 2, "EtherStatsJabbers                 " },
202        { 28, 2, "IfInUcastPkts                     " },
203        { 30, 2, "EtherStatsMulticastPkts           " },
204        { 32, 2, "EtherStatsBroadcastPkts           " },
205        { 34, 2, "EtherStatsDropEvents              " },
206        { 36, 2, "Dot3StatsFCSErrors                " },
207        { 38, 2, "Dot3StatsSymbolErrors             " },
208        { 40, 2, "Dot3InPauseFrames                 " },
209        { 42, 2, "Dot3ControlInUnknownOpcodes       " },
210        { 44, 4, "IfOutOctets                       " },
211        { 48, 2, "Dot3StatsSingleCollisionFrames    " },
212        { 50, 2, "Dot3StatMultipleCollisionFrames   " },
213        { 52, 2, "Dot3sDeferredTransmissions        " },
214        { 54, 2, "Dot3StatsLateCollisions           " },
215        { 56, 2, "EtherStatsCollisions              " },
216        { 58, 2, "Dot3StatsExcessiveCollisions      " },
217        { 60, 2, "Dot3OutPauseFrames                " },
218        { 62, 2, "Dot1dBasePortDelayExceededDiscards" },
219        { 64, 2, "Dot1dTpPortInDiscards             " },
220        { 66, 2, "IfOutUcastPkts                    " },
221        { 68, 2, "IfOutMulticastPkts                " },
222        { 70, 2, "IfOutBroadcastPkts                " },
223};
224
225static inline struct rtl8366rb *smi_to_rtl8366rb(struct rtl8366_smi *smi)
226{
227        return container_of(smi, struct rtl8366rb, smi);
228}
229
230static inline struct rtl8366rb *sw_to_rtl8366rb(struct switch_dev *sw)
231{
232        return container_of(sw, struct rtl8366rb, dev);
233}
234
235static int rtl8366rb_reset_chip(struct rtl8366rb *rtl)
236{
237        struct rtl8366_smi *smi = &rtl->smi;
238        int timeout = 10;
239        u32 data;
240
241        rtl8366_smi_write_reg(smi, RTL8366_RESET_CTRL_REG,
242                              RTL8366_CHIP_CTRL_RESET_HW);
243        do {
244                msleep(1);
245                if (rtl8366_smi_read_reg(smi, RTL8366_RESET_CTRL_REG, &data))
246                        return -EIO;
247
248                if (!(data & RTL8366_CHIP_CTRL_RESET_HW))
249                        break;
250        } while (--timeout);
251
252        if (!timeout) {
253                printk("Timeout waiting for the switch to reset\n");
254                return -EIO;
255        }
256
257        return 0;
258}
259
260static int rtl8366rb_read_phy_reg(struct rtl8366_smi *smi,
261                                 u32 phy_no, u32 page, u32 addr, u32 *data)
262{
263        u32 reg;
264        int ret;
265
266        if (phy_no > RTL8366S_PHY_NO_MAX)
267                return -EINVAL;
268
269        if (page > RTL8366S_PHY_PAGE_MAX)
270                return -EINVAL;
271
272        if (addr > RTL8366S_PHY_ADDR_MAX)
273                return -EINVAL;
274
275        ret = rtl8366_smi_write_reg(smi, RTL8366S_PHY_ACCESS_CTRL_REG,
276                                    RTL8366S_PHY_CTRL_READ);
277        if (ret)
278                return ret;
279
280        reg = 0x8000 | (1 << (phy_no + RTL8366S_PHY_NO_OFFSET)) |
281              ((page << RTL8366S_PHY_PAGE_OFFSET) & RTL8366S_PHY_PAGE_MASK) |
282              (addr & RTL8366S_PHY_REG_MASK);
283
284        ret = rtl8366_smi_write_reg(smi, reg, 0);
285        if (ret)
286                return ret;
287
288        ret = rtl8366_smi_read_reg(smi, RTL8366S_PHY_ACCESS_DATA_REG, data);
289        if (ret)
290                return ret;
291
292        return 0;
293}
294
295static int rtl8366rb_write_phy_reg(struct rtl8366_smi *smi,
296                                  u32 phy_no, u32 page, u32 addr, u32 data)
297{
298        u32 reg;
299        int ret;
300
301        if (phy_no > RTL8366S_PHY_NO_MAX)
302                return -EINVAL;
303
304        if (page > RTL8366S_PHY_PAGE_MAX)
305                return -EINVAL;
306
307        if (addr > RTL8366S_PHY_ADDR_MAX)
308                return -EINVAL;
309
310        ret = rtl8366_smi_write_reg(smi, RTL8366S_PHY_ACCESS_CTRL_REG,
311                                    RTL8366S_PHY_CTRL_WRITE);
312        if (ret)
313                return ret;
314
315        reg = 0x8000 | (1 << (phy_no + RTL8366S_PHY_NO_OFFSET)) |
316              ((page << RTL8366S_PHY_PAGE_OFFSET) & RTL8366S_PHY_PAGE_MASK) |
317              (addr & RTL8366S_PHY_REG_MASK);
318
319        ret = rtl8366_smi_write_reg(smi, reg, data);
320        if (ret)
321                return ret;
322
323        return 0;
324}
325
326static int rtl8366_get_mib_counter(struct rtl8366rb *rtl, int counter,
327                                   int port, unsigned long long *val)
328{
329        struct rtl8366_smi *smi = &rtl->smi;
330        int i;
331        int err;
332        u32 addr, data;
333        u64 mibvalue;
334
335        if (port > RTL8366_NUM_PORTS || counter >= RTL8366S_MIB_COUNT)
336                return -EINVAL;
337
338        addr = RTL8366S_MIB_COUNTER_BASE +
339               RTL8366S_MIB_COUNTER_PORT_OFFSET * (port) +
340               rtl8366rb_mib_counters[counter].offset;
341
342        /*
343         * Writing access counter address first
344         * then ASIC will prepare 64bits counter wait for being retrived
345         */
346        data = 0; /* writing data will be discard by ASIC */
347        err = rtl8366_smi_write_reg(smi, addr, data);
348        if (err)
349                return err;
350
351        /* read MIB control register */
352        err =  rtl8366_smi_read_reg(smi, RTL8366S_MIB_CTRL_REG, &data);
353        if (err)
354                return err;
355
356        if (data & RTL8366S_MIB_CTRL_BUSY_MASK)
357                return -EBUSY;
358
359        if (data & RTL8366S_MIB_CTRL_RESET_MASK)
360                return -EIO;
361
362        mibvalue = 0;
363        for (i = rtl8366rb_mib_counters[counter].length; i > 0; i--) {
364                err = rtl8366_smi_read_reg(smi, addr + (i - 1), &data);
365                if (err)
366                        return err;
367
368                mibvalue = (mibvalue << 16) | (data & 0xFFFF);
369        }
370
371        *val = mibvalue;
372        return 0;
373}
374
375static int rtl8366rb_get_vlan_4k_entry(struct rtl8366rb *rtl, u32 vid,
376                                      struct rtl8366rb_vlan4kentry *vlan4k)
377{
378        struct rtl8366_smi *smi = &rtl->smi;
379        int err;
380        u32 data;
381        u16 *tableaddr;
382
383        memset(vlan4k, '\0', sizeof(struct rtl8366rb_vlan4kentry));
384        vlan4k->vid = vid;
385
386        if (vid >= RTL8366_NUM_VIDS)
387                return -EINVAL;
388
389        tableaddr = (u16 *)vlan4k;
390
391        /* write VID */
392        data = *tableaddr;
393        err = rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TABLE_WRITE_BASE, data);
394        if (err)
395                return err;
396
397        /* write table access control word */
398        err = rtl8366_smi_write_reg(smi, RTL8366S_TABLE_ACCESS_CTRL_REG,
399                                    RTL8366S_TABLE_VLAN_READ_CTRL);
400        if (err)
401                return err;
402
403        err = rtl8366_smi_read_reg(smi, RTL8366S_VLAN_TABLE_READ_BASE, &data);
404        if (err)
405                return err;
406
407        *tableaddr = data;
408        tableaddr++;
409
410        err = rtl8366_smi_read_reg(smi, RTL8366S_VLAN_TABLE_READ_BASE + 1,
411                                   &data);
412        if (err)
413                return err;
414
415        *tableaddr = data;
416        tableaddr++;
417
418        err = rtl8366_smi_read_reg(smi, RTL8366S_VLAN_TABLE_READ_BASE + 2,
419                                   &data);
420        if (err)
421                return err;
422        *tableaddr = data;
423        vlan4k->vid = vid;
424
425        return 0;
426}
427
428static int rtl8366rb_set_vlan_4k_entry(struct rtl8366rb *rtl,
429                                      const struct rtl8366rb_vlan4kentry *vlan4k)
430{
431        struct rtl8366_smi *smi = &rtl->smi;
432        int err;
433        u32 data;
434        u16 *tableaddr;
435
436        if (vlan4k->vid >= RTL8366_NUM_VIDS ||
437            vlan4k->member > RTL8366_PORT_ALL ||
438            vlan4k->untag > RTL8366_PORT_ALL ||
439            vlan4k->fid > RTL8366S_FIDMAX)
440                return -EINVAL;
441
442        tableaddr = (u16 *)vlan4k;
443
444        data = *tableaddr;
445
446        err = rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TABLE_WRITE_BASE, data);
447        if (err)
448                return err;
449
450        tableaddr++;
451
452        data = *tableaddr;
453
454        err = rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TABLE_WRITE_BASE + 1,
455                                    data);
456        if (err)
457                return err;
458
459        tableaddr++;
460
461        data = *tableaddr;
462
463        err = rtl8366_smi_write_reg(smi, RTL8366S_VLAN_TABLE_WRITE_BASE + 2,
464                                    data);
465        if (err)
466                return err;
467
468        /* write table access control word */
469        err = rtl8366_smi_write_reg(smi, RTL8366S_TABLE_ACCESS_CTRL_REG,
470                                    RTL8366S_TABLE_VLAN_WRITE_CTRL);
471
472        return err;
473}
474
475static int rtl8366rb_get_vlan_member_config(struct rtl8366rb *rtl, u32 index,
476                                           struct rtl8366rb_vlanconfig *vlanmc)
477{
478        struct rtl8366_smi *smi = &rtl->smi;
479        int err;
480        u32 addr;
481        u32 data;
482        u16 *tableaddr;
483
484        memset(vlanmc, '\0', sizeof(struct rtl8366rb_vlanconfig));
485
486        if (index >= RTL8366_NUM_VLANS)
487                return -EINVAL;
488
489        tableaddr = (u16 *)vlanmc;
490
491        addr = RTL8366S_VLAN_MEMCONF_BASE + (index * 3);
492        err = rtl8366_smi_read_reg(smi, addr, &data);
493        if (err)
494                return err;
495
496        *tableaddr = data;
497        tableaddr++;
498
499        addr = RTL8366S_VLAN_MEMCONF_BASE + 1 + (index * 3);
500        err = rtl8366_smi_read_reg(smi, addr, &data);
501        if (err)
502                return err;
503
504        *tableaddr = data;
505        tableaddr++;
506
507        addr = RTL8366S_VLAN_MEMCONF_BASE + 2 + (index * 3);
508        err = rtl8366_smi_read_reg(smi, addr, &data);
509        if (err)
510                return err;
511
512        *tableaddr = data;
513
514        return 0;
515}
516
517static int rtl8366rb_set_vlan_member_config(struct rtl8366rb *rtl, u32 index,
518                                           const struct rtl8366rb_vlanconfig
519                                           *vlanmc)
520{
521        struct rtl8366_smi *smi = &rtl->smi;
522        int err;
523        u32 addr;
524        u32 data;
525        u16 *tableaddr;
526
527        if (index >= RTL8366_NUM_VLANS ||
528            vlanmc->vid >= RTL8366_NUM_VIDS ||
529            vlanmc->priority > RTL8366S_PRIORITYMAX ||
530            vlanmc->member > RTL8366_PORT_ALL ||
531            vlanmc->untag > RTL8366_PORT_ALL ||
532            vlanmc->fid > RTL8366S_FIDMAX)
533                return -EINVAL;
534
535        addr = RTL8366S_VLAN_MEMCONF_BASE + (index * 3);
536
537        tableaddr = (u16 *)vlanmc;
538        data = *tableaddr;
539
540        err = rtl8366_smi_write_reg(smi, addr, data);
541        if (err)
542                return err;
543
544        addr = RTL8366S_VLAN_MEMCONF_BASE + 1 + (index * 3);
545
546        tableaddr++;
547        data = *tableaddr;
548
549        err = rtl8366_smi_write_reg(smi, addr, data);
550        if (err)
551                return err;
552
553        addr = RTL8366S_VLAN_MEMCONF_BASE + 2 + (index * 3);
554
555        tableaddr++;
556        data = *tableaddr;
557
558        err = rtl8366_smi_write_reg(smi, addr, data);
559        if (err)
560                return err;
561        return 0;
562}
563
564static int rtl8366rb_get_port_vlan_index(struct rtl8366rb *rtl, int port,
565                                       int *val)
566{
567        struct rtl8366_smi *smi = &rtl->smi;
568        u32 data;
569        int err;
570
571        if (port >= RTL8366_NUM_PORTS)
572                return -EINVAL;
573
574        err = rtl8366_smi_read_reg(smi, RTL8366S_PORT_VLAN_CTRL_REG(port),
575                                   &data);
576        if (err)
577                return err;
578
579        *val = (data >> RTL8366S_PORT_VLAN_CTRL_SHIFT(port)) &
580               RTL8366S_PORT_VLAN_CTRL_MASK;
581
582        return 0;
583
584}
585
586static int rtl8366rb_get_vlan_port_pvid(struct rtl8366rb *rtl, int port,
587                                       int *val)
588{
589        struct rtl8366rb_vlanconfig vlanmc;
590        int err;
591        int index;
592
593        err = rtl8366rb_get_port_vlan_index(rtl, port, &index);
594        if (err)
595                return err;
596
597        err = rtl8366rb_get_vlan_member_config(rtl, index, &vlanmc);
598        if (err)
599                return err;
600
601        *val = vlanmc.vid;
602        return 0;
603}
604
605static int rtl8366rb_set_port_vlan_index(struct rtl8366rb *rtl, int port,
606                                        int index)
607{
608        struct rtl8366_smi *smi = &rtl->smi;
609        u32 data;
610        int err;
611
612        if (port >= RTL8366_NUM_PORTS || index >= RTL8366_NUM_VLANS)
613                return -EINVAL;
614
615        err = rtl8366_smi_read_reg(smi, RTL8366S_PORT_VLAN_CTRL_REG(port),
616                                   &data);
617        if (err)
618                return err;
619
620        data &= ~(RTL8366S_PORT_VLAN_CTRL_MASK <<
621                  RTL8366S_PORT_VLAN_CTRL_SHIFT(port));
622        data |= (index & RTL8366S_PORT_VLAN_CTRL_MASK) <<
623                 RTL8366S_PORT_VLAN_CTRL_SHIFT(port);
624
625        err = rtl8366_smi_write_reg(smi, RTL8366S_PORT_VLAN_CTRL_REG(port),
626                                    data);
627        return err;
628}
629
630static int rtl8366rb_set_vlan_port_pvid(struct rtl8366rb *rtl, int port, int val)
631{
632        int i;
633        struct rtl8366rb_vlanconfig vlanmc;
634        struct rtl8366rb_vlan4kentry vlan4k;
635
636        if (port >= RTL8366_NUM_PORTS || val >= RTL8366_NUM_VIDS)
637                return -EINVAL;
638
639        /* Updating the 4K entry; lookup it and change the port member set */
640        rtl8366rb_get_vlan_4k_entry(rtl, val, &vlan4k);
641        vlan4k.member |= ((1 << port) | RTL8366_PORT_CPU);
642        vlan4k.untag = RTL8366_PORT_ALL_BUT_CPU;
643        rtl8366rb_set_vlan_4k_entry(rtl, &vlan4k);
644
645        /*
646         * For the 16 entries more work needs to be done. First see if such
647         * VID is already there and change it
648         */
649        for (i = 0; i < RTL8366_NUM_VLANS; ++i) {
650                rtl8366rb_get_vlan_member_config(rtl, i, &vlanmc);
651
652                /* Try to find an existing vid and update port member set */
653                if (val == vlanmc.vid) {
654                        vlanmc.member |= ((1 << port) | RTL8366_PORT_CPU);
655                        rtl8366rb_set_vlan_member_config(rtl, i, &vlanmc);
656
657                        /* Now update PVID register settings */
658                        rtl8366rb_set_port_vlan_index(rtl, port, i);
659
660                        return 0;
661                }
662        }
663
664        /*
665         * PVID could not be found from vlan table. Replace unused (one that
666         * has no member ports) with new one
667         */
668        for (i = 0; i < RTL8366_NUM_VLANS; ++i) {
669                rtl8366rb_get_vlan_member_config(rtl, i, &vlanmc);
670
671                /*
672                 * See if this vlan member configuration is unused. It is
673                 * unused if member set contains no ports or CPU port only
674                 */
675                if (!vlanmc.member || vlanmc.member == RTL8366_PORT_CPU) {
676                        vlanmc.vid = val;
677                        vlanmc.priority = 0;
678                        vlanmc.untag = RTL8366_PORT_ALL_BUT_CPU;
679                        vlanmc.member = ((1 << port) | RTL8366_PORT_CPU);
680                        vlanmc.fid = 0;
681
682                        rtl8366rb_set_vlan_member_config(rtl, i, &vlanmc);
683
684                        /* Now update PVID register settings */
685                        rtl8366rb_set_port_vlan_index(rtl, port, i);
686
687                        return 0;
688                }
689        }
690
691        dev_err(rtl->parent,
692                "All 16 vlan member configurations are in use\n");
693
694        return -EINVAL;
695}
696
697
698static int rtl8366rb_vlan_set_vlan(struct rtl8366rb *rtl, int enable)
699{
700        struct rtl8366_smi *smi = &rtl->smi;
701        u32 data = 0;
702
703        rtl8366_smi_read_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, &data);
704
705        if (enable)
706                data |= RTL8366_CHIP_CTRL_VLAN;
707        else
708                data &= ~RTL8366_CHIP_CTRL_VLAN;
709
710        return rtl8366_smi_write_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, data);
711}
712
713static int rtl8366rb_vlan_set_4ktable(struct rtl8366rb *rtl, int enable)
714{
715        struct rtl8366_smi *smi = &rtl->smi;
716        u32 data = 0;
717
718        rtl8366_smi_read_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, &data);
719
720        if (enable)
721                data |= RTL8366_CHIP_CTRL_VLAN_4KTB;
722        else
723                data &= ~RTL8366_CHIP_CTRL_VLAN_4KTB;
724
725        return rtl8366_smi_write_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, data);
726}
727
728static int rtl8366rb_reset_vlan(struct rtl8366rb *rtl)
729{
730        struct rtl8366rb_vlan4kentry vlan4k;
731        struct rtl8366rb_vlanconfig vlanmc;
732        int err;
733        int i;
734
735        /* clear 16 VLAN member configuration */
736        vlanmc.vid = 0;
737        vlanmc.priority = 0;
738        vlanmc.member = 0;
739        vlanmc.untag = 0;
740        vlanmc.fid = 0;
741        for (i = 0; i < RTL8366_NUM_VLANS; i++) {
742                err = rtl8366rb_set_vlan_member_config(rtl, i, &vlanmc);
743                if (err)
744                        return err;
745        }
746
747        /* Set a default VLAN with vid 1 to 4K table for all ports */
748        vlan4k.vid = 1;
749        vlan4k.member = RTL8366_PORT_ALL;
750        vlan4k.untag = RTL8366_PORT_ALL;
751        vlan4k.fid = 0;
752        err = rtl8366rb_set_vlan_4k_entry(rtl, &vlan4k);
753        if (err)
754                return err;
755
756        /* Set all ports PVID to default VLAN */
757        for (i = 0; i < RTL8366_NUM_PORTS; i++) {
758                err = rtl8366rb_set_vlan_port_pvid(rtl, i, 0);
759                if (err)
760                        return err;
761        }
762
763        return 0;
764}
765
766#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
767static int rtl8366rb_debugfs_open(struct inode *inode, struct file *file)
768{
769        file->private_data = inode->i_private;
770        return 0;
771}
772
773static ssize_t rtl8366rb_read_debugfs_mibs(struct file *file,
774                                          char __user *user_buf,
775                                          size_t count, loff_t *ppos)
776{
777        struct rtl8366rb *rtl = (struct rtl8366rb *)file->private_data;
778        int i, j, len = 0;
779        char *buf = rtl->buf;
780
781        len += snprintf(buf + len, sizeof(rtl->buf) - len, "MIB Counters:\n");
782        len += snprintf(buf + len, sizeof(rtl->buf) - len, "Counter"
783                        "                            "
784                        "Port 0 \t\t Port 1 \t\t Port 2 \t\t Port 3 \t\t "
785                        "Port 4\n");
786
787        for (i = 0; i < 33; ++i) {
788                len += snprintf(buf + len, sizeof(rtl->buf) - len, "%d:%s ",
789                                i, rtl8366rb_mib_counters[i].name);
790                for (j = 0; j < RTL8366_NUM_PORTS; ++j) {
791                        unsigned long long counter = 0;
792
793                        if (!rtl8366_get_mib_counter(rtl, i, j, &counter))
794                                len += snprintf(buf + len,
795                                                sizeof(rtl->buf) - len,
796                                                "[%llu]", counter);
797                        else
798                                len += snprintf(buf + len,
799                                                sizeof(rtl->buf) - len,
800                                                "[error]");
801
802                        if (j != RTL8366_NUM_PORTS - 1) {
803                                if (counter < 100000)
804                                        len += snprintf(buf + len,
805                                                        sizeof(rtl->buf) - len,
806                                                        "\t");
807
808                                len += snprintf(buf + len,
809                                                sizeof(rtl->buf) - len,
810                                                "\t");
811                        }
812                }
813                len += snprintf(buf + len, sizeof(rtl->buf) - len, "\n");
814        }
815
816        len += snprintf(buf + len, sizeof(rtl->buf) - len, "\n");
817
818        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
819}
820
821static ssize_t rtl8366rb_read_debugfs_vlan(struct file *file,
822                                          char __user *user_buf,
823                                          size_t count, loff_t *ppos)
824{
825        struct rtl8366rb *rtl = (struct rtl8366rb *)file->private_data;
826        int i, j, len = 0;
827        char *buf = rtl->buf;
828
829        len += snprintf(buf + len, sizeof(rtl->buf) - len,
830                        "VLAN Member Config:\n");
831        len += snprintf(buf + len, sizeof(rtl->buf) - len,
832                        "\t id \t vid \t prio \t member \t untag  \t fid "
833                        "\tports\n");
834
835        for (i = 0; i < RTL8366_NUM_VLANS; ++i) {
836                struct rtl8366rb_vlanconfig vlanmc;
837
838                rtl8366rb_get_vlan_member_config(rtl, i, &vlanmc);
839
840                len += snprintf(buf + len, sizeof(rtl->buf) - len,
841                                "\t[%d] \t %d \t %d \t 0x%04x \t 0x%04x \t %d "
842                                "\t", i, vlanmc.vid, vlanmc.priority,
843                                vlanmc.member, vlanmc.untag, vlanmc.fid);
844
845                for (j = 0; j < RTL8366_NUM_PORTS; ++j) {
846                        int index = 0;
847                        if (!rtl8366rb_get_port_vlan_index(rtl, j, &index)) {
848                                if (index == i)
849                                        len += snprintf(buf + len,
850                                                        sizeof(rtl->buf) - len,
851                                                        "%d", j);
852                        }
853                }
854                len += snprintf(buf + len, sizeof(rtl->buf) - len, "\n");
855        }
856
857        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
858}
859
860static ssize_t rtl8366rb_read_debugfs_reg(struct file *file,
861                                         char __user *user_buf,
862                                         size_t count, loff_t *ppos)
863{
864        struct rtl8366rb *rtl = (struct rtl8366rb *)file->private_data;
865        struct rtl8366_smi *smi = &rtl->smi;
866        u32 t, reg = gl_dbg_reg;
867        int err, len = 0;
868        char *buf = rtl->buf;
869
870        memset(buf, '\0', sizeof(rtl->buf));
871
872        err = rtl8366_smi_read_reg(smi, reg, &t);
873        if (err) {
874                len += snprintf(buf, sizeof(rtl->buf),
875                                "Read failed (reg: 0x%04x)\n", reg);
876                return simple_read_from_buffer(user_buf, count, ppos, buf, len);
877        }
878
879        len += snprintf(buf, sizeof(rtl->buf), "reg = 0x%04x, val = 0x%04x\n",
880                        reg, t);
881
882        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
883}
884
885static ssize_t rtl8366rb_write_debugfs_reg(struct file *file,
886                                          const char __user *user_buf,
887                                          size_t count, loff_t *ppos)
888{
889        struct rtl8366rb *rtl = (struct rtl8366rb *)file->private_data;
890        struct rtl8366_smi *smi = &rtl->smi;
891        unsigned long data;
892        u32 reg = gl_dbg_reg;
893        int err;
894        size_t len;
895        char *buf = rtl->buf;
896
897        len = min(count, sizeof(rtl->buf) - 1);
898        if (copy_from_user(buf, user_buf, len)) {
899                dev_err(rtl->parent, "copy from user failed\n");
900                return -EFAULT;
901        }
902
903        buf[len] = '\0';
904        if (len > 0 && buf[len - 1] == '\n')
905                buf[len - 1] = '\0';
906
907
908        if (strict_strtoul(buf, 16, &data)) {
909                dev_err(rtl->parent, "Invalid reg value %s\n", buf);
910        } else {
911                err = rtl8366_smi_write_reg(smi, reg, data);
912                if (err) {
913                        dev_err(rtl->parent,
914                                "writing reg 0x%04x val 0x%04lx failed\n",
915                                reg, data);
916                }
917        }
918
919        return count;
920}
921
922static const struct file_operations fops_rtl8366rb_regs = {
923        .read = rtl8366rb_read_debugfs_reg,
924        .write = rtl8366rb_write_debugfs_reg,
925        .open = rtl8366rb_debugfs_open,
926        .owner = THIS_MODULE
927};
928
929static const struct file_operations fops_rtl8366rb_vlan = {
930        .read = rtl8366rb_read_debugfs_vlan,
931        .open = rtl8366rb_debugfs_open,
932        .owner = THIS_MODULE
933};
934
935static const struct file_operations fops_rtl8366rb_mibs = {
936        .read = rtl8366rb_read_debugfs_mibs,
937        .open = rtl8366rb_debugfs_open,
938        .owner = THIS_MODULE
939};
940
941static void rtl8366rb_debugfs_init(struct rtl8366rb *rtl)
942{
943        struct dentry *node;
944        struct dentry *root;
945
946        if (!rtl->debugfs_root)
947                rtl->debugfs_root = debugfs_create_dir("rtl8366rb", NULL);
948
949        if (!rtl->debugfs_root) {
950                dev_err(rtl->parent, "Unable to create debugfs dir\n");
951                return;
952        }
953        root = rtl->debugfs_root;
954
955        node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root, &gl_dbg_reg);
956        if (!node) {
957                dev_err(rtl->parent, "Creating debugfs file '%s' failed\n",
958                        "reg");
959                return;
960        }
961
962        node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, rtl,
963                                   &fops_rtl8366rb_regs);
964        if (!node) {
965                dev_err(rtl->parent, "Creating debugfs file '%s' failed\n",
966                        "val");
967                return;
968        }
969
970        node = debugfs_create_file("vlan", S_IRUSR, root, rtl,
971                                   &fops_rtl8366rb_vlan);
972        if (!node) {
973                dev_err(rtl->parent, "Creating debugfs file '%s' failed\n",
974                        "vlan");
975                return;
976        }
977
978        node = debugfs_create_file("mibs", S_IRUSR, root, rtl,
979                                   &fops_rtl8366rb_mibs);
980        if (!node) {
981                dev_err(rtl->parent, "Creating debugfs file '%s' failed\n",
982                        "mibs");
983                return;
984        }
985}
986
987static void rtl8366rb_debugfs_remove(struct rtl8366rb *rtl)
988{
989        if (rtl->debugfs_root) {
990                debugfs_remove_recursive(rtl->debugfs_root);
991                rtl->debugfs_root = NULL;
992        }
993}
994
995#else
996static inline void rtl8366rb_debugfs_init(struct rtl8366rb *rtl) {}
997static inline void rtl8366rb_debugfs_remove(struct rtl8366rb *rtl) {}
998#endif /* CONFIG_RTL8366S_PHY_DEBUG_FS */
999
1000static int rtl8366rb_sw_reset_mibs(struct switch_dev *dev,
1001                                  const struct switch_attr *attr,
1002                                  struct switch_val *val)
1003{
1004        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1005        struct rtl8366_smi *smi = &rtl->smi;
1006        u32 data = 0;
1007
1008        if (val->value.i == 1) {
1009                rtl8366_smi_read_reg(smi, RTL8366S_MIB_CTRL_REG, &data);
1010                data |= (1 << 2);
1011                rtl8366_smi_write_reg(smi, RTL8366S_MIB_CTRL_REG, data);
1012        }
1013
1014        return 0;
1015}
1016
1017static int rtl8366rb_sw_get_vlan_enable(struct switch_dev *dev,
1018                                       const struct switch_attr *attr,
1019                                       struct switch_val *val)
1020{
1021        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1022        struct rtl8366_smi *smi = &rtl->smi;
1023        u32 data;
1024
1025        if (attr->ofs == 1) {
1026                rtl8366_smi_read_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, &data);
1027
1028                if (data & RTL8366_CHIP_CTRL_VLAN)
1029                        val->value.i = 1;
1030                else
1031                        val->value.i = 0;
1032        } else if (attr->ofs == 2) {
1033                rtl8366_smi_read_reg(smi, RTL8366_CHIP_GLOBAL_CTRL_REG, &data);
1034
1035                if (data & RTL8366_CHIP_CTRL_VLAN_4KTB)
1036                        val->value.i = 1;
1037                else
1038                        val->value.i = 0;
1039        }
1040
1041        return 0;
1042}
1043
1044static int rtl8366rb_sw_get_blinkrate(struct switch_dev *dev,
1045                                     const struct switch_attr *attr,
1046                                     struct switch_val *val)
1047{
1048        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1049        struct rtl8366_smi *smi = &rtl->smi;
1050        u32 data;
1051
1052        rtl8366_smi_read_reg(smi, RTL8366_LED_BLINKRATE_REG, &data);
1053
1054        val->value.i = (data & (RTL8366_LED_BLINKRATE_MASK));
1055
1056        return 0;
1057}
1058
1059static int rtl8366rb_sw_set_blinkrate(struct switch_dev *dev,
1060                                    const struct switch_attr *attr,
1061                                    struct switch_val *val)
1062{
1063        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1064        struct rtl8366_smi *smi = &rtl->smi;
1065        u32 data;
1066
1067        if (val->value.i >= 6)
1068                return -EINVAL;
1069
1070        rtl8366_smi_read_reg(smi, RTL8366_LED_BLINKRATE_REG, &data);
1071
1072        data &= ~RTL8366_LED_BLINKRATE_MASK;
1073        data |= val->value.i;
1074
1075        rtl8366_smi_write_reg(smi, RTL8366_LED_BLINKRATE_REG, data);
1076
1077        return 0;
1078}
1079
1080static int rtl8366rb_sw_set_vlan_enable(struct switch_dev *dev,
1081                                       const struct switch_attr *attr,
1082                                       struct switch_val *val)
1083{
1084        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1085
1086        if (attr->ofs == 1)
1087                return rtl8366rb_vlan_set_vlan(rtl, val->value.i);
1088        else
1089                return rtl8366rb_vlan_set_4ktable(rtl, val->value.i);
1090}
1091
1092static const char *rtl8366rb_speed_str(unsigned speed)
1093{
1094        switch (speed) {
1095        case 0:
1096                return "10baseT";
1097        case 1:
1098                return "100baseT";
1099        case 2:
1100                return "1000baseT";
1101        }
1102
1103        return "unknown";
1104}
1105
1106static int rtl8366rb_sw_get_port_link(struct switch_dev *dev,
1107                                     const struct switch_attr *attr,
1108                                     struct switch_val *val)
1109{
1110        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1111        struct rtl8366_smi *smi = &rtl->smi;
1112        u32 len = 0, data = 0;
1113
1114        if (val->port_vlan >= RTL8366_NUM_PORTS)
1115                return -EINVAL;
1116
1117        memset(rtl->buf, '\0', sizeof(rtl->buf));
1118        rtl8366_smi_read_reg(smi, RTL8366S_PORT_LINK_STATUS_BASE +
1119                             (val->port_vlan / 2), &data);
1120
1121        if (val->port_vlan % 2)
1122                data = data >> 8;
1123
1124        if (data & RTL8366S_PORT_STATUS_LINK_MASK) {
1125                len = snprintf(rtl->buf, sizeof(rtl->buf),
1126                                "port:%d link:up speed:%s %s-duplex %s%s%s",
1127                                val->port_vlan,
1128                                rtl8366rb_speed_str(data &
1129                                          RTL8366S_PORT_STATUS_SPEED_MASK),
1130                                (data & RTL8366S_PORT_STATUS_DUPLEX_MASK) ?
1131                                        "full" : "half",
1132                                (data & RTL8366S_PORT_STATUS_TXPAUSE_MASK) ?
1133                                        "tx-pause ": "",
1134                                (data & RTL8366S_PORT_STATUS_RXPAUSE_MASK) ?
1135                                        "rx-pause " : "",
1136                                (data & RTL8366S_PORT_STATUS_AN_MASK) ?
1137                                        "nway ": "");
1138        } else {
1139                len = snprintf(rtl->buf, sizeof(rtl->buf), "port:%d link: down",
1140                                val->port_vlan);
1141        }
1142
1143        val->value.s = rtl->buf;
1144        val->len = len;
1145
1146        return 0;
1147}
1148
1149static int rtl8366rb_sw_get_vlan_info(struct switch_dev *dev,
1150                                     const struct switch_attr *attr,
1151                                     struct switch_val *val)
1152{
1153        int i;
1154        u32 len = 0;
1155        struct rtl8366rb_vlanconfig vlanmc;
1156        struct rtl8366rb_vlan4kentry vlan4k;
1157        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1158        char *buf = rtl->buf;
1159
1160        if (val->port_vlan == 0 || val->port_vlan >= RTL8366_NUM_VLANS)
1161                return -EINVAL;
1162
1163        memset(buf, '\0', sizeof(rtl->buf));
1164
1165        rtl8366rb_get_vlan_member_config(rtl, val->port_vlan, &vlanmc);
1166        rtl8366rb_get_vlan_4k_entry(rtl, vlanmc.vid, &vlan4k);
1167
1168        len += snprintf(buf + len, sizeof(rtl->buf) - len, "VLAN %d: Ports: ",
1169                        val->port_vlan);
1170
1171        for (i = 0; i < RTL8366_NUM_PORTS; ++i) {
1172                int index = 0;
1173                if (!rtl8366rb_get_port_vlan_index(rtl, i, &index) &&
1174                    index == val->port_vlan)
1175                        len += snprintf(buf + len, sizeof(rtl->buf) - len,
1176                                        "%d", i);
1177        }
1178        len += snprintf(buf + len, sizeof(rtl->buf) - len, "\n");
1179
1180        len += snprintf(buf + len, sizeof(rtl->buf) - len,
1181                        "\t\t vid \t prio \t member \t untag \t fid\n");
1182        len += snprintf(buf + len, sizeof(rtl->buf) - len, "\tMC:\t");
1183        len += snprintf(buf + len, sizeof(rtl->buf) - len,
1184                        "%d \t %d \t 0x%04x \t 0x%04x \t %d\n",
1185                        vlanmc.vid, vlanmc.priority, vlanmc.member,
1186                        vlanmc.untag, vlanmc.fid);
1187        len += snprintf(buf + len, sizeof(rtl->buf) - len, "\t4K:\t");
1188        len += snprintf(buf + len, sizeof(rtl->buf) - len,
1189                        "%d \t  \t 0x%04x \t 0x%04x \t %d",
1190                        vlan4k.vid, vlan4k.member, vlan4k.untag, vlan4k.fid);
1191
1192        val->value.s = buf;
1193        val->len = len;
1194
1195        return 0;
1196}
1197
1198static int rtl8366rb_sw_set_port_led(struct switch_dev *dev,
1199                                    const struct switch_attr *attr,
1200                                    struct switch_val *val)
1201{
1202        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1203        struct rtl8366_smi *smi = &rtl->smi;
1204        u32 data = 0;
1205
1206        if (val->port_vlan >= RTL8366_NUM_PORTS)
1207                return -EINVAL;
1208
1209        if (val->port_vlan == RTL8366_PORT_NUM_CPU) {
1210                rtl8366_smi_read_reg(smi, RTL8366_LED_BLINKRATE_REG, &data);
1211                data = (data & (~(0xF << 4))) | (val->value.i << 4);
1212                rtl8366_smi_write_reg(smi, RTL8366_LED_BLINKRATE_REG, data);
1213        } else {
1214                rtl8366_smi_read_reg(smi, RTL8366_LED_CTRL_REG, &data);
1215                data = (data & (~(0xF << (val->port_vlan * 4)))) |
1216                        (val->value.i << (val->port_vlan * 4));
1217                rtl8366_smi_write_reg(smi, RTL8366_LED_CTRL_REG, data);
1218        }
1219
1220        return 0;
1221}
1222
1223static int rtl8366rb_sw_get_port_led(struct switch_dev *dev,
1224                                    const struct switch_attr *attr,
1225                                    struct switch_val *val)
1226{
1227        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1228        struct rtl8366_smi *smi = &rtl->smi;
1229        u32 data = 0;
1230
1231        if (val->port_vlan >= RTL8366_NUM_LEDGROUPS)
1232                return -EINVAL;
1233
1234        rtl8366_smi_read_reg(smi, RTL8366_LED_CTRL_REG, &data);
1235        val->value.i = (data >> (val->port_vlan * 4)) & 0x000F;
1236
1237        return 0;
1238}
1239
1240static int rtl8366rb_sw_reset_port_mibs(struct switch_dev *dev,
1241                                       const struct switch_attr *attr,
1242                                       struct switch_val *val)
1243{
1244        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1245        struct rtl8366_smi *smi = &rtl->smi;
1246        u32 data = 0;
1247
1248        if (val->port_vlan >= RTL8366_NUM_PORTS)
1249                return -EINVAL;
1250
1251        rtl8366_smi_read_reg(smi, RTL8366S_MIB_CTRL_REG, &data);
1252        data |= (1 << (val->port_vlan + 3));
1253        rtl8366_smi_write_reg(smi, RTL8366S_MIB_CTRL_REG, data);
1254
1255        return 0;
1256}
1257
1258static int rtl8366rb_sw_get_port_mib(struct switch_dev *dev,
1259                                    const struct switch_attr *attr,
1260                                    struct switch_val *val)
1261{
1262        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1263        int i, len = 0;
1264        unsigned long long counter = 0;
1265        char *buf = rtl->buf;
1266
1267        if (val->port_vlan >= RTL8366_NUM_PORTS)
1268                return -EINVAL;
1269
1270        len += snprintf(buf + len, sizeof(rtl->buf) - len,
1271                        "Port %d MIB counters\n",
1272                        val->port_vlan);
1273
1274        for (i = 0; i < RTL8366S_MIB_COUNT; ++i) {
1275                len += snprintf(buf + len, sizeof(rtl->buf) - len,
1276                                "%d:%s\t", i, rtl8366rb_mib_counters[i].name);
1277                if (!rtl8366_get_mib_counter(rtl, i, val->port_vlan, &counter))
1278                        len += snprintf(buf + len, sizeof(rtl->buf) - len,
1279                                        "[%llu]\n", counter);
1280                else
1281                        len += snprintf(buf + len, sizeof(rtl->buf) - len,
1282                                        "[error]\n");
1283        }
1284
1285        val->value.s = buf;
1286        val->len = len;
1287        return 0;
1288}
1289
1290static int rtl8366rb_sw_get_vlan_ports(struct switch_dev *dev,
1291                                      struct switch_val *val)
1292{
1293        struct rtl8366rb_vlanconfig vlanmc;
1294        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1295        struct switch_port *port;
1296        int i;
1297
1298        if (val->port_vlan == 0 || val->port_vlan >= RTL8366_NUM_VLANS)
1299                return -EINVAL;
1300
1301        rtl8366rb_get_vlan_member_config(rtl, val->port_vlan, &vlanmc);
1302
1303        port = &val->value.ports[0];
1304        val->len = 0;
1305        for (i = 0; i < RTL8366_NUM_PORTS; i++) {
1306                if (!(vlanmc.member & BIT(i)))
1307                        continue;
1308
1309                port->id = i;
1310                port->flags = (vlanmc.untag & BIT(i)) ?
1311                                        0 : BIT(SWITCH_PORT_FLAG_TAGGED);
1312                val->len++;
1313                port++;
1314        }
1315        return 0;
1316}
1317
1318static int rtl8366rb_sw_set_vlan_ports(struct switch_dev *dev,
1319                                      struct switch_val *val)
1320{
1321        struct rtl8366rb_vlanconfig vlanmc;
1322        struct rtl8366rb_vlan4kentry vlan4k;
1323        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1324        struct switch_port *port;
1325        int i;
1326
1327        if (val->port_vlan == 0 || val->port_vlan >= RTL8366_NUM_VLANS)
1328                return -EINVAL;
1329
1330        rtl8366rb_get_vlan_member_config(rtl, val->port_vlan, &vlanmc);
1331        rtl8366rb_get_vlan_4k_entry(rtl, vlanmc.vid, &vlan4k);
1332
1333        vlanmc.untag = 0;
1334        vlanmc.member = 0;
1335
1336        port = &val->value.ports[0];
1337        for (i = 0; i < val->len; i++, port++) {
1338                vlanmc.member |= BIT(port->id);
1339
1340                if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED)))
1341                        vlanmc.untag |= BIT(port->id);
1342        }
1343
1344        vlan4k.member = vlanmc.member;
1345        vlan4k.untag = vlanmc.untag;
1346
1347        rtl8366rb_set_vlan_member_config(rtl, val->port_vlan, &vlanmc);
1348        rtl8366rb_set_vlan_4k_entry(rtl, &vlan4k);
1349        return 0;
1350}
1351
1352static int rtl8366rb_sw_get_port_pvid(struct switch_dev *dev, int port, int *val)
1353{
1354        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1355        return rtl8366rb_get_vlan_port_pvid(rtl, port, val);
1356}
1357
1358static int rtl8366rb_sw_set_port_pvid(struct switch_dev *dev, int port, int val)
1359{
1360        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1361        return rtl8366rb_set_vlan_port_pvid(rtl, port, val);
1362}
1363
1364static int rtl8366rb_sw_reset_switch(struct switch_dev *dev)
1365{
1366        struct rtl8366rb *rtl = sw_to_rtl8366rb(dev);
1367        int err;
1368
1369        err = rtl8366rb_reset_chip(rtl);
1370        if (err)
1371                return err;
1372
1373        return rtl8366rb_reset_vlan(rtl);
1374}
1375
1376static struct switch_attr rtl8366rb_globals[] = {
1377        {
1378                .type = SWITCH_TYPE_INT,
1379                .name = "enable_vlan",
1380                .description = "Enable VLAN mode",
1381                .set = rtl8366rb_sw_set_vlan_enable,
1382                .get = rtl8366rb_sw_get_vlan_enable,
1383                .max = 1,
1384                .ofs = 1
1385        }, {
1386                .type = SWITCH_TYPE_INT,
1387                .name = "enable_vlan4k",
1388                .description = "Enable VLAN 4K mode",
1389                .set = rtl8366rb_sw_set_vlan_enable,
1390                .get = rtl8366rb_sw_get_vlan_enable,
1391                .max = 1,
1392                .ofs = 2
1393        }, {
1394                .type = SWITCH_TYPE_INT,
1395                .name = "reset_mibs",
1396                .description = "Reset all MIB counters",
1397                .set = rtl8366rb_sw_reset_mibs,
1398                .get = NULL,
1399                .max = 1
1400        }, {
1401                .type = SWITCH_TYPE_INT,
1402                .name = "blinkrate",
1403                .description = "Get/Set LED blinking rate (0 = 43ms, 1 = 84ms,"
1404                " 2 = 120ms, 3 = 170ms, 4 = 340ms, 5 = 670ms)",
1405                .set = rtl8366rb_sw_set_blinkrate,
1406                .get = rtl8366rb_sw_get_blinkrate,
1407                .max = 5
1408        },
1409};
1410
1411static struct switch_attr rtl8366rb_port[] = {
1412        {
1413                .type = SWITCH_TYPE_STRING,
1414                .name = "link",
1415                .description = "Get port link information",
1416                .max = 1,
1417                .set = NULL,
1418                .get = rtl8366rb_sw_get_port_link,
1419        }, {
1420                .type = SWITCH_TYPE_INT,
1421                .name = "reset_mib",
1422                .description = "Reset single port MIB counters",
1423                .max = 1,
1424                .set = rtl8366rb_sw_reset_port_mibs,
1425                .get = NULL,
1426        }, {
1427                .type = SWITCH_TYPE_STRING,
1428                .name = "mib",
1429                .description = "Get MIB counters for port",
1430                .max = 33,
1431                .set = NULL,
1432                .get = rtl8366rb_sw_get_port_mib,
1433        }, {
1434                .type = SWITCH_TYPE_INT,
1435                .name = "led",
1436                .description = "Get/Set port group (0 - 3) led mode (0 - 15)",
1437                .max = 15,
1438                .set = rtl8366rb_sw_set_port_led,
1439                .get = rtl8366rb_sw_get_port_led,
1440        },
1441};
1442
1443static struct switch_attr rtl8366rb_vlan[] = {
1444        {
1445                .type = SWITCH_TYPE_STRING,
1446                .name = "info",
1447                .description = "Get vlan information",
1448                .max = 1,
1449                .set = NULL,
1450                .get = rtl8366rb_sw_get_vlan_info,
1451        },
1452};
1453
1454/* template */
1455static struct switch_dev rtl8366_switch_dev = {
1456        .name = "RTL8366S",
1457        .cpu_port = RTL8366_PORT_NUM_CPU,
1458        .ports = RTL8366_NUM_PORTS,
1459        .vlans = RTL8366_NUM_VLANS,
1460        .attr_global = {
1461                .attr = rtl8366rb_globals,
1462                .n_attr = ARRAY_SIZE(rtl8366rb_globals),
1463        },
1464        .attr_port = {
1465                .attr = rtl8366rb_port,
1466                .n_attr = ARRAY_SIZE(rtl8366rb_port),
1467        },
1468        .attr_vlan = {
1469                .attr = rtl8366rb_vlan,
1470                .n_attr = ARRAY_SIZE(rtl8366rb_vlan),
1471        },
1472
1473        .get_vlan_ports = rtl8366rb_sw_get_vlan_ports,
1474        .set_vlan_ports = rtl8366rb_sw_set_vlan_ports,
1475        .get_port_pvid = rtl8366rb_sw_get_port_pvid,
1476        .set_port_pvid = rtl8366rb_sw_set_port_pvid,
1477        .reset_switch = rtl8366rb_sw_reset_switch,
1478};
1479
1480static int rtl8366rb_switch_init(struct rtl8366rb *rtl)
1481{
1482        struct switch_dev *dev = &rtl->dev;
1483        int err;
1484
1485        memcpy(dev, &rtl8366_switch_dev, sizeof(struct switch_dev));
1486        dev->priv = rtl;
1487        dev->devname = dev_name(rtl->parent);
1488
1489        err = register_switch(dev, NULL);
1490        if (err)
1491                dev_err(rtl->parent, "switch registration failed\n");
1492
1493        return err;
1494}
1495
1496static void rtl8366rb_switch_cleanup(struct rtl8366rb *rtl)
1497{
1498        unregister_switch(&rtl->dev);
1499}
1500
1501static int rtl8366rb_mii_read(struct mii_bus *bus, int addr, int reg)
1502{
1503        struct rtl8366_smi *smi = bus->priv;
1504        u32 val = 0;
1505        int err;
1506
1507        err = rtl8366rb_read_phy_reg(smi, addr, 0, reg, &val);
1508        if (err)
1509                return 0xffff;
1510
1511        return val;
1512}
1513
1514static int rtl8366rb_mii_write(struct mii_bus *bus, int addr, int reg, u16 val)
1515{
1516        struct rtl8366_smi *smi = bus->priv;
1517        u32 t;
1518        int err;
1519
1520        err = rtl8366rb_write_phy_reg(smi, addr, 0, reg, val);
1521        /* flush write */
1522        (void) rtl8366rb_read_phy_reg(smi, addr, 0, reg, &t);
1523
1524        return err;
1525}
1526
1527static int rtl8366rb_mii_bus_match(struct mii_bus *bus)
1528{
1529        return (bus->read == rtl8366rb_mii_read &&
1530                bus->write == rtl8366rb_mii_write);
1531}
1532
1533static int rtl8366rb_setup(struct rtl8366rb *rtl)
1534{
1535        int ret;
1536
1537        ret = rtl8366rb_reset_chip(rtl);
1538        if (ret)
1539                return ret;
1540
1541        rtl8366rb_debugfs_init(rtl);
1542        return 0;
1543}
1544
1545static int rtl8366rb_detect(struct rtl8366_smi *smi)
1546{
1547        u32 chip_id = 0;
1548        u32 chip_ver = 0;
1549        int ret;
1550
1551        ret = rtl8366_smi_read_reg(smi, RTL8366S_CHIP_ID_REG, &chip_id);
1552        if (ret) {
1553                dev_err(smi->parent, "unable to read chip id\n");
1554                return ret;
1555        }
1556
1557        switch (chip_id) {
1558        case RTL8366S_CHIP_ID_8366:
1559                break;
1560        default:
1561                dev_err(smi->parent, "unknown chip id (%04x)\n", chip_id);
1562                return -ENODEV;
1563        }
1564
1565        ret = rtl8366_smi_read_reg(smi, RTL8366S_CHIP_VERSION_CTRL_REG,
1566                                   &chip_ver);
1567        if (ret) {
1568                dev_err(smi->parent, "unable to read chip version\n");
1569                return ret;
1570        }
1571
1572        dev_info(smi->parent, "RTL%04x ver. %u chip found\n",
1573                 chip_id, chip_ver & RTL8366S_CHIP_VERSION_MASK);
1574
1575        return 0;
1576}
1577
1578static struct rtl8366_smi_ops rtl8366rb_smi_ops = {
1579        .detect         = rtl8366rb_detect,
1580        .mii_read       = rtl8366rb_mii_read,
1581        .mii_write      = rtl8366rb_mii_write,
1582};
1583
1584static int __init rtl8366rb_probe(struct platform_device *pdev)
1585{
1586        static int rtl8366_smi_version_printed;
1587        struct rtl8366rb_platform_data *pdata;
1588        struct rtl8366rb *rtl;
1589        struct rtl8366_smi *smi;
1590        int err;
1591
1592        if (!rtl8366_smi_version_printed++)
1593                printk(KERN_NOTICE RTL8366S_DRIVER_DESC
1594                       " version " RTL8366S_DRIVER_VER"\n");
1595
1596        pdata = pdev->dev.platform_data;
1597        if (!pdata) {
1598                dev_err(&pdev->dev, "no platform data specified\n");
1599                err = -EINVAL;
1600                goto err_out;
1601        }
1602
1603        rtl = kzalloc(sizeof(*rtl), GFP_KERNEL);
1604        if (!rtl) {
1605                dev_err(&pdev->dev, "no memory for private data\n");
1606                err = -ENOMEM;
1607                goto err_out;
1608        }
1609
1610        rtl->parent = &pdev->dev;
1611
1612        smi = &rtl->smi;
1613        smi->parent = &pdev->dev;
1614        smi->gpio_sda = pdata->gpio_sda;
1615        smi->gpio_sck = pdata->gpio_sck;
1616        smi->ops = &rtl8366rb_smi_ops;
1617
1618        err = rtl8366_smi_init(smi);
1619        if (err)
1620                goto err_free_rtl;
1621
1622        platform_set_drvdata(pdev, rtl);
1623
1624        err = rtl8366rb_setup(rtl);
1625        if (err)
1626                goto err_clear_drvdata;
1627
1628        err = rtl8366rb_switch_init(rtl);
1629        if (err)
1630                goto err_clear_drvdata;
1631
1632        return 0;
1633
1634 err_clear_drvdata:
1635        platform_set_drvdata(pdev, NULL);
1636        rtl8366_smi_cleanup(smi);
1637 err_free_rtl:
1638        kfree(rtl);
1639 err_out:
1640        return err;
1641}
1642
1643static int rtl8366rb_phy_config_init(struct phy_device *phydev)
1644{
1645        if (!rtl8366rb_mii_bus_match(phydev->bus))
1646                return -EINVAL;
1647
1648        return 0;
1649}
1650
1651static int rtl8366rb_phy_config_aneg(struct phy_device *phydev)
1652{
1653        return 0;
1654}
1655
1656static struct phy_driver rtl8366rb_phy_driver = {
1657        .phy_id         = 0x001cc960,
1658        .name           = "Realtek RTL8366RB",
1659        .phy_id_mask    = 0x1ffffff0,
1660        .features       = PHY_GBIT_FEATURES,
1661        .config_aneg    = rtl8366rb_phy_config_aneg,
1662        .config_init    = rtl8366rb_phy_config_init,
1663        .read_status    = genphy_read_status,
1664        .driver         = {
1665                .owner = THIS_MODULE,
1666        },
1667};
1668
1669static int __devexit rtl8366rb_remove(struct platform_device *pdev)
1670{
1671        struct rtl8366rb *rtl = platform_get_drvdata(pdev);
1672
1673        if (rtl) {
1674                rtl8366rb_switch_cleanup(rtl);
1675                rtl8366rb_debugfs_remove(rtl);
1676                platform_set_drvdata(pdev, NULL);
1677                rtl8366_smi_cleanup(&rtl->smi);
1678                kfree(rtl);
1679        }
1680
1681        return 0;
1682}
1683
1684static struct platform_driver rtl8366rb_driver = {
1685        .driver = {
1686                .name           = RTL8366RB_DRIVER_NAME,
1687                .owner          = THIS_MODULE,
1688        },
1689        .probe          = rtl8366rb_probe,
1690        .remove         = __devexit_p(rtl8366rb_remove),
1691};
1692
1693static int __init rtl8366rb_module_init(void)
1694{
1695        int ret;
1696        ret = platform_driver_register(&rtl8366rb_driver);
1697        if (ret)
1698                return ret;
1699
1700        ret = phy_driver_register(&rtl8366rb_phy_driver);
1701        if (ret)
1702                goto err_platform_unregister;
1703
1704        return 0;
1705
1706 err_platform_unregister:
1707        platform_driver_unregister(&rtl8366rb_driver);
1708        return ret;
1709}
1710module_init(rtl8366rb_module_init);
1711
1712static void __exit rtl8366rb_module_exit(void)
1713{
1714        phy_driver_unregister(&rtl8366rb_phy_driver);
1715        platform_driver_unregister(&rtl8366rb_driver);
1716}
1717module_exit(rtl8366rb_module_exit);
1718
1719MODULE_DESCRIPTION(RTL8366S_DRIVER_DESC);
1720MODULE_VERSION(RTL8366S_DRIVER_VER);
1721MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
1722MODULE_AUTHOR("Antti SeppÀlÀ <a.seppala@gmail.com>");
1723MODULE_LICENSE("GPL v2");
1724MODULE_ALIAS("platform:" RTL8366RB_DRIVER_NAME);
Note: See TracBrowser for help on using the repository browser.