drivers/net/ethernet/microchip/encx24j600-regmap.c

   1 /**
   2  * Register map access API - ENCX24J600 support
   3  *
   4  * Copyright 2015 Gridpoint
   5  *
   6  * Author: Jon Ringle <jringle@gridpoint.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/delay.h>
  14 #include <linux/errno.h>
  15 #include <linux/init.h>
  16 #include <linux/module.h>
  17 #include <linux/netdevice.h>
  18 #include <linux/regmap.h>
  19 #include <linux/spi/spi.h>
  20
  21 #include "encx24j600_hw.h"
  22
  23 static inline bool is_bits_set(int value, int mask)
  24 {
  25         return (value & mask) == mask;
  26 }
  27
  28 static int encx24j600_switch_bank(struct encx24j600_context *ctx,
  29                                          int bank)
  30 {
  31         int ret = 0;
  32
  33         int bank_opcode = BANK_SELECT(bank);
  34         ret = spi_write(ctx->spi, &bank_opcode, 1);
  35         if (ret == 0)
  36                 ctx->bank = bank;
  37
  38         return ret;
  39 }
  40
  41 static int encx24j600_cmdn(struct encx24j600_context *ctx, u8 opcode,
  42                             const void *buf, size_t len)
  43 {
  44         struct spi_message m;
  45         struct spi_transfer t[2] = { { .tx_buf = &opcode, .len = 1, },
  46                                      { .tx_buf = buf, .len = len }, };
  47         spi_message_init(&m);
  48         spi_message_add_tail(&t[0], &m);
  49         spi_message_add_tail(&t[1], &m);
  50
  51         return spi_sync(ctx->spi, &m);
  52 }
  53
  54 static void regmap_lock_mutex(void *context)
  55 {
  56         struct encx24j600_context *ctx = context;
  57         mutex_lock(&ctx->mutex);
  58 }
  59
  60 static void regmap_unlock_mutex(void *context)
  61 {
  62         struct encx24j600_context *ctx = context;
  63         mutex_unlock(&ctx->mutex);
  64 }
  65
  66 static int regmap_encx24j600_sfr_read(void *context, u8 reg, u8 *val,
  67                                       size_t len)
  68 {
  69         struct encx24j600_context *ctx = context;
  70         u8 banked_reg = reg & ADDR_MASK;
  71         u8 bank = ((reg & BANK_MASK) >> BANK_SHIFT);
  72         u8 cmd = RCRU;
  73         int ret = 0;
  74         int i = 0;
  75         u8 tx_buf[2];
  76
  77         if (reg < 0x80) {
  78                 cmd = RCRCODE | banked_reg;
  79                 if ((banked_reg < 0x16) && (ctx->bank != bank))
  80                         ret = encx24j600_switch_bank(ctx, bank);
  81                 if (unlikely(ret))
  82                         return ret;
  83         } else {
  84                 /* Translate registers that are more effecient using
  85                  * 3-byte SPI commands
  86                  */
  87                 switch (reg) {
  88                 case EGPRDPT:
  89                         cmd = RGPRDPT; break;
  90                 case EGPWRPT:
  91                         cmd = RGPWRPT; break;
  92                 case ERXRDPT:
  93                         cmd = RRXRDPT; break;
  94                 case ERXWRPT:
  95                         cmd = RRXWRPT; break;
  96                 case EUDARDPT:
  97                         cmd = RUDARDPT; break;
  98                 case EUDAWRPT:
  99                         cmd = RUDAWRPT; break;
 100                 case EGPDATA:
 101                 case ERXDATA:
 102                 case EUDADATA:
 103                 default:
 104                         return -EINVAL;
 105                 }
 106         }
 107
 108         tx_buf[i++] = cmd;
 109         if (cmd == RCRU)
 110                 tx_buf[i++] = reg;
 111
 112         ret = spi_write_then_read(ctx->spi, tx_buf, i, val, len);
 113
 114         return ret;
 115 }
 116
 117 static int regmap_encx24j600_sfr_update(struct encx24j600_context *ctx,
 118                                         u8 reg, u8 *val, size_t len,
 119                                         u8 unbanked_cmd, u8 banked_code)
 120 {
 121         u8 banked_reg = reg & ADDR_MASK;
 122         u8 bank = ((reg & BANK_MASK) >> BANK_SHIFT);
 123         u8 cmd = unbanked_cmd;
 124         struct spi_message m;
 125         struct spi_transfer t[3] = { { .tx_buf = &cmd, .len = sizeof(cmd), },
 126                                      { .tx_buf = &reg, .len = sizeof(reg), },
 127                                      { .tx_buf = val, .len = len }, };
 128
 129         if (reg < 0x80) {
 130                 int ret = 0;
 131                 cmd = banked_code | banked_reg;
 132                 if ((banked_reg < 0x16) && (ctx->bank != bank))
 133                         ret = encx24j600_switch_bank(ctx, bank);
 134                 if (unlikely(ret))
 135                         return ret;
 136         } else {
 137                 /* Translate registers that are more effecient using
 138                  * 3-byte SPI commands
 139                  */
 140                 switch (reg) {
 141                 case EGPRDPT:
 142                         cmd = WGPRDPT; break;
 143                 case EGPWRPT:
 144                         cmd = WGPWRPT; break;
 145                 case ERXRDPT:
 146                         cmd = WRXRDPT; break;
 147                 case ERXWRPT:
 148                         cmd = WRXWRPT; break;
 149                 case EUDARDPT:
 150                         cmd = WUDARDPT; break;
 151                 case EUDAWRPT:
 152                         cmd = WUDAWRPT; break;
 153                 case EGPDATA:
 154                 case ERXDATA:
 155                 case EUDADATA:
 156                 default:
 157                         return -EINVAL;
 158                 }
 159         }
 160
 161         spi_message_init(&m);
 162         spi_message_add_tail(&t[0], &m);
 163
 164         if (cmd == unbanked_cmd) {
 165                 t[1].tx_buf = &reg;
 166                 spi_message_add_tail(&t[1], &m);
 167         }
 168
 169         spi_message_add_tail(&t[2], &m);
 170         return spi_sync(ctx->spi, &m);
 171 }
 172
 173 static int regmap_encx24j600_sfr_write(void *context, u8 reg, u8 *val,
 174                                        size_t len)
 175 {
 176         struct encx24j600_context *ctx = context;
 177         return regmap_encx24j600_sfr_update(ctx, reg, val, len, WCRU, WCRCODE);
 178 }
 179
 180 static int regmap_encx24j600_sfr_set_bits(struct encx24j600_context *ctx,
 181                                           u8 reg, u8 val)
 182 {
 183         return regmap_encx24j600_sfr_update(ctx, reg, &val, 1, BFSU, BFSCODE);
 184 }
 185
 186 static int regmap_encx24j600_sfr_clr_bits(struct encx24j600_context *ctx,
 187                                           u8 reg, u8 val)
 188 {
 189         return regmap_encx24j600_sfr_update(ctx, reg, &val, 1, BFCU, BFCCODE);
 190 }
 191
 192 static int regmap_encx24j600_reg_update_bits(void *context, unsigned int reg,
 193                                              unsigned int mask,
 194                                              unsigned int val, bool *change,
 195                                              bool force_write)
 196 {
 197         struct encx24j600_context *ctx = context;
 198
 199         int ret = 0;
 200         unsigned int set_mask = mask & val;
 201         unsigned int clr_mask = mask & ~val;
 202
 203         if (change)
 204                 *change = false;
 205
 206         if ((reg >= 0x40 && reg < 0x6c) || reg >= 0x80) {
 207                 /* Must do read/modify/write cycles for
 208                  * MAC/MII regs or Unbanked SFR regs
 209                  */
 210                 u16 tmp, orig;
 211
 212                 ret = regmap_encx24j600_sfr_read(context, reg, (u8 *)&orig,
 213                                                  sizeof(orig));
 214                 if (ret != 0)
 215                         return ret;
 216
 217                 tmp = orig & ~mask;
 218                 tmp |= val & mask;
 219
 220                 if (force_write || (tmp != orig)) {
 221                         ret = regmap_encx24j600_sfr_write(context, reg,
 222                                                           (u8 *)&tmp,
 223                                                           sizeof(tmp));
 224                         if (change)
 225                                 *change = true;
 226                 } else if (change) {
 227                         *change = false;
 228                 }
 229
 230                 return ret;
 231         }
 232
 233         if (set_mask & 0xff) {
 234                 ret = regmap_encx24j600_sfr_set_bits(ctx, reg, set_mask);
 235                 if (ret == 0 && change)
 236                         *change = true;
 237         }
 238         set_mask = (set_mask & 0xff00) >> 8;
 239
 240         if ((set_mask & 0xff) && (ret == 0)) {
 241                 ret = regmap_encx24j600_sfr_set_bits(ctx, reg + 1, set_mask);
 242                 if (ret == 0 && change)
 243                         *change = true;
 244         }
 245
 246         if ((clr_mask & 0xff) && (ret == 0)) {
 247                 ret = regmap_encx24j600_sfr_clr_bits(ctx, reg, clr_mask);
 248                 if (ret == 0 && change)
 249                         *change = true;
 250         }
 251         clr_mask = (clr_mask & 0xff00) >> 8;
 252
 253         if ((clr_mask & 0xff) && (ret == 0)) {
 254                 ret = regmap_encx24j600_sfr_clr_bits(ctx, reg + 1, clr_mask);
 255                 if (ret == 0 && change)
 256                         *change = true;
 257         }
 258
 259         return ret;
 260 }
 261
 262 int regmap_encx24j600_spi_write(void *context, u8 reg, const u8 *data,
 263                                 size_t count)
 264 {
 265         struct encx24j600_context *ctx = context;
 266
 267         if (reg < 0xc0)
 268                 return encx24j600_cmdn(ctx, reg, data, count);
 269         else
 270                 /* SPI 1-byte command. Ignore data */
 271                 return spi_write(ctx->spi, &reg, 1);
 272 }
 273 EXPORT_SYMBOL_GPL(regmap_encx24j600_spi_write);
 274
 275 int regmap_encx24j600_spi_read(void *context, u8 reg, u8 *data, size_t count)
 276 {
 277         struct encx24j600_context *ctx = context;
 278
 279         if (reg == RBSEL && count > 1)
 280                 count = 1;
 281
 282         return spi_write_then_read(ctx->spi, &reg, sizeof(reg), data, count);
 283 }
 284 EXPORT_SYMBOL_GPL(regmap_encx24j600_spi_read);
 285
 286 static int regmap_encx24j600_write(void *context, const void *data,
 287                                    size_t len)
 288 {
 289         u8 *dout = (u8 *)data;
 290         u8 reg = dout[0];
 291         ++dout;
 292         --len;
 293
 294         if (reg > 0xa0)
 295                 return regmap_encx24j600_spi_write(context, reg, dout, len);
 296
 297         if (len > 2)
 298                 return -EINVAL;
 299
 300         return regmap_encx24j600_sfr_write(context, reg, dout, len);
 301 }
 302
 303 static int regmap_encx24j600_read(void *context,
 304                                   const void *reg_buf, size_t reg_size,
 305                                   void *val, size_t val_size)
 306 {
 307         u8 reg = *(const u8 *)reg_buf;
 308
 309         if (reg_size != 1) {
 310                 pr_err("%s: reg=%02x reg_size=%zu\n", __func__, reg, reg_size);
 311                 return -EINVAL;
 312         }
 313
 314         if (reg > 0xa0)
 315                 return regmap_encx24j600_spi_read(context, reg, val, val_size);
 316
 317         if (val_size > 2) {
 318                 pr_err("%s: reg=%02x val_size=%zu\n", __func__, reg, val_size);
 319                 return -EINVAL;
 320         }
 321
 322         return regmap_encx24j600_sfr_read(context, reg, val, val_size);
 323 }
 324
 325 static bool encx24j600_regmap_readable(struct device *dev, unsigned int reg)
 326 {
 327         if ((reg < 0x36) ||
 328             ((reg >= 0x40) && (reg < 0x4c)) ||
 329             ((reg >= 0x52) && (reg < 0x56)) ||
 330             ((reg >= 0x60) && (reg < 0x66)) ||
 331             ((reg >= 0x68) && (reg < 0x80)) ||
 332             ((reg >= 0x86) && (reg < 0x92)) ||
 333             (reg == 0xc8))
 334                 return true;
 335         else
 336                 return false;
 337 }
 338
 339 static bool encx24j600_regmap_writeable(struct device *dev, unsigned int reg)
 340 {
 341         if ((reg < 0x12) ||
 342             ((reg >= 0x14) && (reg < 0x1a)) ||
 343             ((reg >= 0x1c) && (reg < 0x36)) ||
 344             ((reg >= 0x40) && (reg < 0x4c)) ||
 345             ((reg >= 0x52) && (reg < 0x56)) ||
 346             ((reg >= 0x60) && (reg < 0x68)) ||
 347             ((reg >= 0x6c) && (reg < 0x80)) ||
 348             ((reg >= 0x86) && (reg < 0x92)) ||
 349             ((reg >= 0xc0) && (reg < 0xc8)) ||
 350             ((reg >= 0xca) && (reg < 0xf0)))
 351                 return true;
 352         else
 353                 return false;
 354 }
 355
 356 static bool encx24j600_regmap_volatile(struct device *dev, unsigned int reg)
 357 {
 358         switch (reg) {
 359         case ERXHEAD:
 360         case EDMACS:
 361         case ETXSTAT:
 362         case ETXWIRE:
 363         case ECON1:     /* Can be modified via single byte cmds */
 364         case ECON2:     /* Can be modified via single byte cmds */
 365         case ESTAT:
 366         case EIR:       /* Can be modified via single byte cmds */
 367         case MIRD:
 368         case MISTAT:
 369                 return true;
 370         default:
 371                 break;
 372         }
 373
 374         return false;
 375 }
 376
 377 static bool encx24j600_regmap_precious(struct device *dev, unsigned int reg)
 378 {
 379         /* single byte cmds are precious */
 380         if (((reg >= 0xc0) && (reg < 0xc8)) ||
 381             ((reg >= 0xca) && (reg < 0xf0)))
 382                 return true;
 383         else
 384                 return false;
 385 }
 386
 387 static int regmap_encx24j600_phy_reg_read(void *context, unsigned int reg,
 388                                           unsigned int *val)
 389 {
 390         struct encx24j600_context *ctx = context;
 391         int ret;
 392         unsigned int mistat;
 393
 394         reg = MIREGADR_VAL | (reg & PHREG_MASK);
 395         ret = regmap_write(ctx->regmap, MIREGADR, reg);
 396         if (unlikely(ret))
 397                 goto err_out;
 398
 399         ret = regmap_write(ctx->regmap, MICMD, MIIRD);
 400         if (unlikely(ret))
 401                 goto err_out;
 402
 403         usleep_range(26, 100);
 404         while ((ret = regmap_read(ctx->regmap, MISTAT, &mistat) != 0) &&
 405                (mistat & BUSY))
 406                 cpu_relax();
 407
 408         if (unlikely(ret))
 409                 goto err_out;
 410
 411         ret = regmap_write(ctx->regmap, MICMD, 0);
 412         if (unlikely(ret))
 413                 goto err_out;
 414
 415         ret = regmap_read(ctx->regmap, MIRD, val);
 416
 417 err_out:
 418         if (ret)
 419                 pr_err("%s: error %d reading reg %02x\n", __func__, ret,
 420                        reg & PHREG_MASK);
 421
 422         return ret;
 423 }
 424
 425 static int regmap_encx24j600_phy_reg_write(void *context, unsigned int reg,
 426                                            unsigned int val)
 427 {
 428         struct encx24j600_context *ctx = context;
 429         int ret;
 430         unsigned int mistat;
 431
 432         reg = MIREGADR_VAL | (reg & PHREG_MASK);
 433         ret = regmap_write(ctx->regmap, MIREGADR, reg);
 434         if (unlikely(ret))
 435                 goto err_out;
 436
 437         ret = regmap_write(ctx->regmap, MIWR, val);
 438         if (unlikely(ret))
 439                 goto err_out;
 440
 441         usleep_range(26, 100);
 442         while ((ret = regmap_read(ctx->regmap, MISTAT, &mistat) != 0) &&
 443                (mistat & BUSY))
 444                 cpu_relax();
 445
 446 err_out:
 447         if (ret)
 448                 pr_err("%s: error %d writing reg %02x=%04x\n", __func__, ret,
 449                        reg & PHREG_MASK, val);
 450
 451         return ret;
 452 }
 453
 454 static bool encx24j600_phymap_readable(struct device *dev, unsigned int reg)
 455 {
 456         switch (reg) {
 457         case PHCON1:
 458         case PHSTAT1:
 459         case PHANA:
 460         case PHANLPA:
 461         case PHANE:
 462         case PHCON2:
 463         case PHSTAT2:
 464         case PHSTAT3:
 465                 return true;
 466         default:
 467                 return false;
 468         }
 469 }
 470
 471 static bool encx24j600_phymap_writeable(struct device *dev, unsigned int reg)
 472 {
 473         switch (reg) {
 474         case PHCON1:
 475         case PHCON2:
 476         case PHANA:
 477                 return true;
 478         case PHSTAT1:
 479         case PHSTAT2:
 480         case PHSTAT3:
 481         case PHANLPA:
 482         case PHANE:
 483         default:
 484                 return false;
 485         }
 486 }
 487
 488 static bool encx24j600_phymap_volatile(struct device *dev, unsigned int reg)
 489 {
 490         switch (reg) {
 491         case PHSTAT1:
 492         case PHSTAT2:
 493         case PHSTAT3:
 494         case PHANLPA:
 495         case PHANE:
 496         case PHCON2:
 497                 return true;
 498         default:
 499                 return false;
 500         }
 501 }
 502
 503 static struct regmap_config regcfg = {
 504         .name = "reg",
 505         .reg_bits = 8,
 506         .val_bits = 16,
 507         .max_register = 0xee,
 508         .reg_stride = 2,
 509         .cache_type = REGCACHE_RBTREE,
 510         .val_format_endian = REGMAP_ENDIAN_LITTLE,
 511         .readable_reg = encx24j600_regmap_readable,
 512         .writeable_reg = encx24j600_regmap_writeable,
 513         .volatile_reg = encx24j600_regmap_volatile,
 514         .precious_reg = encx24j600_regmap_precious,
 515         .lock = regmap_lock_mutex,
 516         .unlock = regmap_unlock_mutex,
 517 };
 518
 519 static struct regmap_bus regmap_encx24j600 = {
 520         .write = regmap_encx24j600_write,
 521         .read = regmap_encx24j600_read,
 522         .reg_update_bits = regmap_encx24j600_reg_update_bits,
 523 };
 524
 525 static struct regmap_config phycfg = {
 526         .name = "phy",
 527         .reg_bits = 8,
 528         .val_bits = 16,
 529         .max_register = 0x1f,
 530         .cache_type = REGCACHE_RBTREE,
 531         .val_format_endian = REGMAP_ENDIAN_LITTLE,
 532         .readable_reg = encx24j600_phymap_readable,
 533         .writeable_reg = encx24j600_phymap_writeable,
 534         .volatile_reg = encx24j600_phymap_volatile,
 535 };
 536 static struct regmap_bus phymap_encx24j600 = {
 537         .reg_write = regmap_encx24j600_phy_reg_write,
 538         .reg_read = regmap_encx24j600_phy_reg_read,
 539 };
 540
 541 void devm_regmap_init_encx24j600(struct device *dev,
 542                                  struct encx24j600_context *ctx)
 543 {
 544         mutex_init(&ctx->mutex);
 545         regcfg.lock_arg = ctx;
 546         ctx->regmap = devm_regmap_init(dev, &regmap_encx24j600, ctx, &regcfg);
 547         ctx->phymap = devm_regmap_init(dev, &phymap_encx24j600, ctx, &phycfg);
 548 }
 549 EXPORT_SYMBOL_GPL(devm_regmap_init_encx24j600);
 550
 551 MODULE_LICENSE("GPL");