]>
Commit | Line | Data |
---|---|---|
3f85ce27 WD |
1 | /* |
2 | * Copyright (c) 2004 Picture Elements, Inc. | |
3 | * Stephen Williams (XXXXXXXXXXXXXXXX) | |
4 | * | |
1a459660 | 5 | * SPDX-License-Identifier: GPL-2.0+ |
3f85ce27 | 6 | */ |
3f85ce27 WD |
7 | |
8 | /* | |
9 | * The Xilinx SystemACE chip support is activated by defining | |
6d0f6bcf | 10 | * CONFIG_SYSTEMACE to turn on support, and CONFIG_SYS_SYSTEMACE_BASE |
3f85ce27 WD |
11 | * to set the base address of the device. This code currently |
12 | * assumes that the chip is connected via a byte-wide bus. | |
13 | * | |
14 | * The CONFIG_SYSTEMACE also adds to fat support the device class | |
15 | * "ace" that allows the user to execute "fatls ace 0" and the | |
16 | * like. This works by making the systemace_get_dev function | |
17 | * available to cmd_fat.c:get_dev and filling in a block device | |
18 | * description that has all the bits needed for FAT support to | |
19 | * read sectors. | |
8f79e4c2 | 20 | * |
fe599e17 WD |
21 | * According to Xilinx technical support, before accessing the |
22 | * SystemACE CF you need to set the following control bits: | |
984618f3 GL |
23 | * FORCECFGMODE : 1 |
24 | * CFGMODE : 0 | |
25 | * CFGSTART : 0 | |
3f85ce27 WD |
26 | */ |
27 | ||
984618f3 GL |
28 | #include <common.h> |
29 | #include <command.h> | |
30 | #include <systemace.h> | |
31 | #include <part.h> | |
32 | #include <asm/io.h> | |
3f85ce27 | 33 | |
3f85ce27 WD |
34 | /* |
35 | * The ace_readw and writew functions read/write 16bit words, but the | |
36 | * offset value is the BYTE offset as most used in the Xilinx | |
6d0f6bcf | 37 | * datasheet for the SystemACE chip. The CONFIG_SYS_SYSTEMACE_BASE is defined |
3f85ce27 WD |
38 | * to be the base address for the chip, usually in the local |
39 | * peripheral bus. | |
40 | */ | |
5340a7f1 MS |
41 | |
42 | static u32 base = CONFIG_SYS_SYSTEMACE_BASE; | |
43 | static u32 width = CONFIG_SYS_SYSTEMACE_WIDTH; | |
44 | ||
45 | static void ace_writew(u16 val, unsigned off) | |
46 | { | |
47 | if (width == 8) { | |
a5bbcc3c | 48 | #if !defined(__BIG_ENDIAN) |
5340a7f1 MS |
49 | writeb(val >> 8, base + off); |
50 | writeb(val, base + off + 1); | |
a5bbcc3c | 51 | #else |
5340a7f1 MS |
52 | writeb(val, base + off); |
53 | writeb(val >> 8, base + off + 1); | |
a5bbcc3c | 54 | #endif |
7cde9f35 AB |
55 | } else |
56 | out16(base + off, val); | |
5340a7f1 MS |
57 | } |
58 | ||
59 | static u16 ace_readw(unsigned off) | |
60 | { | |
61 | if (width == 8) { | |
62 | #if !defined(__BIG_ENDIAN) | |
63 | return (readb(base + off) << 8) | readb(base + off + 1); | |
a5bbcc3c | 64 | #else |
5340a7f1 | 65 | return readb(base + off) | (readb(base + off + 1) << 8); |
a5bbcc3c | 66 | #endif |
5340a7f1 | 67 | } |
3f85ce27 | 68 | |
5340a7f1 MS |
69 | return in16(base + off); |
70 | } | |
3f85ce27 | 71 | |
984618f3 | 72 | static unsigned long systemace_read(int dev, unsigned long start, |
ac1048ae | 73 | lbaint_t blkcnt, void *buffer); |
3f85ce27 | 74 | |
984618f3 | 75 | static block_dev_desc_t systemace_dev = { 0 }; |
3f85ce27 WD |
76 | |
77 | static int get_cf_lock(void) | |
78 | { | |
984618f3 | 79 | int retry = 10; |
3f85ce27 WD |
80 | |
81 | /* CONTROLREG = LOCKREG */ | |
984618f3 GL |
82 | unsigned val = ace_readw(0x18); |
83 | val |= 0x0002; | |
84 | ace_writew((val & 0xffff), 0x18); | |
3f85ce27 WD |
85 | |
86 | /* Wait for MPULOCK in STATUSREG[15:0] */ | |
984618f3 | 87 | while (!(ace_readw(0x04) & 0x0002)) { |
3f85ce27 | 88 | |
984618f3 GL |
89 | if (retry < 0) |
90 | return -1; | |
3f85ce27 | 91 | |
984618f3 GL |
92 | udelay(100000); |
93 | retry -= 1; | |
94 | } | |
3f85ce27 | 95 | |
984618f3 | 96 | return 0; |
3f85ce27 WD |
97 | } |
98 | ||
99 | static void release_cf_lock(void) | |
100 | { | |
984618f3 GL |
101 | unsigned val = ace_readw(0x18); |
102 | val &= ~(0x0002); | |
103 | ace_writew((val & 0xffff), 0x18); | |
3f85ce27 WD |
104 | } |
105 | ||
df3fc526 | 106 | #ifdef CONFIG_PARTITIONS |
984618f3 | 107 | block_dev_desc_t *systemace_get_dev(int dev) |
3f85ce27 WD |
108 | { |
109 | /* The first time through this, the systemace_dev object is | |
110 | not yet initialized. In that case, fill it in. */ | |
984618f3 GL |
111 | if (systemace_dev.blksz == 0) { |
112 | systemace_dev.if_type = IF_TYPE_UNKNOWN; | |
113 | systemace_dev.dev = 0; | |
114 | systemace_dev.part_type = PART_TYPE_UNKNOWN; | |
115 | systemace_dev.type = DEV_TYPE_HARDDISK; | |
116 | systemace_dev.blksz = 512; | |
0472fbfd | 117 | systemace_dev.log2blksz = LOG2(systemace_dev.blksz); |
984618f3 GL |
118 | systemace_dev.removable = 1; |
119 | systemace_dev.block_read = systemace_read; | |
fe599e17 | 120 | |
d93e2212 | 121 | /* |
8274ec0b | 122 | * Ensure the correct bus mode (8/16 bits) gets enabled |
d93e2212 | 123 | */ |
5340a7f1 | 124 | ace_writew(width == 8 ? 0 : 0x0001, 0); |
d93e2212 | 125 | |
984618f3 | 126 | init_part(&systemace_dev); |
fe599e17 | 127 | |
984618f3 | 128 | } |
3f85ce27 | 129 | |
984618f3 | 130 | return &systemace_dev; |
3f85ce27 | 131 | } |
df3fc526 | 132 | #endif |
3f85ce27 WD |
133 | |
134 | /* | |
135 | * This function is called (by dereferencing the block_read pointer in | |
136 | * the dev_desc) to read blocks of data. The return value is the | |
137 | * number of blocks read. A zero return indicates an error. | |
138 | */ | |
984618f3 | 139 | static unsigned long systemace_read(int dev, unsigned long start, |
ac1048ae | 140 | lbaint_t blkcnt, void *buffer) |
3f85ce27 | 141 | { |
984618f3 GL |
142 | int retry; |
143 | unsigned blk_countdown; | |
eb867a76 | 144 | unsigned char *dp = buffer; |
984618f3 GL |
145 | unsigned val; |
146 | ||
147 | if (get_cf_lock() < 0) { | |
148 | unsigned status = ace_readw(0x04); | |
149 | ||
150 | /* If CFDETECT is false, card is missing. */ | |
151 | if (!(status & 0x0010)) { | |
152 | printf("** CompactFlash card not present. **\n"); | |
153 | return 0; | |
154 | } | |
155 | ||
156 | printf("**** ACE locked away from me (STATUSREG=%04x)\n", | |
157 | status); | |
158 | return 0; | |
159 | } | |
e7c85689 | 160 | #ifdef DEBUG_SYSTEMACE |
984618f3 | 161 | printf("... systemace read %lu sectors at %lu\n", blkcnt, start); |
e7c85689 WD |
162 | #endif |
163 | ||
984618f3 GL |
164 | retry = 2000; |
165 | for (;;) { | |
166 | val = ace_readw(0x04); | |
3f85ce27 | 167 | |
984618f3 GL |
168 | /* If CFDETECT is false, card is missing. */ |
169 | if (!(val & 0x0010)) { | |
170 | printf("**** ACE CompactFlash not found.\n"); | |
171 | release_cf_lock(); | |
172 | return 0; | |
173 | } | |
3f85ce27 | 174 | |
984618f3 GL |
175 | /* If RDYFORCMD, then we are ready to go. */ |
176 | if (val & 0x0100) | |
177 | break; | |
3f85ce27 | 178 | |
984618f3 GL |
179 | if (retry < 0) { |
180 | printf("**** SystemACE not ready.\n"); | |
181 | release_cf_lock(); | |
182 | return 0; | |
183 | } | |
3f85ce27 | 184 | |
984618f3 GL |
185 | udelay(1000); |
186 | retry -= 1; | |
187 | } | |
3f85ce27 | 188 | |
e7c85689 WD |
189 | /* The SystemACE can only transfer 256 sectors at a time, so |
190 | limit the current chunk of sectors. The blk_countdown | |
191 | variable is the number of sectors left to transfer. */ | |
3f85ce27 | 192 | |
984618f3 GL |
193 | blk_countdown = blkcnt; |
194 | while (blk_countdown > 0) { | |
195 | unsigned trans = blk_countdown; | |
3f85ce27 | 196 | |
984618f3 GL |
197 | if (trans > 256) |
198 | trans = 256; | |
3f85ce27 | 199 | |
e7c85689 | 200 | #ifdef DEBUG_SYSTEMACE |
984618f3 | 201 | printf("... transfer %lu sector in a chunk\n", trans); |
e7c85689 | 202 | #endif |
984618f3 GL |
203 | /* Write LBA block address */ |
204 | ace_writew((start >> 0) & 0xffff, 0x10); | |
d93e2212 | 205 | ace_writew((start >> 16) & 0x0fff, 0x12); |
984618f3 GL |
206 | |
207 | /* NOTE: in the Write Sector count below, a count of 0 | |
208 | causes a transfer of 256, so &0xff gives the right | |
209 | value for whatever transfer count we want. */ | |
210 | ||
211 | /* Write sector count | ReadMemCardData. */ | |
212 | ace_writew((trans & 0xff) | 0x0300, 0x14); | |
213 | ||
d62f64cc | 214 | /* |
32556443 MS |
215 | * For FPGA configuration via SystemACE is reset unacceptable |
216 | * CFGDONE bit in STATUSREG is not set to 1. | |
217 | */ | |
218 | #ifndef SYSTEMACE_CONFIG_FPGA | |
984618f3 GL |
219 | /* Reset the configruation controller */ |
220 | val = ace_readw(0x18); | |
221 | val |= 0x0080; | |
222 | ace_writew(val, 0x18); | |
32556443 | 223 | #endif |
984618f3 GL |
224 | |
225 | retry = trans * 16; | |
226 | while (retry > 0) { | |
227 | int idx; | |
228 | ||
229 | /* Wait for buffer to become ready. */ | |
230 | while (!(ace_readw(0x04) & 0x0020)) { | |
231 | udelay(100); | |
232 | } | |
233 | ||
234 | /* Read 16 words of 2bytes from the sector buffer. */ | |
235 | for (idx = 0; idx < 16; idx += 1) { | |
236 | unsigned short val = ace_readw(0x40); | |
237 | *dp++ = val & 0xff; | |
238 | *dp++ = (val >> 8) & 0xff; | |
239 | } | |
240 | ||
241 | retry -= 1; | |
242 | } | |
243 | ||
244 | /* Clear the configruation controller reset */ | |
245 | val = ace_readw(0x18); | |
246 | val &= ~0x0080; | |
247 | ace_writew(val, 0x18); | |
248 | ||
249 | /* Count the blocks we transfer this time. */ | |
250 | start += trans; | |
251 | blk_countdown -= trans; | |
252 | } | |
253 | ||
254 | release_cf_lock(); | |
255 | ||
256 | return blkcnt; | |
3f85ce27 | 257 | } |