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 static 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 /* Read/write via mdiobus */
 244 #define MDC_MDIO_CTRL0_REG              31
 245 #define MDC_MDIO_START_REG              29
 246 #define MDC_MDIO_CTRL1_REG              21
 247 #define MDC_MDIO_ADDRESS_REG            23
 248 #define MDC_MDIO_DATA_WRITE_REG         24
 249 #define MDC_MDIO_DATA_READ_REG          25
 250
 251 #define MDC_MDIO_START_OP               0xFFFF
 252 #define MDC_MDIO_ADDR_OP                0x000E
 253 #define MDC_MDIO_READ_OP                0x0001
 254 #define MDC_MDIO_WRITE_OP               0x0003
 255 #define MDC_REALTEK_PHY_ADDR            0x0
 256
 257 int __rtl8366_mdio_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data)
 258 {
 259         u32 phy_id = MDC_REALTEK_PHY_ADDR;
 260         struct mii_bus *mbus = smi->ext_mbus;
 261
 262         BUG_ON(in_interrupt());
 263
 264         mutex_lock(&mbus->mdio_lock);
 265         /* Write Start command to register 29 */
 266         mbus->write(mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
 267
 268         /* Write address control code to register 31 */
 269         mbus->write(mbus, phy_id, MDC_MDIO_CTRL0_REG, MDC_MDIO_ADDR_OP);
 270
 271         /* Write Start command to register 29 */
 272         mbus->write(mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
 273
 274         /* Write address to register 23 */
 275         mbus->write(mbus, phy_id, MDC_MDIO_ADDRESS_REG, addr);
 276
 277         /* Write Start command to register 29 */
 278         mbus->write(mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
 279
 280         /* Write read control code to register 21 */
 281         mbus->write(mbus, phy_id, MDC_MDIO_CTRL1_REG, MDC_MDIO_READ_OP);
 282
 283         /* Write Start command to register 29 */
 284         mbus->write(smi->ext_mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
 285
 286         /* Read data from register 25 */
 287         *data = mbus->read(mbus, phy_id, MDC_MDIO_DATA_READ_REG);
 288
 289         mutex_unlock(&mbus->mdio_lock);
 290
 291         return 0;
 292 }
 293
 294 static int __rtl8366_mdio_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
 295 {
 296         u32 phy_id = MDC_REALTEK_PHY_ADDR;
 297         struct mii_bus *mbus = smi->ext_mbus;
 298
 299         BUG_ON(in_interrupt());
 300
 301         mutex_lock(&mbus->mdio_lock);
 302
 303         /* Write Start command to register 29 */
 304         mbus->write(mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
 305
 306         /* Write address control code to register 31 */
 307         mbus->write(mbus, phy_id, MDC_MDIO_CTRL0_REG, MDC_MDIO_ADDR_OP);
 308
 309         /* Write Start command to register 29 */
 310         mbus->write(mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
 311
 312         /* Write address to register 23 */
 313         mbus->write(mbus, phy_id, MDC_MDIO_ADDRESS_REG, addr);
 314
 315         /* Write Start command to register 29 */
 316         mbus->write(mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
 317
 318         /* Write data to register 24 */
 319         mbus->write(mbus, phy_id, MDC_MDIO_DATA_WRITE_REG, data);
 320
 321         /* Write Start command to register 29 */
 322         mbus->write(mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
 323
 324         /* Write data control code to register 21 */
 325         mbus->write(mbus, phy_id, MDC_MDIO_CTRL1_REG, MDC_MDIO_WRITE_OP);
 326
 327         mutex_unlock(&mbus->mdio_lock);
 328         return 0;
 329 }
 330
 331 int rtl8366_smi_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data)
 332 {
 333         if (smi->ext_mbus)
 334                 return __rtl8366_mdio_read_reg(smi, addr, data);
 335         else
 336                 return __rtl8366_smi_read_reg(smi, addr, data);
 337 }
 338 EXPORT_SYMBOL_GPL(rtl8366_smi_read_reg);
 339
 340 static int __rtl8366_smi_write_reg(struct rtl8366_smi *smi,
 341                                    u32 addr, u32 data, bool ack)
 342 {
 343         unsigned long flags;
 344         int ret;
 345
 346         spin_lock_irqsave(&smi->lock, flags);
 347
 348         rtl8366_smi_start(smi);
 349
 350         /* send WRITE command */
 351         ret = rtl8366_smi_write_byte(smi, smi->cmd_write);
 352         if (ret)
 353                 goto out;
 354
 355         /* set ADDR[7:0] */
 356         ret = rtl8366_smi_write_byte(smi, addr & 0xff);
 357         if (ret)
 358                 goto out;
 359
 360         /* set ADDR[15:8] */
 361         ret = rtl8366_smi_write_byte(smi, addr >> 8);
 362         if (ret)
 363                 goto out;
 364
 365         /* write DATA[7:0] */
 366         ret = rtl8366_smi_write_byte(smi, data & 0xff);
 367         if (ret)
 368                 goto out;
 369
 370         /* write DATA[15:8] */
 371         if (ack)
 372                 ret = rtl8366_smi_write_byte(smi, data >> 8);
 373         else
 374                 ret = rtl8366_smi_write_byte_noack(smi, data >> 8);
 375         if (ret)
 376                 goto out;
 377
 378         ret = 0;
 379
 380  out:
 381         rtl8366_smi_stop(smi);
 382         spin_unlock_irqrestore(&smi->lock, flags);
 383
 384         return ret;
 385 }
 386
 387 int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
 388 {
 389         if (smi->ext_mbus)
 390                 return __rtl8366_mdio_write_reg(smi, addr, data);
 391         else
 392                 return __rtl8366_smi_write_reg(smi, addr, data, true);
 393 }
 394 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg);
 395
 396 int rtl8366_smi_write_reg_noack(struct rtl8366_smi *smi, u32 addr, u32 data)
 397 {
 398         return __rtl8366_smi_write_reg(smi, addr, data, false);
 399 }
 400 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg_noack);
 401
 402 int rtl8366_smi_rmwr(struct rtl8366_smi *smi, u32 addr, u32 mask, u32 data)
 403 {
 404         u32 t;
 405         int err;
 406
 407         err = rtl8366_smi_read_reg(smi, addr, &t);
 408         if (err)
 409                 return err;
 410
 411         err = rtl8366_smi_write_reg(smi, addr, (t & ~mask) | data);
 412         return err;
 413
 414 }
 415 EXPORT_SYMBOL_GPL(rtl8366_smi_rmwr);
 416
 417 static int rtl8366_reset(struct rtl8366_smi *smi)
 418 {
 419         if (smi->hw_reset) {
 420                 smi->hw_reset(smi, true);
 421                 msleep(RTL8366_SMI_HW_STOP_DELAY);
 422                 smi->hw_reset(smi, false);
 423                 msleep(RTL8366_SMI_HW_START_DELAY);
 424                 return 0;
 425         }
 426
 427         return smi->ops->reset_chip(smi);
 428 }
 429
 430 static int rtl8366_mc_is_used(struct rtl8366_smi *smi, int mc_index, int *used)
 431 {
 432         int err;
 433         int i;
 434
 435         *used = 0;
 436         for (i = 0; i < smi->num_ports; i++) {
 437                 int index = 0;
 438
 439                 err = smi->ops->get_mc_index(smi, i, &index);
 440                 if (err)
 441                         return err;
 442
 443                 if (mc_index == index) {
 444                         *used = 1;
 445                         break;
 446                 }
 447         }
 448
 449         return 0;
 450 }
 451
 452 static int rtl8366_set_vlan(struct rtl8366_smi *smi, int vid, u32 member,
 453                             u32 untag, u32 fid)
 454 {
 455         struct rtl8366_vlan_4k vlan4k;
 456         int err;
 457         int i;
 458
 459         /* Update the 4K table */
 460         err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
 461         if (err)
 462                 return err;
 463
 464         vlan4k.member = member;
 465         vlan4k.untag = untag;
 466         vlan4k.fid = fid;
 467         err = smi->ops->set_vlan_4k(smi, &vlan4k);
 468         if (err)
 469                 return err;
 470
 471         /* Try to find an existing MC entry for this VID */
 472         for (i = 0; i < smi->num_vlan_mc; i++) {
 473                 struct rtl8366_vlan_mc vlanmc;
 474
 475                 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
 476                 if (err)
 477                         return err;
 478
 479                 if (vid == vlanmc.vid) {
 480                         /* update the MC entry */
 481                         vlanmc.member = member;
 482                         vlanmc.untag = untag;
 483                         vlanmc.fid = fid;
 484
 485                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
 486                         break;
 487                 }
 488         }
 489
 490         return err;
 491 }
 492
 493 static int rtl8366_get_pvid(struct rtl8366_smi *smi, int port, int *val)
 494 {
 495         struct rtl8366_vlan_mc vlanmc;
 496         int err;
 497         int index;
 498
 499         err = smi->ops->get_mc_index(smi, port, &index);
 500         if (err)
 501                 return err;
 502
 503         err = smi->ops->get_vlan_mc(smi, index, &vlanmc);
 504         if (err)
 505                 return err;
 506
 507         *val = vlanmc.vid;
 508         return 0;
 509 }
 510
 511 static int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port,
 512                             unsigned vid)
 513 {
 514         struct rtl8366_vlan_mc vlanmc;
 515         struct rtl8366_vlan_4k vlan4k;
 516         int err;
 517         int i;
 518
 519         /* Try to find an existing MC entry for this VID */
 520         for (i = 0; i < smi->num_vlan_mc; i++) {
 521                 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
 522                 if (err)
 523                         return err;
 524
 525                 if (vid == vlanmc.vid) {
 526                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
 527                         if (err)
 528                                 return err;
 529
 530                         err = smi->ops->set_mc_index(smi, port, i);
 531                         return err;
 532                 }
 533         }
 534
 535         /* We have no MC entry for this VID, try to find an empty one */
 536         for (i = 0; i < smi->num_vlan_mc; i++) {
 537                 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
 538                 if (err)
 539                         return err;
 540
 541                 if (vlanmc.vid == 0 && vlanmc.member == 0) {
 542                         /* Update the entry from the 4K table */
 543                         err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
 544                         if (err)
 545                                 return err;
 546
 547                         vlanmc.vid = vid;
 548                         vlanmc.member = vlan4k.member;
 549                         vlanmc.untag = vlan4k.untag;
 550                         vlanmc.fid = vlan4k.fid;
 551                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
 552                         if (err)
 553                                 return err;
 554
 555                         err = smi->ops->set_mc_index(smi, port, i);
 556                         return err;
 557                 }
 558         }
 559
 560         /* MC table is full, try to find an unused entry and replace it */
 561         for (i = 0; i < smi->num_vlan_mc; i++) {
 562                 int used;
 563
 564                 err = rtl8366_mc_is_used(smi, i, &used);
 565                 if (err)
 566                         return err;
 567
 568                 if (!used) {
 569                         /* Update the entry from the 4K table */
 570                         err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
 571                         if (err)
 572                                 return err;
 573
 574                         vlanmc.vid = vid;
 575                         vlanmc.member = vlan4k.member;
 576                         vlanmc.untag = vlan4k.untag;
 577                         vlanmc.fid = vlan4k.fid;
 578                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
 579                         if (err)
 580                                 return err;
 581
 582                         err = smi->ops->set_mc_index(smi, port, i);
 583                         return err;
 584                 }
 585         }
 586
 587         dev_err(smi->parent,
 588                 "all VLAN member configurations are in use\n");
 589
 590         return -ENOSPC;
 591 }
 592
 593 int rtl8366_enable_vlan(struct rtl8366_smi *smi, int enable)
 594 {
 595         int err;
 596
 597         err = smi->ops->enable_vlan(smi, enable);
 598         if (err)
 599                 return err;
 600
 601         smi->vlan_enabled = enable;
 602
 603         if (!enable) {
 604                 smi->vlan4k_enabled = 0;
 605                 err = smi->ops->enable_vlan4k(smi, enable);
 606         }
 607
 608         return err;
 609 }
 610 EXPORT_SYMBOL_GPL(rtl8366_enable_vlan);
 611
 612 static int rtl8366_enable_vlan4k(struct rtl8366_smi *smi, int enable)
 613 {
 614         int err;
 615
 616         if (enable) {
 617                 err = smi->ops->enable_vlan(smi, enable);
 618                 if (err)
 619                         return err;
 620
 621                 smi->vlan_enabled = enable;
 622         }
 623
 624         err = smi->ops->enable_vlan4k(smi, enable);
 625         if (err)
 626                 return err;
 627
 628         smi->vlan4k_enabled = enable;
 629         return 0;
 630 }
 631
 632 int rtl8366_enable_all_ports(struct rtl8366_smi *smi, int enable)
 633 {
 634         int port;
 635         int err;
 636
 637         for (port = 0; port < smi->num_ports; port++) {
 638                 err = smi->ops->enable_port(smi, port, enable);
 639                 if (err)
 640                         return err;
 641         }
 642
 643         return 0;
 644 }
 645 EXPORT_SYMBOL_GPL(rtl8366_enable_all_ports);
 646
 647 int rtl8366_reset_vlan(struct rtl8366_smi *smi)
 648 {
 649         struct rtl8366_vlan_mc vlanmc;
 650         int err;
 651         int i;
 652
 653         rtl8366_enable_vlan(smi, 0);
 654         rtl8366_enable_vlan4k(smi, 0);
 655
 656         /* clear VLAN member configurations */
 657         vlanmc.vid = 0;
 658         vlanmc.priority = 0;
 659         vlanmc.member = 0;
 660         vlanmc.untag = 0;
 661         vlanmc.fid = 0;
 662         for (i = 0; i < smi->num_vlan_mc; i++) {
 663                 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
 664                 if (err)
 665                         return err;
 666         }
 667
 668         return 0;
 669 }
 670 EXPORT_SYMBOL_GPL(rtl8366_reset_vlan);
 671
 672 static int rtl8366_init_vlan(struct rtl8366_smi *smi)
 673 {
 674         int port;
 675         int err;
 676
 677         err = rtl8366_reset_vlan(smi);
 678         if (err)
 679                 return err;
 680
 681         for (port = 0; port < smi->num_ports; port++) {
 682                 u32 mask;
 683
 684                 if (port == smi->cpu_port)
 685                         mask = (1 << smi->num_ports) - 1;
 686                 else
 687                         mask = (1 << port) | (1 << smi->cpu_port);
 688
 689                 err = rtl8366_set_vlan(smi, (port + 1), mask, mask, 0);
 690                 if (err)
 691                         return err;
 692
 693                 err = rtl8366_set_pvid(smi, port, (port + 1));
 694                 if (err)
 695                         return err;
 696         }
 697
 698         return rtl8366_enable_vlan(smi, 1);
 699 }
 700
 701 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
 702 int rtl8366_debugfs_open(struct inode *inode, struct file *file)
 703 {
 704         file->private_data = inode->i_private;
 705         return 0;
 706 }
 707 EXPORT_SYMBOL_GPL(rtl8366_debugfs_open);
 708
 709 static ssize_t rtl8366_read_debugfs_vlan_mc(struct file *file,
 710                                               char __user *user_buf,
 711                                               size_t count, loff_t *ppos)
 712 {
 713         struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
 714         int i, len = 0;
 715         char *buf = smi->buf;
 716
 717         len += snprintf(buf + len, sizeof(smi->buf) - len,
 718                         "%2s %6s %4s %6s %6s %3s\n",
 719                         "id", "vid","prio", "member", "untag", "fid");
 720
 721         for (i = 0; i < smi->num_vlan_mc; ++i) {
 722                 struct rtl8366_vlan_mc vlanmc;
 723
 724                 smi->ops->get_vlan_mc(smi, i, &vlanmc);
 725
 726                 len += snprintf(buf + len, sizeof(smi->buf) - len,
 727                                 "%2d %6d %4d 0x%04x 0x%04x %3d\n",
 728                                 i, vlanmc.vid, vlanmc.priority,
 729                                 vlanmc.member, vlanmc.untag, vlanmc.fid);
 730         }
 731
 732         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 733 }
 734
 735 #define RTL8366_VLAN4K_PAGE_SIZE        64
 736 #define RTL8366_VLAN4K_NUM_PAGES        (4096 / RTL8366_VLAN4K_PAGE_SIZE)
 737
 738 static ssize_t rtl8366_read_debugfs_vlan_4k(struct file *file,
 739                                             char __user *user_buf,
 740                                             size_t count, loff_t *ppos)
 741 {
 742         struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
 743         int i, len = 0;
 744         int offset;
 745         char *buf = smi->buf;
 746
 747         if (smi->dbg_vlan_4k_page >= RTL8366_VLAN4K_NUM_PAGES) {
 748                 len += snprintf(buf + len, sizeof(smi->buf) - len,
 749                                 "invalid page: %u\n", smi->dbg_vlan_4k_page);
 750                 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 751         }
 752
 753         len += snprintf(buf + len, sizeof(smi->buf) - len,
 754                         "%4s %6s %6s %3s\n",
 755                         "vid", "member", "untag", "fid");
 756
 757         offset = RTL8366_VLAN4K_PAGE_SIZE * smi->dbg_vlan_4k_page;
 758         for (i = 0; i < RTL8366_VLAN4K_PAGE_SIZE; i++) {
 759                 struct rtl8366_vlan_4k vlan4k;
 760
 761                 smi->ops->get_vlan_4k(smi, offset + i, &vlan4k);
 762
 763                 len += snprintf(buf + len, sizeof(smi->buf) - len,
 764                                 "%4d 0x%04x 0x%04x %3d\n",
 765                                 vlan4k.vid, vlan4k.member,
 766                                 vlan4k.untag, vlan4k.fid);
 767         }
 768
 769         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 770 }
 771
 772 static ssize_t rtl8366_read_debugfs_pvid(struct file *file,
 773                                          char __user *user_buf,
 774                                          size_t count, loff_t *ppos)
 775 {
 776         struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
 777         char *buf = smi->buf;
 778         int len = 0;
 779         int i;
 780
 781         len += snprintf(buf + len, sizeof(smi->buf) - len, "%4s %4s\n",
 782                         "port", "pvid");
 783
 784         for (i = 0; i < smi->num_ports; i++) {
 785                 int pvid;
 786                 int err;
 787
 788                 err = rtl8366_get_pvid(smi, i, &pvid);
 789                 if (err)
 790                         len += snprintf(buf + len, sizeof(smi->buf) - len,
 791                                 "%4d error\n", i);
 792                 else
 793                         len += snprintf(buf + len, sizeof(smi->buf) - len,
 794                                 "%4d %4d\n", i, pvid);
 795         }
 796
 797         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 798 }
 799
 800 static ssize_t rtl8366_read_debugfs_reg(struct file *file,
 801                                          char __user *user_buf,
 802                                          size_t count, loff_t *ppos)
 803 {
 804         struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
 805         u32 t, reg = smi->dbg_reg;
 806         int err, len = 0;
 807         char *buf = smi->buf;
 808
 809         memset(buf, '\0', sizeof(smi->buf));
 810
 811         err = rtl8366_smi_read_reg(smi, reg, &t);
 812         if (err) {
 813                 len += snprintf(buf, sizeof(smi->buf),
 814                                 "Read failed (reg: 0x%04x)\n", reg);
 815                 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 816         }
 817
 818         len += snprintf(buf, sizeof(smi->buf), "reg = 0x%04x, val = 0x%04x\n",
 819                         reg, t);
 820
 821         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 822 }
 823
 824 static ssize_t rtl8366_write_debugfs_reg(struct file *file,
 825                                           const char __user *user_buf,
 826                                           size_t count, loff_t *ppos)
 827 {
 828         struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
 829         unsigned long data;
 830         u32 reg = smi->dbg_reg;
 831         int err;
 832         size_t len;
 833         char *buf = smi->buf;
 834
 835         len = min(count, sizeof(smi->buf) - 1);
 836         if (copy_from_user(buf, user_buf, len)) {
 837                 dev_err(smi->parent, "copy from user failed\n");
 838                 return -EFAULT;
 839         }
 840
 841         buf[len] = '\0';
 842         if (len > 0 && buf[len - 1] == '\n')
 843                 buf[len - 1] = '\0';
 844
 845
 846         if (kstrtoul(buf, 16, &data)) {
 847                 dev_err(smi->parent, "Invalid reg value %s\n", buf);
 848         } else {
 849                 err = rtl8366_smi_write_reg(smi, reg, data);
 850                 if (err) {
 851                         dev_err(smi->parent,
 852                                 "writing reg 0x%04x val 0x%04lx failed\n",
 853                                 reg, data);
 854                 }
 855         }
 856
 857         return count;
 858 }
 859
 860 static ssize_t rtl8366_read_debugfs_mibs(struct file *file,
 861                                          char __user *user_buf,
 862                                          size_t count, loff_t *ppos)
 863 {
 864         struct rtl8366_smi *smi = file->private_data;
 865         int i, j, len = 0;
 866         char *buf = smi->buf;
 867
 868         len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s",
 869                         "Counter");
 870
 871         for (i = 0; i < smi->num_ports; i++) {
 872                 char port_buf[10];
 873
 874                 snprintf(port_buf, sizeof(port_buf), "Port %d", i);
 875                 len += snprintf(buf + len, sizeof(smi->buf) - len, " %12s",
 876                                 port_buf);
 877         }
 878         len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
 879
 880         for (i = 0; i < smi->num_mib_counters; i++) {
 881                 len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s ",
 882                                 smi->mib_counters[i].name);
 883                 for (j = 0; j < smi->num_ports; j++) {
 884                         unsigned long long counter = 0;
 885
 886                         if (!smi->ops->get_mib_counter(smi, i, j, &counter))
 887                                 len += snprintf(buf + len,
 888                                                 sizeof(smi->buf) - len,
 889                                                 "%12llu ", counter);
 890                         else
 891                                 len += snprintf(buf + len,
 892                                                 sizeof(smi->buf) - len,
 893                                                 "%12s ", "error");
 894                 }
 895                 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
 896         }
 897
 898         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 899 }
 900
 901 static const struct file_operations fops_rtl8366_regs = {
 902         .read   = rtl8366_read_debugfs_reg,
 903         .write  = rtl8366_write_debugfs_reg,
 904         .open   = rtl8366_debugfs_open,
 905         .owner  = THIS_MODULE
 906 };
 907
 908 static const struct file_operations fops_rtl8366_vlan_mc = {
 909         .read   = rtl8366_read_debugfs_vlan_mc,
 910         .open   = rtl8366_debugfs_open,
 911         .owner  = THIS_MODULE
 912 };
 913
 914 static const struct file_operations fops_rtl8366_vlan_4k = {
 915         .read   = rtl8366_read_debugfs_vlan_4k,
 916         .open   = rtl8366_debugfs_open,
 917         .owner  = THIS_MODULE
 918 };
 919
 920 static const struct file_operations fops_rtl8366_pvid = {
 921         .read   = rtl8366_read_debugfs_pvid,
 922         .open   = rtl8366_debugfs_open,
 923         .owner  = THIS_MODULE
 924 };
 925
 926 static const struct file_operations fops_rtl8366_mibs = {
 927         .read = rtl8366_read_debugfs_mibs,
 928         .open = rtl8366_debugfs_open,
 929         .owner = THIS_MODULE
 930 };
 931
 932 static void rtl8366_debugfs_init(struct rtl8366_smi *smi)
 933 {
 934         struct dentry *node;
 935         struct dentry *root;
 936
 937         if (!smi->debugfs_root)
 938                 smi->debugfs_root = debugfs_create_dir(dev_name(smi->parent),
 939                                                        NULL);
 940
 941         if (!smi->debugfs_root) {
 942                 dev_err(smi->parent, "Unable to create debugfs dir\n");
 943                 return;
 944         }
 945         root = smi->debugfs_root;
 946
 947         node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root,
 948                                   &smi->dbg_reg);
 949         if (!node) {
 950                 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
 951                         "reg");
 952                 return;
 953         }
 954
 955         node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, smi,
 956                                    &fops_rtl8366_regs);
 957         if (!node) {
 958                 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
 959                         "val");
 960                 return;
 961         }
 962
 963         node = debugfs_create_file("vlan_mc", S_IRUSR, root, smi,
 964                                    &fops_rtl8366_vlan_mc);
 965         if (!node) {
 966                 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
 967                         "vlan_mc");
 968                 return;
 969         }
 970
 971         node = debugfs_create_u8("vlan_4k_page", S_IRUGO | S_IWUSR, root,
 972                                   &smi->dbg_vlan_4k_page);
 973         if (!node) {
 974                 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
 975                         "vlan_4k_page");
 976                 return;
 977         }
 978
 979         node = debugfs_create_file("vlan_4k", S_IRUSR, root, smi,
 980                                    &fops_rtl8366_vlan_4k);
 981         if (!node) {
 982                 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
 983                         "vlan_4k");
 984                 return;
 985         }
 986
 987         node = debugfs_create_file("pvid", S_IRUSR, root, smi,
 988                                    &fops_rtl8366_pvid);
 989         if (!node) {
 990                 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
 991                         "pvid");
 992                 return;
 993         }
 994
 995         node = debugfs_create_file("mibs", S_IRUSR, smi->debugfs_root, smi,
 996                                    &fops_rtl8366_mibs);
 997         if (!node)
 998                 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
 999                         "mibs");
