Subversion Repositories HelenOS

Rev

Rev 2465 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2215 kebrt 1
/*
2263 kebrt 2
 * Copyright (c) 2007 Michal Kebrt, Petr Stepan
2215 kebrt 3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
2419 kebrt 29
/** @addtogroup arm32gxemul
2215 kebrt 30
 * @{
31
 */
32
/** @file
2410 stepan 33
 *  @brief GXemul drivers.
2215 kebrt 34
 */
35
 
36
#include <interrupt.h>
37
#include <ipc/irq.h>
38
#include <console/chardev.h>
39
#include <arch/drivers/gxemul.h>
40
#include <console/console.h>
41
#include <sysinfo/sysinfo.h>
42
#include <print.h>
2245 stepan 43
#include <ddi/device.h>
2263 kebrt 44
#include <mm/page.h>
2274 kebrt 45
#include <arch/machine.h>
2326 kebrt 46
#include <arch/debug/print.h>
2215 kebrt 47
 
2414 kebrt 48
/* Addresses of devices. */
2263 kebrt 49
#define GXEMUL_VIDEORAM            0x10000000
50
#define GXEMUL_KBD                 0x10000000
2300 kebrt 51
#define GXEMUL_HALT_OFFSET         0x10
2263 kebrt 52
#define GXEMUL_RTC                 0x15000000
53
#define GXEMUL_RTC_FREQ_OFFSET     0x100
54
#define GXEMUL_RTC_ACK_OFFSET      0x110
55
#define GXEMUL_IRQC                0x16000000
56
#define GXEMUL_IRQC_MASK_OFFSET    0x4
57
#define GXEMUL_IRQC_UNMASK_OFFSET  0x8
58
#define GXEMUL_MP                  0x11000000
59
#define GXEMUL_MP_MEMSIZE_OFFSET   0x0090
2340 kebrt 60
#define GXEMUL_FB                  0x12000000
2215 kebrt 61
 
2414 kebrt 62
/* IRQs */
2245 stepan 63
#define GXEMUL_KBD_IRQ      2
64
#define GXEMUL_TIMER_IRQ    4
65
 
2263 kebrt 66
static gxemul_hw_map_t gxemul_hw_map;
2215 kebrt 67
static chardev_t console;
2414 kebrt 68
static irq_t gxemul_console_irq;
2245 stepan 69
static irq_t gxemul_timer_irq;
2215 kebrt 70
 
2290 kebrt 71
static bool hw_map_init_called = false;
72
 
2414 kebrt 73
static void gxemul_kbd_enable(chardev_t *dev);
74
static void gxemul_kbd_disable(chardev_t *dev);
2215 kebrt 75
static void gxemul_write(chardev_t *dev, const char ch);
76
static char gxemul_do_read(chardev_t *dev);
77
 
78
static chardev_operations_t gxemul_ops = {
2414 kebrt 79
    .resume = gxemul_kbd_enable,
80
    .suspend = gxemul_kbd_disable,
2215 kebrt 81
    .write = gxemul_write,
82
    .read = gxemul_do_read,
83
};
84
 
2357 kebrt 85
 
2355 stepan 86
/** Returns the mask of active interrupts. */
2340 kebrt 87
static inline uint32_t gxemul_irqc_get_sources(void)
88
{
2464 jermar 89
    return *((uint32_t *) gxemul_hw_map.irqc);
2340 kebrt 90
}
2263 kebrt 91
 
2357 kebrt 92
 
2340 kebrt 93
/** Masks interrupt.
94
 *
95
 * @param irq interrupt number
96
 */
97
static inline void gxemul_irqc_mask(uint32_t irq)
98
{
2464 jermar 99
    *((uint32_t *) gxemul_hw_map.irqc_mask) = irq;
2340 kebrt 100
}
101
 
2357 kebrt 102
 
2340 kebrt 103
/** Unmasks interrupt.
104
 *
105
 * @param irq interrupt number
106
 */
107
static inline void gxemul_irqc_unmask(uint32_t irq)
108
{
2464 jermar 109
    *((uint32_t *) gxemul_hw_map.irqc_unmask) = irq;
2340 kebrt 110
}
111
 
2357 kebrt 112
 
