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_vlan_info(struct switch_dev *dev,
1034                              const struct switch_attr *attr,
1035                              struct switch_val *val)
1036 {
1037         int i;
1038         u32 len = 0;
1039         struct rtl8366_vlan_4k vlan4k;
1040         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1041         char *buf = smi->buf;
1042         int err;
1043
1044         if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1045                 return -EINVAL;
1046
1047         memset(buf, '\0', sizeof(smi->buf));
1048
1049         err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1050         if (err)
1051                 return err;
1052
1053         len += snprintf(buf + len, sizeof(smi->buf) - len,
1054                         "VLAN %d: Ports: '", vlan4k.vid);
1055
1056         for (i = 0; i < smi->num_ports; i++) {
1057                 if (!(vlan4k.member & (1 << i)))
1058                         continue;
1059
1060                 len += snprintf(buf + len, sizeof(smi->buf) - len, "%d%s", i,
1061                                 (vlan4k.untag & (1 << i)) ? "" : "t");
1062         }
1063
1064         len += snprintf(buf + len, sizeof(smi->buf) - len,
1065                         "', members=%04x, untag=%04x, fid=%u",
1066                         vlan4k.member, vlan4k.untag, vlan4k.fid);
1067
1068         val->value.s = buf;
1069         val->len = len;
1070
1071         return 0;
1072 }
1073 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_info);
1074
1075 int rtl8366_sw_get_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1076 {
1077         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1078         struct switch_port *port;
1079         struct rtl8366_vlan_4k vlan4k;
1080         int i;
1081
1082         if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1083                 return -EINVAL;
1084
1085         smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1086
1087         port = &val->value.ports[0];
1088         val->len = 0;
1089         for (i = 0; i < smi->num_ports; i++) {
1090                 if (!(vlan4k.member & BIT(i)))
1091                         continue;
1092
1093                 port->id = i;
1094                 port->flags = (vlan4k.untag & BIT(i)) ?
1095                                         0 : BIT(SWITCH_PORT_FLAG_TAGGED);
1096                 val->len++;
1097                 port++;
1098         }
1099         return 0;
1100 }
1101 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_ports);
1102
1103 int rtl8366_sw_set_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1104 {
1105         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1106         struct switch_port *port;
1107         u32 member = 0;
1108         u32 untag = 0;
1109         int err;
1110         int i;
1111
1112         if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1113                 return -EINVAL;
1114
1115         port = &val->value.ports[0];
1116         for (i = 0; i < val->len; i++, port++) {
1117                 int pvid = 0;
1118                 member |= BIT(port->id);
1119
1120                 if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED)))
1121                         untag |= BIT(port->id);
1122
1123                 /*
1124                  * To ensure that we have a valid MC entry for this VLAN,
1125                  * initialize the port VLAN ID here.
1126                  */
1127                 err = rtl8366_get_pvid(smi, port->id, &pvid);
1128                 if (err < 0)
1129                         return err;
1130                 if (pvid == 0) {
1131                         err = rtl8366_set_pvid(smi, port->id, val->port_vlan);
1132                         if (err < 0)
1133                                 return err;
1134                 }
1135         }
1136
1137         return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0);
1138 }
1139 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_ports);
1140
1141 int rtl8366_sw_get_vlan_fid(struct switch_dev *dev,
1142                             const struct switch_attr *attr,
1143                             struct switch_val *val)
1144 {
1145         struct rtl8366_vlan_4k vlan4k;
1146         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1147         int err;
1148
1149         if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1150                 return -EINVAL;
1151
1152         err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1153         if (err)
1154                 return err;
1155
1156         val->value.i = vlan4k.fid;
1157
1158         return 0;
1159 }
1160 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_fid);
1161
1162 int rtl8366_sw_set_vlan_fid(struct switch_dev *dev,
1163                             const struct switch_attr *attr,
1164                             struct switch_val *val)
1165 {
1166         struct rtl8366_vlan_4k vlan4k;
1167         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1168         int err;
1169
1170         if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1171                 return -EINVAL;
1172
1173         if (val->value.i < 0 || val->value.i > attr->max)
1174                 return -EINVAL;
1175
1176         err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1177         if (err)
1178                 return err;
1179
1180         return rtl8366_set_vlan(smi, val->port_vlan,
1181                                 vlan4k.member,
1182                                 vlan4k.untag,
1183                                 val->value.i);
1184 }
1185 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_fid);
1186
1187 int rtl8366_sw_get_vlan_enable(struct switch_dev *dev,
1188                                const struct switch_attr *attr,
1189                                struct switch_val *val)
1190 {
1191         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1192
1193         if (attr->ofs > 2)
1194                 return -EINVAL;
1195
1196         if (attr->ofs == 1)
1197                 val->value.i = smi->vlan_enabled;
1198         else
1199                 val->value.i = smi->vlan4k_enabled;
1200
1201         return 0;
1202 }
1203 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_enable);
1204
1205 int rtl8366_sw_set_vlan_enable(struct switch_dev *dev,
1206                                const struct switch_attr *attr,
1207                                struct switch_val *val)
1208 {
1209         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1210         int err;
1211
1212         if (attr->ofs > 2)
1213                 return -EINVAL;
1214
1215         if (attr->ofs == 1)
1216                 err = rtl8366_enable_vlan(smi, val->value.i);
1217         else
1218                 err = rtl8366_enable_vlan4k(smi, val->value.i);
1219
1220         return err;
1221 }
1222 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_enable);
1223
1224 struct rtl8366_smi *rtl8366_smi_alloc(struct device *parent)
1225 {
1226         struct rtl8366_smi *smi;
1227
1228         BUG_ON(!parent);
1229
1230         smi = kzalloc(sizeof(*smi), GFP_KERNEL);
1231         if (!smi) {
1232                 dev_err(parent, "no memory for private data\n");
1233                 return NULL;
1234         }
1235
1236         smi->parent = parent;
1237         return smi;
1238 }
1239 EXPORT_SYMBOL_GPL(rtl8366_smi_alloc);
1240
1241 static int __rtl8366_smi_init(struct rtl8366_smi *smi, const char *name)
1242 {
1243         int err;
1244
1245         err = gpio_request(smi->gpio_sda, name);
1246         if (err) {
1247                 printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1248                         smi->gpio_sda, err);
1249                 goto err_out;
1250         }
1251
1252         err = gpio_request(smi->gpio_sck, name);
1253         if (err) {
1254                 printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1255                         smi->gpio_sck, err);
1256                 goto err_free_sda;
1257         }
1258
1259         spin_lock_init(&smi->lock);
1260
1261         /* start the switch */
1262         if (smi->hw_reset) {
1263                 smi->hw_reset(false);
1264                 msleep(RTL8366_SMI_HW_START_DELAY);
1265         }
1266
1267         return 0;
1268
1269  err_free_sda:
1270         gpio_free(smi->gpio_sda);
1271  err_out:
1272         return err;
1273 }
1274
1275 static void __rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1276 {
1277         if (smi->hw_reset)
1278                 smi->hw_reset(true);
1279
1280         gpio_free(smi->gpio_sck);
1281         gpio_free(smi->gpio_sda);
1282 }
1283
1284 enum rtl8366_type rtl8366_smi_detect(struct rtl8366_platform_data *pdata)
1285 {
1286         static struct rtl8366_smi smi;
1287         enum rtl8366_type type = RTL8366_TYPE_UNKNOWN;
1288         u32 reg = 0;
1289
1290         memset(&smi, 0, sizeof(smi));
1291         smi.gpio_sda = pdata->gpio_sda;
1292         smi.gpio_sck = pdata->gpio_sck;
1293         smi.clk_delay = 10;
1294         smi.cmd_read  = 0xa9;
1295         smi.cmd_write = 0xa8;
1296
1297         if (__rtl8366_smi_init(&smi, "rtl8366"))
1298                 goto out;
1299
1300         if (rtl8366_smi_read_reg(&smi, 0x5c, &reg))
1301                 goto cleanup;
1302
1303         switch(reg) {
1304         case 0x6027:
1305                 printk("Found an RTL8366S switch\n");
1306                 type = RTL8366_TYPE_S;
1307                 break;
1308         case 0x5937:
1309                 printk("Found an RTL8366RB switch\n");
1310                 type = RTL8366_TYPE_RB;
1311                 break;
1312         default:
1313                 printk("Found an Unknown RTL8366 switch (id=0x%04x)\n", reg);
1314                 break;
1315         }
1316
1317 cleanup:
1318         __rtl8366_smi_cleanup(&smi);
1319 out:
1320         return type;
1321 }
1322
1323 int rtl8366_smi_init(struct rtl8366_smi *smi)
1324 {
1325         int err;
1326
1327         if (!smi->ops)
1328                 return -EINVAL;
1329
1330         err = __rtl8366_smi_init(smi, dev_name(smi->parent));
1331         if (err)
1332                 goto err_out;
1333
1334         dev_info(smi->parent, "using GPIO pins %u (SDA) and %u (SCK)\n",
1335                  smi->gpio_sda, smi->gpio_sck);
1336
1337         err = smi->ops->detect(smi);
1338         if (err) {
1339                 dev_err(smi->parent, "chip detection failed, err=%d\n", err);
1340                 goto err_free_sck;
1341         }
1342
1343         err = rtl8366_reset(smi);
1344         if (err)
1345                 goto err_free_sck;
1346
1347         err = smi->ops->setup(smi);
1348         if (err) {
1349                 dev_err(smi->parent, "chip setup failed, err=%d\n", err);
1350                 goto err_free_sck;
1351         }
1352
1353         err = rtl8366_init_vlan(smi);
1354         if (err) {
1355                 dev_err(smi->parent, "VLAN initialization failed, err=%d\n",
1356                         err);
1357                 goto err_free_sck;
1358         }
1359
1360         err = rtl8366_enable_all_ports(smi, 1);
1361         if (err)
1362                 goto err_free_sck;
1363
1364         err = rtl8366_smi_mii_init(smi);
1365         if (err)
1366                 goto err_free_sck;
1367
1368         rtl8366_debugfs_init(smi);
1369
1370         return 0;
1371
1372  err_free_sck:
1373         __rtl8366_smi_cleanup(smi);
1374  err_out:
1375         return err;
1376 }
1377 EXPORT_SYMBOL_GPL(rtl8366_smi_init);
1378
1379 void rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1380 {
1381         rtl8366_debugfs_remove(smi);
1382         rtl8366_smi_mii_cleanup(smi);
1383         __rtl8366_smi_cleanup(smi);
1384 }
1385 EXPORT_SYMBOL_GPL(rtl8366_smi_cleanup);
1386
1387 #ifdef CONFIG_OF
1388 int rtl8366_smi_probe_of(struct platform_device *pdev, struct rtl8366_smi *smi)
1389 {
1390         int sck = of_get_named_gpio(pdev->dev.of_node, "gpio-sck", 0);
1391         int sda = of_get_named_gpio(pdev->dev.of_node, "gpio-sda", 0);
1392
1393         if (!gpio_is_valid(sck) || !gpio_is_valid(sda)) {
1394                 dev_err(&pdev->dev, "gpios missing in devictree\n");
1395                 return -EINVAL;
1396         }
1397
1398         smi->gpio_sda = sda;
1399         smi->gpio_sck = sck;
1400
1401         return 0;
1402 }
1403 #else
1404 static inline int rtl8366_smi_probe_of(struct platform_device *pdev, struct rtl8366_smi *smi)
1405 {
1406         return -ENODEV;
1407 }
1408 #endif
1409
1410 int rtl8366_smi_probe_plat(struct platform_device *pdev, struct rtl8366_smi *smi)
1411 {
1412         struct rtl8366_platform_data *pdata = pdev->dev.platform_data;
1413
1414         if (!pdev->dev.platform_data) {
1415                 dev_err(&pdev->dev, "no platform data specified\n");
1416                 return -EINVAL;
1417         }
1418
1419         smi->gpio_sda = pdata->gpio_sda;
1420         smi->gpio_sck = pdata->gpio_sck;
1421         smi->hw_reset = pdata->hw_reset;
1422
1423         return 0;
1424 }
1425
1426
1427 struct rtl8366_smi *rtl8366_smi_probe(struct platform_device *pdev)
1428 {
1429         struct rtl8366_smi *smi;
1430         int err;
1431
1432         smi = rtl8366_smi_alloc(&pdev->dev);
1433         if (!smi)
1434                 return NULL;
1435
1436         if (pdev->dev.of_node)
1437                 err = rtl8366_smi_probe_of(pdev, smi);
1438         else
1439                 err = rtl8366_smi_probe_plat(pdev, smi);
1440
1441         if (err)
1442                 goto free_smi;
1443
1444         return smi;
1445
1446 free_smi:
1447         kfree(smi);
1448         return NULL;
1449 }
1450 EXPORT_SYMBOL_GPL(rtl8366_smi_probe);
1451
1452 MODULE_DESCRIPTION("Realtek RTL8366 SMI interface driver");
1453 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
1454 MODULE_LICENSE("GPL v2");