source: trunk/target/linux/generic/files/drivers/net/phy/rtl8366_smi.c @ 29677

Last change on this file since 29677 was 29677, checked in by juhosg, 5 years ago

generic: rtl8366: preparing for RTL8367 support

  • make clock delay configurable
  • make read,write commands configurable
  • use u16 for member and untag fields
File size: 27.9 KB
Line 
1/*
2 * Realtek RTL8366 SMI interface driver
3 *
4 * Copyright (C) 2009-2010 Gabor Juhos <juhosg@openwrt.org>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 as published
8 * by the Free Software Foundation.
9 */
10
11#include <linux/kernel.h>
12#include <linux/module.h>
13#include <linux/device.h>
14#include <linux/delay.h>
15#include <linux/gpio.h>
16#include <linux/spinlock.h>
17#include <linux/skbuff.h>
18#include <linux/rtl8366.h>
19
20#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
21#include <linux/debugfs.h>
22#endif
23
24#include "rtl8366_smi.h"
25
26#define RTL8366_SMI_ACK_RETRY_COUNT         5
27
28static inline void rtl8366_smi_clk_delay(struct rtl8366_smi *smi)
29{
30        ndelay(smi->clk_delay);
31}
32
33static void rtl8366_smi_start(struct rtl8366_smi *smi)
34{
35        unsigned int sda = smi->gpio_sda;
36        unsigned int sck = smi->gpio_sck;
37
38        /*
39         * Set GPIO pins to output mode, with initial state:
40         * SCK = 0, SDA = 1
41         */
42        gpio_direction_output(sck, 0);
43        gpio_direction_output(sda, 1);
44        rtl8366_smi_clk_delay(smi);
45
46        /* CLK 1: 0 -> 1, 1 -> 0 */
47        gpio_set_value(sck, 1);
48        rtl8366_smi_clk_delay(smi);
49        gpio_set_value(sck, 0);
50        rtl8366_smi_clk_delay(smi);
51
52        /* CLK 2: */
53        gpio_set_value(sck, 1);
54        rtl8366_smi_clk_delay(smi);
55        gpio_set_value(sda, 0);
56        rtl8366_smi_clk_delay(smi);
57        gpio_set_value(sck, 0);
58        rtl8366_smi_clk_delay(smi);
59        gpio_set_value(sda, 1);
60}
61
62static void rtl8366_smi_stop(struct rtl8366_smi *smi)
63{
64        unsigned int sda = smi->gpio_sda;
65        unsigned int sck = smi->gpio_sck;
66
67        rtl8366_smi_clk_delay(smi);
68        gpio_set_value(sda, 0);
69        gpio_set_value(sck, 1);
70        rtl8366_smi_clk_delay(smi);
71        gpio_set_value(sda, 1);
72        rtl8366_smi_clk_delay(smi);
73        gpio_set_value(sck, 1);
74        rtl8366_smi_clk_delay(smi);
75        gpio_set_value(sck, 0);
76        rtl8366_smi_clk_delay(smi);
77        gpio_set_value(sck, 1);
78
79        /* add a click */
80        rtl8366_smi_clk_delay(smi);
81        gpio_set_value(sck, 0);
82        rtl8366_smi_clk_delay(smi);
83        gpio_set_value(sck, 1);
84
85        /* set GPIO pins to input mode */
86        gpio_direction_input(sda);
87        gpio_direction_input(sck);
88}
89
90static void rtl8366_smi_write_bits(struct rtl8366_smi *smi, u32 data, u32 len)
91{
92        unsigned int sda = smi->gpio_sda;
93        unsigned int sck = smi->gpio_sck;
94
95        for (; len > 0; len--) {
96                rtl8366_smi_clk_delay(smi);
97
98                /* prepare data */
99                gpio_set_value(sda, !!(data & ( 1 << (len - 1))));
100                rtl8366_smi_clk_delay(smi);
101
102                /* clocking */
103                gpio_set_value(sck, 1);
104                rtl8366_smi_clk_delay(smi);
105                gpio_set_value(sck, 0);
106        }
107}
108
109static void rtl8366_smi_read_bits(struct rtl8366_smi *smi, u32 len, u32 *data)
110{
111        unsigned int sda = smi->gpio_sda;
112        unsigned int sck = smi->gpio_sck;
113
114        gpio_direction_input(sda);
115
116        for (*data = 0; len > 0; len--) {
117                u32 u;
118
119                rtl8366_smi_clk_delay(smi);
120
121                /* clocking */
122                gpio_set_value(sck, 1);
123                rtl8366_smi_clk_delay(smi);
124                u = !!gpio_get_value(sda);
125                gpio_set_value(sck, 0);
126
127                *data |= (u << (len - 1));
128        }
129
130        gpio_direction_output(sda, 0);
131}
132
133static int rtl8366_smi_wait_for_ack(struct rtl8366_smi *smi)
134{
135        int retry_cnt;
136
137        retry_cnt = 0;
138        do {
139                u32 ack;
140
141                rtl8366_smi_read_bits(smi, 1, &ack);
142                if (ack == 0)
143                        break;
144
145                if (++retry_cnt > RTL8366_SMI_ACK_RETRY_COUNT) {
146                        dev_err(smi->parent, "ACK timeout\n");
147                        return -ETIMEDOUT;
148                }
149        } while (1);
150
151        return 0;
152}
153
154static int rtl8366_smi_write_byte(struct rtl8366_smi *smi, u8 data)
155{
156        rtl8366_smi_write_bits(smi, data, 8);
157        return rtl8366_smi_wait_for_ack(smi);
158}
159
160static int rtl8366_smi_read_byte0(struct rtl8366_smi *smi, u8 *data)
161{
162        u32 t;
163
164        /* read data */
165        rtl8366_smi_read_bits(smi, 8, &t);
166        *data = (t & 0xff);
167
168        /* send an ACK */
169        rtl8366_smi_write_bits(smi, 0x00, 1);
170
171        return 0;
172}
173
174static int rtl8366_smi_read_byte1(struct rtl8366_smi *smi, u8 *data)
175{
176        u32 t;
177
178        /* read data */
179        rtl8366_smi_read_bits(smi, 8, &t);
180        *data = (t & 0xff);
181
182        /* send an ACK */
183        rtl8366_smi_write_bits(smi, 0x01, 1);
184
185        return 0;
186}
187
188int rtl8366_smi_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data)
189{
190        unsigned long flags;
191        u8 lo = 0;
192        u8 hi = 0;
193        int ret;
194
195        spin_lock_irqsave(&smi->lock, flags);
196
197        rtl8366_smi_start(smi);
198
199        /* send READ command */
200        ret = rtl8366_smi_write_byte(smi, smi->cmd_read);
201        if (ret)
202                goto out;
203
204        /* set ADDR[7:0] */
205        ret = rtl8366_smi_write_byte(smi, addr & 0xff);
206        if (ret)
207                goto out;
208
209        /* set ADDR[15:8] */
210        ret = rtl8366_smi_write_byte(smi, addr >> 8);
211        if (ret)
212                goto out;
213
214        /* read DATA[7:0] */
215        rtl8366_smi_read_byte0(smi, &lo);
216        /* read DATA[15:8] */
217        rtl8366_smi_read_byte1(smi, &hi);
218
219        *data = ((u32) lo) | (((u32) hi) << 8);
220
221        ret = 0;
222
223 out:
224        rtl8366_smi_stop(smi);
225        spin_unlock_irqrestore(&smi->lock, flags);
226
227        return ret;
228}
229EXPORT_SYMBOL_GPL(rtl8366_smi_read_reg);
230
231int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
232{
233        unsigned long flags;
234        int ret;
235
236        spin_lock_irqsave(&smi->lock, flags);
237
238        rtl8366_smi_start(smi);
239
240        /* send WRITE command */
241        ret = rtl8366_smi_write_byte(smi, smi->cmd_write);
242        if (ret)
243                goto out;
244
245        /* set ADDR[7:0] */
246        ret = rtl8366_smi_write_byte(smi, addr & 0xff);
247        if (ret)
248                goto out;
249
250        /* set ADDR[15:8] */
251        ret = rtl8366_smi_write_byte(smi, addr >> 8);
252        if (ret)
253                goto out;
254
255        /* write DATA[7:0] */
256        ret = rtl8366_smi_write_byte(smi, data & 0xff);
257        if (ret)
258                goto out;
259
260        /* write DATA[15:8] */
261        ret = rtl8366_smi_write_byte(smi, data >> 8);
262        if (ret)
263                goto out;
264
265        ret = 0;
266
267 out:
268        rtl8366_smi_stop(smi);
269        spin_unlock_irqrestore(&smi->lock, flags);
270
271        return ret;
272}
273EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg);
274
275int rtl8366_smi_rmwr(struct rtl8366_smi *smi, u32 addr, u32 mask, u32 data)
276{
277        u32 t;
278        int err;
279
280        err = rtl8366_smi_read_reg(smi, addr, &t);
281        if (err)
282                return err;
283
284        err = rtl8366_smi_write_reg(smi, addr, (t & ~mask) | data);
285        return err;
286
287}
288EXPORT_SYMBOL_GPL(rtl8366_smi_rmwr);
289
290static int rtl8366_mc_is_used(struct rtl8366_smi *smi, int mc_index, int *used)
291{
292        int err;
293        int i;
294
295        *used = 0;
296        for (i = 0; i < smi->num_ports; i++) {
297                int index = 0;
298
299                err = smi->ops->get_mc_index(smi, i, &index);
300                if (err)
301                        return err;
302
303                if (mc_index == index) {
304                        *used = 1;
305                        break;
306                }
307        }
308
309        return 0;
310}
311
312static int rtl8366_set_vlan(struct rtl8366_smi *smi, int vid, u32 member,
313                            u32 untag, u32 fid)
314{
315        struct rtl8366_vlan_4k vlan4k;
316        int err;
317        int i;
318
319        /* Update the 4K table */
320        err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
321        if (err)
322                return err;
323
324        vlan4k.member = member;
325        vlan4k.untag = untag;
326        vlan4k.fid = fid;
327        err = smi->ops->set_vlan_4k(smi, &vlan4k);
328        if (err)
329                return err;
330
331        /* Try to find an existing MC entry for this VID */
332        for (i = 0; i < smi->num_vlan_mc; i++) {
333                struct rtl8366_vlan_mc vlanmc;
334
335                err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
336                if (err)
337                        return err;
338
339                if (vid == vlanmc.vid) {
340                        /* update the MC entry */
341                        vlanmc.member = member;
342                        vlanmc.untag = untag;
343                        vlanmc.fid = fid;
344
345                        err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
346                        break;
347                }
348        }
349
350        return err;
351}
352
353static int rtl8366_get_pvid(struct rtl8366_smi *smi, int port, int *val)
354{
355        struct rtl8366_vlan_mc vlanmc;
356        int err;
357        int index;
358
359        err = smi->ops->get_mc_index(smi, port, &index);
360        if (err)
361                return err;
362
363        err = smi->ops->get_vlan_mc(smi, index, &vlanmc);
364        if (err)
365                return err;
366
367        *val = vlanmc.vid;
368        return 0;
369}
370
371static int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port,
372                            unsigned vid)
373{
374        struct rtl8366_vlan_mc vlanmc;
375        struct rtl8366_vlan_4k vlan4k;
376        int err;
377        int i;
378
379        /* Try to find an existing MC entry for this VID */
380        for (i = 0; i < smi->num_vlan_mc; i++) {
381                err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
382                if (err)
383                        return err;
384
385                if (vid == vlanmc.vid) {
386                        err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
387                        if (err)
388                                return err;
389
390                        err = smi->ops->set_mc_index(smi, port, i);
391                        return err;
392                }
393        }
394
395        /* We have no MC entry for this VID, try to find an empty one */
396        for (i = 0; i < smi->num_vlan_mc; i++) {
397                err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
398                if (err)
399                        return err;
400
401                if (vlanmc.vid == 0 && vlanmc.member == 0) {
402                        /* Update the entry from the 4K table */
403                        err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
404                        if (err)
405                                return err;
406
407                        vlanmc.vid = vid;
408                        vlanmc.member = vlan4k.member;
409                        vlanmc.untag = vlan4k.untag;
410                        vlanmc.fid = vlan4k.fid;
411                        err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
412                        if (err)
413                                return err;
414
415                        err = smi->ops->set_mc_index(smi, port, i);
416                        return err;
417                }
418        }
419
420        /* MC table is full, try to find an unused entry and replace it */
421        for (i = 0; i < smi->num_vlan_mc; i++) {
422                int used;
423
424                err = rtl8366_mc_is_used(smi, i, &used);
425                if (err)
426                        return err;
427
428                if (!used) {
429                        /* Update the entry from the 4K table */
430                        err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
431                        if (err)
432                                return err;
433
434                        vlanmc.vid = vid;
435                        vlanmc.member = vlan4k.member;
436                        vlanmc.untag = vlan4k.untag;
437                        vlanmc.fid = vlan4k.fid;
438                        err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
439                        if (err)
440                                return err;
441
442                        err = smi->ops->set_mc_index(smi, port, i);
443                        return err;
444                }
445        }
446
447        dev_err(smi->parent,
448                "all VLAN member configurations are in use\n");
449
450        return -ENOSPC;
451}
452
453int rtl8366_enable_vlan(struct rtl8366_smi *smi, int enable)
454{
455        int err;
456
457        err = smi->ops->enable_vlan(smi, enable);
458        if (err)
459                return err;
460
461        smi->vlan_enabled = enable;
462
463        if (!enable) {
464                smi->vlan4k_enabled = 0;
465                err = smi->ops->enable_vlan4k(smi, enable);
466        }
467
468        return err;
469}
470EXPORT_SYMBOL_GPL(rtl8366_enable_vlan);
471
472static int rtl8366_enable_vlan4k(struct rtl8366_smi *smi, int enable)
473{
474        int err;
475
476        if (enable) {
477                err = smi->ops->enable_vlan(smi, enable);
478                if (err)
479                        return err;
480
481                smi->vlan_enabled = enable;
482        }
483
484        err = smi->ops->enable_vlan4k(smi, enable);
485        if (err)
486                return err;
487
488        smi->vlan4k_enabled = enable;
489        return 0;
490}
491
492int rtl8366_enable_all_ports(struct rtl8366_smi *smi, int enable)
493{
494        int port;
495        int err;
496
497        for (port = 0; port < smi->num_ports; port++) {
498                err = smi->ops->enable_port(smi, port, enable);
499                if (err)
500                        return err;
501        }
502
503        return 0;
504}
505EXPORT_SYMBOL_GPL(rtl8366_enable_all_ports);
506
507int rtl8366_reset_vlan(struct rtl8366_smi *smi)
508{
509        struct rtl8366_vlan_mc vlanmc;
510        int err;
511        int i;
512
513        rtl8366_enable_vlan(smi, 0);
514        rtl8366_enable_vlan4k(smi, 0);
515
516        /* clear VLAN member configurations */
517        vlanmc.vid = 0;
518        vlanmc.priority = 0;
519        vlanmc.member = 0;
520        vlanmc.untag = 0;
521        vlanmc.fid = 0;
522        for (i = 0; i < smi->num_vlan_mc; i++) {
523                err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
524                if (err)
525                        return err;
526        }
527
528        return 0;
529}
530EXPORT_SYMBOL_GPL(rtl8366_reset_vlan);
531
532static int rtl8366_init_vlan(struct rtl8366_smi *smi)
533{
534        int port;
535        int err;
536
537        err = rtl8366_reset_vlan(smi);
538        if (err)
539                return err;
540
541        for (port = 0; port < smi->num_ports; port++) {
542                u32 mask;
543
544                if (port == smi->cpu_port)
545                        mask = (1 << smi->num_ports) - 1;
546                else
547                        mask = (1 << port) | (1 << smi->cpu_port);
548
549                err = rtl8366_set_vlan(smi, (port + 1), mask, mask, 0);
550                if (err)
551                        return err;
552
553                err = rtl8366_set_pvid(smi, port, (port + 1));
554                if (err)
555                        return err;
556        }
557
558        return rtl8366_enable_vlan(smi, 1);
559}
560
561#ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
562int rtl8366_debugfs_open(struct inode *inode, struct file *file)
563{
564        file->private_data = inode->i_private;
565        return 0;
566}
567EXPORT_SYMBOL_GPL(rtl8366_debugfs_open);
568
569static ssize_t rtl8366_read_debugfs_vlan_mc(struct file *file,
570                                              char __user *user_buf,
571                                              size_t count, loff_t *ppos)
572{
573        struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
574        int i, len = 0;
575        char *buf = smi->buf;
576
577        len += snprintf(buf + len, sizeof(smi->buf) - len,
578                        "%2s %6s %4s %6s %6s %3s\n",
579                        "id", "vid","prio", "member", "untag", "fid");
580
581        for (i = 0; i < smi->num_vlan_mc; ++i) {
582                struct rtl8366_vlan_mc vlanmc;
583
584                smi->ops->get_vlan_mc(smi, i, &vlanmc);
585
586                len += snprintf(buf + len, sizeof(smi->buf) - len,
587                                "%2d %6d %4d 0x%04x 0x%04x %3d\n",
588                                i, vlanmc.vid, vlanmc.priority,
589                                vlanmc.member, vlanmc.untag, vlanmc.fid);
590        }
591
592        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
593}
594
595#define RTL8366_VLAN4K_PAGE_SIZE        64
596#define RTL8366_VLAN4K_NUM_PAGES        (4096 / RTL8366_VLAN4K_PAGE_SIZE)
597
598static ssize_t rtl8366_read_debugfs_vlan_4k(struct file *file,
599                                            char __user *user_buf,
600                                            size_t count, loff_t *ppos)
601{
602        struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
603        int i, len = 0;
604        int offset;
605        char *buf = smi->buf;
606
607        if (smi->dbg_vlan_4k_page >= RTL8366_VLAN4K_NUM_PAGES) {
608                len += snprintf(buf + len, sizeof(smi->buf) - len,
609                                "invalid page: %u\n", smi->dbg_vlan_4k_page);
610                return simple_read_from_buffer(user_buf, count, ppos, buf, len);
611        }
612
613        len += snprintf(buf + len, sizeof(smi->buf) - len,
614                        "%4s %6s %6s %3s\n",
615                        "vid", "member", "untag", "fid");
616
617        offset = RTL8366_VLAN4K_PAGE_SIZE * smi->dbg_vlan_4k_page;
618        for (i = 0; i < RTL8366_VLAN4K_PAGE_SIZE; i++) {
619                struct rtl8366_vlan_4k vlan4k;
620
621                smi->ops->get_vlan_4k(smi, offset + i, &vlan4k);
622
623                len += snprintf(buf + len, sizeof(smi->buf) - len,
624                                "%4d 0x%04x 0x%04x %3d\n",
625                                vlan4k.vid, vlan4k.member,
626                                vlan4k.untag, vlan4k.fid);
627        }
628
629        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
630}
631
632static ssize_t rtl8366_read_debugfs_pvid(struct file *file,
633                                         char __user *user_buf,
634                                         size_t count, loff_t *ppos)
635{
636        struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
637        char *buf = smi->buf;
638        int len = 0;
639        int i;
640
641        len += snprintf(buf + len, sizeof(smi->buf) - len, "%4s %4s\n",
642                        "port", "pvid");
643
644        for (i = 0; i < smi->num_ports; i++) {
645                int pvid;
646                int err;
647
648                err = rtl8366_get_pvid(smi, i, &pvid);
649                if (err)
650                        len += snprintf(buf + len, sizeof(smi->buf) - len,
651                                "%4d error\n", i);
652                else
653                        len += snprintf(buf + len, sizeof(smi->buf) - len,
654                                "%4d %4d\n", i, pvid);
655        }
656
657        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
658}
659
660static ssize_t rtl8366_read_debugfs_reg(struct file *file,
661                                         char __user *user_buf,
662                                         size_t count, loff_t *ppos)
663{
664        struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
665        u32 t, reg = smi->dbg_reg;
666        int err, len = 0;
667        char *buf = smi->buf;
668
669        memset(buf, '\0', sizeof(smi->buf));
670
671        err = rtl8366_smi_read_reg(smi, reg, &t);
672        if (err) {
673                len += snprintf(buf, sizeof(smi->buf),
674                                "Read failed (reg: 0x%04x)\n", reg);
675                return simple_read_from_buffer(user_buf, count, ppos, buf, len);
676        }
677
678        len += snprintf(buf, sizeof(smi->buf), "reg = 0x%04x, val = 0x%04x\n",
679                        reg, t);
680
681        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
682}
683
684static ssize_t rtl8366_write_debugfs_reg(struct file *file,
685                                          const char __user *user_buf,
686                                          size_t count, loff_t *ppos)
687{
688        struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
689        unsigned long data;
690        u32 reg = smi->dbg_reg;
691        int err;
692        size_t len;
693        char *buf = smi->buf;
694
695        len = min(count, sizeof(smi->buf) - 1);
696        if (copy_from_user(buf, user_buf, len)) {
697                dev_err(smi->parent, "copy from user failed\n");
698                return -EFAULT;
699        }
700
701        buf[len] = '\0';
702        if (len > 0 && buf[len - 1] == '\n')
703                buf[len - 1] = '\0';
704
705
706        if (strict_strtoul(buf, 16, &data)) {
707                dev_err(smi->parent, "Invalid reg value %s\n", buf);
708        } else {
709                err = rtl8366_smi_write_reg(smi, reg, data);
710                if (err) {
711                        dev_err(smi->parent,
712                                "writing reg 0x%04x val 0x%04lx failed\n",
713                                reg, data);
714                }
715        }
716
717        return count;
718}
719
720static ssize_t rtl8366_read_debugfs_mibs(struct file *file,
721                                         char __user *user_buf,
722                                         size_t count, loff_t *ppos)
723{
724        struct rtl8366_smi *smi = file->private_data;
725        int i, j, len = 0;
726        char *buf = smi->buf;
727
728        len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s",
729                        "Counter");
730
731        for (i = 0; i < smi->num_ports; i++) {
732                char port_buf[10];
733
734                snprintf(port_buf, sizeof(port_buf), "Port %d", i);
735                len += snprintf(buf + len, sizeof(smi->buf) - len, " %12s",
736                                port_buf);
737        }
738        len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
739
740        for (i = 0; i < smi->num_mib_counters; i++) {
741                len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s ",
742                                smi->mib_counters[i].name);
743                for (j = 0; j < smi->num_ports; j++) {
744                        unsigned long long counter = 0;
745
746                        if (!smi->ops->get_mib_counter(smi, i, j, &counter))
747                                len += snprintf(buf + len,
748                                                sizeof(smi->buf) - len,
749                                                "%12llu ", counter);
750                        else
751                                len += snprintf(buf + len,
752                                                sizeof(smi->buf) - len,
753                                                "%12s ", "error");
754                }
755                len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
756        }
757
758        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
759}
760
761static const struct file_operations fops_rtl8366_regs = {
762        .read   = rtl8366_read_debugfs_reg,
763        .write  = rtl8366_write_debugfs_reg,
764        .open   = rtl8366_debugfs_open,
765        .owner  = THIS_MODULE
766};
767
768static const struct file_operations fops_rtl8366_vlan_mc = {
769        .read   = rtl8366_read_debugfs_vlan_mc,
770        .open   = rtl8366_debugfs_open,
771        .owner  = THIS_MODULE
772};
773
774static const struct file_operations fops_rtl8366_vlan_4k = {
775        .read   = rtl8366_read_debugfs_vlan_4k,
776        .open   = rtl8366_debugfs_open,
777        .owner  = THIS_MODULE
778};
779
780static const struct file_operations fops_rtl8366_pvid = {
781        .read   = rtl8366_read_debugfs_pvid,
782        .open   = rtl8366_debugfs_open,
783        .owner  = THIS_MODULE
784};
785
786static const struct file_operations fops_rtl8366_mibs = {
787        .read = rtl8366_read_debugfs_mibs,
788        .open = rtl8366_debugfs_open,
789        .owner = THIS_MODULE
790};
791
792static void rtl8366_debugfs_init(struct rtl8366_smi *smi)
793{
794        struct dentry *node;
795        struct dentry *root;
796
797        if (!smi->debugfs_root)
798                smi->debugfs_root = debugfs_create_dir(dev_name(smi->parent),
799                                                       NULL);
800
801        if (!smi->debugfs_root) {
802                dev_err(smi->parent, "Unable to create debugfs dir\n");
803                return;
804        }
805        root = smi->debugfs_root;
806
807        node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root,
808                                  &smi->dbg_reg);
809        if (!node) {
810                dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
811                        "reg");
812                return;
813        }
814
815        node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, smi,
816                                   &fops_rtl8366_regs);
817        if (!node) {
818                dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
819                        "val");
820                return;
821        }
822
823        node = debugfs_create_file("vlan_mc", S_IRUSR, root, smi,
824                                   &fops_rtl8366_vlan_mc);
825        if (!node) {
826                dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
827                        "vlan_mc");
828                return;
829        }
830
831        node = debugfs_create_u8("vlan_4k_page", S_IRUGO | S_IWUSR, root,
832                                  &smi->dbg_vlan_4k_page);
833        if (!node) {
834                dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
835                        "vlan_4k_page");
836                return;
837        }
838
839        node = debugfs_create_file("vlan_4k", S_IRUSR, root, smi,
840                                   &fops_rtl8366_vlan_4k);
841        if (!node) {
842                dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
843                        "vlan_4k");
844                return;
845        }
846
847        node = debugfs_create_file("pvid", S_IRUSR, root, smi,
848                                   &fops_rtl8366_pvid);
849        if (!node) {
850                dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
851                        "pvid");
852                return;
853        }
854
855        node = debugfs_create_file("mibs", S_IRUSR, smi->debugfs_root, smi,
856                                   &fops_rtl8366_mibs);
857        if (!node)
858                dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
859                        "mibs");
860}
861
862static void rtl8366_debugfs_remove(struct rtl8366_smi *smi)
863{
864        if (smi->debugfs_root) {
865                debugfs_remove_recursive(smi->debugfs_root);
866                smi->debugfs_root = NULL;
867        }
868}
869#else
870static inline void rtl8366_debugfs_init(struct rtl8366_smi *smi) {}
871static inline void rtl8366_debugfs_remove(struct rtl8366_smi *smi) {}
872#endif /* CONFIG_RTL8366S_PHY_DEBUG_FS */
873
874static int rtl8366_smi_mii_init(struct rtl8366_smi *smi)
875{
876        int ret;
877        int i;
878
879        smi->mii_bus = mdiobus_alloc();
880        if (smi->mii_bus == NULL) {
881                ret = -ENOMEM;
882                goto err;
883        }
884
885        smi->mii_bus->priv = (void *) smi;
886        smi->mii_bus->name = dev_name(smi->parent);
887        smi->mii_bus->read = smi->ops->mii_read;
888        smi->mii_bus->write = smi->ops->mii_write;
889        snprintf(smi->mii_bus->id, MII_BUS_ID_SIZE, "%s",
890                 dev_name(smi->parent));
891        smi->mii_bus->parent = smi->parent;
892        smi->mii_bus->phy_mask = ~(0x1f);
893        smi->mii_bus->irq = smi->mii_irq;
894        for (i = 0; i < PHY_MAX_ADDR; i++)
895                smi->mii_irq[i] = PHY_POLL;
896
897        ret = mdiobus_register(smi->mii_bus);
898        if (ret)
899                goto err_free;
900
901        return 0;
902
903 err_free:
904        mdiobus_free(smi->mii_bus);
905 err:
906        return ret;
907}
908
909static void rtl8366_smi_mii_cleanup(struct rtl8366_smi *smi)
910{
911        mdiobus_unregister(smi->mii_bus);
912        mdiobus_free(smi->mii_bus);
913}
914
915int rtl8366_sw_get_port_pvid(struct switch_dev *dev, int port, int *val)
916{
917        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
918        return rtl8366_get_pvid(smi, port, val);
919}
920EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_pvid);
921
922int rtl8366_sw_set_port_pvid(struct switch_dev *dev, int port, int val)
923{
924        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
925        return rtl8366_set_pvid(smi, port, val);
926}
927EXPORT_SYMBOL_GPL(rtl8366_sw_set_port_pvid);
928
929int rtl8366_sw_get_port_mib(struct switch_dev *dev,
930                            const struct switch_attr *attr,
931                            struct switch_val *val)
932{
933        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
934        int i, len = 0;
935        unsigned long long counter = 0;
936        char *buf = smi->buf;
937
938        if (val->port_vlan >= smi->num_ports)
939                return -EINVAL;
940
941        len += snprintf(buf + len, sizeof(smi->buf) - len,
942                        "Port %d MIB counters\n",
943                        val->port_vlan);
944
945        for (i = 0; i < smi->num_mib_counters; ++i) {
946                len += snprintf(buf + len, sizeof(smi->buf) - len,
947                                "%-36s: ", smi->mib_counters[i].name);
948                if (!smi->ops->get_mib_counter(smi, i, val->port_vlan,
949                                               &counter))
950                        len += snprintf(buf + len, sizeof(smi->buf) - len,
951                                        "%llu\n", counter);
952                else
953                        len += snprintf(buf + len, sizeof(smi->buf) - len,
954                                        "%s\n", "error");
955        }
956
957        val->value.s = buf;
958        val->len = len;
959        return 0;
960}
961EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_mib);
962
963int rtl8366_sw_get_vlan_info(struct switch_dev *dev,
964                             const struct switch_attr *attr,
965                             struct switch_val *val)
966{
967        int i;
968        u32 len = 0;
969        struct rtl8366_vlan_4k vlan4k;
970        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
971        char *buf = smi->buf;
972        int err;
973
974        if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
975                return -EINVAL;
976
977        memset(buf, '\0', sizeof(smi->buf));
978
979        err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
980        if (err)
981                return err;
982
983        len += snprintf(buf + len, sizeof(smi->buf) - len,
984                        "VLAN %d: Ports: '", vlan4k.vid);
985
986        for (i = 0; i < smi->num_ports; i++) {
987                if (!(vlan4k.member & (1 << i)))
988                        continue;
989
990                len += snprintf(buf + len, sizeof(smi->buf) - len, "%d%s", i,
991                                (vlan4k.untag & (1 << i)) ? "" : "t");
992        }
993
994        len += snprintf(buf + len, sizeof(smi->buf) - len,
995                        "', members=%04x, untag=%04x, fid=%u",
996                        vlan4k.member, vlan4k.untag, vlan4k.fid);
997
998        val->value.s = buf;
999        val->len = len;
1000
1001        return 0;
1002}
1003EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_info);
1004
1005int rtl8366_sw_get_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1006{
1007        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1008        struct switch_port *port;
1009        struct rtl8366_vlan_4k vlan4k;
1010        int i;
1011
1012        if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1013                return -EINVAL;
1014
1015        smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1016
1017        port = &val->value.ports[0];
1018        val->len = 0;
1019        for (i = 0; i < smi->num_ports; i++) {
1020                if (!(vlan4k.member & BIT(i)))
1021                        continue;
1022
1023                port->id = i;
1024                port->flags = (vlan4k.untag & BIT(i)) ?
1025                                        0 : BIT(SWITCH_PORT_FLAG_TAGGED);
1026                val->len++;
1027                port++;
1028        }
1029        return 0;
1030}
1031EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_ports);
1032
1033int rtl8366_sw_set_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1034{
1035        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1036        struct switch_port *port;
1037        u32 member = 0;
1038        u32 untag = 0;
1039        int err;
1040        int i;
1041
1042        if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1043                return -EINVAL;
1044
1045        port = &val->value.ports[0];
1046        for (i = 0; i < val->len; i++, port++) {
1047                member |= BIT(port->id);
1048
1049                if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED)))
1050                        untag |= BIT(port->id);
1051
1052                /*
1053                 * To ensure that we have a valid MC entry for this VLAN,
1054                 * initialize the port VLAN ID here.
1055                 */
1056                err = rtl8366_set_pvid(smi, port->id, val->port_vlan);
1057                if (err < 0)
1058                        return err;
1059        }
1060
1061        return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0);
1062}
1063EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_ports);
1064
1065int rtl8366_sw_get_vlan_fid(struct switch_dev *dev,
1066                            const struct switch_attr *attr,
1067                            struct switch_val *val)
1068{
1069        struct rtl8366_vlan_4k vlan4k;
1070        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1071        int err;
1072
1073        if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1074                return -EINVAL;
1075
1076        err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1077        if (err)
1078                return err;
1079
1080        val->value.i = vlan4k.fid;
1081
1082        return 0;
1083}
1084EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_fid);
1085
1086int rtl8366_sw_set_vlan_fid(struct switch_dev *dev,
1087                            const struct switch_attr *attr,
1088                            struct switch_val *val)
1089{
1090        struct rtl8366_vlan_4k vlan4k;
1091        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1092        int err;
1093
1094        if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1095                return -EINVAL;
1096
1097        if (val->value.i < 0 || val->value.i > attr->max)
1098                return -EINVAL;
1099
1100        err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1101        if (err)
1102                return err;
1103
1104        return rtl8366_set_vlan(smi, val->port_vlan,
1105                                vlan4k.member,
1106                                vlan4k.untag,
1107                                val->value.i);
1108}
1109EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_fid);
1110
1111int rtl8366_sw_get_vlan_enable(struct switch_dev *dev,
1112                               const struct switch_attr *attr,
1113                               struct switch_val *val)
1114{
1115        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1116
1117        if (attr->ofs > 2)
1118                return -EINVAL;
1119
1120        if (attr->ofs == 1)
1121                val->value.i = smi->vlan_enabled;
1122        else
1123                val->value.i = smi->vlan4k_enabled;
1124
1125        return 0;
1126}
1127EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_enable);
1128
1129int rtl8366_sw_set_vlan_enable(struct switch_dev *dev,
1130                               const struct switch_attr *attr,
1131                               struct switch_val *val)
1132{
1133        struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1134        int err;
1135
1136        if (attr->ofs > 2)
1137                return -EINVAL;
1138
1139        if (attr->ofs == 1)
1140                err = rtl8366_enable_vlan(smi, val->value.i);
1141        else
1142                err = rtl8366_enable_vlan4k(smi, val->value.i);
1143
1144        return err;
1145}
1146EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_enable);
1147
1148struct rtl8366_smi *rtl8366_smi_alloc(struct device *parent)
1149{
1150        struct rtl8366_smi *smi;
1151
1152        BUG_ON(!parent);
1153
1154        smi = kzalloc(sizeof(*smi), GFP_KERNEL);
1155        if (!smi) {
1156                dev_err(parent, "no memory for private data\n");
1157                return NULL;
1158        }
1159
1160        smi->parent = parent;
1161        return smi;
1162}
1163EXPORT_SYMBOL_GPL(rtl8366_smi_alloc);
1164
1165static int __rtl8366_smi_init(struct rtl8366_smi *smi, const char *name)
1166{
1167        int err;
1168
1169        err = gpio_request(smi->gpio_sda, name);
1170        if (err) {
1171                printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1172                        smi->gpio_sda, err);
1173                goto err_out;
1174        }
1175
1176        err = gpio_request(smi->gpio_sck, name);
1177        if (err) {
1178                printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1179                        smi->gpio_sck, err);
1180                goto err_free_sda;
1181        }
1182
1183        spin_lock_init(&smi->lock);
1184        return 0;
1185
1186 err_free_sda:
1187        gpio_free(smi->gpio_sda);
1188 err_out:
1189        return err;
1190}
1191
1192static void __rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1193{
1194        gpio_free(smi->gpio_sck);
1195        gpio_free(smi->gpio_sda);
1196}
1197
1198enum rtl8366_type rtl8366_smi_detect(struct rtl8366_platform_data *pdata)
1199{
1200        static struct rtl8366_smi smi;
1201        enum rtl8366_type type = RTL8366_TYPE_UNKNOWN;
1202        u32 reg = 0;
1203
1204        memset(&smi, 0, sizeof(smi));
1205        smi.gpio_sda = pdata->gpio_sda;
1206        smi.gpio_sck = pdata->gpio_sck;
1207
1208        if (__rtl8366_smi_init(&smi, "rtl8366"))
1209                goto out;
1210
1211        if (rtl8366_smi_read_reg(&smi, 0x5c, &reg))
1212                goto cleanup;
1213
1214        switch(reg) {
1215        case 0x6027:
1216                printk("Found an RTL8366S switch\n");
1217                type = RTL8366_TYPE_S;
1218                break;
1219        case 0x5937:
1220                printk("Found an RTL8366RB switch\n");
1221                type = RTL8366_TYPE_RB;
1222                break;
1223        default:
1224                printk("Found an Unknown RTL8366 switch (id=0x%04x)\n", reg);
1225                break;
1226        }
1227
1228cleanup:
1229        __rtl8366_smi_cleanup(&smi);
1230out:
1231        return type;
1232}
1233
1234int rtl8366_smi_init(struct rtl8366_smi *smi)
1235{
1236        int err;
1237
1238        if (!smi->ops)
1239                return -EINVAL;
1240
1241        err = __rtl8366_smi_init(smi, dev_name(smi->parent));
1242        if (err)
1243                goto err_out;
1244
1245        spin_lock_init(&smi->lock);
1246
1247        dev_info(smi->parent, "using GPIO pins %u (SDA) and %u (SCK)\n",
1248                 smi->gpio_sda, smi->gpio_sck);
1249
1250        err = smi->ops->detect(smi);
1251        if (err) {
1252                dev_err(smi->parent, "chip detection failed, err=%d\n", err);
1253                goto err_free_sck;
1254        }
1255
1256        err = smi->ops->setup(smi);
1257        if (err) {
1258                dev_err(smi->parent, "chip setup failed, err=%d\n", err);
1259                goto err_free_sck;
1260        }
1261
1262        err = rtl8366_init_vlan(smi);
1263        if (err) {
1264                dev_err(smi->parent, "VLAN initialization failed, err=%d\n",
1265                        err);
1266                goto err_free_sck;
1267        }
1268
1269        err = rtl8366_enable_all_ports(smi, 1);
1270        if (err)
1271                goto err_free_sck;
1272
1273        err = rtl8366_smi_mii_init(smi);
1274        if (err)
1275                goto err_free_sck;
1276
1277        rtl8366_debugfs_init(smi);
1278
1279        return 0;
1280
1281 err_free_sck:
1282        __rtl8366_smi_cleanup(smi);
1283 err_out:
1284        return err;
1285}
1286EXPORT_SYMBOL_GPL(rtl8366_smi_init);
1287
1288void rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1289{
1290        rtl8366_debugfs_remove(smi);
1291        rtl8366_smi_mii_cleanup(smi);
1292        gpio_free(smi->gpio_sck);
1293        gpio_free(smi->gpio_sda);
1294}
1295EXPORT_SYMBOL_GPL(rtl8366_smi_cleanup);
1296
1297MODULE_DESCRIPTION("Realtek RTL8366 SMI interface driver");
1298MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
1299MODULE_LICENSE("GPL v2");
Note: See TracBrowser for help on using the repository browser.