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
  19 #ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
  20 #include <linux/debugfs.h>
  21 #endif
  22
  23 #include "rtl8366_smi.h"
  24
  25 #define RTL8366_SMI_ACK_RETRY_COUNT         5
  26 #define RTL8366_SMI_CLK_DELAY               10 /* nsec */
  27
  28 static inline void rtl8366_smi_clk_delay(struct rtl8366_smi *smi)
  29 {
  30         ndelay(RTL8366_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                         return -EIO;
 147         } while (1);
 148
 149         return 0;
 150 }
 151
 152 static int rtl8366_smi_write_byte(struct rtl8366_smi *smi, u8 data)
 153 {
 154         rtl8366_smi_write_bits(smi, data, 8);
 155         return rtl8366_smi_wait_for_ack(smi);
 156 }
 157
 158 static int rtl8366_smi_read_byte0(struct rtl8366_smi *smi, u8 *data)
 159 {
 160         u32 t;
 161
 162         /* read data */
 163         rtl8366_smi_read_bits(smi, 8, &t);
 164         *data = (t & 0xff);
 165
 166         /* send an ACK */
 167         rtl8366_smi_write_bits(smi, 0x00, 1);
 168
 169         return 0;
 170 }
 171
 172 static int rtl8366_smi_read_byte1(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, 0x01, 1);
 182
 183         return 0;
 184 }
 185
 186 int rtl8366_smi_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data)
 187 {
 188         unsigned long flags;
 189         u8 lo = 0;
 190         u8 hi = 0;
 191         int ret;
 192
 193         spin_lock_irqsave(&smi->lock, flags);
 194
 195         rtl8366_smi_start(smi);
 196
 197         /* send READ command */
 198         ret = rtl8366_smi_write_byte(smi, 0x0a << 4 | 0x04 << 1 | 0x01);
 199         if (ret)
 200                 goto out;
 201
 202         /* set ADDR[7:0] */
 203         ret = rtl8366_smi_write_byte(smi, addr & 0xff);
 204         if (ret)
 205                 goto out;
 206
 207         /* set ADDR[15:8] */
 208         ret = rtl8366_smi_write_byte(smi, addr >> 8);
 209         if (ret)
 210                 goto out;
 211
 212         /* read DATA[7:0] */
 213         rtl8366_smi_read_byte0(smi, &lo);
 214         /* read DATA[15:8] */
 215         rtl8366_smi_read_byte1(smi, &hi);
 216
 217         *data = ((u32) lo) | (((u32) hi) << 8);
 218
 219         ret = 0;
 220
 221  out:
 222         rtl8366_smi_stop(smi);
 223         spin_unlock_irqrestore(&smi->lock, flags);
 224
 225         return ret;
 226 }
 227 EXPORT_SYMBOL_GPL(rtl8366_smi_read_reg);
 228
 229 int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
 230 {
 231         unsigned long flags;
 232         int ret;
 233
 234         spin_lock_irqsave(&smi->lock, flags);
 235
 236         rtl8366_smi_start(smi);
 237
 238         /* send WRITE command */
 239         ret = rtl8366_smi_write_byte(smi, 0x0a << 4 | 0x04 << 1 | 0x00);
 240         if (ret)
 241                 goto out;
 242
 243         /* set ADDR[7:0] */
 244         ret = rtl8366_smi_write_byte(smi, addr & 0xff);
 245         if (ret)
 246                 goto out;
 247
 248         /* set ADDR[15:8] */
 249         ret = rtl8366_smi_write_byte(smi, addr >> 8);
 250         if (ret)
 251                 goto out;
 252
 253         /* write DATA[7:0] */
 254         ret = rtl8366_smi_write_byte(smi, data & 0xff);
 255         if (ret)
 256                 goto out;
 257
 258         /* write DATA[15:8] */
 259         ret = rtl8366_smi_write_byte(smi, data >> 8);
 260         if (ret)
 261                 goto out;
 262
 263         ret = 0;
 264
 265  out:
 266         rtl8366_smi_stop(smi);
 267         spin_unlock_irqrestore(&smi->lock, flags);
 268
 269         return ret;
 270 }
 271 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg);
 272
 273 int rtl8366_smi_rmwr(struct rtl8366_smi *smi, u32 addr, u32 mask, u32 data)
 274 {
 275         u32 t;
 276         int err;
 277
 278         err = rtl8366_smi_read_reg(smi, addr, &t);
 279         if (err)
 280                 return err;
 281
 282         err = rtl8366_smi_write_reg(smi, addr, (t & ~mask) | data);
 283         return err;
 284
 285 }
 286 EXPORT_SYMBOL_GPL(rtl8366_smi_rmwr);
 287
 288 static int rtl8366_mc_is_used(struct rtl8366_smi *smi, int mc_index, int *used)
 289 {
 290         int err;
 291         int i;
 292
 293         *used = 0;
 294         for (i = 0; i < smi->num_ports; i++) {
 295                 int index = 0;
 296
 297                 err = smi->ops->get_mc_index(smi, i, &index);
 298                 if (err)
 299                         return err;
 300
 301                 if (mc_index == index) {
 302                         *used = 1;
 303                         break;
 304                 }
 305         }
 306
 307         return 0;
 308 }
 309
 310 static int rtl8366_set_vlan(struct rtl8366_smi *smi, int vid, u32 member,
 311                             u32 untag, u32 fid)
 312 {
 313         struct rtl8366_vlan_4k vlan4k;
 314         int err;
 315         int i;
 316
 317         /* Update the 4K table */
 318         err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
 319         if (err)
 320                 return err;
 321
 322         vlan4k.member = member;
 323         vlan4k.untag = untag;
 324         vlan4k.fid = fid;
 325         err = smi->ops->set_vlan_4k(smi, &vlan4k);
 326         if (err)
 327                 return err;
 328
 329         /* Try to find an existing MC entry for this VID */
 330         for (i = 0; i < smi->num_vlan_mc; i++) {
 331                 struct rtl8366_vlan_mc vlanmc;
 332
 333                 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
 334                 if (err)
 335                         return err;
 336
 337                 if (vid == vlanmc.vid) {
 338                         /* update the MC entry */
 339                         vlanmc.member = member;
 340                         vlanmc.untag = untag;
 341                         vlanmc.fid = fid;
 342
 343                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
 344                         break;
 345                 }
 346         }
 347
 348         return err;
 349 }
 350
 351 static int rtl8366_get_pvid(struct rtl8366_smi *smi, int port, int *val)
 352 {
 353         struct rtl8366_vlan_mc vlanmc;
 354         int err;
 355         int index;
 356
 357         err = smi->ops->get_mc_index(smi, port, &index);
 358         if (err)
 359                 return err;
 360
 361         err = smi->ops->get_vlan_mc(smi, index, &vlanmc);
 362         if (err)
 363                 return err;
 364
 365         *val = vlanmc.vid;
 366         return 0;
 367 }
 368
 369 static int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port,
 370                             unsigned vid)
 371 {
 372         struct rtl8366_vlan_mc vlanmc;
 373         struct rtl8366_vlan_4k vlan4k;
 374         int err;
 375         int i;
 376
 377         /* Try to find an existing MC entry for this VID */
 378         for (i = 0; i < smi->num_vlan_mc; i++) {
 379                 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
 380                 if (err)
 381                         return err;
 382
 383                 if (vid == vlanmc.vid) {
 384                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
 385                         if (err)
 386                                 return err;
 387
 388                         err = smi->ops->set_mc_index(smi, port, i);
 389                         return err;
 390                 }
 391         }
 392
 393         /* We have no MC entry for this VID, try to find an empty one */
 394         for (i = 0; i < smi->num_vlan_mc; i++) {
 395                 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
 396                 if (err)
 397                         return err;
 398
 399                 if (vlanmc.vid == 0 && vlanmc.member == 0) {
 400                         /* Update the entry from the 4K table */
 401                         err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
 402                         if (err)
 403                                 return err;
 404
 405                         vlanmc.vid = vid;
 406                         vlanmc.member = vlan4k.member;
 407                         vlanmc.untag = vlan4k.untag;
 408                         vlanmc.fid = vlan4k.fid;
 409                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
 410                         if (err)
 411                                 return err;
 412
 413                         err = smi->ops->set_mc_index(smi, port, i);
 414                         return err;
 415                 }
 416         }
 417
 418         /* MC table is full, try to find an unused entry and replace it */
 419         for (i = 0; i < smi->num_vlan_mc; i++) {
 420                 int used;
 421
 422                 err = rtl8366_mc_is_used(smi, i, &used);
 423                 if (err)
 424                         return err;
 425
 426                 if (!used) {
 427                         /* Update the entry from the 4K table */
 428                         err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
 429                         if (err)
 430                                 return err;
 431
 432                         vlanmc.vid = vid;
 433                         vlanmc.member = vlan4k.member;
 434                         vlanmc.untag = vlan4k.untag;
 435                         vlanmc.fid = vlan4k.fid;
 436                         err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
 437                         if (err)
 438                                 return err;
 439
 440                         err = smi->ops->set_mc_index(smi, port, i);
 441                         return err;
 442                 }
 443         }
 444
 445         dev_err(smi->parent,
 446                 "all VLAN member configurations are in use\n");
 447
 448         return -ENOSPC;
 449 }
 450
 451 int rtl8366_reset_vlan(struct rtl8366_smi *smi)
 452 {
 453         struct rtl8366_vlan_mc vlanmc;
 454         int err;
 455         int i;
 456
 457         /* clear VLAN member configurations */
 458         vlanmc.vid = 0;
 459         vlanmc.priority = 0;
 460         vlanmc.member = 0;
 461         vlanmc.untag = 0;
 462         vlanmc.fid = 0;
 463         for (i = 0; i < smi->num_vlan_mc; i++) {
 464                 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
 465                 if (err)
 466                         return err;
 467         }
 468
 469         for (i = 0; i < smi->num_ports; i++) {
 470                 if (i == smi->cpu_port)
 471                         continue;
 472
 473                 err = rtl8366_set_vlan(smi, (i + 1),
 474                                         (1 << i) | (1 << smi->cpu_port),
 475                                         (1 << i) | (1 << smi->cpu_port),
 476                                         0);
 477                 if (err)
 478                         return err;
 479
 480                 err = rtl8366_set_pvid(smi, i, (i + 1));
 481                 if (err)
 482                         return err;
 483         }
 484
 485         return 0;
 486 }
 487 EXPORT_SYMBOL_GPL(rtl8366_reset_vlan);
 488
 489 #ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
 490 int rtl8366_debugfs_open(struct inode *inode, struct file *file)
 491 {
 492         file->private_data = inode->i_private;
 493         return 0;
 494 }
 495 EXPORT_SYMBOL_GPL(rtl8366_debugfs_open);
 496
 497 static ssize_t rtl8366_read_debugfs_vlan_mc(struct file *file,
 498                                               char __user *user_buf,
 499                                               size_t count, loff_t *ppos)
 500 {
 501         struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
 502         int i, len = 0;
 503         char *buf = smi->buf;
 504
 505         len += snprintf(buf + len, sizeof(smi->buf) - len,
 506                         "%2s %6s %4s %6s %6s %3s\n",
 507                         "id", "vid","prio", "member", "untag", "fid");
 508
 509         for (i = 0; i < smi->num_vlan_mc; ++i) {
 510                 struct rtl8366_vlan_mc vlanmc;
 511
 512                 smi->ops->get_vlan_mc(smi, i, &vlanmc);
 513
 514                 len += snprintf(buf + len, sizeof(smi->buf) - len,
 515                                 "%2d %6d %4d 0x%04x 0x%04x %3d\n",
 516                                 i, vlanmc.vid, vlanmc.priority,
 517                                 vlanmc.member, vlanmc.untag, vlanmc.fid);
 518         }
 519
 520         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 521 }
 522
 523 static ssize_t rtl8366_read_debugfs_pvid(struct file *file,
 524                                          char __user *user_buf,
 525                                          size_t count, loff_t *ppos)
 526 {
 527         struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
 528         char *buf = smi->buf;
 529         int len = 0;
 530         int i;
 531
 532         len += snprintf(buf + len, sizeof(smi->buf) - len, "%4s %4s\n",
 533                         "port", "pvid");
 534
 535         for (i = 0; i < smi->num_ports; i++) {
 536                 int pvid;
 537                 int err;
 538
 539                 err = rtl8366_get_pvid(smi, i, &pvid);
 540                 if (err)
 541                         len += snprintf(buf + len, sizeof(smi->buf) - len,
 542                                 "%4d error\n", i);
 543                 else
 544                         len += snprintf(buf + len, sizeof(smi->buf) - len,
 545                                 "%4d %4d\n", i, pvid);
 546         }
 547
 548         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 549 }
 550
 551 static ssize_t rtl8366_read_debugfs_reg(struct file *file,
 552                                          char __user *user_buf,
 553                                          size_t count, loff_t *ppos)
 554 {
 555         struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
 556         u32 t, reg = smi->dbg_reg;
 557         int err, len = 0;
 558         char *buf = smi->buf;
 559
 560         memset(buf, '\0', sizeof(smi->buf));
 561
 562         err = rtl8366_smi_read_reg(smi, reg, &t);
 563         if (err) {
 564                 len += snprintf(buf, sizeof(smi->buf),
 565                                 "Read failed (reg: 0x%04x)\n", reg);
 566                 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 567         }
 568
 569         len += snprintf(buf, sizeof(smi->buf), "reg = 0x%04x, val = 0x%04x\n",
 570                         reg, t);
 571
 572         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 573 }
 574
 575 static ssize_t rtl8366_write_debugfs_reg(struct file *file,
 576                                           const char __user *user_buf,
 577                                           size_t count, loff_t *ppos)
 578 {
 579         struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
 580         unsigned long data;
 581         u32 reg = smi->dbg_reg;
 582         int err;
 583         size_t len;
 584         char *buf = smi->buf;
 585
 586         len = min(count, sizeof(smi->buf) - 1);
 587         if (copy_from_user(buf, user_buf, len)) {
 588                 dev_err(smi->parent, "copy from user failed\n");
 589                 return -EFAULT;
 590         }
 591
 592         buf[len] = '\0';
 593         if (len > 0 && buf[len - 1] == '\n')
 594                 buf[len - 1] = '\0';
 595
 596
 597         if (strict_strtoul(buf, 16, &data)) {
 598                 dev_err(smi->parent, "Invalid reg value %s\n", buf);
 599         } else {
 600                 err = rtl8366_smi_write_reg(smi, reg, data);
 601                 if (err) {
 602                         dev_err(smi->parent,
 603                                 "writing reg 0x%04x val 0x%04lx failed\n",
 604                                 reg, data);
 605                 }
 606         }
 607
 608         return count;
 609 }
 610
 611 static ssize_t rtl8366_read_debugfs_mibs(struct file *file,
 612                                          char __user *user_buf,
 613                                          size_t count, loff_t *ppos)
 614 {
 615         struct rtl8366_smi *smi = file->private_data;
 616         int i, j, len = 0;
 617         char *buf = smi->buf;
 618
 619         len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s",
 620                         "Counter");
 621
 622         for (i = 0; i < smi->num_ports; i++) {
 623                 char port_buf[10];
 624
 625                 snprintf(port_buf, sizeof(port_buf), "Port %d", i);
 626                 len += snprintf(buf + len, sizeof(smi->buf) - len, " %12s",
 627                                 port_buf);
 628         }
 629         len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
 630
 631         for (i = 0; i < smi->num_mib_counters; i++) {
 632                 len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s ",
 633                                 smi->mib_counters[i].name);
 634                 for (j = 0; j < smi->num_ports; j++) {
 635                         unsigned long long counter = 0;
 636
 637                         if (!smi->ops->get_mib_counter(smi, i, j, &counter))
 638                                 len += snprintf(buf + len,
 639                                                 sizeof(smi->buf) - len,
 640                                                 "%12llu ", counter);
 641                         else
 642                                 len += snprintf(buf + len,
 643                                                 sizeof(smi->buf) - len,
 644                                                 "%12s ", "error");
 645                 }
 646                 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
 647         }
 648
 649         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 650 }
 651
 652 static const struct file_operations fops_rtl8366_regs = {
 653         .read   = rtl8366_read_debugfs_reg,
 654         .write  = rtl8366_write_debugfs_reg,
 655         .open   = rtl8366_debugfs_open,
 656         .owner  = THIS_MODULE
 657 };
 658
 659 static const struct file_operations fops_rtl8366_vlan_mc = {
 660         .read   = rtl8366_read_debugfs_vlan_mc,
 661         .open   = rtl8366_debugfs_open,
 662         .owner  = THIS_MODULE
 663 };
 664
 665 static const struct file_operations fops_rtl8366_pvid = {
 666         .read   = rtl8366_read_debugfs_pvid,
 667         .open   = rtl8366_debugfs_open,
 668         .owner  = THIS_MODULE
 669 };
 670
 671 static const struct file_operations fops_rtl8366_mibs = {
 672         .read = rtl8366_read_debugfs_mibs,
 673         .open = rtl8366_debugfs_open,
 674         .owner = THIS_MODULE
 675 };
 676
 677 static void rtl8366_debugfs_init(struct rtl8366_smi *smi)
 678 {
 679         struct dentry *node;
 680         struct dentry *root;
 681
 682         if (!smi->debugfs_root)
 683                 smi->debugfs_root = debugfs_create_dir(dev_name(smi->parent),
 684                                                        NULL);
 685
 686         if (!smi->debugfs_root) {
 687                 dev_err(smi->parent, "Unable to create debugfs dir\n");
 688                 return;
 689         }
 690         root = smi->debugfs_root;
 691
 692         node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root,
 693                                   &smi->dbg_reg);
 694         if (!node) {
 695                 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
 696                         "reg");
 697                 return;
 698         }
 699
 700         node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, smi,
 701                                    &fops_rtl8366_regs);
 702         if (!node) {
 703                 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
 704                         "val");
 705                 return;
 706         }
 707
 708         node = debugfs_create_file("vlan_mc", S_IRUSR, root, smi,
 709                                    &fops_rtl8366_vlan_mc);
 710         if (!node) {
 711                 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
 712                         "vlan_mc");
 713                 return;
 714         }
 715
 716         node = debugfs_create_file("pvid", S_IRUSR, root, smi,
 717                                    &fops_rtl8366_pvid);
 718         if (!node) {
 719                 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
 720                         "pvid");
 721                 return;
 722         }
 723
 724         node = debugfs_create_file("mibs", S_IRUSR, smi->debugfs_root, smi,
 725                                    &fops_rtl8366_mibs);
 726         if (!node)
 727                 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
 728                         "mibs");
 729 }
 730
 731 static void rtl8366_debugfs_remove(struct rtl8366_smi *smi)
 732 {
 733         if (smi->debugfs_root) {
 734                 debugfs_remove_recursive(smi->debugfs_root);
 735                 smi->debugfs_root = NULL;
 736         }
 737 }
 738 #else
 739 static inline void rtl8366_debugfs_init(struct rtl8366_smi *smi) {}
 740 static inline void rtl8366_debugfs_remove(struct rtl8366_smi *smi) {}
 741 #endif /* CONFIG_RTL8366S_PHY_DEBUG_FS */
 742
 743 static int rtl8366_smi_mii_init(struct rtl8366_smi *smi)
 744 {
 745         int ret;
 746         int i;
 747
 748         smi->mii_bus = mdiobus_alloc();
 749         if (smi->mii_bus == NULL) {
 750                 ret = -ENOMEM;
 751                 goto err;
 752         }
 753
 754         smi->mii_bus->priv = (void *) smi;
 755         smi->mii_bus->name = dev_name(smi->parent);
 756         smi->mii_bus->read = smi->ops->mii_read;
 757         smi->mii_bus->write = smi->ops->mii_write;
 758         snprintf(smi->mii_bus->id, MII_BUS_ID_SIZE, "%s",
 759                  dev_name(smi->parent));
 760         smi->mii_bus->parent = smi->parent;
 761         smi->mii_bus->phy_mask = ~(0x1f);
 762         smi->mii_bus->irq = smi->mii_irq;
 763         for (i = 0; i < PHY_MAX_ADDR; i++)
 764                 smi->mii_irq[i] = PHY_POLL;
 765
 766         ret = mdiobus_register(smi->mii_bus);
 767         if (ret)
 768                 goto err_free;
 769
 770         return 0;
 771
 772  err_free:
 773         mdiobus_free(smi->mii_bus);
 774  err:
 775         return ret;
 776 }
 777
 778 static void rtl8366_smi_mii_cleanup(struct rtl8366_smi *smi)
 779 {
 780         mdiobus_unregister(smi->mii_bus);
 781         mdiobus_free(smi->mii_bus);
 782 }
 783
 784 int rtl8366_sw_get_port_pvid(struct switch_dev *dev, int port, int *val)
 785 {
 786         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
 787         return rtl8366_get_pvid(smi, port, val);
 788 }
 789 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_pvid);
 790
 791 int rtl8366_sw_set_port_pvid(struct switch_dev *dev, int port, int val)
 792 {
 793         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
 794         return rtl8366_set_pvid(smi, port, val);
 795 }
 796 EXPORT_SYMBOL_GPL(rtl8366_sw_set_port_pvid);
 797
 798 int rtl8366_sw_get_port_mib(struct switch_dev *dev,
 799                             const struct switch_attr *attr,
 800                             struct switch_val *val)
 801 {
 802         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
 803         int i, len = 0;
 804         unsigned long long counter = 0;
 805         char *buf = smi->buf;
 806
 807         if (val->port_vlan >= smi->num_ports)
 808                 return -EINVAL;
 809
 810         len += snprintf(buf + len, sizeof(smi->buf) - len,
 811                         "Port %d MIB counters\n",
 812                         val->port_vlan);
 813
 814         for (i = 0; i < smi->num_mib_counters; ++i) {
 815                 len += snprintf(buf + len, sizeof(smi->buf) - len,
 816                                 "%-36s: ", smi->mib_counters[i].name);
 817                 if (!smi->ops->get_mib_counter(smi, i, val->port_vlan,
 818                                                &counter))
 819                         len += snprintf(buf + len, sizeof(smi->buf) - len,
 820                                         "%llu\n", counter);
 821                 else
 822                         len += snprintf(buf + len, sizeof(smi->buf) - len,
 823                                         "%s\n", "error");
 824         }
 825
 826         val->value.s = buf;
 827         val->len = len;
 828         return 0;
 829 }
 830 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_mib);
 831
 832 int rtl8366_sw_get_vlan_info(struct switch_dev *dev,
 833                              const struct switch_attr *attr,
 834                              struct switch_val *val)
 835 {
 836         int i;
 837         u32 len = 0;
 838         struct rtl8366_vlan_4k vlan4k;
 839         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
 840         char *buf = smi->buf;
 841         int err;
 842
 843         if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
 844                 return -EINVAL;
 845
 846         memset(buf, '\0', sizeof(smi->buf));
 847
 848         err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
 849         if (err)
 850                 return err;
 851
 852         len += snprintf(buf + len, sizeof(smi->buf) - len,
 853                         "VLAN %d: Ports: '", vlan4k.vid);
 854
 855         for (i = 0; i < smi->num_ports; i++) {
 856                 if (!(vlan4k.member & (1 << i)))
 857                         continue;
 858
 859                 len += snprintf(buf + len, sizeof(smi->buf) - len, "%d%s", i,
 860                                 (vlan4k.untag & (1 << i)) ? "" : "t");
 861         }
 862
 863         len += snprintf(buf + len, sizeof(smi->buf) - len,
 864                         "', members=%04x, untag=%04x, fid=%u",
 865                         vlan4k.member, vlan4k.untag, vlan4k.fid);
 866
 867         val->value.s = buf;
 868         val->len = len;
 869
 870         return 0;
 871 }
 872 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_info);
 873
 874 int rtl8366_sw_get_vlan_ports(struct switch_dev *dev, struct switch_val *val)
 875 {
 876         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
 877         struct switch_port *port;
 878         struct rtl8366_vlan_4k vlan4k;
 879         int i;
 880
 881         if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
 882                 return -EINVAL;
 883
 884         smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
 885
 886         port = &val->value.ports[0];
 887         val->len = 0;
 888         for (i = 0; i < smi->num_ports; i++) {
 889                 if (!(vlan4k.member & BIT(i)))
 890                         continue;
 891
 892                 port->id = i;
 893                 port->flags = (vlan4k.untag & BIT(i)) ?
 894                                         0 : BIT(SWITCH_PORT_FLAG_TAGGED);
 895                 val->len++;
 896                 port++;
 897         }
 898         return 0;
 899 }
 900 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_ports);
 901
 902 int rtl8366_sw_set_vlan_ports(struct switch_dev *dev, struct switch_val *val)
 903 {
 904         struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
 905         struct switch_port *port;
 906         u32 member = 0;
 907         u32 untag = 0;
 908         int i;
 909
 910         if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
 911                 return -EINVAL;
 912
 913         port = &val->value.ports[0];
 914         for (i = 0; i < val->len; i++, port++) {
 915                 member |= BIT(port->id);
 916
 917                 if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED)))
 918                         untag |= BIT(port->id);
 919         }
 920
 921         return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0);
 922 }
 923 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_ports);
 924
 925 struct rtl8366_smi *rtl8366_smi_alloc(struct device *parent)
 926 {
 927         struct rtl8366_smi *smi;
 928
 929         BUG_ON(!parent);
 930
 931         smi = kzalloc(sizeof(*smi), GFP_KERNEL);
 932         if (!smi) {
 933                 dev_err(parent, "no memory for private data\n");
 934                 return NULL;
 935         }
 936
 937         smi->parent = parent;
 938         return smi;
 939 }
 940 EXPORT_SYMBOL_GPL(rtl8366_smi_alloc);
 941
 942 int rtl8366_smi_init(struct rtl8366_smi *smi)
 943 {
 944         int err;
 945
 946         if (!smi->ops)
 947                 return -EINVAL;
 948
 949         err = gpio_request(smi->gpio_sda, dev_name(smi->parent));
 950         if (err) {
 951                 dev_err(smi->parent, "gpio_request failed for %u, err=%d\n",
 952                         smi->gpio_sda, err);
 953                 goto err_out;
 954         }
 955
 956         err = gpio_request(smi->gpio_sck, dev_name(smi->parent));
 957         if (err) {
 958                 dev_err(smi->parent, "gpio_request failed for %u, err=%d\n",
 959                         smi->gpio_sck, err);
 960                 goto err_free_sda;
 961         }
 962
 963         spin_lock_init(&smi->lock);
 964
 965         dev_info(smi->parent, "using GPIO pins %u (SDA) and %u (SCK)\n",
 966                  smi->gpio_sda, smi->gpio_sck);
 967
 968         err = smi->ops->detect(smi);
 969         if (err) {
 970                 dev_err(smi->parent, "chip detection failed, err=%d\n", err);
 971                 goto err_free_sck;
 972         }
 973
 974         err = smi->ops->setup(smi);
 975         if (err) {
 976                 dev_err(smi->parent, "chip setup failed, err=%d\n", err);
 977                 goto err_free_sck;
 978         }
 979
 980         err = rtl8366_smi_mii_init(smi);
 981         if (err)
 982                 goto err_free_sck;
 983
 984         rtl8366_debugfs_init(smi);
 985
 986         return 0;
 987
 988  err_free_sck:
 989         gpio_free(smi->gpio_sck);
 990  err_free_sda:
 991         gpio_free(smi->gpio_sda);
 992  err_out:
 993         return err;
 994 }
 995 EXPORT_SYMBOL_GPL(rtl8366_smi_init);
 996
 997 void rtl8366_smi_cleanup(struct rtl8366_smi *smi)
 998 {
 999         rtl8366_debugfs_remove(smi);
1000         rtl8366_smi_mii_cleanup(smi);
1001         gpio_free(smi->gpio_sck);
1002         gpio_free(smi->gpio_sda);
1003 }
1004 EXPORT_SYMBOL_GPL(rtl8366_smi_cleanup);
1005
1006 MODULE_DESCRIPTION("Realtek RTL8366 SMI interface driver");
1007 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
1008 MODULE_LICENSE("GPL v2");