TX51 pre-release
[karo-tx-redboot.git] / packages / hal / arm / mx37 / var / v2_0 / src / soc_misc.c
1 //==========================================================================
2 //
3 //              soc_misc.c
4 //
5 //              HAL misc board support code
6 //
7 //==========================================================================
8 //####ECOSGPLCOPYRIGHTBEGIN####
9 // -------------------------------------------
10 // This file is part of eCos, the Embedded Configurable Operating System.
11 // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
12 //
13 // eCos is free software; you can redistribute it and/or modify it under
14 // the terms of the GNU General Public License as published by the Free
15 // Software Foundation; either version 2 or (at your option) any later version.
16 //
17 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY
18 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
20 // for more details.
21 //
22 // You should have received a copy of the GNU General Public License along
23 // with eCos; if not, write to the Free Software Foundation, Inc.,
24 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
25 //
26 // As a special exception, if other files instantiate templates or use macros
27 // or inline functions from this file, or you compile this file and link it
28 // with other works to produce a work based on this file, this file does not
29 // by itself cause the resulting work to be covered by the GNU General Public
30 // License. However the source code for this file must still be made available
31 // in accordance with section (3) of the GNU General Public License.
32 //
33 // This exception does not invalidate any other reasons why a work based on
34 // this file might be covered by the GNU General Public License.
35 //
36 // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
37 // at http://sources.redhat.com/ecos/ecos-license/
38 // -------------------------------------------
39 //####ECOSGPLCOPYRIGHTEND####
40 //========================================================================*/
41
42 #include <redboot.h>
43 #include <pkgconf/hal.h>
44 #include <pkgconf/system.h>
45 #include CYGBLD_HAL_PLATFORM_H
46
47 #include <cyg/infra/cyg_type.h>                 // base types
48 #include <cyg/infra/cyg_trac.h>                 // tracing macros
49 #include <cyg/infra/cyg_ass.h>                  // assertion macros
50
51 #include <cyg/hal/hal_misc.h>                   // Size constants
52 #include <cyg/hal/hal_io.h>                             // IO macros
53 #include <cyg/hal/hal_arch.h>                   // Register state info
54 #include <cyg/hal/hal_diag.h>
55 #include <cyg/hal/hal_intr.h>                   // Interrupt names
56 #include <cyg/hal/hal_cache.h>                  // Cache control
57 #include <cyg/hal/hal_soc.h>                    // Hardware definitions
58 #include <cyg/hal/hal_mm.h>                             // MMap table definitions
59
60 #include <cyg/infra/diag.h>                             // diag_printf
61 #include <cyg/io/imx_nfc.h>
62
63 // Most initialization has already been done before we get here.
64 // All we do here is set up the interrupt environment.
65 // FIXME: some of the stuff in hal_platform_setup could be moved here.
66
67 externC void plf_hardware_init(void);
68 int _mxc_boot, _mxc_fis;
69
70 #define IIM_PROD_REV_SH                 3
71 #define IIM_PROD_REV_LEN                5
72 #define IIM_SREV_REV_SH                 4
73 #define IIM_SREV_REV_LEN                4
74 #define PROD_SIGNATURE_MX37             0x1
75
76 #define PROD_SIGNATURE_SUPPORTED  PROD_SIGNATURE_MX37
77
78 #define CHIP_VERSION_NONE                       0xFFFFFFFF              // invalid product ID
79 #define CHIP_VERSION_UNKNOWN            0xDEADBEEF              // invalid chip rev
80
81 /*
82  * System_rev will have the following format
83  * 31-12 = part # (0x31, 0x32, 0x27, 0x91131, 0x91321, etc)
84  * 11-8 = PMIC ID
85  * 7-4 = major (1.y)
86  * 3-0 = minor (x.0)
87  */
88 unsigned int system_rev = CHIP_REV_1_0;
89 static int find_correct_chip;
90
91 /*
92  * This functions reads the IIM module and returns the system revision number.
93  * It returns the IIM silicon revision reg value if valid product rev is found.
94  . Otherwise, it returns -1.
95  */
96 static int read_system_rev(void)
97 {
98         int val;
99
100         val = readl(IIM_BASE_ADDR + IIM_PREV_OFF);
101
102         system_rev = 0x37 << PART_NUMBER_OFFSET; /* For MX37 Platform*/
103
104         /* Now trying to retrieve the silicon rev from IIM's SREV register */
105         return readl(IIM_BASE_ADDR + IIM_SREV_OFF);
106 }
107
108 extern nfc_setup_func_t *nfc_setup;
109 unsigned int mxc_nfc_soc_setup(unsigned int pg_sz, unsigned int io_sz,
110                                    unsigned int is_mlc, unsigned int num_of_chips);
111 void hal_hardware_init(void)
112 {
113         volatile unsigned int esdmisc = readl(ESDCTL_BASE + 0x10);
114         volatile unsigned int esdctl0 = readl(ESDCTL_BASE);
115         volatile unsigned int sbmr;
116         int bt_mem_type = 0, bt_mem_control = 0;
117         int ver = read_system_rev();
118         unsigned int *fis_addr = (unsigned int *)IRAM_BASE_ADDR;
119
120         switch (*fis_addr) {
121         case FROM_MMC_FLASH:
122                 _mxc_fis = FROM_MMC_FLASH;
123                 break;
124         case FROM_NAND_FLASH:
125                 _mxc_fis = FROM_NAND_FLASH;
126                 break;
127         default:
128                 sbmr = readl(SRC_BASE_ADDR + 0x4);
129                 bt_mem_control = sbmr & 0x3;
130                 bt_mem_type = (sbmr & 0x180) >> 7;
131                 if (bt_mem_control == 0x3) {
132                         if (bt_mem_type == 0) {
133                                 _mxc_fis = FROM_MMC_FLASH;
134                                 _mxc_boot = FROM_MMC_FLASH;
135                         } else if (bt_mem_type == 3) {
136                                 _mxc_fis = FROM_SPI_NOR_FLASH;
137                                 _mxc_boot = FROM_SPI_NOR_FLASH;
138                         }
139                 } else if (bt_mem_control == 0x1) {
140                         _mxc_fis = FROM_NAND_FLASH;
141                         _mxc_boot = FROM_NAND_FLASH;
142                 }
143         }
144
145         find_correct_chip = ver;
146
147         if (ver != CHIP_VERSION_NONE) {
148                 /* Valid product revision found. Check actual silicon rev and
149                  * NOT use the version from the ROM code. */
150                 if (((ver >> 4) & 0xF) == 0x0) {
151                         HAL_PLATFORM_EXTRA[5] = '1';
152                         HAL_PLATFORM_EXTRA[7] = '0';
153                         system_rev |= 1 << MAJOR_NUMBER_OFFSET; /*Major Number*/
154                         system_rev |= 0 << MINOR_NUMBER_OFFSET; /*Minor Number*/
155                 } else if (((ver >> 4) & 0xF) == 0x1) {
156                         HAL_PLATFORM_EXTRA[5] = '1';
157                         HAL_PLATFORM_EXTRA[7] = '1';
158                         system_rev |= 1 << MAJOR_NUMBER_OFFSET; /*Major Number*/
159                         system_rev |= 1 << MINOR_NUMBER_OFFSET; /*Minor Number*/
160                 } else {
161                         HAL_PLATFORM_EXTRA[5] = 'x';
162                         HAL_PLATFORM_EXTRA[7] = 'x';
163                         system_rev |= 1 << MAJOR_NUMBER_OFFSET; /*Major Number*/
164                         system_rev |= 1 << MINOR_NUMBER_OFFSET; /*Minor Number*/
165                         find_correct_chip = CHIP_VERSION_UNKNOWN;
166                 }
167         }
168
169         if ((esdmisc & 0x4) == 0) {
170                 HAL_PLATFORM_EXTRA[14] = 'S';
171         }
172         if ((esdctl0 & 0x30000) != 0x20000) {
173                 HAL_PLATFORM_EXTRA[11] = '1';
174                 HAL_PLATFORM_EXTRA[12] = '6';
175         }
176
177         // Enable caches
178         HAL_ICACHE_ENABLE();
179         HAL_DCACHE_ENABLE();
180
181         // enable EPIT and start it with 32KHz input clock
182         writel(0x00010000, EPIT_BASE_ADDR + EPITCR);
183
184         // make sure reset is complete
185         while ((readl(EPIT_BASE_ADDR + EPITCR) & 0x10000) != 0) {
186         }
187
188         writel(0x030E0002, EPIT_BASE_ADDR + EPITCR);
189         writel(0x030E0003, EPIT_BASE_ADDR + EPITCR);
190
191         writel(0, EPIT_BASE_ADDR + EPITCMPR);  // always compare with 0
192
193         if ((readw(WDOG_BASE_ADDR) & 4) != 0) {
194                 // increase the WDOG timeout value to the max
195                 writew(readw(WDOG_BASE_ADDR) | 0xFF00, WDOG_BASE_ADDR);
196         }
197
198         // Perform any platform specific initializations
199         plf_hardware_init();
200
201         // Set up eCos/ROM interfaces
202         hal_if_init();
203
204         nfc_setup = (nfc_setup_func_t*)mxc_nfc_soc_setup;
205 }
206
207 // -------------------------------------------------------------------------
208 void hal_clock_initialize(cyg_uint32 period)
209 {
210 }
211
212 // This routine is called during a clock interrupt.
213
214 // Define this if you want to ensure that the clock is perfect (i.e. does
215 // not drift).  One reason to leave it turned off is that it costs some
216 // us per system clock interrupt for this maintenance.
217 #undef COMPENSATE_FOR_CLOCK_DRIFT
218
219 void hal_clock_reset(cyg_uint32 vector, cyg_uint32 period)
220 {
221 }
222
223 // Read the current value of the clock, returning the number of hardware
224 // "ticks" that have occurred (i.e. how far away the current value is from
225 // the start)
226
227 // Note: The "contract" for this function is that the value is the number
228 // of hardware clocks that have happened since the last interrupt (i.e.
229 // when it was reset).  This value is used to measure interrupt latencies.
230 // However, since the hardware counter runs freely, this routine computes
231 // the difference between the current clock period and the number of hardware
232 // ticks left before the next timer interrupt.
233 void hal_clock_read(cyg_uint32 *pvalue)
234 {
235 }
236
237 // This is to cope with the test read used by tm_basic with
238 // CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY defined; we read the count ASAP
239 // in the ISR, *before* resetting the clock.  Which returns 1tick +
240 // latency if we just use plain hal_clock_read().
241 void hal_clock_latency(cyg_uint32 *pvalue)
242 {
243 }
244
245 unsigned int hal_timer_count(void)
246 {
247         return (0xFFFFFFFF - readl(EPIT_BASE_ADDR + EPITCNR));
248 }
249
250 #define WDT_MAGIC_1                             0x5555
251 #define WDT_MAGIC_2                             0xAAAA
252 #define MXC_WDT_WSR                             0x2
253
254 unsigned int i2c_base_addr[] = {
255         I2C_BASE_ADDR,
256         I2C2_BASE_ADDR,
257         I2C3_BASE_ADDR
258 };
259 unsigned int i2c_num = 3;
260
261 //
262 // Delay for some number of micro-seconds
263 //
264 void hal_delay_us(unsigned int usecs)
265 {
266         /*
267          * This causes overflow.
268          * unsigned int delayCount = (usecs * 32768) / 1000000;
269          * So use the following one instead
270          */
271         unsigned int delayCount = (usecs * 512) / 15625;
272         static unsigned int led_on;
273
274         if (delayCount == 0) {
275                 return;
276         }
277
278         // issue the service sequence instructions
279         if ((readw(WDOG_BASE_ADDR) & 4) != 0) {
280                 writew(WDT_MAGIC_1, WDOG_BASE_ADDR + MXC_WDT_WSR);
281                 writew(WDT_MAGIC_2, WDOG_BASE_ADDR + MXC_WDT_WSR);
282         }
283
284         writel(0x01, EPIT_BASE_ADDR + EPITSR); // clear the compare status bit
285
286         writel(delayCount, EPIT_BASE_ADDR + EPITLR);
287
288         while ((0x1 & readl(EPIT_BASE_ADDR + EPITSR)) == 0); // return until compare bit is set
289
290         if ((++led_on % 3000) == 0)
291                 BOARD_DEBUG_LED(0);
292 }
293
294 // -------------------------------------------------------------------------
295
296 // This routine is called to respond to a hardware interrupt (IRQ).      It
297 // should interrogate the hardware and return the IRQ vector number.
298 int hal_IRQ_handler(void)
299 {
300 #ifdef HAL_EXTENDED_IRQ_HANDLER
301         cyg_uint32 index;
302
303         // Use platform specific IRQ handler, if defined
304         // Note: this macro should do a 'return' with the appropriate
305         // interrupt number if such an extended interrupt exists.  The
306         // assumption is that the line after the macro starts 'normal' processing.
307         HAL_EXTENDED_IRQ_HANDLER(index);
308 #endif
309
310         return CYGNUM_HAL_INTERRUPT_NONE; // This shouldn't happen!
311 }
312
313 //
314 // Interrupt control
315 //
316
317 void hal_interrupt_mask(int vector)
318 {
319 //        diag_printf("6hal_interrupt_mask(vector=%d) \n", vector);
320 #ifdef HAL_EXTENDED_INTERRUPT_MASK
321         // Use platform specific handling, if defined
322         // Note: this macro should do a 'return' for "extended" values of 'vector'
323         // Normal vectors are handled by code subsequent to the macro call.
324         HAL_EXTENDED_INTERRUPT_MASK(vector);
325 #endif
326 }
327
328 void hal_interrupt_unmask(int vector)
329 {
330 //        diag_printf("7hal_interrupt_unmask(vector=%d) \n", vector);
331
332 #ifdef HAL_EXTENDED_INTERRUPT_UNMASK
333         // Use platform specific handling, if defined
334         // Note: this macro should do a 'return' for "extended" values of 'vector'
335         // Normal vectors are handled by code subsequent to the macro call.
336         HAL_EXTENDED_INTERRUPT_UNMASK(vector);
337 #endif
338 }
339
340 void hal_interrupt_acknowledge(int vector)
341 {
342
343 //        diag_printf("8hal_interrupt_acknowledge(vector=%d) \n", vector);
344 #ifdef HAL_EXTENDED_INTERRUPT_UNMASK
345         // Use platform specific handling, if defined
346         // Note: this macro should do a 'return' for "extended" values of 'vector'
347         // Normal vectors are handled by code subsequent to the macro call.
348         HAL_EXTENDED_INTERRUPT_ACKNOWLEDGE(vector);
349 #endif
350 }
351
352 void hal_interrupt_configure(int vector, int level, int up)
353 {
354
355 #ifdef HAL_EXTENDED_INTERRUPT_CONFIGURE
356         // Use platform specific handling, if defined
357         // Note: this macro should do a 'return' for "extended" values of 'vector'
358         // Normal vectors are handled by code subsequent to the macro call.
359         HAL_EXTENDED_INTERRUPT_CONFIGURE(vector, level, up);
360 #endif
361 }
362
363 void hal_interrupt_set_level(int vector, int level)
364 {
365
366 #ifdef HAL_EXTENDED_INTERRUPT_SET_LEVEL
367         // Use platform specific handling, if defined
368         // Note: this macro should do a 'return' for "extended" values of 'vector'
369         // Normal vectors are handled by code subsequent to the macro call.
370         HAL_EXTENDED_INTERRUPT_SET_LEVEL(vector, level);
371 #endif
372
373         // Interrupt priorities are not configurable.
374 }
375
376 unsigned int mxc_nfc_soc_setup(unsigned int pg_sz, unsigned int io_sz,
377                                                            unsigned int is_mlc, unsigned int num_of_chips)
378 {
379         return MXC_NFC_V2;      // NFC version 2
380 }
381
382 static void check_correct_chip(void)
383 {
384         if (find_correct_chip == CHIP_VERSION_UNKNOWN) {
385                 diag_printf("Unrecognized chip version: 0x%x!!!\n", read_system_rev());
386                 diag_printf("Assuming chip version=0x%x\n", system_rev);
387         } else if (find_correct_chip == CHIP_VERSION_NONE) {
388                 diag_printf("Unrecognized chip: 0x%x!!!\n", readl(IIM_BASE_ADDR + IIM_PREV_OFF));
389         }
390 }
391
392 RedBoot_init(check_correct_chip, RedBoot_INIT_LAST);