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