2263 kebrt 113
/** Initializes #gxemul_hw_map. */
2358 kebrt 114
void gxemul_hw_map_init(void)
2263 kebrt 115
{
116
    gxemul_hw_map.videoram = hw_map(GXEMUL_VIDEORAM, PAGE_SIZE);
117
    gxemul_hw_map.kbd = hw_map(GXEMUL_KBD, PAGE_SIZE);
118
    gxemul_hw_map.rtc = hw_map(GXEMUL_RTC, PAGE_SIZE);
119
    gxemul_hw_map.irqc = hw_map(GXEMUL_IRQC, PAGE_SIZE);
120
 
121
    gxemul_hw_map.rtc_freq = gxemul_hw_map.rtc + GXEMUL_RTC_FREQ_OFFSET;
122
    gxemul_hw_map.rtc_ack = gxemul_hw_map.rtc + GXEMUL_RTC_ACK_OFFSET;
123
    gxemul_hw_map.irqc_mask = gxemul_hw_map.irqc + GXEMUL_IRQC_MASK_OFFSET;
2464 jermar 124
    gxemul_hw_map.irqc_unmask = gxemul_hw_map.irqc +
125
        GXEMUL_IRQC_UNMASK_OFFSET;
2264 kebrt 126
 
2290 kebrt 127
    hw_map_init_called = true;
2263 kebrt 128
}
129
 
2357 kebrt 130
 
2414 kebrt 131
/** Putchar that works with gxemul.
132
 *
133
 * @param dev Not used.
134
 * @param ch Characted to be printed.
135
 */
2340 kebrt 136
static void gxemul_write(chardev_t *dev, const char ch)
2215 kebrt 137
{
2263 kebrt 138
    *((char *) gxemul_hw_map.videoram) = ch;
2215 kebrt 139
}
140
 
2414 kebrt 141
/** Enables gxemul keyboard (interrupt unmasked).
142
 *
143
 * @param dev Not used.
144
 *
145
 * Called from getc().
146
 */
147
static void gxemul_kbd_enable(chardev_t *dev)
2215 kebrt 148
{
2245 stepan 149
    gxemul_irqc_unmask(GXEMUL_KBD_IRQ);
2215 kebrt 150
}
151
 
2414 kebrt 152
/** Disables gxemul keyboard (interrupt masked).
153
 *
154
 * @param dev not used
155
 *
156
 * Called from getc().
157
 */
158
static void gxemul_kbd_disable(chardev_t *dev)
2215 kebrt 159
{
2245 stepan 160
    gxemul_irqc_mask(GXEMUL_KBD_IRQ);
2215 kebrt 161
}
162
 
2357 kebrt 163
/** Read character using polling, assume interrupts disabled.
164
 *
165
 *  @param dev Not used.
166
 */
2215 kebrt 167
static char gxemul_do_read(chardev_t *dev)
168
{
169
    char ch;
170
 
171
    while (1) {
2263 kebrt 172
        ch = *((volatile char *) gxemul_hw_map.kbd);
2215 kebrt 173
        if (ch) {
174
            if (ch == '\r')
175
                return '\n';
176
            if (ch == 0x7f)
177
                return '\b';
178
            return ch;
179
        }
180
    }
181
}
182
 
2414 kebrt 183
/** Process keyboard interrupt.
184
 *  
185
 *  @param irq IRQ information.
186
 *  @param arg Not used.
187
 */
2215 kebrt 188
static void gxemul_irq_handler(irq_t *irq, void *arg, ...)
189
{
2357 kebrt 190
    if ((irq->notif_cfg.notify) && (irq->notif_cfg.answerbox)) {
2215 kebrt 191
        ipc_irq_send_notif(irq);
2357 kebrt 192
    } else {
2215 kebrt 193
        char ch = 0;
194
 
2357 kebrt 195
        ch = *((char *) gxemul_hw_map.kbd);
196
        if (ch == '\r') {
197
            ch = '\n';
198
        }
199
        if (ch == 0x7f) {
200
            ch = '\b';
201
        }
202
        chardev_push_character(&console, ch);
2215 kebrt 203
    }
204
}
205
 
206
static irq_ownership_t gxemul_claim(void)
207
{
208
    return IRQ_ACCEPT;
209
}
210
 
