target/linux/generic/files/drivers/net/phy/rtl8366_smi.c

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