source: branches/backfire/target/linux/generic-2.6/files/drivers/net/phy/rtl8366_smi.c @ 22025

Last change on this file since 22025 was 22025, checked in by juhosg, 6 years ago

backfire: generic: rtl8366: move common VLAN handling functions to rtl8366_smi.c (backport of 21979)

File size: 11.6 KB
Line 
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
19#include "rtl8366_smi.h"
20
21#define RTL8366_SMI_ACK_RETRY_COUNT         5
22#define RTL8366_SMI_CLK_DELAY               10 /* nsec */
23
24static inline void rtl8366_smi_clk_delay(struct rtl8366_smi *smi)
25{
26        ndelay(RTL8366_SMI_CLK_DELAY);
27}
28
29static void rtl8366_smi_start(struct rtl8366_smi *smi)
30{
31        unsigned int sda = smi->gpio_sda;
32        unsigned int sck = smi->gpio_sck;
33
34        /*
35         * Set GPIO pins to output mode, with initial state:
36         * SCK = 0, SDA = 1
37         */
38        gpio_direction_output(sck, 0);
39        gpio_direction_output(sda, 1);
40        rtl8366_smi_clk_delay(smi);
41
42        /* CLK 1: 0 -> 1, 1 -> 0 */
43        gpio_set_value(sck, 1);
44        rtl8366_smi_clk_delay(smi);
45        gpio_set_value(sck, 0);
46        rtl8366_smi_clk_delay(smi);
47
48        /* CLK 2: */
49        gpio_set_value(sck, 1);
50        rtl8366_smi_clk_delay(smi);
51        gpio_set_value(sda, 0);
52        rtl8366_smi_clk_delay(smi);
53        gpio_set_value(sck, 0);
54        rtl8366_smi_clk_delay(smi);
55        gpio_set_value(sda, 1);
56}
57
58static void rtl8366_smi_stop(struct rtl8366_smi *smi)
59{
60        unsigned int sda = smi->gpio_sda;
61        unsigned int sck = smi->gpio_sck;
62
63        rtl8366_smi_clk_delay(smi);
64        gpio_set_value(sda, 0);
65        gpio_set_value(sck, 1);
66        rtl8366_smi_clk_delay(smi);
67        gpio_set_value(sda, 1);
68        rtl8366_smi_clk_delay(smi);
69        gpio_set_value(sck, 1);
70        rtl8366_smi_clk_delay(smi);
71        gpio_set_value(sck, 0);
72        rtl8366_smi_clk_delay(smi);
73        gpio_set_value(sck, 1);
74
75        /* add a click */
76        rtl8366_smi_clk_delay(smi);
77        gpio_set_value(sck, 0);
78        rtl8366_smi_clk_delay(smi);
79        gpio_set_value(sck, 1);
80
81        /* set GPIO pins to input mode */
82        gpio_direction_input(sda);
83        gpio_direction_input(sck);
84}
85
86static void rtl8366_smi_write_bits(struct rtl8366_smi *smi, u32 data, u32 len)
87{
88        unsigned int sda = smi->gpio_sda;
89        unsigned int sck = smi->gpio_sck;
90
91        for (; len > 0; len--) {
92                rtl8366_smi_clk_delay(smi);
93
94                /* prepare data */
95                gpio_set_value(sda, !!(data & ( 1 << (len - 1))));
96                rtl8366_smi_clk_delay(smi);
97
98                /* clocking */
99                gpio_set_value(sck, 1);
100                rtl8366_smi_clk_delay(smi);
101                gpio_set_value(sck, 0);
102        }
103}
104
105static void rtl8366_smi_read_bits(struct rtl8366_smi *smi, u32 len, u32 *data)
106{
107        unsigned int sda = smi->gpio_sda;
108        unsigned int sck = smi->gpio_sck;
109
110        gpio_direction_input(sda);
111
112        for (*data = 0; len > 0; len--) {
113                u32 u;
114
115                rtl8366_smi_clk_delay(smi);
116
117                /* clocking */
118                gpio_set_value(sck, 1);
119                rtl8366_smi_clk_delay(smi);
120                u = !!gpio_get_value(sda);
121                gpio_set_value(sck, 0);
122
123                *data |= (u << (len - 1));
124        }
125
126        gpio_direction_output(sda, 0);
127}
128
129static int rtl8366_smi_wait_for_ack(struct rtl8366_smi *smi)
130{
131        int retry_cnt;
132
133        retry_cnt = 0;
134        do {
135                u32 ack;
136
137                rtl8366_smi_read_bits(smi, 1, &ack);
138                if (ack == 0)
139                        break;
140
141                if (++retry_cnt > RTL8366_SMI_ACK_RETRY_COUNT)
142                        return -EIO;
143        } while (1);
144
145        return 0;
146}
147
148static int rtl8366_smi_write_byte(struct rtl8366_smi *smi, u8 data)
149{
150        rtl8366_smi_write_bits(smi, data, 8);
151        return rtl8366_smi_wait_for_ack(smi);
152}
153
154static int rtl8366_smi_read_byte0(struct rtl8366_smi *smi, u8 *data)
155{
156        u32 t;
157
158        /* read data */
159        rtl8366_smi_read_bits(smi, 8, &t);
160        *data = (t & 0xff);
161
162        /* send an ACK */
163        rtl8366_smi_write_bits(smi, 0x00, 1);
164
165        return 0;
166}
167
168static int rtl8366_smi_read_byte1(struct rtl8366_smi *smi, u8 *data)
169{
170        u32 t;
171
172        /* read data */
173        rtl8366_smi_read_bits(smi, 8, &t);
174        *data = (t & 0xff);
175
176        /* send an ACK */
177        rtl8366_smi_write_bits(smi, 0x01, 1);
178
179        return 0;
180}
181
182int rtl8366_smi_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data)
183{
184        unsigned long flags;
185        u8 lo = 0;
186        u8 hi = 0;
187        int ret;
188
189        spin_lock_irqsave(&smi->lock, flags);
190
191        rtl8366_smi_start(smi);
192
193        /* send READ command */
194        ret = rtl8366_smi_write_byte(smi, 0x0a << 4 | 0x04 << 1 | 0x01);
195        if (ret)
196                goto out;
197
198        /* set ADDR[7:0] */
199        ret = rtl8366_smi_write_byte(smi, addr & 0xff);
200        if (ret)
201                goto out;
202
203        /* set ADDR[15:8] */
204        ret = rtl8366_smi_write_byte(smi, addr >> 8);
205        if (ret)
206                goto out;
207
208        /* read DATA[7:0] */
209        rtl8366_smi_read_byte0(smi, &lo);
210        /* read DATA[15:8] */
211        rtl8366_smi_read_byte1(smi, &hi);
212
213        *data = ((u32) lo) | (((u32) hi) << 8);
214
215        ret = 0;
216
217 out:
218        rtl8366_smi_stop(smi);
219        spin_unlock_irqrestore(&smi->lock, flags);
220
221        return ret;
222}
223EXPORT_SYMBOL_GPL(rtl8366_smi_read_reg);
224
225int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
226{
227        unsigned long flags;
228        int ret;
229
230        spin_lock_irqsave(&smi->lock, flags);
231
232        rtl8366_smi_start(smi);
233
234        /* send WRITE command */
235        ret = rtl8366_smi_write_byte(smi, 0x0a << 4 | 0x04 << 1 | 0x00);
236        if (ret)
237                goto out;
238
239        /* set ADDR[7:0] */
240        ret = rtl8366_smi_write_byte(smi, addr & 0xff);
241        if (ret)
242                goto out;
243
244        /* set ADDR[15:8] */
245        ret = rtl8366_smi_write_byte(smi, addr >> 8);
246        if (ret)
247                goto out;
248
249        /* write DATA[7:0] */
250        ret = rtl8366_smi_write_byte(smi, data & 0xff);
251        if (ret)
252                goto out;
253
254        /* write DATA[15:8] */
255        ret = rtl8366_smi_write_byte(smi, data >> 8);
256        if (ret)
257                goto out;
258
259        ret = 0;
260
261 out:
262        rtl8366_smi_stop(smi);
263        spin_unlock_irqrestore(&smi->lock, flags);
264
265        return ret;
266}
267EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg);
268
269int rtl8366_smi_rmwr(struct rtl8366_smi *smi, u32 addr, u32 mask, u32 data)
270{
271        u32 t;
272        int err;
273
274        err = rtl8366_smi_read_reg(smi, addr, &t);
275        if (err)
276                return err;
277
278        err = rtl8366_smi_write_reg(smi, addr, (t & ~mask) | data);
279        return err;
280
281}
282EXPORT_SYMBOL_GPL(rtl8366_smi_rmwr);
283
284static int rtl8366_mc_is_used(struct rtl8366_smi *smi, int mc_index, int *used)
285{
286        int err;
287        int i;
288
289        *used = 0;
290        for (i = 0; i < smi->num_ports; i++) {
291                int index = 0;
292
293                err = smi->ops->get_mc_index(smi, i, &index);
294                if (err)
295                        return err;
296
297                if (mc_index == index) {
298                        *used = 1;
299                        break;
300                }
301        }
302
303        return 0;
304}
305
306int rtl8366_set_vlan(struct rtl8366_smi *smi, int vid, u32 member, u32 untag,
307                     u32 fid)
308{
309        struct rtl8366_vlan_4k vlan4k;
310        int err;
311        int i;
312
313        /* Update the 4K table */
314        err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
315        if (err)
316                return err;
317
318        vlan4k.member = member;
319        vlan4k.untag = untag;
320        vlan4k.fid = fid;
321        err = smi->ops->set_vlan_4k(smi, &vlan4k);
322        if (err)
323                return err;
324
325        /* Try to find an existing MC entry for this VID */
326        for (i = 0; i < smi->num_vlan_mc; i++) {
327                struct rtl8366_vlan_mc vlanmc;
328
329                err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
330                if (err)
331                        return err;
332
333                if (vid == vlanmc.vid) {
334                        /* update the MC entry */
335                        vlanmc.member = member;
336                        vlanmc.untag = untag;
337                        vlanmc.fid = fid;
338
339                        err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
340                        break;
341                }
342        }
343
344        return err;
345}
346EXPORT_SYMBOL_GPL(rtl8366_set_vlan);
347
348int rtl8366_reset_vlan(struct rtl8366_smi *smi)
349{
350        struct rtl8366_vlan_mc vlanmc;
351        int err;
352        int i;
353
354        /* clear VLAN member configurations */
355        vlanmc.vid = 0;
356        vlanmc.priority = 0;
357        vlanmc.member = 0;
358        vlanmc.untag = 0;
359        vlanmc.fid = 0;
360        for (i = 0; i < smi->num_vlan_mc; i++) {
361                err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
362                if (err)
363                        return err;
364        }
365
366        for (i = 0; i < smi->num_ports; i++) {
367                if (i == smi->cpu_port)
368                        continue;
369
370                err = rtl8366_set_vlan(smi, (i + 1),
371                                        (1 << i) | (1 << smi->cpu_port),
372                                        (1 << i) | (1 << smi->cpu_port),
373                                        0);
374                if (err)
375                        return err;
376
377                err = rtl8366_set_pvid(smi, i, (i + 1));
378                if (err)
379                        return err;
380        }
381
382        return 0;
383}
384EXPORT_SYMBOL_GPL(rtl8366_reset_vlan);
385
386int rtl8366_get_pvid(struct rtl8366_smi *smi, int port, int *val)
387{
388        struct rtl8366_vlan_mc vlanmc;
389        int err;
390        int index;
391
392        err = smi->ops->get_mc_index(smi, port, &index);
393        if (err)
394                return err;
395
396        err = smi->ops->get_vlan_mc(smi, index, &vlanmc);
397        if (err)
398                return err;
399
400        *val = vlanmc.vid;
401        return 0;
402}
403EXPORT_SYMBOL_GPL(rtl8366_get_pvid);
404
405int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port, unsigned vid)
406{
407        struct rtl8366_vlan_mc vlanmc;
408        struct rtl8366_vlan_4k vlan4k;
409        int err;
410        int i;
411
412        /* Try to find an existing MC entry for this VID */
413        for (i = 0; i < smi->num_vlan_mc; i++) {
414                err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
415                if (err)
416                        return err;
417
418                if (vid == vlanmc.vid) {
419                        err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
420                        if (err)
421                                return err;
422
423                        err = smi->ops->set_mc_index(smi, port, i);
424                        return err;
425                }
426        }
427
428        /* We have no MC entry for this VID, try to find an empty one */
429        for (i = 0; i < smi->num_vlan_mc; i++) {
430                err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
431                if (err)
432                        return err;
433
434                if (vlanmc.vid == 0 && vlanmc.member == 0) {
435                        /* Update the entry from the 4K table */
436                        err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
437                        if (err)
438                                return err;
439
440                        vlanmc.vid = vid;
441                        vlanmc.member = vlan4k.member;
442                        vlanmc.untag = vlan4k.untag;
443                        vlanmc.fid = vlan4k.fid;
444                        err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
445                        if (err)
446                                return err;
447
448                        err = smi->ops->set_mc_index(smi, port, i);
449                        return err;
450                }
451        }
452
453        /* MC table is full, try to find an unused entry and replace it */
454        for (i = 0; i < smi->num_vlan_mc; i++) {
455                int used;
456
457                err = rtl8366_mc_is_used(smi, i, &used);
458                if (err)
459                        return err;
460
461                if (!used) {
462                        /* Update the entry from the 4K table */
463                        err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
464                        if (err)
465                                return err;
466
467                        vlanmc.vid = vid;
468                        vlanmc.member = vlan4k.member;
469                        vlanmc.untag = vlan4k.untag;
470                        vlanmc.fid = vlan4k.fid;
471                        err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
472                        if (err)
473                                return err;
474
475                        err = smi->ops->set_mc_index(smi, port, i);
476                        return err;
477                }
478        }
479
480        dev_err(smi->parent,
481                "all VLAN member configurations are in use\n");
482
483        return -ENOSPC;
484}
485EXPORT_SYMBOL_GPL(rtl8366_set_pvid);
486
487static int rtl8366_smi_mii_init(struct rtl8366_smi *smi)
488{
489        int ret;
490        int i;
491
492        smi->mii_bus = mdiobus_alloc();
493        if (smi->mii_bus == NULL) {
494                ret = -ENOMEM;
495                goto err;
496        }
497
498        smi->mii_bus->priv = (void *) smi;
499        smi->mii_bus->name = dev_name(smi->parent);
500        smi->mii_bus->read = smi->ops->mii_read;
501        smi->mii_bus->write = smi->ops->mii_write;
502        snprintf(smi->mii_bus->id, MII_BUS_ID_SIZE, "%s",
503                 dev_name(smi->parent));
504        smi->mii_bus->parent = smi->parent;
505        smi->mii_bus->phy_mask = ~(0x1f);
506        smi->mii_bus->irq = smi->mii_irq;
507        for (i = 0; i < PHY_MAX_ADDR; i++)
508                smi->mii_irq[i] = PHY_POLL;
509
510        ret = mdiobus_register(smi->mii_bus);
511        if (ret)
512                goto err_free;
513
514        return 0;
515
516 err_free:
517        mdiobus_free(smi->mii_bus);
518 err:
519        return ret;
520}
521
522static void rtl8366_smi_mii_cleanup(struct rtl8366_smi *smi)
523{
524        mdiobus_unregister(smi->mii_bus);
525        mdiobus_free(smi->mii_bus);
526}
527
528int rtl8366_smi_init(struct rtl8366_smi *smi)
529{
530        int err;
531
532        if (!smi->parent)
533                return -EINVAL;
534
535        if (!smi->ops)
536                return -EINVAL;
537
538        err = gpio_request(smi->gpio_sda, dev_name(smi->parent));
539        if (err) {
540                dev_err(smi->parent, "gpio_request failed for %u, err=%d\n",
541                        smi->gpio_sda, err);
542                goto err_out;
543        }
544
545        err = gpio_request(smi->gpio_sck, dev_name(smi->parent));
546        if (err) {
547                dev_err(smi->parent, "gpio_request failed for %u, err=%d\n",
548                        smi->gpio_sck, err);
549                goto err_free_sda;
550        }
551
552        spin_lock_init(&smi->lock);
553
554        dev_info(smi->parent, "using GPIO pins %u (SDA) and %u (SCK)\n",
555                 smi->gpio_sda, smi->gpio_sck);
556
557        err = smi->ops->detect(smi);
558        if (err) {
559                dev_err(smi->parent, "chip detection failed, err=%d\n", err);
560                goto err_free_sck;
561        }
562
563        err = rtl8366_smi_mii_init(smi);
564        if (err)
565                goto err_free_sck;
566
567        return 0;
568
569 err_free_sck:
570        gpio_free(smi->gpio_sck);
571 err_free_sda:
572        gpio_free(smi->gpio_sda);
573 err_out:
574        return err;
575}
576EXPORT_SYMBOL_GPL(rtl8366_smi_init);
577
578void rtl8366_smi_cleanup(struct rtl8366_smi *smi)
579{
580        rtl8366_smi_mii_cleanup(smi);
581        gpio_free(smi->gpio_sck);
582        gpio_free(smi->gpio_sda);
583}
584EXPORT_SYMBOL_GPL(rtl8366_smi_cleanup);
585
586MODULE_DESCRIPTION("Realtek RTL8366 SMI interface driver");
587MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
588MODULE_LICENSE("GPL v2");
Note: See TracBrowser for help on using the repository browser.