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

Last change on this file since 27785 was 27785, checked in by nbd, 5 years ago

backport rtl8366 detection support from trunk

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