target/linux/generic-2.6/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 #include "rtl8366_smi.h"
  20
  21 #define RTL8366_SMI_ACK_RETRY_COUNT         5
  22 #define RTL8366_SMI_CLK_DELAY               10 /* nsec */
  23
  24 static inline void rtl8366_smi_clk_delay(struct rtl8366_smi *smi)
  25 {
  26         ndelay(RTL8366_SMI_CLK_DELAY);
  27 }
  28
  29 static void rtl8366_smi_start(struct rtl8366_smi *smi)
  30 {
  31         unsigned int sda = smi->gpio_sda;
  32         unsigned int sck = smi->gpio_sck;
  33
  34         /*
  35          * Set GPIO pins to output mode, with initial state:
  36          * SCK = 0, SDA = 1
  37          */
  38         gpio_direction_output(sck, 0);
  39         gpio_direction_output(sda, 1);
  40         rtl8366_smi_clk_delay(smi);
  41
  42         /* CLK 1: 0 -> 1, 1 -> 0 */
  43         gpio_set_value(sck, 1);
  44         rtl8366_smi_clk_delay(smi);
  45         gpio_set_value(sck, 0);
  46         rtl8366_smi_clk_delay(smi);
  47
  48         /* CLK 2: */
  49         gpio_set_value(sck, 1);
  50         rtl8366_smi_clk_delay(smi);
  51         gpio_set_value(sda, 0);
  52         rtl8366_smi_clk_delay(smi);
  53         gpio_set_value(sck, 0);
  54         rtl8366_smi_clk_delay(smi);
  55         gpio_set_value(sda, 1);
  56 }
  57
  58 static void rtl8366_smi_stop(struct rtl8366_smi *smi)
  59 {
  60         unsigned int sda = smi->gpio_sda;
  61         unsigned int sck = smi->gpio_sck;
  62
  63         rtl8366_smi_clk_delay(smi);
  64         gpio_set_value(sda, 0);
  65         gpio_set_value(sck, 1);
  66         rtl8366_smi_clk_delay(smi);
  67         gpio_set_value(sda, 1);
  68         rtl8366_smi_clk_delay(smi);
  69         gpio_set_value(sck, 1);
  70         rtl8366_smi_clk_delay(smi);
  71         gpio_set_value(sck, 0);
  72         rtl8366_smi_clk_delay(smi);
  73         gpio_set_value(sck, 1);
  74
  75         /* add a click */
  76         rtl8366_smi_clk_delay(smi);
  77         gpio_set_value(sck, 0);
  78         rtl8366_smi_clk_delay(smi);
  79         gpio_set_value(sck, 1);
  80
  81         /* set GPIO pins to input mode */
  82         gpio_direction_input(sda);
  83         gpio_direction_input(sck);
  84 }
  85
  86 static void rtl8366_smi_write_bits(struct rtl8366_smi *smi, u32 data, u32 len)
  87 {
  88         unsigned int sda = smi->gpio_sda;
  89         unsigned int sck = smi->gpio_sck;
  90
  91         for (; len > 0; len--) {
  92                 rtl8366_smi_clk_delay(smi);
  93
  94                 /* prepare data */
  95                 gpio_set_value(sda, !!(data & ( 1 << (len - 1))));
  96                 rtl8366_smi_clk_delay(smi);
  97
  98                 /* clocking */
  99                 gpio_set_value(sck, 1);
 100                 rtl8366_smi_clk_delay(smi);
 101                 gpio_set_value(sck, 0);
 102         }
 103 }
 104
 105 static void rtl8366_smi_read_bits(struct rtl8366_smi *smi, u32 len, u32 *data)
 106 {
 107         unsigned int sda = smi->gpio_sda;
 108         unsigned int sck = smi->gpio_sck;
 109
 110         gpio_direction_input(sda);
 111
 112         for (*data = 0; len > 0; len--) {
 113                 u32 u;
 114
 115                 rtl8366_smi_clk_delay(smi);
 116
 117                 /* clocking */
 118                 gpio_set_value(sck, 1);
 119                 rtl8366_smi_clk_delay(smi);
 120                 u = !!gpio_get_value(sda);
 121                 gpio_set_value(sck, 0);
 122
 123                 *data |= (u << (len - 1));
 124         }
 125
 126         gpio_direction_output(sda, 0);
 127 }
 128
 129 static int rtl8366_smi_wait_for_ack(struct rtl8366_smi *smi)
 130 {
 131         int retry_cnt;
 132
 133         retry_cnt = 0;
 134         do {
 135                 u32 ack;
 136
 137                 rtl8366_smi_read_bits(smi, 1, &ack);
 138                 if (ack == 0)
 139                         break;
 140
 141                 if (++retry_cnt > RTL8366_SMI_ACK_RETRY_COUNT)
 142                         return -EIO;
 143         } while (1);
 144
 145         return 0;
 146 }
 147
 148 static int rtl8366_smi_write_byte(struct rtl8366_smi *smi, u8 data)
 149 {
 150         rtl8366_smi_write_bits(smi, data, 8);
 151         return rtl8366_smi_wait_for_ack(smi);
 152 }
 153
 154 static int rtl8366_smi_read_byte0(struct rtl8366_smi *smi, u8 *data)
 155 {
 156         u32 t;
 157
 158         /* read data */
 159         rtl8366_smi_read_bits(smi, 8, &t);
 160         *data = (t & 0xff);
 161
 162         /* send an ACK */
 163         rtl8366_smi_write_bits(smi, 0x00, 1);
 164
 165         return 0;
 166 }
 167
 168 static int rtl8366_smi_read_byte1(struct rtl8366_smi *smi, u8 *data)
 169 {
 170         u32 t;
 171
 172         /* read data */
 173         rtl8366_smi_read_bits(smi, 8, &t);
 174         *data = (t & 0xff);
 175
 176         /* send an ACK */
 177         rtl8366_smi_write_bits(smi, 0x01, 1);
 178
 179         return 0;
 180 }
 181
 182 int rtl8366_smi_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data)
 183 {
 184         unsigned long flags;
 185         u8 lo = 0;
 186         u8 hi = 0;
 187         int ret;
 188
 189         spin_lock_irqsave(&smi->lock, flags);
 190
 191         rtl8366_smi_start(smi);
 192
 193         /* send READ command */
 194         ret = rtl8366_smi_write_byte(smi, 0x0a << 4 | 0x04 << 1 | 0x01);
 195         if (ret)
 196                 goto out;
 197
 198         /* set ADDR[7:0] */
 199         ret = rtl8366_smi_write_byte(smi, addr & 0xff);
 200         if (ret)
 201                 goto out;
 202
 203         /* set ADDR[15:8] */
 204         ret = rtl8366_smi_write_byte(smi, addr >> 8);
 205         if (ret)
 206                 goto out;
 207
 208         /* read DATA[7:0] */
 209         rtl8366_smi_read_byte0(smi, &lo);
 210         /* read DATA[15:8] */
 211         rtl8366_smi_read_byte1(smi, &hi);
 212
 213         *data = ((u32) lo) | (((u32) hi) << 8);
 214
 215         ret = 0;
 216
 217  out:
 218         rtl8366_smi_stop(smi);
 219         spin_unlock_irqrestore(&smi->lock, flags);
 220
 221         return ret;
 222 }
 223 EXPORT_SYMBOL_GPL(rtl8366_smi_read_reg);
 224
 225 int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
 226 {
 227         unsigned long flags;
 228         int ret;
 229
 230         spin_lock_irqsave(&smi->lock, flags);
 231
 232         rtl8366_smi_start(smi);
 233
 234         /* send WRITE command */
 235         ret = rtl8366_smi_write_byte(smi, 0x0a << 4 | 0x04 << 1 | 0x00);
 236         if (ret)
 237                 goto out;
 238
 239         /* set ADDR[7:0] */
 240         ret = rtl8366_smi_write_byte(smi, addr & 0xff);
 241         if (ret)
 242                 goto out;
 243
 244         /* set ADDR[15:8] */
 245         ret = rtl8366_smi_write_byte(smi, addr >> 8);
 246         if (ret)
 247                 goto out;
 248
 249         /* write DATA[7:0] */
 250         ret = rtl8366_smi_write_byte(smi, data & 0xff);
 251         if (ret)
 252                 goto out;
 253
 254         /* write DATA[15:8] */
 255         ret = rtl8366_smi_write_byte(smi, data >> 8);
 256         if (ret)
 257                 goto out;
 258
 259         ret = 0;
 260
 261  out:
 262         rtl8366_smi_stop(smi);
 263         spin_unlock_irqrestore(&smi->lock, flags);
 264
 265         return ret;
 266 }
 267 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg);
 268
 269 static int rtl8366_smi_mii_init(struct rtl8366_smi *smi)
 270 {
 271         int ret;
 272         int i;
 273
 274         smi->mii_bus = mdiobus_alloc();
 275         if (smi->mii_bus == NULL) {
 276                 ret = -ENOMEM;
 277                 goto err;
 278         }
 279
 280         smi->mii_bus->priv = (void *) smi;
 281         smi->mii_bus->name = dev_name(smi->parent);
 282         smi->mii_bus->read = smi->ops->mii_read;
 283         smi->mii_bus->write = smi->ops->mii_write;
 284         snprintf(smi->mii_bus->id, MII_BUS_ID_SIZE, "%s",
 285                  dev_name(smi->parent));
 286         smi->mii_bus->parent = smi->parent;
 287         smi->mii_bus->phy_mask = ~(0x1f);
 288         smi->mii_bus->irq = smi->mii_irq;
 289         for (i = 0; i < PHY_MAX_ADDR; i++)
 290                 smi->mii_irq[i] = PHY_POLL;
 291
 292         ret = mdiobus_register(smi->mii_bus);
 293         if (ret)
 294                 goto err_free;
 295
 296         return 0;
 297
 298  err_free:
 299         mdiobus_free(smi->mii_bus);
 300  err:
 301         return ret;
 302 }
 303
 304 static void rtl8366_smi_mii_cleanup(struct rtl8366_smi *smi)
 305 {
 306         mdiobus_unregister(smi->mii_bus);
 307         mdiobus_free(smi->mii_bus);
 308 }
 309
 310 int rtl8366_smi_init(struct rtl8366_smi *smi)
 311 {
 312         int err;
 313
 314         if (!smi->parent)
 315                 return -EINVAL;
 316
 317         if (!smi->ops)
 318                 return -EINVAL;
 319
 320         err = gpio_request(smi->gpio_sda, dev_name(smi->parent));
 321         if (err) {
 322                 dev_err(smi->parent, "gpio_request failed for %u, err=%d\n",
 323                         smi->gpio_sda, err);
 324                 goto err_out;
 325         }
 326
 327         err = gpio_request(smi->gpio_sck, dev_name(smi->parent));
 328         if (err) {
 329                 dev_err(smi->parent, "gpio_request failed for %u, err=%d\n",
 330                         smi->gpio_sck, err);
 331                 goto err_free_sda;
 332         }
 333
 334         spin_lock_init(&smi->lock);
 335
 336         dev_info(smi->parent, "using GPIO pins %u (SDA) and %u (SCK)\n",
 337                  smi->gpio_sda, smi->gpio_sck);
 338
 339         err = smi->ops->detect(smi);
 340         if (err) {
 341                 dev_err(smi->parent, "chip detection failed, err=%d\n", err);
 342                 goto err_free_sck;
 343         }
 344
 345         err = rtl8366_smi_mii_init(smi);
 346         if (err)
 347                 goto err_free_sck;
 348
 349         return 0;
 350
 351  err_free_sck:
 352         gpio_free(smi->gpio_sck);
 353  err_free_sda:
 354         gpio_free(smi->gpio_sda);
 355  err_out:
 356         return err;
 357 }
 358 EXPORT_SYMBOL_GPL(rtl8366_smi_init);
 359
 360 void rtl8366_smi_cleanup(struct rtl8366_smi *smi)
 361 {
 362         rtl8366_smi_mii_cleanup(smi);
 363         gpio_free(smi->gpio_sck);
 364         gpio_free(smi->gpio_sda);
 365 }
 366 EXPORT_SYMBOL_GPL(rtl8366_smi_cleanup);
 367
 368 MODULE_DESCRIPTION("Realtek RTL8366 SMI interface driver");
 369 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
 370 MODULE_LICENSE("GPL v2");