source: rtems/c/src/lib/libbsp/powerpc/shared/flash/flash.c @ fa4fe456

4.11
Last change on this file since fa4fe456 was fa4fe456, checked in by Nick Withers <nick.withers@…>, on Jan 30, 2014 at 1:58:41 AM

Move the flash size probe into bankValidate()

Previously, bankValidate() could be called (e.g., BSP_flashWrite() -> regionCheckAndErase() -> argcheck() -> bankValidate()) without the probe having happened. When it then invoked BSP_flashCheckId(), unmapped memory could be read, possibly causing a fatal exception.

  • Property mode set to 100644
File size: 20.5 KB
Line 
1/* Trivial Flash Programmer                                  */
2
3/* Author: Till Straumann <strauman@slac.stanford.edu>, 2006 */
4
5/* To keep things simple, this driver makes a few assumptions about the
6 * hardware:
7 *
8 * - no CFI
9 * - devices operate with 16-bit data width
10 * - two devices are used in parallel (stride 4) to
11 *   provide 32-bit data. I.e., the devices are
12 *   organized like this:
13 *   unsigned short flash[FLASH_SIZE][2];
14 * - no endianness issues (i.e., flash endianness ==  CPU endianness)
15 * - fixed block size
16 * - fixed buffer size
17 * - all devices in a bank are identical
18 * - NOT THREAD SAFE; no locking scheme is implemented.
19 * - cannot copy within same flash bank.
20 * - timeout uses polling/busy-wait.
21 *
22 * NOTE: some attempts have been made to remove the restrictions
23 * on stride and 16-bit width with the goal to support widths 1/2 (bytes)
24 * and strides 1/2/4 and all (legal) combinations thereof.
25 * However, the intel chip driver only implements stride 4 / width 2
26 * and other combinations are untested.
27 */
28
29/*
30 * Authorship
31 * ----------
32 * This software was created by
33 *     Till Straumann <strauman@slac.stanford.edu>, 2005-2007,
34 *         Stanford Linear Accelerator Center, Stanford University.
35 *
36 * Acknowledgement of sponsorship
37 * ------------------------------
38 * The software was produced by
39 *     the Stanford Linear Accelerator Center, Stanford University,
40 *         under Contract DE-AC03-76SFO0515 with the Department of Energy.
41 *
42 * Government disclaimer of liability
43 * ----------------------------------
44 * Neither the United States nor the United States Department of Energy,
45 * nor any of their employees, makes any warranty, express or implied, or
46 * assumes any legal liability or responsibility for the accuracy,
47 * completeness, or usefulness of any data, apparatus, product, or process
48 * disclosed, or represents that its use would not infringe privately owned
49 * rights.
50 *
51 * Stanford disclaimer of liability
52 * --------------------------------
53 * Stanford University makes no representations or warranties, express or
54 * implied, nor assumes any liability for the use of this software.
55 *
56 * Stanford disclaimer of copyright
57 * --------------------------------
58 * Stanford University, owner of the copyright, hereby disclaims its
59 * copyright and all other rights in this software.  Hence, anyone may
60 * freely use it for any purpose without restriction.
61 *
62 * Maintenance of notices
63 * ----------------------
64 * In the interest of clarity regarding the origin and status of this
65 * SLAC software, this and all the preceding Stanford University notices
66 * are to remain affixed to any copy or derivative of this software made
67 * or distributed by the recipient and are to be affixed to any copy of
68 * software made or distributed by the recipient that contains a copy or
69 * derivative of this software.
70 *
71 * ------------------ SLAC Software Notices, Set 4 OTT.002a, 2004 FEB 03
72 */
73#ifndef TESTING
74#include <rtems.h>
75#include <bsp/flashPgm.h>
76#include <bsp/flashPgmPvt.h>
77#else
78#include "flashPgm.h"
79#include "flashPgmPvt.h"
80#endif
81
82#include <unistd.h>
83#include <stdio.h>
84#include <inttypes.h>
85#include <ctype.h>
86#include <fcntl.h>
87#include <stdlib.h>
88
89#define  DEBUG          0
90#undef   DEBUG
91
92#ifdef   DEBUG
93#define  STATIC
94#else
95#define  STATIC                         static
96#endif
97
98/* Forward decls. */
99
100STATIC uint32_t
101BSP_flashProbeSize(struct bankdesc *b);
102
103STATIC struct bankdesc *
104bankValidate(int bank, int quiet);
105
106static struct bankdesc *
107argcheck(int bank, uint32_t offset, const char *src, uint32_t size);
108
109/* Type definitions */
110
111union bconv     {
112        uint32_t u;
113        uint16_t s[2];
114        char     c[4];
115};
116
117/* Little helpers... */
118
119/* Read parallel devices */
120static void
121rd_par(struct bankdesc *b, union bconv *pv, uint32_t a)
122{
123        if ( 4 == FLASH_STRIDE(b) ) {
124                pv->u    = *(_u32_a_t*)a;
125        } else if ( 2 == FLASH_STRIDE(b) ) {
126                pv->s[0] = *(_u16_a_t*)a;
127        } else {
128                pv->c[0] = *(_u8_a_t*)a;
129        }
130}
131
132/* 'flush' input buffer and get an upper-case char from stdin */
133STATIC int
134getUc(void)
135{
136        fseek(stdin, 0, SEEK_END);
137        return toupper(getchar());
138}
139
140/* Advance rotating progress indicator on stdout.
141 * The idea is that the caller updates a state variable
142 * using 'flip':
143 *
144 * unsigned f = 0;
145 *
146 *    // advance indicator
147 *    f = flip(f);
148 *
149 *    ...
150 *
151 *    // erase indicator
152 *    wipe(f);
153 */
154static unsigned flip(unsigned x)
155{
156static char bar[]= { '/', '-', '\\', '|' };
157        putchar('\b');
158        putchar(bar[ x & 3]);
159        fflush(stdout);
160        return x+1;
161}
162
163/* If f!=0 then erase one char on stdout.
164 * ( If 'flip' was never called then f should still
165 * be zero and no action is taken).
166 */
167static void wipe(unsigned f)
168{
169        if ( f ) {
170                putchar('\b');
171                putchar(' ');
172                putchar('\b');
173                fflush(stdout);
174        }
175}
176
177/* lookup vendor ID in table of known vendors using ops
178 * associated with the vendor.
179 */
180STATIC struct vendesc *
181knownVendor(struct bankdesc *b, uint32_t addr, uint32_t *pd, unsigned quiet)
182{
183uint32_t        v;
184struct vendesc *rval;
185
186        for ( rval=b->knownVendors; rval->name; rval++ ) {
187
188                if ( rval->ops->get_id(b, addr, &v, pd) ) {
189                        if ( quiet < 2 )
190                                fprintf(stderr,"Unable to read vendor/device info at 0x%08"PRIx32"\n", addr);
191                        return 0;
192                }
193
194                if ( rval->id == v ) {
195                        return rval;
196                }
197        }
198        if ( quiet < 2 )
199                fprintf(stderr,"Unknown vendor id (0x%04"PRIx32") at 0x%08"PRIx32"\n",v, addr);
200        return 0;
201}
202
203/* lookup device ID in table of known devices */
204STATIC struct devdesc *
205knownDevice(struct vendesc *v, uint32_t d)
206{
207struct devdesc *rval;
208        for ( rval=v->known_devs; rval->name; rval++ ) {
209                if ( rval->id == d ) {
210                        return rval;
211                }
212        }
213        return 0;
214}
215
216/* Write 'n_words' (32-bit) from 'src' to 'addr'ess on flash.
217 * (src is a char* to emphasize that no src-alignment is required)
218 *
219 * RETURNS: 0 on success, (destination) address of failure on error.
220 *
221 *   NOTES: - device switched back to array mode on exit.
222 *          - 'addr' must be 32-bit aligned.
223 */
224
225STATIC uint32_t
226BSP_flashWriteDataRaw(struct bankdesc *b, uint32_t addr, const char *src, uint32_t n_words, int quiet)
227{
228uint32_t   sta;
229uint32_t   N;
230uint32_t   nxt, a, i, bufsz;
231uint32_t   then, now;
232unsigned   f;
233const char *s;
234
235#ifdef DEBUG
236        printf("\nflashWriteDataRaw(0x%08"PRIx32", %p, 0x%"PRIx32")\n", addr, src, n_words);
237#endif
238
239        if ( 0 == n_words ) {
240                return 0;
241        }
242
243        if ( !b ) {
244                fprintf(stderr,"Missing bank descriptor argument\n");
245                return -1;
246        }
247        if ( !b->dd ) {
248                fprintf(stderr,"Bank descriptor not initialized\n");
249                return -1;
250        }
251
252        if ( addr & (FLASH_STRIDE(b)-1) ) {
253                fprintf(stderr,"Misaligned address (not on word boundary) 0x%08"PRIx32"\n", addr);
254                return -1;
255        }
256
257        if ( (sta = b->ops->check_ready(b, addr)) ) {
258                /* Error msgs have already been printed */
259                return addr;
260        }
261
262        bufsz = FLASH_NDEVS(b) * b->dd->bufsz;
263
264        then = BSP_flashBspOps.read_us_timer();
265
266        for ( f = 0, a = addr, s=src, i = n_words; i ; s+=N ) {
267                /* start of next buffer */
268                nxt = (a + bufsz) & ~(bufsz-1);
269
270                /* number of bytes */
271                N = (nxt - a);
272
273                if ( N > i * FLASH_STRIDE(b) )
274                        N = i * FLASH_STRIDE(b);
275
276                i -= N/FLASH_STRIDE(b);
277
278                if ( (sta = b->ops->write_line(b, a, s, N)) )
279                        goto bail;
280
281                if ( ! quiet && (now = BSP_flashBspOps.read_us_timer()) - then > 500000 ) {
282                        f = flip(f);
283                        then = now;
284                }
285
286                a = nxt;
287        }
288
289        sta = 0;
290
291        /* verify */
292        for ( i=0, a=addr; i < n_words * FLASH_STRIDE(b); i++, a++ ) {
293                if ( *(char*)a != src[i] ) {
294                        sta = -2;
295                        goto bail;
296                }
297        }
298
299bail:
300        if ( ! quiet ) {
301                wipe(f);
302        }
303        if ( sta ) {
304                switch ( sta ) {
305                        default:
306                                fprintf(stderr,"Error (flashWriteDataRaw): write error\n");
307                                b->ops->print_stat(b, sta,0);
308                        break;
309
310                        case -1:
311                                fprintf(stderr,"Error (flashWriteDataRaw): Timeout\n");
312                        break;
313
314                        case -2:
315                                fprintf(stderr,"Error (flashWriteDataRaw): write verification failed at 0x%08"PRIx32"\n", a);
316                        break;
317                }
318                b->ops->array_mode(b, a);
319        } else {
320                /* no errors */
321                a = 0;
322        }
323        return a;
324}
325
326
327/* Query device for basic information verifying that we talk
328 * to a 'known'/'supported' device.
329 *
330 * This is not really clean since (until we implement CFI)
331 * we already need to know what kind of device it is to
332 * be able to read its ID...
333 *
334 *   NOTES: - device switched back to array mode on exit.
335 *          - 'addr' must be 32-bit aligned.
336 */
337
338STATIC struct devdesc *
339BSP_flashCheckId(struct bankdesc *b, uint32_t addr, unsigned quiet)
340{
341uint8_t  x;
342uint32_t d;
343struct vendesc  *vd;
344struct devdesc  *dd;
345
346        /* check if it's flash at all: */
347        x = *(A8)addr;
348        *(A8)addr = ~x;
349        if ( x != *(A8)addr ) {
350                /* restore */
351                *(A8)addr = x;
352                if ( quiet < 3 )
353                        fprintf(stderr,"Addr 0x%08"PRIx32" seems to be RAM!\n", addr);
354                return 0;
355        }
356
357        if ( !(vd = knownVendor(b, addr, &d, quiet)) ) {
358                return 0;
359        }
360
361        /* Use the vendor ops for this bank */
362        b->ops    = vd->ops;
363
364        if ( !quiet )
365                printf("Flash device, vendor: %s", vd->name);
366
367        if ( !(dd = knownDevice(vd, d)) ) {
368                if ( !quiet )
369                        printf("\n");
370                if ( quiet < 2 )
371                        fprintf(stderr,"Unknown device id (0x%04"PRIx32") at 0x%08"PRIx32"\n",d, addr);
372                return 0;
373        }
374
375        /* logical sector size is device sector size
376         * multiplied by # of devices in parallel
377         */
378        b->fblksz = dd->fblksz * FLASH_NDEVS(b);
379
380        if ( !quiet )
381                printf(", device: %s -- size 0x%08"PRIx32" bytes\n", dd->name, dd->size);
382        return dd;
383}
384
385/* We don't have device info yet so just
386 * use 64k alignment
387 */
388#define SCAN_BACK_OFFSET        0x10000
389
390/* Scan address range for flash devices and compute total size
391 * of bank.
392 *
393 * RETURNS: size in bytes.
394 */
395STATIC uint32_t
396BSP_flashProbeSize(struct bankdesc *b)
397{
398int             max = b->max_size;
399uint32_t                rval;
400struct devdesc  *dd;
401unsigned                q;
402        if ( max > 0 ) {
403                for ( rval = 0, q=1; rval < max && (dd = BSP_flashCheckId(b, b->start + rval, q)); q=3 ) {
404                        rval += dd->size * FLASH_NDEVS(b);
405                }
406        } else {
407                /* bank is populated from the top; scan backwards */
408                max = -max;
409                for ( rval = 0, q=1; rval < max && (dd = BSP_flashCheckId(b, b->start + max - SCAN_BACK_OFFSET - rval, q)); q=3 ) {
410                        rval += dd->size * FLASH_NDEVS(b);
411                }
412                b->start += max - rval;
413        }
414        return rval;
415}
416
417uint32_t
418BSP_flashStart(int bank)
419{
420struct bankdesc *b;
421        if ( ! ( b = argcheck(bank, 0, 0, 0) ) )
422                return -1;
423        return b->start;
424}
425
426uint32_t
427BSP_flashSize(int bank)
428{
429struct bankdesc *b;
430        if ( ! ( b = argcheck(bank, 0, 0, 0) ) )
431                return -1;
432        return b->size;
433}
434
435uint32_t
436BSP_flashBlockSize(int bank)
437{
438struct bankdesc *b;
439        if ( ! ( b = argcheck(bank, 0, 0, 0) ) )
440                return -1;
441        return b->fblksz;
442}
443
444
445#ifndef TESTING
446
447/* Obtain bank description making sure it is initialized and not write protected */
448STATIC struct bankdesc *
449bankValidate(int bank, int quiet)
450{
451struct bankdesc *b = BSP_flashBspOps.bankcheck(bank, quiet);
452
453        /* If flash is write-protected then we can't even talk to it... */
454        if ( BSP_flashBspOps.flash_wp(bank, -1) ) {
455                fprintf(stderr,"Flash bank #%i is write-protected; use 'BSP_flashWriteEnable(int bank)' and/or jumper\n", bank);
456                return 0;
457        }
458
459        if ( !b->size && !(b->size = BSP_flashProbeSize(b)) ) {
460                fprintf(stderr,"Configuration Error - unable to determine flash size\n");
461                return 0;
462        }
463
464        if ( !b->dd && !(b->dd = BSP_flashCheckId(b, b->start,1)) ) {
465                fprintf(stderr,"Error: unable to detect flash device in bank #%i\n", bank);
466                return 0;
467        }
468        return b;
469}
470
471/* Validate arguments and write-protection status of 'bank'.
472 *
473 *    'bank': 0..max bank supported by board.
474 *  'offset': 0..bank size - 1
475 *     'src': src .. src + size - 1 must not overlap bank; 'src' may be NULL
476 *            (check is skipped in this case)
477 *
478 *      RETURNS: pointer to bank description on success, NULL on error (invalid args;
479 *               error message is printed to stderr).
480 *
481 * SIDE EFFECTS: probes for bank size and stores result in bank description table.
482 */
483
484static struct bankdesc *
485argcheck(int bank, uint32_t offset, const char *src, uint32_t size)
486{
487struct bankdesc *b;
488
489        if ( !(b=bankValidate(bank, 0)) ) {
490                return 0;
491        }
492
493        if ( offset + size > b->size ) {
494                fprintf(stderr,"Error: requested size exceeds available flash (0x%08"PRIx32" bytes)\n", b->size);
495                return 0;
496        }
497
498        if ( src && ( src + size > (char*)b->start && src < (char*)(b->start + b->size) ) ) {
499                fprintf(stderr,"Error: cannot copy data within flash bank\n");
500                return 0;
501        }
502
503
504        return b;
505}
506
507/* Calculate region that needs to be erased from 'offset' and 'n_bytes'
508 * handling alignment and checking for blank areas that need not be
509 * erased.
510 * Ask for user confirmation and erase calculated region.
511 *
512 * RETURNS: 0 on success, -1 or destination address on error.
513 *
514 *   NOTES: - device switched back to array mode on exit.
515 *          - prints progress/messages.
516 */
517STATIC int
518regionCheckAndErase(int bank, uint32_t offset, const char *src, uint32_t n_bytes, int quiet)
519{
520struct bankdesc *b;
521uint32_t         i;
522char            *p;
523uint32_t                a,e;
524
525        if ( ! (b = argcheck(bank, offset, src, n_bytes)) )
526                return -1;
527
528        a = offset & ~(b->fblksz - 1);
529        e = (offset + n_bytes +  b->fblksz - 1) & ~ (b->fblksz - 1);
530
531        /* If 'offset' is not block-aligned then rest of the block must
532         * be free.
533         */
534        if ( a != offset ) {
535                a += b->fblksz;
536                i  = ( a > offset + n_bytes ) ? offset + n_bytes : a;
537                for ( p = (char*)(b->start + offset); p < (char*)(b->start + i); p++ ) {
538                        if ( (char)0xff != *p ) {
539                                if ( ! quiet ) {
540                                        fprintf(stderr,"Starting offset not block-aligned and destination area not empty.\n");
541                                        fprintf(stderr,"I'll need to erase data below destination start\n");
542                                }
543                                a -= b->fblksz;
544                                break;
545                        }
546                }
547        }
548        if ( e != offset + n_bytes ) {
549                e -= b->fblksz;
550                i  = ( e < offset ) ? offset : e;
551                for ( p = (char*)(b->start + i); p < (char*)(b->start + offset + n_bytes); p++ ) {
552                        if ( (char)0xff != *p ) {
553                                if ( ! quiet ) {
554                                        fprintf(stderr,"Ending offset not block-aligned and destination area not empty.\n");
555                                        fprintf(stderr,"I'll need to erase data beyond destination end\n");
556                                }
557                                e += b->fblksz;
558                                break;
559                        }
560                }
561        }
562        if ( ! quiet ) {
563                if ( e > a )
564                        printf("ERASING 0x%08"PRIx32" .. 0x%08"PRIx32"\n", (b->start+a), (b->start + e - 1));
565                printf("WRITING 0x%08"PRIx32" .. 0x%08"PRIx32"\n", (b->start+offset), (b->start + offset + n_bytes - 1));
566                printf("OK to proceed y/[n]?"); fflush(stdout);
567                if ( 'Y' != getUc() ) {
568                        printf("ABORTED\n");
569                        return -1;
570                }
571        }
572        if ( e > a ) {
573                if ( quiet < 2 ) {
574                        printf("ERASING  "); fflush(stdout);
575                }
576
577                if ( (i = BSP_flashErase(bank, a, e-a, quiet ? quiet : 1)) )
578                        return i;
579
580                if ( quiet < 2 ) {
581                        printf("DONE\n");
582                }
583        }
584
585        return 0;
586}
587
588/* Write to a flash region ('offset'..'offset'+'n_bytes'-1 on 'bank').
589 *
590 * RETURNS: 0 on success, -1 or destination address on error.
591 *
592 *   NOTES: - device switched back to array mode on exit.
593 *          - no erase operation is performed.
594 *          - written data is verified against source.
595 */
596
597STATIC int
598BSP_flashWriteRegion(int bank, uint32_t offset, const char *src, uint32_t n_bytes, int quiet)
599{
600struct bankdesc *b = BSP_flashBspOps.bankcheck(bank, 0);        /* caller did bankValidate() */
601uint32_t     ab = offset & ~(b->fblksz - 1);
602uint32_t     eb = (offset + n_bytes + b->fblksz - 1) & ~(b->fblksz - 1);
603uint32_t     o,i,a,e;
604int          err;
605const char   *p;
606union bconv  buf;
607
608        /* unlock */
609        for ( i=ab; i<eb; i+=b->fblksz ) {
610                b->ops->unlock_block(b, b->start + i );
611        }
612
613        err = 0;
614        p = src;
615
616        /* handle misaligned offset merging old contents */
617        o = b->start + offset;
618        a = o & ~(FLASH_STRIDE(b)-1);
619        e = (o + n_bytes) & ~(FLASH_STRIDE(b)-1);
620
621        if ( o > a ) {
622                i = o - a;
623
624                rd_par(b, &buf, a);
625
626                while ( i < FLASH_STRIDE(b) && p < src + n_bytes ) {
627                        buf.c[i++] = *p++;
628                }
629                if ( (err = BSP_flashWriteDataRaw(b, a, buf.c, 1, quiet)) )
630                        goto bail;
631                a += FLASH_STRIDE(b);
632        }
633
634
635        /* caution if misaligned data covering only one or two words */
636
637        if ( e > a ) {
638                i = (e-a);
639                if ( (err = BSP_flashWriteDataRaw(b, a, p, i/FLASH_STRIDE(b), quiet)) )
640                        goto bail;
641                p += i;
642        }
643
644        /* handle misaligned end */
645        if ( o + n_bytes > e)  {
646                rd_par(b, &buf, e);
647                for ( i=0; p < src + n_bytes; ) {
648                        buf.c[i++] = *p++;
649                }
650                if ( (err = BSP_flashWriteDataRaw(b, e, buf.c, 1, quiet)) )
651                        goto bail;
652        }
653
654bail:
655        /* lock area */
656        for ( i=ab; i<eb; i+=b->fblksz ) {
657                b->ops->lock_block(b, b->start + i );
658        }
659
660        /* final verification */
661        if ( !err ) {
662                for ( i=0; i<n_bytes; i++ ) {
663                        if ( ((char*)(b->start + offset))[i] != src[i] ) {
664                                fprintf(stderr,"Final verification failed at offset 0x%08"PRIx32"\n", (offset + i));
665                                return b->start + offset + i;
666                        }
667                }
668        }
669
670        return err;
671}
672
673int
674BSP_flashErase(int bank, uint32_t offset, uint32_t size, int quiet)
675{
676struct bankdesc *b;
677uint32_t                 a,i;
678int              f;
679
680        if ( ! (b = argcheck(bank, offset, 0, size)) )
681                return -1;
682
683        if ( offset & (b->fblksz - 1) ) {
684                fprintf(stderr,"Offset misaligned (needs to be multiple of 0x%08"PRIx32")\n", b->fblksz);
685                return -1;
686        }
687        if ( size & (b->fblksz - 1) ) {
688                fprintf(stderr,"Size misaligned (needs to be multiple of 0x%08"PRIx32")\n", b->fblksz);
689                return -1;
690        }
691
692        a = b->start + offset;
693
694        if ( !quiet ) {
695                printf("ERASING Flash (Bank #%i)\n    from 0x%08"PRIx32" .. 0x%08"PRIx32"\nproceed y/[n]?",
696                        bank, a, (a+size-1));
697                fflush(stdout);
698                if ( 'Y' != getUc() ) {
699                        printf("ABORTED\n");
700                        return -1;
701                }
702        }
703        f = 0;
704        while ( size ) {
705                /* work to do ? */
706                for ( i = 0; i<b->fblksz; i++ ) {
707                        if ( (char)0xff != ((char*)a)[i] ) {
708                                b->ops->unlock_block(b, a);
709                                i = b->ops->erase_block(b, a);
710                                b->ops->lock_block(b, a);
711                                if (i) {
712                                        wipe(f);
713                                        return a;
714                                }
715                                break;
716                        }
717                }
718
719                if ( quiet < 2 ) {
720                        f = flip(f);
721                }
722
723                a    += b->fblksz;
724                size -= b->fblksz;
725        }
726        b->ops->array_mode(b, a);
727        if ( quiet < 2 ) {
728                wipe(f);
729        }
730        return 0;
731}
732
733int
734BSP_flashWrite(int bank, uint32_t offset, const char *src, uint32_t n_bytes, int quiet)
735{
736int      rval;
737
738        if ( !src ) {
739                fprintf(stderr,"Error: Data source pointer is NULL\n");
740                return -1;
741        }
742
743        if ( (rval = regionCheckAndErase(bank, offset, src, n_bytes, quiet)) )
744                return rval;
745
746        if ( ! quiet ) {
747                printf("WRITING  "); fflush(stdout);
748        }
749
750        rval = BSP_flashWriteRegion(bank, offset, src, n_bytes, quiet);
751
752        if ( !quiet && !rval ) {
753                printf("DONE");
754        }
755        if ( !quiet )
756                printf("\n");
757        return rval;
758}
759
760static int
761bfill(int fd, char *buf, int size)
762{
763int got, avail;
764        for (avail = size; (got = read(fd, buf, avail)) > 0; avail-=got ) {
765                buf  += got;
766        }
767        return size - avail;
768}
769
770int
771BSP_flashWriteFile(int bank, uint32_t offset, const char *fname, int quiet)
772{
773int             fd   = -1;
774struct stat     sb;
775uint32_t            sz;
776int                         rval = -1;
777char               *buf  = 0;
778uint32_t            got;
779struct bankdesc *b;
780unsigned        f    = 0;
781
782        if ( ! (b = bankValidate(bank, 0)) )
783                return -1;
784
785        for ( sz = 0; -1 == fd ;  ) {
786                if ( (fd = open(fname,O_RDONLY)) < 0 ) {
787                        perror("Opening file");
788                        return -1;
789                }
790
791                if ( sz )
792                        break;
793
794                if ( fstat(fd, &sb) ) {
795                        fprintf(stderr,"Warning: fstat doesn't work; need to slurp file to determine size; please be patient.\n");
796                        FILE *f;
797                        close(fd); fd = -1;
798                        f = fopen(fname,"r");
799                        if ( !f ) {
800                                perror("fdopen");
801                                return -1;
802                        }
803                        while ( EOF != fgetc(f) )
804                                sz++;
805                        fclose(f);
806                        /* reopen */
807                } else {
808                        sz = sb.st_size;
809                }
810                if ( 0 == sz ) {
811                        fprintf(stderr,"Error: zero file size (?)\n");
812                        goto bail;
813                }
814        }
815
816        if ( !(buf = malloc(b->fblksz)) ) {
817                perror("buffer allocation");
818                goto bail;
819        }
820
821        /* See if we can erase the entire region */
822        if ( (rval = regionCheckAndErase(bank, offset, buf, sz, quiet)) )
823                goto bail;
824
825        /* Proceed copying chunks */
826        if ( quiet < 2 ) {
827                printf("WRITING  "); fflush(stdout);
828        }
829
830        while ( (got = bfill(fd, buf, b->fblksz)) > 0 && sz ) {
831                if ( (rval = BSP_flashWriteRegion(bank, offset, buf, got, 1)) ) {
832                        wipe(f);
833                        goto bail;
834                }
835                offset += got;
836                sz     -= got;
837                if ( quiet < 2 ) {
838                        f = flip(f);
839                }
840        }
841        if ( got < 0 ) {
842                perror("reading file");
843                rval = offset;
844                goto bail;
845        }
846
847        if ( quiet < 2 ) {
848                wipe(f);
849                printf("DONE");
850        }
851bail:
852        if ( quiet < 2 ) {
853                printf("\n");
854        }
855        if ( fd > -1 )
856                close(fd);
857        free(buf);
858        return rval;
859}
860
861int
862BSP_flashWriteEnable(int bank)
863{
864        return BSP_flashBspOps.flash_wp(bank,0);
865}
866
867int
868BSP_flashWriteDisable(int bank)
869{
870        return BSP_flashBspOps.flash_wp(bank,1);
871}
872
873int
874BSP_flashDumpInfo(FILE *f)
875{
876struct bankdesc *b;
877int                     bank;
878
879        if ( !f )
880                f = stdout;
881
882        /* use 'bankValidate()' with 'quiet' flag to suppress error message when
883         * we reach the end of the table.
884         */
885        for ( bank = 0; BSP_flashBspOps.bankcheck(bank,1); bank++ ) {
886                if ( (b=argcheck(bank,0,0,0)) ) {
887                        fprintf(f,"Flash Bank #%i; 0x%08"PRIx32" .. 0x%08"PRIx32" (%"PRId32" bytes)\n",
888                                bank, b->start, (b->start + b->size - 1), b->size);
889                        fprintf(f,"%i * %i-bit devices in parallel; block size 0x%"PRIx32"\n", FLASH_NDEVS(b), FLASH_WIDTH(b)*8, b->fblksz);
890                        BSP_flashCheckId(b, b->start, 0);
891                }
892        }
893
894        return 0;
895}
896
897#else
898
899int
900main(int argc, char **argv)
901{
902uint32_t fla[1000];
903uint32_t qqq[1000];
904int i;
905        for ( i=0; i<sizeof(qqq)/sizeof(qqq[0]); i++ )
906                qqq[i] = 0xdada<<16 | i;
907        BSP_flashWriteDataRaw(0, (uint32_t)fla, (char*)qqq, 32, 0);
908}
909#endif
Note: See TracBrowser for help on using the repository browser.