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