projects / openwrt / svn-archive / archive.git / blob
? search:


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