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