2357 kebrt 211
 
2412 kebrt 212
/** Acquire console back for kernel. */
2358 kebrt 213
void gxemul_grab_console(void)
2215 kebrt 214
{
215
    ipl_t ipl = interrupts_disable();
2414 kebrt 216
    spinlock_lock(&gxemul_console_irq.lock);
217
    gxemul_console_irq.notif_cfg.notify = false;
218
    spinlock_unlock(&gxemul_console_irq.lock);
2215 kebrt 219
    interrupts_restore(ipl);
220
}
221
 
2412 kebrt 222
/** Return console to userspace. */
2358 kebrt 223
void gxemul_release_console(void)
2215 kebrt 224
{
225
    ipl_t ipl = interrupts_disable();
2414 kebrt 226
    spinlock_lock(&gxemul_console_irq.lock);
227
    if (gxemul_console_irq.notif_cfg.answerbox) {
228
        gxemul_console_irq.notif_cfg.notify = true;
2357 kebrt 229
    }
2414 kebrt 230
    spinlock_unlock(&gxemul_console_irq.lock);
2215 kebrt 231
    interrupts_restore(ipl);
232
}
233
 
2357 kebrt 234
/** Initializes console object representing gxemul console.
235
 *
2418 kebrt 236
 *  @param devno device number.
2357 kebrt 237
 */
2358 kebrt 238
void gxemul_console_init(devno_t devno)
2215 kebrt 239
{
2263 kebrt 240
    chardev_initialize("gxemul_console", &console, &gxemul_ops);
2215 kebrt 241
    stdin = &console;
242
    stdout = &console;
243
 
2414 kebrt 244
    irq_initialize(&gxemul_console_irq);
245
    gxemul_console_irq.devno = devno;
246
    gxemul_console_irq.inr = GXEMUL_KBD_IRQ;
247
    gxemul_console_irq.claim = gxemul_claim;
248
    gxemul_console_irq.handler = gxemul_irq_handler;
249
    irq_register(&gxemul_console_irq);
2215 kebrt 250
 
2245 stepan 251
    gxemul_irqc_unmask(GXEMUL_KBD_IRQ);
2215 kebrt 252
 
253
    sysinfo_set_item_val("kbd", NULL, true);
254
    sysinfo_set_item_val("kbd.devno", NULL, devno);
255
    sysinfo_set_item_val("kbd.inr", NULL, GXEMUL_KBD_IRQ);
2263 kebrt 256
    sysinfo_set_item_val("kbd.address.virtual", NULL, gxemul_hw_map.kbd);
2215 kebrt 257
}
258
 
2245 stepan 259
/** Starts gxemul Real Time Clock device, which asserts regular interrupts.
260
 *
2357 kebrt 261
 * @param frequency Interrupts frequency (0 disables RTC).
2245 stepan 262
 */
2340 kebrt 263
static void gxemul_timer_start(uint32_t frequency)
2245 stepan 264
{
2464 jermar 265
    *((uint32_t*) gxemul_hw_map.rtc_freq) = frequency;
2245 stepan 266
}
267
 
268
static irq_ownership_t gxemul_timer_claim(void)
269
{
270
    return IRQ_ACCEPT;
271
}
272
 
2355 stepan 273
/** Timer interrupt handler.
274
 *
2357 kebrt 275
 * @param irq Interrupt information.
276
 * @param arg Not used.
2355 stepan 277
 */
2245 stepan 278
static void gxemul_timer_irq_handler(irq_t *irq, void *arg, ...)
279
{
280
    /*
281
    * We are holding a lock which prevents preemption.
282
    * Release the lock, call clock() and reacquire the lock again.
283
    */
284
    spinlock_unlock(&irq->lock);
2286 stepan 285
    clock();
2245 stepan 286
    spinlock_lock(&irq->lock);
2261 stepan 287
 
288
    /* acknowledge tick */
2464 jermar 289
    *((uint32_t*) gxemul_hw_map.rtc_ack) = 0;
2245 stepan 290
}
291
 
