]>
git.ipfire.org Git - people/ms/u-boot.git/blob - drivers/net/e1000_spi.c
2 #include <linux/compiler.h>
4 /*-----------------------------------------------------------------------
7 * This writes "bitlen" bits out the SPI MOSI port and simultaneously clocks
8 * "bitlen" bits in the SPI MISO port. That's just the way SPI works.
10 * The source of the outgoing bits is the "dout" parameter and the
11 * destination of the input bits is the "din" parameter. Note that "dout"
12 * and "din" can point to the same memory location, in which case the
13 * input data overwrites the output data (since both are buffered by
14 * temporary variables, this is OK).
16 * This may be interrupted with Ctrl-C if "intr" is true, otherwise it will
17 * never return an error.
19 static int e1000_spi_xfer(struct e1000_hw
*hw
, unsigned int bitlen
,
20 const void *dout_mem
, void *din_mem
, bool intr
)
22 const uint8_t *dout
= dout_mem
;
23 uint8_t *din
= din_mem
;
29 /* Pre-read the control register */
30 eecd
= E1000_READ_REG(hw
, EECD
);
32 /* Iterate over each bit */
33 for (i
= 0, mask
= 0x80; i
< bitlen
; i
++, mask
= (mask
>> 1)?:0x80) {
34 /* Check for interrupt */
38 /* Determine the output bit */
39 if (dout
&& dout
[i
>> 3] & mask
)
40 eecd
|= E1000_EECD_DI
;
42 eecd
&= ~E1000_EECD_DI
;
44 /* Write the output bit and wait 50us */
45 E1000_WRITE_REG(hw
, EECD
, eecd
);
46 E1000_WRITE_FLUSH(hw
);
49 /* Poke the clock (waits 50us) */
50 e1000_raise_ee_clk(hw
, &eecd
);
52 /* Now read the input bit */
53 eecd
= E1000_READ_REG(hw
, EECD
);
55 if (eecd
& E1000_EECD_DO
)
61 /* Poke the clock again (waits 50us) */
62 e1000_lower_ee_clk(hw
, &eecd
);
65 /* Now clear any remaining bits of the input */
67 din
[i
>> 3] &= ~((mask
<< 1) - 1);
72 #ifdef CONFIG_E1000_SPI_GENERIC
73 static inline struct e1000_hw
*e1000_hw_from_spi(struct spi_slave
*spi
)
75 return container_of(spi
, struct e1000_hw
, spi
);
78 /* Not sure why all of these are necessary */
79 void spi_init_r(void) { /* Nothing to do */ }
80 void spi_init_f(void) { /* Nothing to do */ }
81 void spi_init(void) { /* Nothing to do */ }
83 struct spi_slave
*spi_setup_slave(unsigned int bus
, unsigned int cs
,
84 unsigned int max_hz
, unsigned int mode
)
86 /* Find the right PCI device */
87 struct e1000_hw
*hw
= e1000_find_card(bus
);
89 printf("ERROR: No such e1000 device: e1000#%u\n", bus
);
93 /* Make sure it has an SPI chip */
94 if (hw
->eeprom
.type
!= e1000_eeprom_spi
) {
95 E1000_ERR(hw
->nic
, "No attached SPI EEPROM found!\n");
99 /* Argument sanity checks */
101 E1000_ERR(hw
->nic
, "No such SPI chip: %u\n", cs
);
104 if (mode
!= SPI_MODE_0
) {
105 E1000_ERR(hw
->nic
, "Only SPI MODE-0 is supported!\n");
109 /* TODO: Use max_hz somehow */
110 E1000_DBG(hw
->nic
, "EEPROM SPI access requested\n");
114 void spi_free_slave(struct spi_slave
*spi
)
116 __maybe_unused
struct e1000_hw
*hw
= e1000_hw_from_spi(spi
);
117 E1000_DBG(hw
->nic
, "EEPROM SPI access released\n");
120 int spi_claim_bus(struct spi_slave
*spi
)
122 struct e1000_hw
*hw
= e1000_hw_from_spi(spi
);
124 if (e1000_acquire_eeprom(hw
)) {
125 E1000_ERR(hw
->nic
, "EEPROM SPI cannot be acquired!\n");
132 void spi_release_bus(struct spi_slave
*spi
)
134 struct e1000_hw
*hw
= e1000_hw_from_spi(spi
);
135 e1000_release_eeprom(hw
);
138 /* Skinny wrapper around e1000_spi_xfer */
139 int spi_xfer(struct spi_slave
*spi
, unsigned int bitlen
,
140 const void *dout_mem
, void *din_mem
, unsigned long flags
)
142 struct e1000_hw
*hw
= e1000_hw_from_spi(spi
);
145 if (flags
& SPI_XFER_BEGIN
)
146 e1000_standby_eeprom(hw
);
148 ret
= e1000_spi_xfer(hw
, bitlen
, dout_mem
, din_mem
, true);
150 if (flags
& SPI_XFER_END
)
151 e1000_standby_eeprom(hw
);
156 #endif /* not CONFIG_E1000_SPI_GENERIC */
158 #ifdef CONFIG_CMD_E1000
160 /* The EEPROM opcodes */
161 #define SPI_EEPROM_ENABLE_WR 0x06
162 #define SPI_EEPROM_DISABLE_WR 0x04
163 #define SPI_EEPROM_WRITE_STATUS 0x01
164 #define SPI_EEPROM_READ_STATUS 0x05
165 #define SPI_EEPROM_WRITE_PAGE 0x02
166 #define SPI_EEPROM_READ_PAGE 0x03
168 /* The EEPROM status bits */
169 #define SPI_EEPROM_STATUS_BUSY 0x01
170 #define SPI_EEPROM_STATUS_WREN 0x02
172 static int e1000_spi_eeprom_enable_wr(struct e1000_hw
*hw
, bool intr
)
174 u8 op
[] = { SPI_EEPROM_ENABLE_WR
};
175 e1000_standby_eeprom(hw
);
176 return e1000_spi_xfer(hw
, 8*sizeof(op
), op
, NULL
, intr
);
180 * These have been tested to perform correctly, but they are not used by any
181 * of the EEPROM commands at this time.
184 static int e1000_spi_eeprom_disable_wr(struct e1000_hw
*hw
, bool intr
)
186 u8 op
[] = { SPI_EEPROM_DISABLE_WR
};
187 e1000_standby_eeprom(hw
);
188 return e1000_spi_xfer(hw
, 8*sizeof(op
), op
, NULL
, intr
);
191 static int e1000_spi_eeprom_write_status(struct e1000_hw
*hw
,
192 u8 status
, bool intr
)
194 u8 op
[] = { SPI_EEPROM_WRITE_STATUS
, status
};
195 e1000_standby_eeprom(hw
);
196 return e1000_spi_xfer(hw
, 8*sizeof(op
), op
, NULL
, intr
);
200 static int e1000_spi_eeprom_read_status(struct e1000_hw
*hw
, bool intr
)
202 u8 op
[] = { SPI_EEPROM_READ_STATUS
, 0 };
203 e1000_standby_eeprom(hw
);
204 if (e1000_spi_xfer(hw
, 8*sizeof(op
), op
, op
, intr
))
209 static int e1000_spi_eeprom_write_page(struct e1000_hw
*hw
,
210 const void *data
, u16 off
, u16 len
, bool intr
)
213 SPI_EEPROM_WRITE_PAGE
,
214 (off
>> (hw
->eeprom
.address_bits
- 8)) & 0xff, off
& 0xff
217 e1000_standby_eeprom(hw
);
219 if (e1000_spi_xfer(hw
, 8 + hw
->eeprom
.address_bits
, op
, NULL
, intr
))
221 if (e1000_spi_xfer(hw
, len
<< 3, data
, NULL
, intr
))
227 static int e1000_spi_eeprom_read_page(struct e1000_hw
*hw
,
228 void *data
, u16 off
, u16 len
, bool intr
)
231 SPI_EEPROM_READ_PAGE
,
232 (off
>> (hw
->eeprom
.address_bits
- 8)) & 0xff, off
& 0xff
235 e1000_standby_eeprom(hw
);
237 if (e1000_spi_xfer(hw
, 8 + hw
->eeprom
.address_bits
, op
, NULL
, intr
))
239 if (e1000_spi_xfer(hw
, len
<< 3, NULL
, data
, intr
))
245 static int e1000_spi_eeprom_poll_ready(struct e1000_hw
*hw
, bool intr
)
248 while ((status
= e1000_spi_eeprom_read_status(hw
, intr
)) >= 0) {
249 if (!(status
& SPI_EEPROM_STATUS_BUSY
))
255 static int e1000_spi_eeprom_dump(struct e1000_hw
*hw
,
256 void *data
, u16 off
, unsigned int len
, bool intr
)
258 /* Interruptibly wait for the EEPROM to be ready */
259 if (e1000_spi_eeprom_poll_ready(hw
, intr
))
262 /* Dump each page in sequence */
264 /* Calculate the data bytes on this page */
265 u16 pg_off
= off
& (hw
->eeprom
.page_size
- 1);
266 u16 pg_len
= hw
->eeprom
.page_size
- pg_off
;
270 /* Now dump the page */
271 if (e1000_spi_eeprom_read_page(hw
, data
, off
, pg_len
, intr
))
274 /* Otherwise go on to the next page */
284 static int e1000_spi_eeprom_program(struct e1000_hw
*hw
,
285 const void *data
, u16 off
, u16 len
, bool intr
)
287 /* Program each page in sequence */
289 /* Calculate the data bytes on this page */
290 u16 pg_off
= off
& (hw
->eeprom
.page_size
- 1);
291 u16 pg_len
= hw
->eeprom
.page_size
- pg_off
;
295 /* Interruptibly wait for the EEPROM to be ready */
296 if (e1000_spi_eeprom_poll_ready(hw
, intr
))
299 /* Enable write access */
300 if (e1000_spi_eeprom_enable_wr(hw
, intr
))
303 /* Now program the page */
304 if (e1000_spi_eeprom_write_page(hw
, data
, off
, pg_len
, intr
))
307 /* Otherwise go on to the next page */
313 /* Wait for the last write to complete */
314 if (e1000_spi_eeprom_poll_ready(hw
, intr
))
321 static int do_e1000_spi_show(cmd_tbl_t
*cmdtp
, struct e1000_hw
*hw
,
322 int argc
, char * const argv
[])
324 unsigned int length
= 0;
334 /* Parse the offset and length */
336 offset
= simple_strtoul(argv
[0], NULL
, 0);
338 length
= simple_strtoul(argv
[1], NULL
, 0);
339 else if (offset
< (hw
->eeprom
.word_size
<< 1))
340 length
= (hw
->eeprom
.word_size
<< 1) - offset
;
342 /* Extra sanity checks */
344 E1000_ERR(hw
->nic
, "Requested zero-sized dump!\n");
347 if ((0x10000 < length
) || (0x10000 - length
< offset
)) {
348 E1000_ERR(hw
->nic
, "Can't dump past 0xFFFF!\n");
352 /* Allocate a buffer to hold stuff */
353 buffer
= malloc(length
);
355 E1000_ERR(hw
->nic
, "Out of Memory!\n");
359 /* Acquire the EEPROM and perform the dump */
360 if (e1000_acquire_eeprom(hw
)) {
361 E1000_ERR(hw
->nic
, "EEPROM SPI cannot be acquired!\n");
365 err
= e1000_spi_eeprom_dump(hw
, buffer
, offset
, length
, true);
366 e1000_release_eeprom(hw
);
368 E1000_ERR(hw
->nic
, "Interrupted!\n");
373 /* Now hexdump the result */
374 printf("%s: ===== Intel e1000 EEPROM (0x%04hX - 0x%04hX) =====",
375 hw
->nic
->name
, offset
, offset
+ length
- 1);
376 for (i
= 0; i
< length
; i
++) {
378 printf("\n%s: %04hX: ", hw
->nic
->name
, offset
+ i
);
379 else if ((i
& 0xF) == 0x8)
381 printf(" %02hx", buffer
[i
]);
390 static int do_e1000_spi_dump(cmd_tbl_t
*cmdtp
, struct e1000_hw
*hw
,
391 int argc
, char * const argv
[])
402 /* Parse the arguments */
403 dest
= (void *)simple_strtoul(argv
[0], NULL
, 16);
404 offset
= simple_strtoul(argv
[1], NULL
, 0);
405 length
= simple_strtoul(argv
[2], NULL
, 0);
407 /* Extra sanity checks */
409 E1000_ERR(hw
->nic
, "Requested zero-sized dump!\n");
412 if ((0x10000 < length
) || (0x10000 - length
< offset
)) {
413 E1000_ERR(hw
->nic
, "Can't dump past 0xFFFF!\n");
417 /* Acquire the EEPROM */
418 if (e1000_acquire_eeprom(hw
)) {
419 E1000_ERR(hw
->nic
, "EEPROM SPI cannot be acquired!\n");
423 /* Perform the programming operation */
424 if (e1000_spi_eeprom_dump(hw
, dest
, offset
, length
, true) < 0) {
425 E1000_ERR(hw
->nic
, "Interrupted!\n");
426 e1000_release_eeprom(hw
);
430 e1000_release_eeprom(hw
);
431 printf("%s: ===== EEPROM DUMP COMPLETE =====\n", hw
->nic
->name
);
435 static int do_e1000_spi_program(cmd_tbl_t
*cmdtp
, struct e1000_hw
*hw
,
436 int argc
, char * const argv
[])
447 /* Parse the arguments */
448 source
= (const void *)simple_strtoul(argv
[0], NULL
, 16);
449 offset
= simple_strtoul(argv
[1], NULL
, 0);
450 length
= simple_strtoul(argv
[2], NULL
, 0);
452 /* Acquire the EEPROM */
453 if (e1000_acquire_eeprom(hw
)) {
454 E1000_ERR(hw
->nic
, "EEPROM SPI cannot be acquired!\n");
458 /* Perform the programming operation */
459 if (e1000_spi_eeprom_program(hw
, source
, offset
, length
, true) < 0) {
460 E1000_ERR(hw
->nic
, "Interrupted!\n");
461 e1000_release_eeprom(hw
);
465 e1000_release_eeprom(hw
);
466 printf("%s: ===== EEPROM PROGRAMMED =====\n", hw
->nic
->name
);
470 static int do_e1000_spi_checksum(cmd_tbl_t
*cmdtp
, struct e1000_hw
*hw
,
471 int argc
, char * const argv
[])
473 uint16_t i
, length
, checksum
= 0, checksum_reg
;
479 else if ((argc
== 1) && !strcmp(argv
[0], "update"))
486 /* Allocate a temporary buffer */
487 length
= sizeof(uint16_t) * (EEPROM_CHECKSUM_REG
+ 1);
488 buffer
= malloc(length
);
490 E1000_ERR(hw
->nic
, "Unable to allocate EEPROM buffer!\n");
494 /* Acquire the EEPROM */
495 if (e1000_acquire_eeprom(hw
)) {
496 E1000_ERR(hw
->nic
, "EEPROM SPI cannot be acquired!\n");
500 /* Read the EEPROM */
501 if (e1000_spi_eeprom_dump(hw
, buffer
, 0, length
, true) < 0) {
502 E1000_ERR(hw
->nic
, "Interrupted!\n");
503 e1000_release_eeprom(hw
);
507 /* Compute the checksum and read the expected value */
508 for (i
= 0; i
< EEPROM_CHECKSUM_REG
; i
++)
509 checksum
+= le16_to_cpu(buffer
[i
]);
510 checksum
= ((uint16_t)EEPROM_SUM
) - checksum
;
511 checksum_reg
= le16_to_cpu(buffer
[i
]);
514 if (checksum_reg
== checksum
) {
515 printf("%s: INFO: EEPROM checksum is correct! (0x%04hx)\n",
516 hw
->nic
->name
, checksum
);
517 e1000_release_eeprom(hw
);
521 /* Hrm, verification failed, print an error */
522 E1000_ERR(hw
->nic
, "EEPROM checksum is incorrect!\n");
523 E1000_ERR(hw
->nic
, " ...register was 0x%04hx, calculated 0x%04hx\n",
524 checksum_reg
, checksum
);
526 /* If they didn't ask us to update it, just return an error */
528 e1000_release_eeprom(hw
);
532 /* Ok, correct it! */
533 printf("%s: Reprogramming the EEPROM checksum...\n", hw
->nic
->name
);
534 buffer
[i
] = cpu_to_le16(checksum
);
535 if (e1000_spi_eeprom_program(hw
, &buffer
[i
], i
* sizeof(uint16_t),
536 sizeof(uint16_t), true)) {
537 E1000_ERR(hw
->nic
, "Interrupted!\n");
538 e1000_release_eeprom(hw
);
542 e1000_release_eeprom(hw
);
546 int do_e1000_spi(cmd_tbl_t
*cmdtp
, struct e1000_hw
*hw
,
547 int argc
, char * const argv
[])
554 /* Make sure it has an SPI chip */
555 if (hw
->eeprom
.type
!= e1000_eeprom_spi
) {
556 E1000_ERR(hw
->nic
, "No attached SPI EEPROM found!\n");
560 /* Check the eeprom sub-sub-command arguments */
561 if (!strcmp(argv
[0], "show"))
562 return do_e1000_spi_show(cmdtp
, hw
, argc
- 1, argv
+ 1);
564 if (!strcmp(argv
[0], "dump"))
565 return do_e1000_spi_dump(cmdtp
, hw
, argc
- 1, argv
+ 1);
567 if (!strcmp(argv
[0], "program"))
568 return do_e1000_spi_program(cmdtp
, hw
, argc
- 1, argv
+ 1);
570 if (!strcmp(argv
[0], "checksum"))
571 return do_e1000_spi_checksum(cmdtp
, hw
, argc
- 1, argv
+ 1);
577 #endif /* not CONFIG_CMD_E1000 */