1000 }
1001
1002 static void rtl8366_debugfs_remove(struct rtl8366_smi *smi)
1003 {
1004         if (smi->debugfs_root) {
1005                 debugfs_remove_recursive(smi->debugfs_root);
1006                 smi->debugfs_root = NULL;
1007         }
1008 }
1009 #else
1010 static inline void rtl8366_debugfs_init(struct rtl8366_smi *smi) {}
1011 static inline void rtl8366_debugfs_remove(struct rtl8366_smi *smi) {}
1012 #endif /* CONFIG_RTL8366_SMI_DEBUG_FS */
1013
1014 static int rtl8366_smi_mii_init(struct rtl8366_smi *smi)
1015 {
1016         int ret;
1017
1018 #ifdef CONFIG_OF
1019         struct device_node *np = NULL;
1020
1021         np = of_get_child_by_name(smi->parent->of_node, "mdio-bus");
1022 #endif
1023
1024         smi->mii_bus = mdiobus_alloc();
1025         if (smi->mii_bus == NULL) {
1026                 ret = -ENOMEM;
1027                 goto err;
1028         }
1029
1030         smi->mii_bus->priv = (void *) smi;
1031         smi->mii_bus->name = dev_name(smi->parent);
1032         smi->mii_bus->read = smi->ops->mii_read;
1033         smi->mii_bus->write = smi->ops->mii_write;
1034         snprintf(smi->mii_bus->id, MII_BUS_ID_SIZE, "%s",
1035                  dev_name(smi->parent));
1036         smi->mii_bus->parent = smi->parent;
1037         smi->mii_bus->phy_mask = ~(0x1f);
1038 #if LINUX_VERSION_CODE < KERNEL_VERSION(4,5,0)
1039         {
1040                 int i;
1041                 smi->mii_bus->irq = smi->mii_irq;
1042                 for (i = 0; i < PHY_MAX_ADDR; i++)
1043                         smi->mii_irq[i] = PHY_POLL;
1044         }
1045 #endif
1046
1047 #ifdef CONFIG_OF
1048         if (np)
1049                 ret = of_mdiobus_register(smi->mii_bus, np);
1050         else
1051 #endif
1052                 ret = mdiobus_register(smi->mii_bus);
1053
1054         if (ret)
1055                 goto err_free;
1056
1057         return 0;
1058
1059  err_free:
1060         mdiobus_free(smi->mii_bus);
1061  err:
1062         return ret;
1063 }
1064
1065 static void rtl8366_smi_mii_cleanup(struct rtl8366_smi *smi)
1066 {
1067         mdiobus_unregister(smi->mii_bus);
1068         mdiobus_free(smi->mii_bus);
1069 }
1070
1071 int rtl8366_sw_reset_switch(struct switch_dev *dev)
1072 {
1073         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1074         int err;
1075
1076         err = rtl8366_reset(smi);
1077         if (err)
1078                 return err;
1079
1080         err = smi->ops->setup(smi);
1081         if (err)
1082                 return err;
1083
1084         err = rtl8366_reset_vlan(smi);
1085         if (err)
1086                 return err;
1087
1088         err = rtl8366_enable_vlan(smi, 1);
1089         if (err)
1090                 return err;
1091
1092         return rtl8366_enable_all_ports(smi, 1);
1093 }
1094 EXPORT_SYMBOL_GPL(rtl8366_sw_reset_switch);
1095
1096 int rtl8366_sw_get_port_pvid(struct switch_dev *dev, int port, int *val)
1097 {
1098         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1099         return rtl8366_get_pvid(smi, port, val);
1100 }
1101 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_pvid);
1102
1103 int rtl8366_sw_set_port_pvid(struct switch_dev *dev, int port, int val)
1104 {
1105         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1106         return rtl8366_set_pvid(smi, port, val);
1107 }
1108 EXPORT_SYMBOL_GPL(rtl8366_sw_set_port_pvid);
1109
1110 int rtl8366_sw_get_port_mib(struct switch_dev *dev,
1111                             const struct switch_attr *attr,
1112                             struct switch_val *val)
1113 {
1114         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1115         int i, len = 0;
1116         unsigned long long counter = 0;
1117         char *buf = smi->buf;
1118
1119         if (val->port_vlan >= smi->num_ports)
1120                 return -EINVAL;
1121
1122         len += snprintf(buf + len, sizeof(smi->buf) - len,
1123                         "Port %d MIB counters\n",
1124                         val->port_vlan);
1125
1126         for (i = 0; i < smi->num_mib_counters; ++i) {
1127                 len += snprintf(buf + len, sizeof(smi->buf) - len,
1128                                 "%-36s: ", smi->mib_counters[i].name);
1129                 if (!smi->ops->get_mib_counter(smi, i, val->port_vlan,
1130                                                &counter))
1131                         len += snprintf(buf + len, sizeof(smi->buf) - len,
1132                                         "%llu\n", counter);
1133                 else
1134                         len += snprintf(buf + len, sizeof(smi->buf) - len,
1135                                         "%s\n", "error");
1136         }
1137
1138         val->value.s = buf;
1139         val->len = len;
1140         return 0;
1141 }
1142 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_mib);
1143
1144 int rtl8366_sw_get_port_stats(struct switch_dev *dev, int port,
1145                                 struct switch_port_stats *stats,
1146                                 int txb_id, int rxb_id)
1147 {
1148         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1149         unsigned long long counter = 0;
1150         int ret;
1151
1152         if (port >= smi->num_ports)
1153                 return -EINVAL;
1154
1155         ret = smi->ops->get_mib_counter(smi, txb_id, port, &counter);
1156         if (ret)
1157                 return ret;
1158
1159         stats->tx_bytes = counter;
1160
1161         ret = smi->ops->get_mib_counter(smi, rxb_id, port, &counter);
1162         if (ret)
1163                 return ret;
1164
1165         stats->rx_bytes = counter;
1166
1167         return 0;
1168 }
1169 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_stats);
1170
1171 int rtl8366_sw_get_vlan_info(struct switch_dev *dev,
1172                              const struct switch_attr *attr,
1173                              struct switch_val *val)
1174 {
1175         int i;
1176         u32 len = 0;
1177         struct rtl8366_vlan_4k vlan4k;
1178         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1179         char *buf = smi->buf;
1180         int err;
1181
1182         if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1183                 return -EINVAL;
1184
1185         memset(buf, '\0', sizeof(smi->buf));
1186
1187         err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1188         if (err)
1189                 return err;
1190
1191         len += snprintf(buf + len, sizeof(smi->buf) - len,
1192                         "VLAN %d: Ports: '", vlan4k.vid);
1193
1194         for (i = 0; i < smi->num_ports; i++) {
1195                 if (!(vlan4k.member & (1 << i)))
1196                         continue;
1197
1198                 len += snprintf(buf + len, sizeof(smi->buf) - len, "%d%s", i,
1199                                 (vlan4k.untag & (1 << i)) ? "" : "t");
1200         }
1201
1202         len += snprintf(buf + len, sizeof(smi->buf) - len,
1203                         "', members=%04x, untag=%04x, fid=%u",
1204                         vlan4k.member, vlan4k.untag, vlan4k.fid);
1205
1206         val->value.s = buf;
1207         val->len = len;
1208
1209         return 0;
1210 }
1211 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_info);
1212
1213 int rtl8366_sw_get_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1214 {
1215         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1216         struct switch_port *port;
1217         struct rtl8366_vlan_4k vlan4k;
1218         int i;
1219
1220         if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1221                 return -EINVAL;
1222
1223         smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1224
1225         port = &val->value.ports[0];
1226         val->len = 0;
1227         for (i = 0; i < smi->num_ports; i++) {
1228                 if (!(vlan4k.member & BIT(i)))
1229                         continue;
1230
1231                 port->id = i;
1232                 port->flags = (vlan4k.untag & BIT(i)) ?
1233                                         0 : BIT(SWITCH_PORT_FLAG_TAGGED);
1234                 val->len++;
1235                 port++;
1236         }
1237         return 0;
1238 }
1239 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_ports);
1240
1241 int rtl8366_sw_set_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1242 {
1243         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1244         struct switch_port *port;
1245         u32 member = 0;
1246         u32 untag = 0;
1247         int err;
1248         int i;
1249
1250         if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1251                 return -EINVAL;
1252
1253         port = &val->value.ports[0];
1254         for (i = 0; i < val->len; i++, port++) {
1255                 int pvid = 0;
1256                 member |= BIT(port->id);
1257
1258                 if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED)))
1259                         untag |= BIT(port->id);
1260
1261                 /*
1262                  * To ensure that we have a valid MC entry for this VLAN,
1263                  * initialize the port VLAN ID here.
1264                  */
1265                 err = rtl8366_get_pvid(smi, port->id, &pvid);
1266                 if (err < 0)
1267                         return err;
1268                 if (pvid == 0) {
1269                         err = rtl8366_set_pvid(smi, port->id, val->port_vlan);
1270                         if (err < 0)
1271                                 return err;
1272                 }
1273         }
1274
1275         return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0);
1276 }
1277 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_ports);
1278
1279 int rtl8366_sw_get_vlan_fid(struct switch_dev *dev,
1280                             const struct switch_attr *attr,
1281                             struct switch_val *val)
1282 {
1283         struct rtl8366_vlan_4k vlan4k;
1284         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1285         int err;
1286
1287         if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1288                 return -EINVAL;
1289
1290         err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1291         if (err)
1292                 return err;
1293
1294         val->value.i = vlan4k.fid;
1295
1296         return 0;
1297 }
1298 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_fid);
1299
1300 int rtl8366_sw_set_vlan_fid(struct switch_dev *dev,
1301                             const struct switch_attr *attr,
1302                             struct switch_val *val)
1303 {
1304         struct rtl8366_vlan_4k vlan4k;
1305         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1306         int err;
1307
1308         if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1309                 return -EINVAL;
1310
1311         if (val->value.i < 0 || val->value.i > attr->max)
1312                 return -EINVAL;
1313
1314         err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1315         if (err)
1316                 return err;
1317
1318         return rtl8366_set_vlan(smi, val->port_vlan,
1319                                 vlan4k.member,
1320                                 vlan4k.untag,
1321                                 val->value.i);
1322 }
1323 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_fid);
1324
1325 int rtl8366_sw_get_vlan_enable(struct switch_dev *dev,
1326                                const struct switch_attr *attr,
1327                                struct switch_val *val)
1328 {
1329         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1330
1331         if (attr->ofs > 2)
1332                 return -EINVAL;
1333
1334         if (attr->ofs == 1)
1335                 val->value.i = smi->vlan_enabled;
1336         else
1337                 val->value.i = smi->vlan4k_enabled;
1338
1339         return 0;
1340 }
1341 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_enable);
1342
1343 int rtl8366_sw_set_vlan_enable(struct switch_dev *dev,
1344                                const struct switch_attr *attr,
1345                                struct switch_val *val)
1346 {
1347         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1348         int err;
1349
1350         if (attr->ofs > 2)
1351                 return -EINVAL;
1352
1353         if (attr->ofs == 1)
1354                 err = rtl8366_enable_vlan(smi, val->value.i);
1355         else
1356                 err = rtl8366_enable_vlan4k(smi, val->value.i);
1357
1358         return err;
1359 }
1360 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_enable);
1361
1362 struct rtl8366_smi *rtl8366_smi_alloc(struct device *parent)
1363 {
1364         struct rtl8366_smi *smi;
1365
1366         BUG_ON(!parent);
1367
1368         smi = kzalloc(sizeof(*smi), GFP_KERNEL);
1369         if (!smi) {
1370                 dev_err(parent, "no memory for private data\n");
1371                 return NULL;
1372         }
1373
1374         smi->parent = parent;
1375         return smi;
1376 }
1377 EXPORT_SYMBOL_GPL(rtl8366_smi_alloc);
1378
1379 static int __rtl8366_smi_init(struct rtl8366_smi *smi, const char *name)
1380 {
1381         int err;
1382
1383         if (!smi->ext_mbus) {
1384                 err = gpio_request(smi->gpio_sda, name);
1385                 if (err) {
1386                         printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1387                                 smi->gpio_sda, err);
1388                         goto err_out;
1389                 }
1390
1391                 err = gpio_request(smi->gpio_sck, name);
1392                 if (err) {
1393                         printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1394                                 smi->gpio_sck, err);
1395                         goto err_free_sda;
1396                 }
1397         }
1398
1399         spin_lock_init(&smi->lock);
1400
1401         /* start the switch */
1402         if (smi->hw_reset) {
1403                 smi->hw_reset(smi, false);
1404                 msleep(RTL8366_SMI_HW_START_DELAY);
1405         }
1406
1407         return 0;
1408
1409  err_free_sda:
1410         gpio_free(smi->gpio_sda);
1411  err_out:
1412         return err;
1413 }
1414
1415 static void __rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1416 {
1417         if (smi->hw_reset)
1418                 smi->hw_reset(smi, true);
1419
1420         if (!smi->ext_mbus) {
1421                 gpio_free(smi->gpio_sck);
1422                 gpio_free(smi->gpio_sda);
1423         }
1424 }
1425
1426 enum rtl8366_type rtl8366_smi_detect(struct rtl8366_platform_data *pdata)
1427 {
1428         static struct rtl8366_smi smi;
1429         enum rtl8366_type type = RTL8366_TYPE_UNKNOWN;
1430         u32 reg = 0;
1431
1432         memset(&smi, 0, sizeof(smi));
1433         smi.gpio_sda = pdata->gpio_sda;
1434         smi.gpio_sck = pdata->gpio_sck;
1435         smi.clk_delay = 10;
1436         smi.cmd_read  = 0xa9;
1437         smi.cmd_write = 0xa8;
1438
1439         if (__rtl8366_smi_init(&smi, "rtl8366"))
1440                 goto out;
1441
1442         if (rtl8366_smi_read_reg(&smi, 0x5c, &reg))
1443                 goto cleanup;
1444
1445         switch(reg) {
1446         case 0x6027:
1447                 printk("Found an RTL8366S switch\n");
1448                 type = RTL8366_TYPE_S;
1449                 break;
1450         case 0x5937:
1451                 printk("Found an RTL8366RB switch\n");
1452                 type = RTL8366_TYPE_RB;
1453                 break;
1454         default:
1455                 printk("Found an Unknown RTL8366 switch (id=0x%04x)\n", reg);
1456                 break;
1457         }
1458
1459 cleanup:
1460         __rtl8366_smi_cleanup(&smi);
1461 out:
1462         return type;
1463 }
1464
1465 int rtl8366_smi_init(struct rtl8366_smi *smi)
1466 {
1467         int err;
1468
1469         if (!smi->ops)
1470                 return -EINVAL;
1471
1472         err = __rtl8366_smi_init(smi, dev_name(smi->parent));
1473         if (err)
1474                 goto err_out;
1475
1476         if (!smi->ext_mbus)
1477                 dev_info(smi->parent, "using GPIO pins %u (SDA) and %u (SCK)\n",
1478                          smi->gpio_sda, smi->gpio_sck);
1479         else
1480                 dev_info(smi->parent, "using MDIO bus '%s'\n", smi->ext_mbus->name);
1481
1482         err = smi->ops->detect(smi);
1483         if (err) {
1484                 dev_err(smi->parent, "chip detection failed, err=%d\n", err);
1485                 goto err_free_sck;
1486         }
1487
1488         err = rtl8366_reset(smi);
1489         if (err)
1490                 goto err_free_sck;
1491
1492         err = smi->ops->setup(smi);
1493         if (err) {
1494                 dev_err(smi->parent, "chip setup failed, err=%d\n", err);
1495                 goto err_free_sck;
1496         }
1497
1498         err = rtl8366_init_vlan(smi);
1499         if (err) {
1500                 dev_err(smi->parent, "VLAN initialization failed, err=%d\n",
1501                         err);
1502                 goto err_free_sck;
1503         }
1504
1505         err = rtl8366_enable_all_ports(smi, 1);
1506         if (err)
1507                 goto err_free_sck;
1508
1509         err = rtl8366_smi_mii_init(smi);
1510         if (err)
1511                 goto err_free_sck;
1512
1513         rtl8366_debugfs_init(smi);
1514
1515         return 0;
1516
1517  err_free_sck:
1518         __rtl8366_smi_cleanup(smi);
1519  err_out:
1520         return err;
1521 }
1522 EXPORT_SYMBOL_GPL(rtl8366_smi_init);
1523
1524 void rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1525 {
1526         rtl8366_debugfs_remove(smi);
1527         rtl8366_smi_mii_cleanup(smi);
1528         __rtl8366_smi_cleanup(smi);
1529 }
1530 EXPORT_SYMBOL_GPL(rtl8366_smi_cleanup);
1531
1532 #ifdef CONFIG_OF
1533 static void rtl8366_smi_reset(struct rtl8366_smi *smi, bool active)
1534 {
1535         if (active)
1536                 reset_control_assert(smi->reset);
1537         else
1538                 reset_control_deassert(smi->reset);
1539 }
1540
1541 int rtl8366_smi_probe_of(struct platform_device *pdev, struct rtl8366_smi *smi)
1542 {
1543         int sck = of_get_named_gpio(pdev->dev.of_node, "gpio-sck", 0);
1544         int sda = of_get_named_gpio(pdev->dev.of_node, "gpio-sda", 0);
1545         struct device_node *np = pdev->dev.of_node;
1546         struct device_node *mdio_node;
1547
1548         mdio_node = of_parse_phandle(np, "mii-bus", 0);
1549         if (!mdio_node) {
1550                 dev_err(&pdev->dev, "cannot find mdio node phandle");
1551                 goto try_gpio;
1552         }
1553
1554         smi->ext_mbus = of_mdio_find_bus(mdio_node);
1555         if (!smi->ext_mbus) {
1556                 dev_info(&pdev->dev,
1557                         "cannot find mdio bus from bus handle (yet)");
1558                 goto try_gpio;
1559         }
1560
1561         return 0;
1562
1563 try_gpio:
1564         if (!gpio_is_valid(sck) || !gpio_is_valid(sda)) {
1565                 if (!mdio_node) {
1566                         dev_err(&pdev->dev, "gpios missing in devictree\n");
1567                         return -EINVAL;
1568                 } else {
1569                         return -EPROBE_DEFER;
1570                 }
1571         }
1572
1573         smi->gpio_sda = sda;
1574         smi->gpio_sck = sck;
1575         smi->reset = devm_reset_control_get(&pdev->dev, "switch");
1576         if (!IS_ERR(smi->reset))
1577                 smi->hw_reset = rtl8366_smi_reset;
1578
1579         return 0;
1580 }
1581 #else
1582 static inline int rtl8366_smi_probe_of(struct platform_device *pdev, struct rtl8366_smi *smi)
1583 {
1584         return -ENODEV;
1585 }
1586 #endif
1587
1588 int rtl8366_smi_probe_plat(struct platform_device *pdev, struct rtl8366_smi *smi)
1589 {
1590         struct rtl8366_platform_data *pdata = pdev->dev.platform_data;
1591
1592         if (!pdev->dev.platform_data) {
1593                 dev_err(&pdev->dev, "no platform data specified\n");
1594                 return -EINVAL;
1595         }
1596
1597         smi->gpio_sda = pdata->gpio_sda;
1598         smi->gpio_sck = pdata->gpio_sck;
1599         smi->hw_reset = pdata->hw_reset;
1600
1601         return 0;
1602 }
1603
1604
1605 struct rtl8366_smi *rtl8366_smi_probe(struct platform_device *pdev)
1606 {
1607         struct rtl8366_smi *smi;
1608         int err;
1609
1610         smi = rtl8366_smi_alloc(&pdev->dev);
1611         if (!smi)
1612                 return NULL;
1613
1614         if (pdev->dev.of_node)
1615                 err = rtl8366_smi_probe_of(pdev, smi);
1616         else
1617                 err = rtl8366_smi_probe_plat(pdev, smi);
1618
1619         if (err)
1620                 goto free_smi;
1621
1622         return smi;
1623
1624 free_smi:
1625         kfree(smi);
1626         return ERR_PTR(err);
1627 }
1628 EXPORT_SYMBOL_GPL(rtl8366_smi_probe);
1629
1630 MODULE_DESCRIPTION("Realtek RTL8366 SMI interface driver");
1631 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
1632 MODULE_LICENSE("GPL v2");