projects / openwrt / staging / chunkeey.git / blob
? search:


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