Root/usbboot/src/cmd.c

1/*
2 * Copyright(C) 2009 Qi Hardware Inc.,
3 * Authors: Marek Lindner <lindner_marek@yahoo.de>
4 * Xiangfu Liu <xiangfu@sharism.cc>
5 *
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20#include <stdio.h>
21#include <string.h>
22#include <unistd.h>
23#include <stdlib.h>
24#include <errno.h>
25#include <fcntl.h>
26#include <sys/types.h>
27#include <sys/stat.h>
28#include <ctype.h>
29#include <byteswap.h>
30#include "cmd.h"
31#include "ingenic_cfg.h"
32#include "ingenic_usb.h"
33#include "ingenic_request.h"
34#include "usb_boot_defines.h"
35
36extern int com_argc;
37extern char com_argv[MAX_ARGC][MAX_COMMAND_LENGTH];
38extern char * stage1;
39
40struct ingenic_dev ingenic_dev;
41struct hand hand;
42struct sdram_in sdram_in;
43struct nand_in nand_in;
44
45unsigned int total_size;
46unsigned char code_buf[4 * 512 * 1024];
47unsigned char check_buf[4 * 512 * 1024];
48unsigned char cs[16];
49unsigned char ret[8];
50
51static const char IMAGE_TYPE[][30] = {
52    "with oob and ecc",
53    "with oob and without ecc",
54    "without oob",
55};
56
57static int load_file(struct ingenic_dev *ingenic_dev, const char *file_path)
58{
59    struct stat fstat;
60    int fd, status, res = -1;
61
62    status = stat(file_path, &fstat);
63
64    if (status < 0) {
65        fprintf(stderr, "Error - can't get file size from '%s': %s\n",
66            file_path, strerror(errno));
67        goto out;
68    }
69
70    ingenic_dev->file_len = fstat.st_size;
71    ingenic_dev->file_buff = code_buf;
72
73    fd = open(file_path, O_RDONLY);
74
75    if (fd < 0) {
76        fprintf(stderr, "Error - can't open file '%s': %s\n",
77            file_path, strerror(errno));
78        goto out;
79    }
80
81    status = read(fd, ingenic_dev->file_buff, ingenic_dev->file_len);
82
83    if (status < ingenic_dev->file_len) {
84        fprintf(stderr, "Error - can't read file '%s': %s\n",
85            file_path, strerror(errno));
86        goto close;
87    }
88
89    struct fw_args *fw_args_copy = malloc(sizeof(struct fw_args));
90    if (!fw_args_copy)
91        goto close;
92
93    memcpy(fw_args_copy, &hand.fw_args, sizeof(struct fw_args));
94
95#if defined (__BIG_ENDIAN__) || defined(MIPSEB)
96    fw_args_copy->cpu_id = bswap_32(fw_args_copy->cpu_id);
97    fw_args_copy->boudrate = bswap_32(fw_args_copy->boudrate);
98    fw_args_copy->start = bswap_32(fw_args_copy->start);
99    fw_args_copy->size = bswap_32(fw_args_copy->size);
100#endif
101
102    /* write args to code */
103    memcpy(ingenic_dev->file_buff + 8, fw_args_copy,
104           sizeof(struct fw_args));
105
106    free(fw_args_copy);
107
108    res = 1;
109
110close:
111    close(fd);
112out:
113    return res;
114}
115
116int get_ingenic_cpu()
117{
118    int status;
119
120    status = usb_get_ingenic_cpu(&ingenic_dev);
121
122    switch (status) {
123    case JZ4740V1:
124        hand.fw_args.cpu_id = 0x4740;
125        break;
126    case JZ4750V1:
127        hand.fw_args.cpu_id = 0x4750;
128        break;
129    case JZ4760V1:
130        hand.fw_args.cpu_id = 0x4760;
131        break;
132    case BOOT4740:
133        hand.fw_args.cpu_id = 0x4740;
134        break;
135    case BOOT4750:
136        hand.fw_args.cpu_id = 0x4750;
137        break;
138    case BOOT4760:
139        hand.fw_args.cpu_id = 0x4760;
140        break;
141    default:
142        hand.fw_args.cpu_id = 0;
143    }
144
145    return status;
146}
147
148/* after upload stage2. must init device */
149void init_cfg()
150{
151    int cpu = get_ingenic_cpu();
152    if (cpu != BOOT4740 && cpu != BOOT4750 && cpu != BOOT4760) {
153        printf(" Device unboot! boot it first!\n");
154        return;
155    }
156
157    struct hand *hand_copy = malloc(sizeof(struct hand));
158    if (!hand_copy)
159        goto xout;
160
161    memcpy(hand_copy, &hand, sizeof(struct hand));
162
163#if defined (__BIG_ENDIAN__) || defined(MIPSEB)
164    hand_copy->fw_args.cpu_id = bswap_32(hand.fw_args.cpu_id);
165    hand_copy->fw_args.boudrate = bswap_32(hand.fw_args.boudrate);
166    hand_copy->fw_args.start = bswap_32(hand.fw_args.start);
167    hand_copy->fw_args.size = bswap_32(hand.fw_args.size);
168
169    hand_copy->pt = bswap_32(hand.pt);
170    hand_copy->nand_bw = bswap_32(hand_copy->nand_bw);
171    hand_copy->nand_rc = bswap_32(hand_copy->nand_rc);
172    hand_copy->nand_ps = bswap_32(hand_copy->nand_ps);
173    hand_copy->nand_ppb = bswap_32(hand_copy->nand_ppb);
174    hand_copy->nand_force_erase = bswap_32(hand_copy->nand_force_erase);
175    hand_copy->nand_pn = bswap_32(hand_copy->nand_pn);
176    hand_copy->nand_os = bswap_32(hand_copy->nand_os);
177    hand_copy->nand_eccpos = bswap_32(hand_copy->nand_eccpos);
178    hand_copy->nand_bbpage = bswap_32(hand_copy->nand_bbpage);
179    hand_copy->nand_bbpos = bswap_32(hand_copy->nand_bbpos);
180    hand_copy->nand_plane = bswap_32(hand_copy->nand_plane);
181    hand_copy->nand_bchbit = bswap_32(hand_copy->nand_bchbit);
182    hand_copy->nand_wppin = bswap_32(hand_copy->nand_wppin);
183    hand_copy->nand_bpc = bswap_32(hand_copy->nand_bpc);
184#endif
185
186
187    ingenic_dev.file_buff = hand_copy;
188    ingenic_dev.file_len = sizeof(struct hand);
189    if (usb_send_data_to_ingenic(&ingenic_dev) != 1)
190        goto xout;
191
192    free(hand_copy);
193
194    sleep(1);
195    if (usb_ingenic_configration(&ingenic_dev, DS_hand) != 1)
196        goto xout;
197
198    if (usb_read_data_from_ingenic(&ingenic_dev, ret, 8) != 1)
199        goto xout;
200
201    printf(" Configuring XBurst CPU succeeded.\n");
202    return;
203xout:
204    printf(" Configuring XBurst CPU failed.\n");
205}
206
207int boot(char *stage1_path, char *stage2_path){
208    int status = get_ingenic_cpu();
209
210    if (status == BOOT4740 || status == BOOT4750 || status == BOOT4760) {
211        printf(" Already booted.\n");
212        return 1;
213    } else {
214        printf(" CPU not yet booted, now booting...\n");
215
216        /* now we upload the boot stage1 */
217        printf(" Loading stage1 from '%s'\n", stage1_path);
218        if (load_file(&ingenic_dev, stage1_path) < 1)
219            return -1;
220
221        if (usb_ingenic_upload(&ingenic_dev, 1) < 1)
222            return -1;
223
224        /* now we upload the boot stage2 */
225        usleep(100);
226        printf(" Loading stage2 from '%s'\n", stage2_path);
227        if (load_file(&ingenic_dev, stage2_path) < 1)
228            return -1;
229
230        if (usb_ingenic_upload(&ingenic_dev, 2) < 1)
231            return -1;
232
233        printf(" Booted successfully!\n");
234    }
235
236    usleep(100);
237    init_cfg();
238
239    return 1;
240}
241
242/* nand function */
243int error_check(unsigned char *org,unsigned char * obj,unsigned int size)
244{
245    unsigned int i;
246    printf(" Comparing %d bytes - ", size);
247    for (i = 0; i < size; i++) {
248        if (org[i] != obj[i]) {
249            unsigned int s = (i < 8) ? i : i - 8; // start_dump
250            printf("FAIL at off %d, wrote 0x%x, read 0x%x\n", i, org[i], obj[i]);
251            printf(" off %d write: %02x %02x %02x %02x %02x %02x %02x %02x"
252                   " %02x %02x %02x %02x %02x %02x %02x %02x\n", s,
253                org[s], org[s+1], org[s+2], org[s+3], org[s+4], org[s+5], org[s+6], org[s+7],
254                org[s+8], org[s+9], org[s+10], org[s+11], org[s+12], org[s+13], org[s+14], org[s+15]);
255            printf(" off %d read: %02x %02x %02x %02x %02x %02x %02x %02x"
256                   " %02x %02x %02x %02x %02x %02x %02x %02x\n", s,
257                obj[s], obj[s+1], obj[s+2], obj[s+3], obj[s+4], obj[s+5], obj[s+6], obj[s+7],
258                obj[s+8], obj[s+9], obj[s+10], obj[s+11], obj[s+12], obj[s+13], obj[s+14], obj[s+15]);
259            fflush(NULL);
260            return 0;
261        }
262    }
263    printf("SUCCESS\n");
264    fflush(NULL);
265    return 1;
266}
267
268int nand_markbad(struct nand_in *nand_in)
269{
270    int cpu = get_ingenic_cpu();
271    if (cpu != BOOT4740 && cpu != BOOT4750 && cpu != BOOT4760) {
272        printf(" Device unboot! boot it first!\n");
273        return -1;
274    }
275    printf(" Mark bad block : %d\n",nand_in->start);
276    usb_send_data_address_to_ingenic(&ingenic_dev, nand_in->start);
277    usb_ingenic_nand_ops(&ingenic_dev, NAND_MARK_BAD);
278    usb_read_data_from_ingenic(&ingenic_dev, ret, 8);
279    printf(" Mark bad block at %d\n",((ret[3] << 24) |
280                       (ret[2] << 16) |
281                       (ret[1] << 8) |
282                       (ret[0] << 0)) / hand.nand_ppb);
283    return 0;
284}
285
286int nand_program_check(struct nand_in *nand_in, unsigned int *start_page)
287{
288    unsigned int i, page_num, cur_page = -1;
289    unsigned int start_addr;
290    unsigned short temp;
291    int status = -1;
292
293    printf(" Writing NAND page %d len %d...\n", nand_in->start, nand_in->length);
294    if (nand_in->length > (unsigned int)MAX_TRANSFER_SIZE) {
295        printf(" Buffer size too long!\n");
296        goto err;
297    }
298
299    int cpu = get_ingenic_cpu();
300    if (cpu != BOOT4740 && cpu != BOOT4750 && cpu != BOOT4760) {
301        printf(" Device unboot! boot it first!\n");
302        goto err;
303    }
304
305    ingenic_dev.file_buff = nand_in->buf;
306    ingenic_dev.file_len = nand_in->length;
307    usb_send_data_to_ingenic(&ingenic_dev);
308    for (i = 0; i < nand_in->max_chip; i++) {
309        if ((nand_in->cs_map)[i] == 0)
310            continue;
311        if (nand_in->option == NO_OOB) {
312            page_num = nand_in->length / hand.nand_ps;
313            if ((nand_in->length % hand.nand_ps) !=0)
314                page_num++;
315        } else {
316            page_num = nand_in->length /
317                (hand.nand_ps + hand.nand_os);
318            if ((nand_in->length% (hand.nand_ps + hand.nand_os)) !=0)
319                page_num++;
320        }
321        temp = ((nand_in->option << 12) & 0xf000) +
322            ((i<<4) & 0xff0) + NAND_PROGRAM;
323        if (usb_send_data_address_to_ingenic(&ingenic_dev, nand_in->start) != 1)
324            goto err;
325        if (usb_send_data_length_to_ingenic(&ingenic_dev, page_num) != 1)
326            goto err;
327        if (usb_ingenic_nand_ops(&ingenic_dev, temp) != 1)
328            goto err;
329        if (usb_read_data_from_ingenic(&ingenic_dev, ret, 8) != 1)
330            goto err;
331
332        printf(" Finish! (len %d start_page %d page_num %d)\n",
333               nand_in->length, nand_in->start, page_num);
334
335        /* Read back to check! */
336        usb_send_data_address_to_ingenic(&ingenic_dev, nand_in->start);
337        usb_send_data_length_to_ingenic(&ingenic_dev, page_num);
338
339        switch (nand_in->option) {
340        case OOB_ECC:
341            temp = ((OOB_ECC << 12) & 0xf000) +
342                ((i << 4) & 0xff0) + NAND_READ;
343            start_addr = page_num * (hand.nand_ps + hand.nand_os);
344            break;
345        case OOB_NO_ECC: /* do not support data verify */
346            temp = ((OOB_NO_ECC << 12) & 0xf000) +
347                ((i << 4) & 0xff0) + NAND_READ;
348            start_addr = page_num * (hand.nand_ps + hand.nand_os);
349            break;
350        case NO_OOB:
351            temp = ((NO_OOB << 12) & 0xf000) +
352                ((i << 4) & 0xff0) + NAND_READ;
353            start_addr = page_num * hand.nand_ps;
354            break;
355        default:
356            ;
357        }
358
359        printf(" Checking %d bytes...", nand_in->length);
360        usb_ingenic_nand_ops(&ingenic_dev, temp);
361        usb_read_data_from_ingenic(&ingenic_dev, check_buf, start_addr);
362        usb_read_data_from_ingenic(&ingenic_dev, ret, 8);
363
364        cur_page = (ret[3] << 24) | (ret[2] << 16) | (ret[1] << 8) |
365            (ret[0] << 0);
366
367        if (nand_in->start == 0 && hand.nand_ps == 4096 &&
368            hand.fw_args.cpu_id == 0x4740) {
369            printf(" No check! end at page: %d\n", cur_page);
370            fflush(NULL);
371            continue;
372        }
373
374        if (!nand_in->check(nand_in->buf, check_buf, nand_in->length)) {
375            struct nand_in bad;
376            // tbd: doesn't the other side skip bad blocks too? Can we just deduct 1 from cur_page?
377            // tbd: why do we only mark a block as bad if the last page in the block was written?
378            bad.start = (cur_page - 1) / hand.nand_ppb;
379            if (cur_page % hand.nand_ppb == 0)
380                nand_markbad(&bad);
381        }
382
383        printf(" End at page: %d\n", cur_page);
384        fflush(NULL);
385    }
386
387    *start_page = cur_page;
388
389    status = 1;
390err:
391    return status;
392}
393
394int nand_erase(struct nand_in *nand_in)
395{
396    unsigned int start_blk, blk_num, end_block;
397    int i;
398
399    start_blk = nand_in->start;
400    blk_num = nand_in->length;
401    if (start_blk > (unsigned int)NAND_MAX_BLK_NUM) {
402        printf(" Start block number overflow!\n");
403        return -1;
404    }
405    if (blk_num > (unsigned int)NAND_MAX_BLK_NUM) {
406        printf(" Length block number overflow!\n");
407        return -1;
408    }
409
410    int cpu = get_ingenic_cpu();
411    if (cpu != BOOT4740 && cpu != BOOT4750 && cpu != BOOT4760) {
412        printf(" Device unboot! boot it first!\n");
413        return -1;
414    }
415
416    for (i = 0; i < nand_in->max_chip; i++) {
417        if ((nand_in->cs_map)[i]==0)
418            continue;
419        printf(" Erasing No.%d device No.%d flash (start_blk %u blk_num %u)......\n",
420               nand_in->dev, i, start_blk, blk_num);
421
422        usb_send_data_address_to_ingenic(&ingenic_dev, start_blk);
423        usb_send_data_length_to_ingenic(&ingenic_dev, blk_num);
424
425        unsigned short temp = ((i << 4) & 0xff0) + NAND_ERASE;
426        usb_ingenic_nand_ops(&ingenic_dev, temp);
427
428        usb_read_data_from_ingenic(&ingenic_dev, ret, 8);
429        printf(" Finish!");
430    }
431    end_block = ((ret[3] << 24) |
432             (ret[2] << 16) |
433             (ret[1] << 8) |
434             (ret[0] << 0)) / hand.nand_ppb;
435    printf(" Return: %02x %02x %02x %02x %02x %02x %02x %02x (position %d)\n",
436           ret[0], ret[1], ret[2], ret[3], ret[4], ret[5], ret[6], ret[7], end_block);
437    if (!hand.nand_force_erase) {
438    /* not force erase, show bad block infomation */
439        printf(" There are marked bad blocks: %d\n",
440               end_block - start_blk - blk_num );
441    } else {
442    /* force erase, no bad block infomation can show */
443        printf(" Force erase, no bad block infomation!\n" );
444    }
445
446    return 1;
447}
448
449int nand_program_file(struct nand_in *nand_in, char *fname)
450{
451
452    int flen, m, j, k;
453    unsigned int start_page = 0, page_num, code_len, offset, transfer_size;
454    int fd, status;
455    struct stat fstat;
456    struct nand_in n_in;
457
458    status = stat(fname, &fstat);
459
460    if (status < 0) {
461        fprintf(stderr, "Error - can't get file size from '%s': %s\n",
462            fname, strerror(errno));
463        return -1;
464    }
465    flen = fstat.st_size;
466
467    fd = open(fname, O_RDONLY);
468    if (fd < 0) {
469        fprintf(stderr, "Error - can't open file '%s': %s\n",
470            fname, strerror(errno));
471        return -1;
472    }
473
474    printf(" Programing No.%d device, flen %d, start page %d...\n",nand_in->dev, flen, nand_in->start);
475    n_in.start = nand_in->start / hand.nand_ppb;
476    if (nand_in->option == NO_OOB) {
477        if (flen % (hand.nand_ppb * hand.nand_ps) == 0)
478            n_in.length = flen / (hand.nand_ps * hand.nand_ppb);
479        else
480            n_in.length = flen / (hand.nand_ps * hand.nand_ppb) + 1;
481    } else {
482        if (flen % (hand.nand_ppb * (hand.nand_ps + hand.nand_os)) == 0)
483            n_in.length = flen /
484                ((hand.nand_ps + hand.nand_os) * hand.nand_ppb);
485        else
486            n_in.length = flen /
487                ((hand.nand_ps + hand.nand_os) * hand.nand_ppb)
488                + 1;
489    }
490    n_in.cs_map = nand_in->cs_map;
491    n_in.dev = nand_in->dev;
492    n_in.max_chip = nand_in->max_chip;
493    if (nand_erase(&n_in) != 1)
494        return -1;
495    if (nand_in->option == NO_OOB)
496        transfer_size = (hand.nand_ppb * hand.nand_ps);
497    else
498        transfer_size = (hand.nand_ppb * (hand.nand_ps + hand.nand_os));
499
500    m = flen / transfer_size;
501    j = flen % transfer_size;
502    printf(" Size to send %d, transfer_size %d\n", flen, transfer_size);
503    printf(" Image type : %s\n", IMAGE_TYPE[nand_in->option]);
504    printf(" It will cause %d times buffer transfer.\n", j == 0 ? m : m + 1);
505    fflush(NULL);
506
507    offset = 0;
508    for (k = 0; k < m; k++) {
509        if (nand_in->option == NO_OOB)
510            page_num = transfer_size / hand.nand_ps;
511        else
512            page_num = transfer_size / (hand.nand_ps + hand.nand_os);
513
514        code_len = transfer_size;
515        status = read(fd, code_buf, code_len);
516        if (status < code_len) {
517            fprintf(stderr, "Error - can't read file '%s': %s\n",
518                fname, strerror(errno));
519            return -1;
520        }
521
522        nand_in->length = code_len; /* code length,not page number! */
523        nand_in->buf = code_buf;
524        if (nand_program_check(nand_in, &start_page) == -1)
525            return -1;
526
527        if (start_page - nand_in->start > hand.nand_ppb)
528            printf(" Info - skip bad block!\n");
529        nand_in->start = start_page;
530
531        offset += code_len ;
532    }
533
534    if (j) {
535        code_len = j;
536        if (j % hand.nand_ps)
537            j += hand.nand_ps - (j % hand.nand_ps);
538        memset(code_buf, 0, j); /* set all to null */
539
540        status = read(fd, code_buf, code_len);
541
542        if (status < code_len) {
543            fprintf(stderr, "Error - can't read file '%s': %s\n",
544                fname, strerror(errno));
545            return -1;
546        }
547
548        nand_in->length = j;
549        nand_in->buf = code_buf;
550        if (nand_program_check(nand_in, &start_page) == -1)
551            return -1;
552
553        if (start_page - nand_in->start > hand.nand_ppb)
554            printf(" Info - skip bad block!");
555
556    }
557
558    close(fd);
559    return 1;
560}
561
562int nand_program_file_planes(struct nand_in *nand_in, char *fname)
563{
564    printf(" not implement yet !\n");
565    return -1;
566}
567
568int init_nand_in(void)
569{
570    nand_in.buf = code_buf;
571    nand_in.check = error_check;
572    nand_in.dev = 0;
573    nand_in.cs_map = cs;
574    memset(nand_in.cs_map, 0, MAX_DEV_NUM);
575
576    nand_in.max_chip = 16;
577    return 0;
578}
579
580int nand_prog(void)
581{
582    int status = -1;
583    char *image_file;
584    char *help = " Usage: nprog (1) (2) (3) (4) (5)\n"
585        " (1)\tstart page number\n"
586        " (2)\timage file name\n"
587        " (3)\tdevice index number\n"
588        " (4)\tflash index number\n"
589        " (5) image type must be:\n"
590        " \t-n:\tno oob\n"
591        " \t-o:\twith oob no ecc\n"
592        " \t-e:\twith oob and ecc\n";
593
594    if (com_argc != 6) {
595        printf("%s", help);
596        return 0;
597    }
598
599    init_nand_in();
600
601    nand_in.start = atoi(com_argv[1]);
602    image_file = com_argv[2];
603    nand_in.dev = atoi(com_argv[3]);
604
605    (nand_in.cs_map)[atoi(com_argv[4])] = 1;
606    if (!strcmp(com_argv[5], "-e"))
607        nand_in.option = OOB_ECC;
608    else if (!strcmp(com_argv[5], "-o"))
609        nand_in.option = OOB_NO_ECC;
610    else if (!strcmp(com_argv[5], "-n"))
611        nand_in.option = NO_OOB;
612    else
613        printf("%s", help);
614
615    if (hand.nand_plane > 1)
616        nand_program_file_planes(&nand_in, image_file);
617    else
618        nand_program_file(&nand_in, image_file);
619
620    status = 1;
621err:
622    return status;
623}
624
625int nand_query(void)
626{
627    int i;
628    unsigned char csn;
629
630    if (com_argc < 3) {
631        printf(" Usage: nquery (1) (2)\n"
632               " (1):device index number\n"
633               " (2):flash index number\n");
634        return -1;
635    }
636    init_nand_in();
637
638    nand_in.dev = atoi(com_argv[1]);
639    (nand_in.cs_map)[atoi(com_argv[2])] = 1;
640
641    for (i = 0; i < nand_in.max_chip; i++) {
642        if ((nand_in.cs_map)[i] != 0)
643            break;
644    }
645    if (i >= nand_in.max_chip)
646        return -1;
647
648    int cpu = get_ingenic_cpu();
649    if (cpu != BOOT4740 && cpu != BOOT4750 && cpu != BOOT4760) {
650        printf(" Device unboot! boot it first!\n");
651        return -1;
652    }
653
654    csn = i;
655    printf(" ID of No.%d device No.%d flash: \n", nand_in.dev, csn);
656
657    unsigned short ops = ((csn << 4) & 0xff0) + NAND_QUERY;
658    usb_ingenic_nand_ops(&ingenic_dev, ops);
659    usb_read_data_from_ingenic(&ingenic_dev, ret, 8);
660    printf(" Vendor ID :0x%x \n",(unsigned char)ret[0]);
661    printf(" Product ID :0x%x \n",(unsigned char)ret[1]);
662    printf(" Chip ID :0x%x \n",(unsigned char)ret[2]);
663    printf(" Page ID :0x%x \n",(unsigned char)ret[3]);
664    printf(" Plane ID :0x%x \n",(unsigned char)ret[4]);
665
666    usb_read_data_from_ingenic(&ingenic_dev, ret, 8);
667
668    return 1;
669}
670
671int nand_read(int mode)
672{
673    unsigned int i, j, cpu;
674    unsigned int start_addr, length, page_num;
675    unsigned char csn;
676    unsigned short temp = 0;
677
678    if (com_argc < 5) {
679        printf(" Usage: nread (1) (2) (3) (4)\n"
680               " 1:start page number\n"
681               " 2:length in byte\n"
682               " 3:device index number\n"
683               " 4:flash index number\n");
684        return -1;
685    }
686
687    init_nand_in();
688
689    nand_in.start = atoi(com_argv[1]);
690    nand_in.length = atoi(com_argv[2]);
691    nand_in.dev = atoi(com_argv[3]);
692
693    csn = atoi(com_argv[4]);
694    start_addr = nand_in.start;
695    length = nand_in.length;
696
697    if (csn >= MAX_DEV_NUM) {
698        printf(" Flash index number overflow!\n");
699        return -1;
700    }
701    nand_in.cs_map[csn] = 1;
702
703    if (start_addr > NAND_MAX_PAGE_NUM || length > NAND_MAX_PAGE_NUM ) {
704        printf(" Page number overflow!\n");
705        return -1;
706    }
707
708    cpu = get_ingenic_cpu();
709    if (cpu != BOOT4740 && cpu != BOOT4750 && cpu != BOOT4760) {
710        printf(" Device unboot! boot it first!\n");
711        return -1;
712    }
713
714    printf(" Reading from No.%d device No.%d flash....\n", nand_in.dev, csn);
715
716    page_num = length / hand.nand_ps +1;
717
718    switch(mode) {
719    case NAND_READ:
720        temp = ((NO_OOB<<12) & 0xf000) + ((csn<<4) & 0xff0) + NAND_READ;
721        break;
722    case NAND_READ_OOB:
723        temp = ((csn<<4) & 0xff0) + NAND_READ_OOB;
724        break;
725    case NAND_READ_RAW:
726        temp = ((NO_OOB<<12) & 0xf000) + ((csn<<4) & 0xff0) +
727            NAND_READ_RAW;
728        break;
729    default:
730        printf(" Unknow mode!\n");
731        return -1;
732    }
733
734    usb_send_data_address_to_ingenic(&ingenic_dev, start_addr);
735    usb_send_data_length_to_ingenic(&ingenic_dev, page_num);
736
737    usb_ingenic_nand_ops(&ingenic_dev, temp);
738
739    usb_read_data_from_ingenic(&ingenic_dev, nand_in.buf, page_num * hand.nand_ps);
740
741    for (j = 0; j < length; j++) {
742        if (j % 16 == 0)
743            printf("\n 0x%08x : ",j);
744        printf("%02x ",(nand_in.buf)[j]);
745    }
746    printf("\n");
747
748    usb_read_data_from_ingenic(&ingenic_dev, ret, 8);
749    printf(" Operation end position : %d \n",
750           (ret[3]<<24)|(ret[2]<<16)|(ret[1]<<8)|(ret[0]<<0));
751
752    return 1;
753}
754
755int debug_memory(int obj, unsigned int start, unsigned int size)
756{
757    unsigned int buffer[8],tmp;
758
759    tmp = get_ingenic_cpu();
760    if (tmp == BOOT4740 || tmp == BOOT4750 || tmp == BOOT4760) {
761        printf(" This command only run under UNBOOT state!\n");
762        return -1;
763    }
764
765    switch (tmp) {
766    case 1:
767        tmp = 0;
768        hand.fw_args.cpu_id = 0x4740;
769        break;
770    case 2:
771        tmp = 0;
772        hand.fw_args.cpu_id = 0x4750;
773        break;
774    }
775
776    hand.fw_args.debug_ops = 1;/* tell device it's memory debug */
777    hand.fw_args.start = start;
778
779    if (size == 0)
780        hand.fw_args.size = total_size;
781    else
782        hand.fw_args.size = size;
783
784    printf(" Now test memory from 0x%x to 0x%x: \n",
785           start, start + hand.fw_args.size);
786
787    if (load_file(&ingenic_dev, stage1) < 1)
788        return -1;
789    if (usb_ingenic_upload(&ingenic_dev, 1) < 1)
790        return -1;
791
792    usleep(100);
793    usb_read_data_from_ingenic(&ingenic_dev, buffer, 8);
794    if (buffer[0] != 0)
795        printf(" Test memory fail! Last error address is 0x%x !\n",
796               buffer[0]);
797    else
798        printf(" Test memory pass!\n");
799
800    return 1;
801}
802
803int debug_gpio(int obj, unsigned char ops, unsigned char pin)
804{
805    unsigned int tmp;
806
807    tmp = get_ingenic_cpu();
808    if (tmp == BOOT4740 || tmp == BOOT4750 || tmp == BOOT4760) {
809        printf(" This command only run under UNBOOT state!\n");
810        return -1;
811    }
812
813    switch (tmp) {
814    case 1:
815        tmp = 0;
816        hand.fw_args.cpu_id = 0x4740;
817        if (pin > 124) {
818            printf(" Jz4740 has 124 GPIO pin in all!\n");
819            return -1;
820        }
821        break;
822    case 2:
823        tmp = 0;
824        hand.fw_args.cpu_id = 0x4750;
825        if (pin > 178) {
826            printf(" Jz4750 has 178 GPIO pin in all!\n");
827            return -1;
828        }
829        break;
830    }
831
832    hand.fw_args.debug_ops = ops;/* tell device it's memory debug */
833    hand.fw_args.pin_num = pin;
834
835    if (ops == 2)
836        printf(" GPIO %d set!\n",pin);
837    else
838        printf(" GPIO %d clear!\n",pin);
839
840    if (load_file(&ingenic_dev, stage1) < 1)
841        return -1;
842    if (usb_ingenic_upload(&ingenic_dev, 1) < 1)
843        return -1;
844
845    return 0;
846}
847
848int debug_go(void)
849{
850    unsigned int addr,obj;
851    if (com_argc<3) {
852        printf(" Usage: go (1) (2) \n"
853               " 1:start SDRAM address\n"
854               " 2:device index number\n");
855        return 0;
856    }
857
858    addr = strtoul(com_argv[1], NULL, 0);
859    obj = atoi(com_argv[2]);
860
861    printf(" Executing No.%d device at address 0x%x\n", obj, addr);
862
863    if (usb_ingenic_start(&ingenic_dev, VR_PROGRAM_START2, addr) < 1)
864        return -1;
865
866    return 1;
867}
868
869int sdram_load(struct sdram_in *sdram_in)
870{
871    int cpu = get_ingenic_cpu();
872    if (cpu != BOOT4740 && cpu != BOOT4750 && cpu != BOOT4760) {
873        printf(" Device unboot! boot it first!\n");
874        return -1;
875    }
876
877    if (sdram_in->length > (unsigned int) MAX_LOAD_SIZE) {
878        printf(" Image length too long!\n");
879        return -1;
880    }
881
882    ingenic_dev.file_buff = sdram_in->buf;
883    ingenic_dev.file_len = sdram_in->length;
884    usb_send_data_to_ingenic(&ingenic_dev);
885    usb_send_data_address_to_ingenic(&ingenic_dev, sdram_in->start);
886    usb_send_data_length_to_ingenic(&ingenic_dev, sdram_in->length);
887    usb_ingenic_sdram_ops(&ingenic_dev, sdram_in);
888
889    usb_read_data_from_ingenic(&ingenic_dev, ret, 8);
890    printf(" Load last address at 0x%x\n",
891           ((ret[3]<<24)|(ret[2]<<16)|(ret[1]<<8)|(ret[0]<<0)));
892
893    return 1;
894}
895
896int sdram_load_file(struct sdram_in *sdram_in, char *file_path)
897{
898    struct stat fstat;
899    unsigned int flen,m,j,offset,k;
900    int fd, status, res = -1;
901
902    status = stat(file_path, &fstat);
903    if (status < 0) {
904        fprintf(stderr, "Error - can't get file size from '%s': %s\n",
905            file_path, strerror(errno));
906        goto out;
907    }
908    flen = fstat.st_size;
909
910    fd = open(file_path, O_RDONLY);
911    if (fd < 0) {
912        fprintf(stderr, "Error - can't open file '%s': %s\n",
913            file_path, strerror(errno));
914        goto out;
915    }
916
917    m = flen / MAX_LOAD_SIZE;
918    j = flen % MAX_LOAD_SIZE;
919    offset = 0;
920
921    printf(" Total size to send in byte is :%d\n", flen);
922    printf(" Loading data to SDRAM :\n");
923
924    for (k = 0; k < m; k++) {
925        status = read(fd, sdram_in->buf, MAX_LOAD_SIZE);
926        if (status < MAX_LOAD_SIZE) {
927            fprintf(stderr, "Error - can't read file '%s': %s\n",
928                file_path, strerror(errno));
929            goto close;
930        }
931
932        sdram_in->length = MAX_LOAD_SIZE;
933        if (sdram_load(sdram_in) < 1)
934            goto close;
935
936        sdram_in->start += MAX_LOAD_SIZE;
937        if ( k % 60 == 0)
938            printf(" 0x%x \n", sdram_in->start);
939    }
940
941    if (j) {
942        if (j % 4 !=0)
943            j += 4 - (j % 4);
944        status = read(fd, sdram_in->buf, j);
945        if (status < j) {
946            fprintf(stderr, "Error - can't read file '%s': %s\n",
947                file_path, strerror(errno));
948            goto close;
949        }
950
951        sdram_in->length = j;
952        if (sdram_load(sdram_in) < 1)
953            goto close;
954    }
955
956    res = 1;
957
958close:
959    close(fd);
960out:
961    return res;
962}
963
964int device_reset(int ops)
965{
966    int cpu = get_ingenic_cpu();
967    if (cpu != BOOT4740 && cpu != BOOT4750 && cpu != BOOT4760) {
968        printf(" Device unboot! boot it first!\n");
969        return -1;
970    }
971
972    if (usb_ingenic_reset(&ingenic_dev, ops) < 1)
973        return -1;
974
975    return 1;
976}
977

Archive Download this file

Branches:
lars
master

Tags:
201007
201012
201103
201105
201206



interactive