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

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