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