drivers/net/e1000_spi.c

   1 #include <common.h>
   2 #include <console.h>
   3 #include "e1000.h"
   4 #include <linux/compiler.h>
   5
   6 /*-----------------------------------------------------------------------
   7  * SPI transfer
   8  *
   9  * This writes "bitlen" bits out the SPI MOSI port and simultaneously clocks
  10  * "bitlen" bits in the SPI MISO port.  That's just the way SPI works.
  11  *
  12  * The source of the outgoing bits is the "dout" parameter and the
  13  * destination of the input bits is the "din" parameter.  Note that "dout"
  14  * and "din" can point to the same memory location, in which case the
  15  * input data overwrites the output data (since both are buffered by
  16  * temporary variables, this is OK).
  17  *
  18  * This may be interrupted with Ctrl-C if "intr" is true, otherwise it will
  19  * never return an error.
  20  */
  21 static int e1000_spi_xfer(struct e1000_hw *hw, unsigned int bitlen,
  22                 const void *dout_mem, void *din_mem, bool intr)
  23 {
  24         const uint8_t *dout = dout_mem;
  25         uint8_t *din = din_mem;
  26
  27         uint8_t mask = 0;
  28         uint32_t eecd;
  29         unsigned long i;
  30
  31         /* Pre-read the control register */
  32         eecd = E1000_READ_REG(hw, EECD);
  33
  34         /* Iterate over each bit */
  35         for (i = 0, mask = 0x80; i < bitlen; i++, mask = (mask >> 1)?:0x80) {
  36                 /* Check for interrupt */
  37                 if (intr && ctrlc())
  38                         return -1;
  39
  40                 /* Determine the output bit */
  41                 if (dout && dout[i >> 3] & mask)
  42                         eecd |=  E1000_EECD_DI;
  43                 else
  44                         eecd &= ~E1000_EECD_DI;
  45
  46                 /* Write the output bit and wait 50us */
  47                 E1000_WRITE_REG(hw, EECD, eecd);
  48                 E1000_WRITE_FLUSH(hw);
  49                 udelay(50);
  50
  51                 /* Poke the clock (waits 50us) */
  52                 e1000_raise_ee_clk(hw, &eecd);
  53
  54                 /* Now read the input bit */
  55                 eecd = E1000_READ_REG(hw, EECD);
  56                 if (din) {
  57                         if (eecd & E1000_EECD_DO)
  58                                 din[i >> 3] |=  mask;
  59                         else
  60                                 din[i >> 3] &= ~mask;
  61                 }
  62
  63                 /* Poke the clock again (waits 50us) */
  64                 e1000_lower_ee_clk(hw, &eecd);
  65         }
  66
  67         /* Now clear any remaining bits of the input */
  68         if (din && (i & 7))
  69                 din[i >> 3] &= ~((mask << 1) - 1);
  70
  71         return 0;
  72 }
  73
  74 #ifdef CONFIG_E1000_SPI_GENERIC
  75 static inline struct e1000_hw *e1000_hw_from_spi(struct spi_slave *spi)
  76 {
  77         return container_of(spi, struct e1000_hw, spi);
  78 }
  79
  80 struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs,
  81                 unsigned int max_hz, unsigned int mode)
  82 {
  83         /* Find the right PCI device */
  84         struct e1000_hw *hw = e1000_find_card(bus);
  85         if (!hw) {
  86                 printf("ERROR: No such e1000 device: e1000#%u\n", bus);
  87                 return NULL;
  88         }
  89
  90         /* Make sure it has an SPI chip */
  91         if (hw->eeprom.type != e1000_eeprom_spi) {
  92                 E1000_ERR(hw, "No attached SPI EEPROM found!\n");
  93                 return NULL;
  94         }
  95
  96         /* Argument sanity checks */
  97         if (cs != 0) {
  98                 E1000_ERR(hw, "No such SPI chip: %u\n", cs);
  99                 return NULL;
 100         }
 101         if (mode != SPI_MODE_0) {
 102                 E1000_ERR(hw, "Only SPI MODE-0 is supported!\n");
 103                 return NULL;
 104         }
 105
 106         /* TODO: Use max_hz somehow */
 107         E1000_DBG(hw->nic, "EEPROM SPI access requested\n");
 108         return &hw->spi;
 109 }
 110
 111 void spi_free_slave(struct spi_slave *spi)
 112 {
 113         __maybe_unused struct e1000_hw *hw = e1000_hw_from_spi(spi);
 114         E1000_DBG(hw->nic, "EEPROM SPI access released\n");
 115 }
 116
 117 int spi_claim_bus(struct spi_slave *spi)
 118 {
 119         struct e1000_hw *hw = e1000_hw_from_spi(spi);
 120
 121         if (e1000_acquire_eeprom(hw)) {
 122                 E1000_ERR(hw, "EEPROM SPI cannot be acquired!\n");
 123                 return -1;
 124         }
 125
 126         return 0;
 127 }
 128
 129 void spi_release_bus(struct spi_slave *spi)
 130 {
 131         struct e1000_hw *hw = e1000_hw_from_spi(spi);
 132         e1000_release_eeprom(hw);
 133 }
 134
 135 /* Skinny wrapper around e1000_spi_xfer */
 136 int spi_xfer(struct spi_slave *spi, unsigned int bitlen,
 137                 const void *dout_mem, void *din_mem, unsigned long flags)
 138 {
 139         struct e1000_hw *hw = e1000_hw_from_spi(spi);
 140         int ret;
 141
 142         if (flags & SPI_XFER_BEGIN)
 143                 e1000_standby_eeprom(hw);
 144
 145         ret = e1000_spi_xfer(hw, bitlen, dout_mem, din_mem, true);
 146
 147         if (flags & SPI_XFER_END)
 148                 e1000_standby_eeprom(hw);
 149
 150         return ret;
 151 }
 152
 153 #endif /* not CONFIG_E1000_SPI_GENERIC */
 154
 155 #ifdef CONFIG_CMD_E1000
 156
 157 /* The EEPROM opcodes */
 158 #define SPI_EEPROM_ENABLE_WR    0x06
 159 #define SPI_EEPROM_DISABLE_WR   0x04
 160 #define SPI_EEPROM_WRITE_STATUS 0x01
 161 #define SPI_EEPROM_READ_STATUS  0x05
 162 #define SPI_EEPROM_WRITE_PAGE   0x02
 163 #define SPI_EEPROM_READ_PAGE    0x03
 164
 165 /* The EEPROM status bits */
 166 #define SPI_EEPROM_STATUS_BUSY  0x01
 167 #define SPI_EEPROM_STATUS_WREN  0x02
 168
 169 static int e1000_spi_eeprom_enable_wr(struct e1000_hw *hw, bool intr)
 170 {
 171         u8 op[] = { SPI_EEPROM_ENABLE_WR };
 172         e1000_standby_eeprom(hw);
 173         return e1000_spi_xfer(hw, 8*sizeof(op), op, NULL, intr);
 174 }
 175
 176 /*
 177  * These have been tested to perform correctly, but they are not used by any
 178  * of the EEPROM commands at this time.
 179  */
 180 static __maybe_unused int e1000_spi_eeprom_disable_wr(struct e1000_hw *hw,
 181                                                       bool intr)
 182 {
 183         u8 op[] = { SPI_EEPROM_DISABLE_WR };
 184         e1000_standby_eeprom(hw);
 185         return e1000_spi_xfer(hw, 8*sizeof(op), op, NULL, intr);
 186 }
 187
 188 static __maybe_unused int e1000_spi_eeprom_write_status(struct e1000_hw *hw,
 189                                                         u8 status, bool intr)
 190 {
 191         u8 op[] = { SPI_EEPROM_WRITE_STATUS, status };
 192         e1000_standby_eeprom(hw);
 193         return e1000_spi_xfer(hw, 8*sizeof(op), op, NULL, intr);
 194 }
 195
 196 static int e1000_spi_eeprom_read_status(struct e1000_hw *hw, bool intr)
 197 {
 198         u8 op[] = { SPI_EEPROM_READ_STATUS, 0 };
 199         e1000_standby_eeprom(hw);
 200         if (e1000_spi_xfer(hw, 8*sizeof(op), op, op, intr))
 201                 return -1;
 202         return op[1];
 203 }
 204
 205 static int e1000_spi_eeprom_write_page(struct e1000_hw *hw,
 206                 const void *data, u16 off, u16 len, bool intr)
 207 {
 208         u8 op[] = {
 209                 SPI_EEPROM_WRITE_PAGE,
 210                 (off >> (hw->eeprom.address_bits - 8)) & 0xff, off & 0xff
 211         };
 212
 213         e1000_standby_eeprom(hw);
 214
 215         if (e1000_spi_xfer(hw, 8 + hw->eeprom.address_bits, op, NULL, intr))
 216                 return -1;
 217         if (e1000_spi_xfer(hw, len << 3, data, NULL, intr))
 218                 return -1;
 219
 220         return 0;
 221 }
 222
 223 static int e1000_spi_eeprom_read_page(struct e1000_hw *hw,
 224                 void *data, u16 off, u16 len, bool intr)
 225 {
 226         u8 op[] = {
 227                 SPI_EEPROM_READ_PAGE,
 228                 (off >> (hw->eeprom.address_bits - 8)) & 0xff, off & 0xff
 229         };
 230
 231         e1000_standby_eeprom(hw);
 232
 233         if (e1000_spi_xfer(hw, 8 + hw->eeprom.address_bits, op, NULL, intr))
 234                 return -1;
 235         if (e1000_spi_xfer(hw, len << 3, NULL, data, intr))
 236                 return -1;
 237
 238         return 0;
 239 }
 240
 241 static int e1000_spi_eeprom_poll_ready(struct e1000_hw *hw, bool intr)
 242 {
 243         int status;
 244         while ((status = e1000_spi_eeprom_read_status(hw, intr)) >= 0) {
 245                 if (!(status & SPI_EEPROM_STATUS_BUSY))
 246                         return 0;
 247         }
 248         return -1;
 249 }
 250
 251 static int e1000_spi_eeprom_dump(struct e1000_hw *hw,
 252                 void *data, u16 off, unsigned int len, bool intr)
 253 {
 254         /* Interruptibly wait for the EEPROM to be ready */
 255         if (e1000_spi_eeprom_poll_ready(hw, intr))
 256                 return -1;
 257
 258         /* Dump each page in sequence */
 259         while (len) {
 260                 /* Calculate the data bytes on this page */
 261                 u16 pg_off = off & (hw->eeprom.page_size - 1);
 262                 u16 pg_len = hw->eeprom.page_size - pg_off;
 263                 if (pg_len > len)
 264                         pg_len = len;
 265
 266                 /* Now dump the page */
 267                 if (e1000_spi_eeprom_read_page(hw, data, off, pg_len, intr))
 268                         return -1;
 269
 270                 /* Otherwise go on to the next page */
 271                 len  -= pg_len;
 272                 off  += pg_len;
 273                 data += pg_len;
 274         }
 275
 276         /* We're done! */
 277         return 0;
 278 }
 279
 280 static int e1000_spi_eeprom_program(struct e1000_hw *hw,
 281                 const void *data, u16 off, u16 len, bool intr)
 282 {
 283         /* Program each page in sequence */
 284         while (len) {
 285                 /* Calculate the data bytes on this page */
 286                 u16 pg_off = off & (hw->eeprom.page_size - 1);
 287                 u16 pg_len = hw->eeprom.page_size - pg_off;
 288                 if (pg_len > len)
 289                         pg_len = len;
 290
 291                 /* Interruptibly wait for the EEPROM to be ready */
 292                 if (e1000_spi_eeprom_poll_ready(hw, intr))
 293                         return -1;
 294
 295                 /* Enable write access */
 296                 if (e1000_spi_eeprom_enable_wr(hw, intr))
 297                         return -1;
 298
 299                 /* Now program the page */
 300                 if (e1000_spi_eeprom_write_page(hw, data, off, pg_len, intr))
 301                         return -1;
 302
 303                 /* Otherwise go on to the next page */
 304                 len  -= pg_len;
 305                 off  += pg_len;
 306                 data += pg_len;
 307         }
 308
 309         /* Wait for the last write to complete */
 310         if (e1000_spi_eeprom_poll_ready(hw, intr))
 311                 return -1;
 312
 313         /* We're done! */
 314         return 0;
 315 }
 316
 317 static int do_e1000_spi_show(cmd_tbl_t *cmdtp, struct e1000_hw *hw,
 318                 int argc, char * const argv[])
 319 {
 320         unsigned int length = 0;
 321         u16 i, offset = 0;
 322         u8 *buffer;
 323         int err;
 324
 325         if (argc > 2) {
 326                 cmd_usage(cmdtp);
 327                 return 1;
 328         }
 329
 330         /* Parse the offset and length */
 331         if (argc >= 1)
 332                 offset = simple_strtoul(argv[0], NULL, 0);
 333         if (argc == 2)
 334                 length = simple_strtoul(argv[1], NULL, 0);
 335         else if (offset < (hw->eeprom.word_size << 1))
 336                 length = (hw->eeprom.word_size << 1) - offset;
 337
 338         /* Extra sanity checks */
 339         if (!length) {
 340                 E1000_ERR(hw, "Requested zero-sized dump!\n");
 341                 return 1;
 342         }
 343         if ((0x10000 < length) || (0x10000 - length < offset)) {
 344                 E1000_ERR(hw, "Can't dump past 0xFFFF!\n");
 345                 return 1;
 346         }
 347
 348         /* Allocate a buffer to hold stuff */
 349         buffer = malloc(length);
 350         if (!buffer) {
 351                 E1000_ERR(hw, "Out of Memory!\n");
 352                 return 1;
 353         }
 354
 355         /* Acquire the EEPROM and perform the dump */
 356         if (e1000_acquire_eeprom(hw)) {
 357                 E1000_ERR(hw, "EEPROM SPI cannot be acquired!\n");
 358                 free(buffer);
 359                 return 1;
 360         }
 361         err = e1000_spi_eeprom_dump(hw, buffer, offset, length, true);
 362         e1000_release_eeprom(hw);
 363         if (err) {
 364                 E1000_ERR(hw, "Interrupted!\n");
 365                 free(buffer);
 366                 return 1;
 367         }
 368
 369         /* Now hexdump the result */
 370         printf("%s: ===== Intel e1000 EEPROM (0x%04hX - 0x%04hX) =====",
 371                         hw->name, offset, offset + length - 1);
 372         for (i = 0; i < length; i++) {
 373                 if ((i & 0xF) == 0)
 374                         printf("\n%s: %04hX: ", hw->name, offset + i);
 375                 else if ((i & 0xF) == 0x8)
 376                         printf(" ");
 377                 printf(" %02hx", buffer[i]);
 378         }
 379         printf("\n");
 380
 381         /* Success! */
 382         free(buffer);
 383         return 0;
 384 }
 385
 386 static int do_e1000_spi_dump(cmd_tbl_t *cmdtp, struct e1000_hw *hw,
 387                 int argc, char * const argv[])
 388 {
 389         unsigned int length;
 390         u16 offset;
 391         void *dest;
 392
 393         if (argc != 3) {
 394                 cmd_usage(cmdtp);
 395                 return 1;
 396         }
 397
 398         /* Parse the arguments */
 399         dest = (void *)simple_strtoul(argv[0], NULL, 16);
 400         offset = simple_strtoul(argv[1], NULL, 0);
 401         length = simple_strtoul(argv[2], NULL, 0);
 402
 403         /* Extra sanity checks */
 404         if (!length) {
 405                 E1000_ERR(hw, "Requested zero-sized dump!\n");
 406                 return 1;
 407         }
 408         if ((0x10000 < length) || (0x10000 - length < offset)) {
 409                 E1000_ERR(hw, "Can't dump past 0xFFFF!\n");
 410                 return 1;
 411         }
 412
 413         /* Acquire the EEPROM */
 414         if (e1000_acquire_eeprom(hw)) {
 415                 E1000_ERR(hw, "EEPROM SPI cannot be acquired!\n");
 416                 return 1;
 417         }
 418
 419         /* Perform the programming operation */
 420         if (e1000_spi_eeprom_dump(hw, dest, offset, length, true) < 0) {
 421                 E1000_ERR(hw, "Interrupted!\n");
 422                 e1000_release_eeprom(hw);
 423                 return 1;
 424         }
 425
 426         e1000_release_eeprom(hw);
 427         printf("%s: ===== EEPROM DUMP COMPLETE =====\n", hw->name);
 428         return 0;
 429 }
 430
 431 static int do_e1000_spi_program(cmd_tbl_t *cmdtp, struct e1000_hw *hw,
 432                 int argc, char * const argv[])
 433 {
 434         unsigned int length;
 435         const void *source;
 436         u16 offset;
 437
 438         if (argc != 3) {
 439                 cmd_usage(cmdtp);
 440                 return 1;
 441         }
 442
 443         /* Parse the arguments */
 444         source = (const void *)simple_strtoul(argv[0], NULL, 16);
 445         offset = simple_strtoul(argv[1], NULL, 0);
 446         length = simple_strtoul(argv[2], NULL, 0);
 447
 448         /* Acquire the EEPROM */
 449         if (e1000_acquire_eeprom(hw)) {
 450                 E1000_ERR(hw, "EEPROM SPI cannot be acquired!\n");
 451                 return 1;
 452         }
 453
 454         /* Perform the programming operation */
 455         if (e1000_spi_eeprom_program(hw, source, offset, length, true) < 0) {
 456                 E1000_ERR(hw, "Interrupted!\n");
 457                 e1000_release_eeprom(hw);
 458                 return 1;
 459         }
 460
 461         e1000_release_eeprom(hw);
 462         printf("%s: ===== EEPROM PROGRAMMED =====\n", hw->name);
 463         return 0;
 464 }
 465
 466 static int do_e1000_spi_checksum(cmd_tbl_t *cmdtp, struct e1000_hw *hw,
 467                 int argc, char * const argv[])
 468 {
 469         uint16_t i, length, checksum = 0, checksum_reg;
 470         uint16_t *buffer;
 471         bool upd;
 472
 473         if (argc == 0)
 474                 upd = 0;
 475         else if ((argc == 1) && !strcmp(argv[0], "update"))
 476                 upd = 1;
 477         else {
 478                 cmd_usage(cmdtp);
 479                 return 1;
 480         }
 481
 482         /* Allocate a temporary buffer */
 483         length = sizeof(uint16_t) * (EEPROM_CHECKSUM_REG + 1);
 484         buffer = malloc(length);
 485         if (!buffer) {
 486                 E1000_ERR(hw, "Unable to allocate EEPROM buffer!\n");
 487                 return 1;
 488         }
 489
 490         /* Acquire the EEPROM */
 491         if (e1000_acquire_eeprom(hw)) {
 492                 E1000_ERR(hw, "EEPROM SPI cannot be acquired!\n");
 493                 return 1;
 494         }
 495
 496         /* Read the EEPROM */
 497         if (e1000_spi_eeprom_dump(hw, buffer, 0, length, true) < 0) {
 498                 E1000_ERR(hw, "Interrupted!\n");
 499                 e1000_release_eeprom(hw);
 500                 return 1;
 501         }
 502
 503         /* Compute the checksum and read the expected value */
 504         for (i = 0; i < EEPROM_CHECKSUM_REG; i++)
 505                 checksum += le16_to_cpu(buffer[i]);
 506         checksum = ((uint16_t)EEPROM_SUM) - checksum;
 507         checksum_reg = le16_to_cpu(buffer[i]);
 508
 509         /* Verify it! */
 510         if (checksum_reg == checksum) {
 511                 printf("%s: INFO: EEPROM checksum is correct! (0x%04hx)\n",
 512                                 hw->name, checksum);
 513                 e1000_release_eeprom(hw);
 514                 return 0;
 515         }
 516
 517         /* Hrm, verification failed, print an error */
 518         E1000_ERR(hw, "EEPROM checksum is incorrect!\n");
 519         E1000_ERR(hw, "  ...register was 0x%04hx, calculated 0x%04hx\n",
 520                   checksum_reg, checksum);
 521
 522         /* If they didn't ask us to update it, just return an error */
 523         if (!upd) {
 524                 e1000_release_eeprom(hw);
 525                 return 1;
 526         }
 527
 528         /* Ok, correct it! */
 529         printf("%s: Reprogramming the EEPROM checksum...\n", hw->name);
 530         buffer[i] = cpu_to_le16(checksum);
 531         if (e1000_spi_eeprom_program(hw, &buffer[i], i * sizeof(uint16_t),
 532                         sizeof(uint16_t), true)) {
 533                 E1000_ERR(hw, "Interrupted!\n");
 534                 e1000_release_eeprom(hw);
 535                 return 1;
 536         }
 537
 538         e1000_release_eeprom(hw);
 539         return 0;
 540 }
 541
 542 int do_e1000_spi(cmd_tbl_t *cmdtp, struct e1000_hw *hw,
 543                 int argc, char * const argv[])
 544 {
 545         if (argc < 1) {
 546                 cmd_usage(cmdtp);
 547                 return 1;
 548         }
 549
 550         /* Make sure it has an SPI chip */
 551         if (hw->eeprom.type != e1000_eeprom_spi) {
 552                 E1000_ERR(hw, "No attached SPI EEPROM found (%d)!\n",
 553                           hw->eeprom.type);
 554                 return 1;
 555         }
 556
 557         /* Check the eeprom sub-sub-command arguments */
 558         if (!strcmp(argv[0], "show"))
 559                 return do_e1000_spi_show(cmdtp, hw, argc - 1, argv + 1);
 560
 561         if (!strcmp(argv[0], "dump"))
 562                 return do_e1000_spi_dump(cmdtp, hw, argc - 1, argv + 1);
 563
 564         if (!strcmp(argv[0], "program"))
 565                 return do_e1000_spi_program(cmdtp, hw, argc - 1, argv + 1);
 566
 567         if (!strcmp(argv[0], "checksum"))
 568                 return do_e1000_spi_checksum(cmdtp, hw, argc - 1, argv + 1);
 569
 570         cmd_usage(cmdtp);
 571         return 1;
 572 }
 573
 574 #endif /* not CONFIG_CMD_E1000 */