summaryrefslogtreecommitdiffstats
path: root/firmware/target/arm/imx233/system-imx233.c
blob: 68f063512d434a4c61471c2a5e2bb430d23bac56 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 * $Id$
 *
 * Copyright (C) 2011 by Amaury Pouly
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/

#include "kernel.h"
#include "system.h"
#include "gcc_extensions.h"
#include "system-target.h"
#include "cpu.h"
#include "clkctrl-imx233.h"
#include "pinctrl-imx233.h"
#include "timrot-imx233.h"
#include "dma-imx233.h"
#include "ssp-imx233.h"
#include "i2c-imx233.h"
#include "dcp-imx233.h"
#include "pwm-imx233.h"
#include "icoll-imx233.h"
#include "lradc-imx233.h"
#include "rtc-imx233.h"
#include "power-imx233.h"
#include "emi-imx233.h"
#include "lcd.h"
#include "backlight-target.h"
#include "button.h"
#include "fmradio_i2c.h"

void imx233_chip_reset(void)
{
    HW_CLKCTRL_RESET = HW_CLKCTRL_RESET_CHIP;
}

void system_reboot(void)
{
    _backlight_off();

    disable_irq();

    /* use watchdog to reset */
    imx233_chip_reset();
    while(1);
}

void system_exception_wait(void)
{
    /* make sure lcd and backlight are on */
    lcd_update();
    _backlight_on();
    _backlight_set_brightness(DEFAULT_BRIGHTNESS_SETTING);
    /* wait until button release (if a button is pressed) */
#ifdef HAVE_BUTTON_DATA
    int data;
    while(button_read_device(&data));
    /* then wait until next button press */
    while(!button_read_device(&data));
#else
    while(button_read_device());
    /* then wait until next button press */
    while(!button_read_device());
#endif
}

int system_memory_guard(int newmode)
{
    (void)newmode;
    return 0;
}

static void set_page_tables(void)
{
    /* map every memory region to itself */
    map_section(0, 0, 0x1000, CACHE_NONE);

    /* map RAM and enable caching for it */
    map_section(DRAM_ORIG, CACHED_DRAM_ADDR, MEMORYSIZE, CACHE_ALL);
    map_section(DRAM_ORIG, BUFFERED_DRAM_ADDR, MEMORYSIZE, BUFFERED);
}

void memory_init(void)
{
    ttb_init();
    set_page_tables();
    enable_mmu();
}

void system_init(void)
{
    /* NOTE: don't use anything here that might require tick task !
     * It is initialized by kernel_init *after* system_init().
     * The main() will naturally set cpu speed to normal after kernel_init()
     * so don't bother if the cpu is running at 24MHz here. */
    imx233_clkctrl_enable_clock(CLK_PLL, true);
    imx233_rtc_init();
    imx233_icoll_init();
    imx233_pinctrl_init();
    imx233_timrot_init();
    imx233_dma_init();
    imx233_ssp_init();
    imx233_dcp_init();
    imx233_pwm_init();
    imx233_lradc_init();
    imx233_power_init();
    imx233_i2c_init();

    imx233_clkctrl_enable_auto_slow_monitor(AS_CPU_INSTR, true);
    imx233_clkctrl_enable_auto_slow_monitor(AS_CPU_DATA, true);
    imx233_clkctrl_enable_auto_slow_monitor(AS_TRAFFIC, true);
    imx233_clkctrl_enable_auto_slow_monitor(AS_TRAFFIC_JAM, true);
    imx233_clkctrl_enable_auto_slow_monitor(AS_APBXDMA, true);
    imx233_clkctrl_enable_auto_slow_monitor(AS_APBHDMA, true);
    imx233_clkctrl_set_auto_slow_divisor(AS_DIV_8);
    imx233_clkctrl_enable_auto_slow(true);

#if !defined(BOOTLOADER) &&(defined(SANSA_FUZEPLUS) || \
    defined(CREATIVE_ZENXFI3) || defined(CREATIVE_ZENXFI2))
    fmradio_i2c_init();
#endif
}

bool imx233_us_elapsed(uint32_t ref, unsigned us_delay)
{
    uint32_t cur = HW_DIGCTL_MICROSECONDS;
    if(ref + us_delay <= ref)
        return !(cur > ref) && !(cur < (ref + us_delay));
    else
        return (cur < ref) || cur >= (ref + us_delay);
}

void imx233_reset_block(volatile uint32_t *block_reg)
{
    /* soft-reset */
    __REG_SET(*block_reg) = __BLOCK_SFTRST;
    /* make sure block is gated off */
    while(!(*block_reg & __BLOCK_CLKGATE));
    /* bring block out of reset */
    __REG_CLR(*block_reg) = __BLOCK_SFTRST;
    while(*block_reg & __BLOCK_SFTRST);
    /* make sure clock is running */
    __REG_CLR(*block_reg) = __BLOCK_CLKGATE;
    while(*block_reg & __BLOCK_CLKGATE);
}

