backport rtl8366 detection support from trunk
[openwrt-10.03/.git] / target / linux / generic-2.6 / 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_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
29 static inline void rtl8366_smi_clk_delay(struct rtl8366_smi *smi)
30 {
31         ndelay(RTL8366_SMI_CLK_DELAY);
32 }
33
34 static 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
63 static 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
91 static 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
110 static 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
134 static 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
153 static 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
159 static 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
173 static 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
187 int 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 }
228 EXPORT_SYMBOL_GPL(rtl8366_smi_read_reg);
229
230 int 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 }
272 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg);
273
274 int 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 }
287 EXPORT_SYMBOL_GPL(rtl8366_smi_rmwr);
288
289 static 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
311 static 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
352 static 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
370 static 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
452 int 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 }
469 EXPORT_SYMBOL_GPL(rtl8366_enable_vlan);
470
471 static 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
491 int 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 }
504 EXPORT_SYMBOL_GPL(rtl8366_enable_all_ports);
505
506 int 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 }
529 EXPORT_SYMBOL_GPL(rtl8366_reset_vlan);
530
531 static 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
561 int rtl8366_debugfs_open(struct inode *inode, struct file *file)
562 {
563         file->private_data = inode->i_private;
564         return 0;
565 }
566 EXPORT_SYMBOL_GPL(rtl8366_debugfs_open);
567
568 static 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
597 static 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
631 static 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
659 static 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
683 static 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
719 static 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
760 static 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
767 static 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
773 static 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
779 static const struct file_operations fops_rtl8366_pvid = {
780         .read   = rtl8366_read_debugfs_pvid,
781         .open   = rtl8366_debugfs_open,
782         .owner  = THIS_MODULE
783 };
784
785 static const struct file_operations fops_rtl8366_mibs = {
786         .read = rtl8366_read_debugfs_mibs,
787         .open = rtl8366_debugfs_open,
788         .owner = THIS_MODULE
789 };
790
791 static 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
861 static 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
869 static inline void rtl8366_debugfs_init(struct rtl8366_smi *smi) {}
870 static inline void rtl8366_debugfs_remove(struct rtl8366_smi *smi) {}
871 #endif /* CONFIG_RTL8366S_PHY_DEBUG_FS */
872
873 static 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
908 static void rtl8366_smi_mii_cleanup(struct rtl8366_smi *smi)
909 {
910         mdiobus_unregister(smi->mii_bus);
911         mdiobus_free(smi->mii_bus);
912 }
913
914 int 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 }
919 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_pvid);
920
921 int 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 }
926 EXPORT_SYMBOL_GPL(rtl8366_sw_set_port_pvid);
927
928 int 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 }
960 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_mib);
961
962 int 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 }
1002 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_info);
1003
1004 int 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 }
1030 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_ports);
1031
1032 int 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 }
1062 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_ports);
1063
1064 int 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 }
1083 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_fid);
1084
1085 int 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 }
1108 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_fid);
1109
1110 int 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 }
1126 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_enable);
1127
1128 int 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 }
1145 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_enable);
1146
1147 struct rtl8366_smi *rtl8366_smi_alloc(struct device *parent)
1148 {
1149         struct rtl8366_smi *smi;
1150
1151         BUG_ON(!parent);