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

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