Root/target/linux/generic/files/drivers/net/phy/rtl8366_smi.c

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

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive