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