2357 kebrt 292
/** Initializes and registers timer interrupt handler. */
2464 jermar 293
static void gxemul_timer_irq_init(void)
2245 stepan 294
{
295
    irq_initialize(&gxemul_timer_irq);
296
    gxemul_timer_irq.devno = device_assign_devno();
297
    gxemul_timer_irq.inr = GXEMUL_TIMER_IRQ;
298
    gxemul_timer_irq.claim = gxemul_timer_claim;
299
    gxemul_timer_irq.handler = gxemul_timer_irq_handler;
2261 stepan 300
 
2245 stepan 301
    irq_register(&gxemul_timer_irq);
302
}
303
 
2357 kebrt 304
 
2355 stepan 305
/** Starts timer.
306
 *
307
 * Initiates regular timer interrupts after initializing
308
 * corresponding interrupt handler.
309
 */
2464 jermar 310
void gxemul_timer_irq_start(void)
2263 kebrt 311
{
2274 kebrt 312
    gxemul_timer_irq_init();
313
    gxemul_timer_start(GXEMUL_TIMER_FREQ);
314
}
315
 
2355 stepan 316
/** Returns the size of emulated memory.
317
 *
2357 kebrt 318
 * @return Size in bytes.
2355 stepan 319
 */
2358 kebrt 320
size_t gxemul_get_memory_size(void)
2274 kebrt 321
{
2464 jermar 322
    return  *((int *) (GXEMUL_MP + GXEMUL_MP_MEMSIZE_OFFSET));
2263 kebrt 323
}
2245 stepan 324
 
2412 kebrt 325
/** Prints a character.
326
 *
327
 *  @param ch Character to be printed.
328
 */
2358 kebrt 329
void gxemul_debug_putc(char ch)
2300 kebrt 330
{
2464 jermar 331
    char *addr = 0;
2290 kebrt 332
    if (!hw_map_init_called) {
2300 kebrt 333
        addr = (char *) GXEMUL_KBD;
2290 kebrt 334
    } else {
2300 kebrt 335
        addr = (char *) gxemul_hw_map.videoram;
2290 kebrt 336
    }
2300 kebrt 337
 
338
    *(addr) = ch;
2264 kebrt 339
}
340
 
2355 stepan 341
/** Stops gxemul. */
2358 kebrt 342
void gxemul_cpu_halt(void)
2300 kebrt 343
{
344
    char * addr = 0;
345
    if (!hw_map_init_called) {
346
        addr = (char *) GXEMUL_KBD;
347
    } else {
348
        addr = (char *) gxemul_hw_map.videoram;
349
    }
350
 
351
    *(addr + GXEMUL_HALT_OFFSET) = '\0';
352
}
353
 
2355 stepan 354
/** Gxemul specific interrupt exception handler.
355
 *
356
 * Determines sources of the interrupt from interrupt controller and
357
 * calls high-level handlers for them.
358
 *
2357 kebrt 359
 * @param exc_no Interrupt exception number.
360
 * @param istate Saved processor state.
2355 stepan 361
 */
2358 kebrt 362
void gxemul_irq_exception(int exc_no, istate_t *istate)
2306 kebrt 363
{
364
    uint32_t sources = gxemul_irqc_get_sources();
2464 jermar 365
    int i;
366
 
367
    for (i = 0; i < GXEMUL_IRQC_MAX_IRQ; i++) {
2306 kebrt 368
        if (sources & (1 << i)) {
369
            irq_t *irq = irq_dispatch_and_lock(i);
370
            if (irq) {
371
                /* The IRQ handler was found. */
372
                irq->handler(irq, irq->arg);
373
                spinlock_unlock(&irq->lock);
374
            } else {
375
                /* Spurious interrupt.*/
2464 jermar 376
                dprintf("cpu%d: spurious interrupt (inum=%d)\n",
377
                    CPU->id, i);
2306 kebrt 378
            }
379
        }
380
    }
381
}
382
 
2412 kebrt 383
/** Returns address of framebuffer device.
384
 *
385
 *  @return Address of framebuffer device.
386
 */
2358 kebrt 387
uintptr_t gxemul_get_fb_address(void)
2357 kebrt 388
{
2360 kebrt 389
    return (uintptr_t) GXEMUL_FB;
2357 kebrt 390
}
391
 
2215 kebrt 392
/** @}
393
 */