void udelay(unsigned us)
{
    uint32_t ref = HW_DIGCTL_MICROSECONDS;
    while(!imx233_us_elapsed(ref, us));
}

#ifdef HAVE_ADJUSTABLE_CPU_FREQ
void set_cpu_frequency(long frequency)
{
    /* don't change the frequency if it is useless (changes are expensive) */
    if(cpu_frequency == frequency)
        return;
    
    cpu_frequency = frequency;
    /* disable auto-slow (enable back afterwards) */
    bool as = imx233_clkctrl_is_auto_slow_enabled();
    imx233_clkctrl_enable_auto_slow(false);
    /* go back to a known state in safe way:
     * clk_p@24 MHz
     * clk_h@6 MHz
     * WARNING: we must absolutely avoid that clk_h be too low or too high
     * during the change. We first change the clk_p/clk_h ratio to 4 so
     * that it cannot be too high (480/4=120 MHz max) or too low
     * (24/4=6 MHz min). Then we switch clk_p to bypass. We chose a ratio of 4
     * which is greater than all clk_p/clk_h ratios used below so that further
     * changes are safe too */
    imx233_clkctrl_set_clock_divisor(CLK_HBUS, 4);
    imx233_clkctrl_set_bypass_pll(CLK_CPU, true);

    switch(frequency)
    {
        case IMX233_CPUFREQ_454_MHz:
            /* set VDDD to 1.550 mV (brownout at 1.450 mV) */
            imx233_power_set_regulator(REGULATOR_VDDD, 1550, 1450);
            /* clk_h@clk_p/3 */
            imx233_clkctrl_set_clock_divisor(CLK_HBUS, 3);
            /* clk_p@ref_cpu/1*18/19 */
            imx233_clkctrl_set_fractional_divisor(CLK_CPU, 19);
            imx233_clkctrl_set_clock_divisor(CLK_CPU, 1);
            imx233_clkctrl_set_bypass_pll(CLK_CPU, false);

            imx233_emi_set_frequency(IMX233_EMIFREQ_130_MHz);
            /* ref_cpu@480 MHz
             * ref_emi@480 MHz
             * clk_emi@130.91 MHz
             * clk_p@454.74 MHz
             * clk_h@130.91 MHz */
            break;
        case IMX233_CPUFREQ_261_MHz:
            /* set VDDD to 1.275 mV (brownout at 1.175 mV) */
            imx233_power_set_regulator(REGULATOR_VDDD, 1275, 1175);
            /* clk_h@clk_p/2 */
            imx233_clkctrl_set_clock_divisor(CLK_HBUS, 2);
            /* clk_p@ref_cpu/1*18/33 */
            imx233_clkctrl_set_fractional_divisor(CLK_CPU, 33);
            imx233_clkctrl_set_clock_divisor(CLK_CPU, 1);
            imx233_clkctrl_set_bypass_pll(CLK_CPU, false);

            imx233_emi_set_frequency(IMX233_EMIFREQ_130_MHz);
            /* ref_cpu@480 MHz
             * ref_emi@480 MHz
             * clk_emi@130.91 MHz
             * clk_p@261.82 MHz
             * clk_h@130.91 MHz */
            break;
        case IMX233_CPUFREQ_64_MHz:
            /* set VDDD to 1.050 mV (brownout at 0.975 mV) */
            imx233_power_set_regulator(REGULATOR_VDDD, 1050, 975);
            /* clk_h@clk_p */
            imx233_clkctrl_set_clock_divisor(CLK_HBUS, 1);
            /* clk_p@ref_cpu/5*18/27 */
            imx233_clkctrl_set_fractional_divisor(CLK_CPU, 27);
            imx233_clkctrl_set_clock_divisor(CLK_CPU, 5);
            imx233_clkctrl_set_bypass_pll(CLK_CPU, false);

            imx233_emi_set_frequency(IMX233_EMIFREQ_64_MHz);
            /* ref_cpu@480 MHz
             * ref_emi@480 MHz
             * clk_emi@64 MHz
             * clk_p@64 MHz
             * clk_h@64 MHz */
        default:
            break;
    }

    /* enable auto slow again */
    imx233_clkctrl_enable_auto_slow(as);
}
#endif

void imx233_enable_usb_controller(bool enable)
{
    if(enable)
        __REG_CLR(HW_DIGCTL_CTRL) = HW_DIGCTL_CTRL__USB_CLKGATE;
    else
        __REG_SET(HW_DIGCTL_CTRL) = HW_DIGCTL_CTRL__USB_CLKGATE;
}

void imx233_enable_usb_phy(bool enable)
{
    if(enable)
    {
        __REG_CLR(HW_USBPHY_CTRL) = __BLOCK_CLKGATE | __BLOCK_SFTRST;
        __REG_CLR(HW_USBPHY_PWD) = HW_USBPHY_PWD__ALL;
    }
    else
    {
        __REG_SET(HW_USBPHY_PWD) = HW_USBPHY_PWD__ALL;
        __REG_SET(HW_USBPHY_CTRL) = __BLOCK_CLKGATE | __BLOCK_SFTRST;
    }
}