← Back to branch summary

~ubuntu-branches/ubuntu/maverick/u-boot-omap3/maverick

« back to all changes in this revision

Viewing changes to board/esd/ocrtc/flash.c

  • Committer: Bazaar Package Importer
  • Author(s): Oliver Grawert
  • Date: 2010-03-22 15:06:23 UTC
  • Revision ID: james.westby@ubuntu.com-20100322150623-i21g8rgiyl5dohag
Tags: upstream-2010.3git20100315
Import upstream version 2010.3git20100315

Show diffs side-by-side

added added

removed removed

Lines of Context:
board/esd/ocrtc/flash.c
 
1
/*
 
2
 * (C) Copyright 2001
 
3
 * Stefan Roese, esd gmbh germany, stefan.roese@esd-electronics.com
 
4
 *
 
5
 * See file CREDITS for list of people who contributed to this
 
6
 * project.
 
7
 *
 
8
 * This program is free software; you can redistribute it and/or
 
9
 * modify it under the terms of the GNU General Public License as
 
10
 * published by the Free Software Foundation; either version 2 of
 
11
 * the License, or (at your option) any later version.
 
12
 *
 
13
 * This program is distributed in the hope that it will be useful,
 
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
16
 * GNU General Public License for more details.
 
17
 *
 
18
 * You should have received a copy of the GNU General Public License
 
19
 * along with this program; if not, write to the Free Software
 
20
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 
21
 * MA 02111-1307 USA
 
22
 */
 
23
 
 
24
#include <common.h>
 
25
#include <ppc4xx.h>
 
26
#include <asm/processor.h>
 
27
 
 
28
/*
 
29
 * include common flash code (for esd boards)
 
30
 */
 
31
#include "../common/flash.c"
 
32
 
 
33
/*-----------------------------------------------------------------------
 
34
 * Functions
 
35
 */
 
36
static ulong flash_get_size (vu_long * addr, flash_info_t * info);
 
37
static void flash_get_offsets (ulong base, flash_info_t * info);
 
38
 
 
39
/*-----------------------------------------------------------------------
 
40
 */
 
41
 
 
42
unsigned long flash_init (void)
 
43
{
 
44
        unsigned long size_b0, size_b1;
 
45
        int i;
 
46
        uint pbcr;
 
47
        unsigned long base_b0, base_b1;
 
48
        int size_val = 0;
 
49
 
 
50
        /* Init: no FLASHes known */
 
51
        for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; ++i) {
 
52
                flash_info[i].flash_id = FLASH_UNKNOWN;
 
53
        }
 
54
 
 
55
        /* Static FLASH Bank configuration here - FIXME XXX */
 
56
 
 
57
        base_b0 = FLASH_BASE0_PRELIM;
 
58
        size_b0 = flash_get_size ((vu_long *) base_b0, &flash_info[0]);
 
59
 
 
60
        if (flash_info[0].flash_id == FLASH_UNKNOWN) {
 
61
                printf ("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
 
62
                        size_b0, size_b0 << 20);
 
63
        }
 
64
 
 
65
        base_b1 = FLASH_BASE1_PRELIM;
 
66
        size_b1 = flash_get_size ((vu_long *) base_b1, &flash_info[1]);
 
67
 
 
68
        /* Re-do sizing to get full correct info */
 
69
 
 
70
        if (size_b1) {
 
71
                mtdcr (EBC0_CFGADDR, PB0CR);
 
72
                pbcr = mfdcr (EBC0_CFGDATA);
 
73
                mtdcr (EBC0_CFGADDR, PB0CR);
 
74
                base_b1 = -size_b1;
 
75
                switch (size_b1) {
 
76
                case 1 << 20:
 
77
                        size_val = 0;
 
78
                        break;
 
79
                case 2 << 20:
 
80
                        size_val = 1;
 
81
                        break;
 
82
                case 4 << 20:
 
83
                        size_val = 2;
 
84
                        break;
 
85
                case 8 << 20:
 
86
                        size_val = 3;
 
87
                        break;
 
88
                case 16 << 20:
 
89
                        size_val = 4;
 
90
                        break;
 
91
                }
 
92
                pbcr = (pbcr & 0x0001ffff) | base_b1 | (size_val << 17);
 
93
                mtdcr (EBC0_CFGDATA, pbcr);
 
94
                /*          printf("PB1CR = %x\n", pbcr); */
 
95
        }
 
96
 
 
97
        if (size_b0) {
 
98
                mtdcr (EBC0_CFGADDR, PB1CR);
 
99
                pbcr = mfdcr (EBC0_CFGDATA);
 
100
                mtdcr (EBC0_CFGADDR, PB1CR);
 
101
                base_b0 = base_b1 - size_b0;
 
102
                switch (size_b1) {
 
103
                case 1 << 20:
 
104
                        size_val = 0;
 
105
                        break;
 
106
                case 2 << 20:
 
107
                        size_val = 1;
 
108
                        break;
 
109
                case 4 << 20:
 
110
                        size_val = 2;
 
111
                        break;
 
112
                case 8 << 20:
 
113
                        size_val = 3;
 
114
                        break;
 
115
                case 16 << 20:
 
116
                        size_val = 4;
 
117
                        break;
 
118
                }
 
119
                pbcr = (pbcr & 0x0001ffff) | base_b0 | (size_val << 17);
 
120
                mtdcr (EBC0_CFGDATA, pbcr);
 
121
                /*            printf("PB0CR = %x\n", pbcr); */
 
122
        }
 
123
 
 
124
        size_b0 = flash_get_size ((vu_long *) base_b0, &flash_info[0]);
 
125
 
 
126
        flash_get_offsets (base_b0, &flash_info[0]);
 
127
 
 
128
        /* monitor protection ON by default */
 
129
        flash_protect (FLAG_PROTECT_SET,
 
130
                        base_b0 + size_b0 - monitor_flash_len,
 
131
                        base_b0 + size_b0 - 1, &flash_info[0]);
 
132
 
 
133
        if (size_b1) {
 
134
                /* Re-do sizing to get full correct info */
 
135
                size_b1 = flash_get_size ((vu_long *) base_b1, &flash_info[1]);
 
136
 
 
137
                flash_get_offsets (base_b1, &flash_info[1]);
 
138
 
 
139
                /* monitor protection ON by default */
 
140
                flash_protect (FLAG_PROTECT_SET,
 
141
                                base_b1 + size_b1 - monitor_flash_len,
 
142
                                base_b1 + size_b1 - 1, &flash_info[1]);
 
143
                /* monitor protection OFF by default (one is enough) */
 
144
                flash_protect (FLAG_PROTECT_CLEAR,
 
145
                                base_b0 + size_b0 - monitor_flash_len,
 
146
                                base_b0 + size_b0 - 1, &flash_info[0]);
 
147
        } else {
 
148
                flash_info[1].flash_id = FLASH_UNKNOWN;
 
149
                flash_info[1].sector_count = -1;
 
150
        }
 
151
 
 
152
        flash_info[0].size = size_b0;
 
153
        flash_info[1].size = size_b1;
 
154
 
 
155
        return (size_b0 + size_b1);
 
156
}