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