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