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