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