Subversion Repositories HelenOS-historic

Rev

Rev 1221 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
332 palkovsky 1
/*
2
 * Copyright (C) 2005 Ondrej Palkovsky
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
 
1702 cejka 29
 /** @addtogroup mips32
30
 * @{
31
 */
32
/** @file
33
 */
34
 
332 palkovsky 35
#include <arch/drivers/arc.h>
36
#include <arch/mm/page.h>
37
#include <print.h>
38
#include <arch.h>
39
#include <arch/byteorder.h>
573 palkovsky 40
#include <arch/mm/frame.h>
41
#include <mm/frame.h>
575 palkovsky 42
#include <interrupt.h>
605 palkovsky 43
#include <align.h>
606 palkovsky 44
#include <console/console.h>
852 palkovsky 45
#include <console/kconsole.h>
46
#include <console/cmd.h>
853 palkovsky 47
#include <mm/slab.h>
332 palkovsky 48
 
49
/* This is a good joke, SGI HAS different types than NT bioses... */
50
/* Here is the SGI type */
51
static char *basetypes[] = {
52
    "ExceptionBlock",
53
    "SystemParameterBlock",
54
    "FreeContiguous",
55
    "FreeMemory",
56
    "BadMemory",
57
    "LoadedProgram",
58
    "FirmwareTemporary",
59
    "FirmwarePermanent"
60
};
61
 
344 palkovsky 62
static char *ctypes[] = {
63
    "ARC_type",
64
    "CPU_type",
65
    "FPU_type",
66
    "PrimaryICache",
67
    "PrimaryDCache",
68
    "SecondaryICache",
69
    "SecondaryDCache",
70
    "SecondaryCache",
71
    "Memory",
72
    "EISAAdapter",
73
    "TCAdapter",
74
    "SCSIAdapter",
75
    "DTIAdapter",
76
    "MultiFunctionAdapter",
77
    "DiskController",
78
    "TapeController",
79
    "CDROMController",
80
    "WORMController",
81
    "SerialController",
82
    "NetworkController",
83
    "DisplayController",
84
    "ParallelController",
85
    "PointerController",
86
    "KeyboardController",
87
    "AudioController",
88
    "OtherController",
89
    "DiskPeripheral",
90
    "FloppyDiskPeripheral",
91
    "TapePeripheral",
92
    "ModemPeripheral",
93
    "MonitorPeripheral",
94
    "PrinterPeripheral",
95
    "PointerPeripheral",
96
    "KeyboardPeripheral",
97
    "TerminalPeripheral",
98
    "OtherPeripheral",
99
    "LinePeripheral",
100
    "NetworkPeripheral"
101
    "OtherPeripheral",
102
    "XTalkAdapter",
103
    "PCIAdapter",
104
    "GIOAdapter",
105
    "TPUAdapter",
106
    "Anonymous"
107
};
108
 
332 palkovsky 109
static arc_sbp *sbp = (arc_sbp *)PA2KA(0x1000);
110
static arc_func_vector_t *arc_entry;
111
 
112
 
575 palkovsky 113
static void arc_putchar(char ch);
332 palkovsky 114
 
115
/** Return true if ARC is available */
116
int arc_enabled(void)
117
{
118
    return sbp != NULL;
119
}
120
 
853 palkovsky 121
 
122
/** Print configuration data that ARC reports about component */
123
static void arc_print_confdata(arc_component *c)
124
{
125
    cm_resource_list *configdata;
126
    int i;
127
 
128
    if (!c->configdatasize)
129
        return; /* No configuration data */
130
 
131
    configdata = malloc(c->configdatasize, 0);
132
 
133
    if (arc_entry->getconfigurationdata(configdata, c)) {
134
        free(configdata);
135
        return;
136
    }
137
    /* Does not seem to return meaningful data, don't use now */
138
    free(configdata);
139
    return;
140
 
141
    for (i=0; i < configdata->count; i++) {
142
        switch (configdata->descr[i].type) {
143
        case CmResourceTypePort:
1221 decky 144
            printf("Port: %p-size:%d ",
853 palkovsky 145
                   (__address)configdata->descr[i].u.port.start,
146
                   configdata->descr[i].u.port.length);
147
            break;
148
        case CmResourceTypeInterrupt:
149
            printf("Irq: level(%d) vector(%d) ",
150
                   configdata->descr[i].u.interrupt.level,
151
                   configdata->descr[i].u.interrupt.vector);
152
            break;
153
        case CmResourceTypeMemory:
1221 decky 154
            printf("Memory: %p-size:%d ",
853 palkovsky 155
                   (__address)configdata->descr[i].u.port.start,
156
                   configdata->descr[i].u.port.length);
157
            break;
158
        default:
159
            break;
160
        }
161
    }
162
 
163
    free(configdata);
164
}
165
 
166
/** Print information about component */
344 palkovsky 167
static void arc_print_component(arc_component *c)
168
{
169
    int i;
170
 
171
    printf("%s: ",ctypes[c->type]);
172
    for (i=0;i < c->identifier_len;i++)
853 palkovsky 173
        printf("%c",c->identifier[i]);
174
 
175
    printf(" ");
176
    arc_print_confdata(c);
177
    printf("\n");
344 palkovsky 178
}
179
 
853 palkovsky 180
/**
181
 * Read from ARC bios configuration data and print it
182
 */
183
static int cmd_arc_print_devices(cmd_arg_t *argv)
344 palkovsky 184
{
185
    arc_component *c,*next;
186
 
187
    c = arc_entry->getchild(NULL);
188
    while (c) {
189
        arc_print_component(c);
190
        next = arc_entry->getchild(c);
191
        while (!next) {
192
            next = arc_entry->getpeer(c);
193
            if (!next)
194
                c = arc_entry->getparent(c);
195
            if (!c)
853 palkovsky 196
                return 0;
344 palkovsky 197
        }
198
        c = next;
199
    }
853 palkovsky 200
    return 1;
344 palkovsky 201
}
853 palkovsky 202
static cmd_info_t devlist_info = {
203
    .name = "arcdevlist",
204
    .description = "Print arc device list",
205
    .func = cmd_arc_print_devices,
206
    .argc = 0
207
};
344 palkovsky 208
 
853 palkovsky 209
 
210
/** Read from arc bios memory map and print it
211
 *
212
 */
213
static int cmd_arc_print_memmap(cmd_arg_t *argv)
332 palkovsky 214
{
215
    arc_memdescriptor_t *desc;
216
 
217
    printf("Memory map:\n");
218
 
219
    desc = arc_entry->getmemorydescriptor(NULL);
220
    while (desc) {
1221 decky 221
        printf("%s: %d(%p) (size: %dKB)\n",basetypes[desc->type],
573 palkovsky 222
               desc->basepage * ARC_FRAME,
852 palkovsky 223
               desc->basepage * ARC_FRAME,
573 palkovsky 224
               desc->basecount*ARC_FRAME/1024);
332 palkovsky 225
        desc = arc_entry->getmemorydescriptor(desc);
226
    }
853 palkovsky 227
    return 1;
332 palkovsky 228
}
853 palkovsky 229
static cmd_info_t memmap_info = {
230
    .name = "arcmemmap",
231
    .description = "Print arc memory map",
232
    .func = cmd_arc_print_memmap,
233
    .argc = 0
234
};
332 palkovsky 235
 
236
/** Print charactor to console */
575 palkovsky 237
static void arc_putchar(char ch)
332 palkovsky 238
{
239
    __u32 cnt;
413 jermar 240
    ipl_t ipl;
332 palkovsky 241
 
242
    /* TODO: Should be spinlock? */
413 jermar 243
    ipl = interrupts_disable();
332 palkovsky 244
    arc_entry->write(1, &ch, 1, &cnt);
413 jermar 245
    interrupts_restore(ipl);
332 palkovsky 246
 
247
}
567 palkovsky 248
 
852 palkovsky 249
static int cmd_reboot(cmd_arg_t *argv)
250
{
251
    arc_entry->reboot();
252
    return 0;
253
}
254
static cmd_info_t reboot_info = {
255
    .name = "reboot",
256
    .description = "Reboot computer",
257
    .func = cmd_reboot,
258
    .argc = 0
259
};
260
 
575 palkovsky 261
/** Initialize ARC structure
262
 *
263
 * @return 0 - ARC OK, -1 - ARC does not exist
264
 */
265
int arc_init(void)
266
{
267
    if (sbp->signature != ARC_MAGIC) {
268
        sbp = NULL;
269
        return -1;
270
    }
271
    arc_entry = sbp->firmwarevector;
272
 
273
    arc_putchar('A');
274
    arc_putchar('R');
275
    arc_putchar('C');
276
    arc_putchar('\n');
625 palkovsky 277
 
852 palkovsky 278
    /* Add command for resetting the computer */
279
    cmd_initialize(&reboot_info);
280
    cmd_register(&reboot_info);
853 palkovsky 281
    cmd_initialize(&memmap_info);
282
    cmd_register(&memmap_info);
283
    cmd_initialize(&devlist_info);
284
    cmd_register(&devlist_info);
852 palkovsky 285
 
625 palkovsky 286
    return 0;
575 palkovsky 287
}
288
 
577 palkovsky 289
static bool kbd_polling_enabled;
575 palkovsky 290
static chardev_t console;
291
 
567 palkovsky 292
/** Try to get character, return character or -1 if not available */
575 palkovsky 293
static void arc_keyboard_poll(void)
567 palkovsky 294
{
295
    char ch;
296
    __u32 count;
297
    long result;
575 palkovsky 298
 
299
    if (! kbd_polling_enabled)
300
        return;
567 palkovsky 301
 
302
    if (arc_entry->getreadstatus(0))
575 palkovsky 303
        return;
567 palkovsky 304
    result = arc_entry->read(0, &ch, 1, &count);
305
    if (result || count!=1) {
575 palkovsky 306
        return;
567 palkovsky 307
    }
308
    if (ch == '\r')
575 palkovsky 309
        ch = '\n';
588 palkovsky 310
    if (ch == 0x7f)
311
        ch = '\b';
312
 
575 palkovsky 313
    chardev_push_character(&console, ch);
567 palkovsky 314
}
573 palkovsky 315
 
610 palkovsky 316
static char arc_read(chardev_t *dev)
317
{
318
    char ch;
319
    __u32 count;
320
    long result;
321
 
322
    result = arc_entry->read(0, &ch, 1, &count);
323
    if (result || count!=1) {
324
        printf("Error reading from ARC keyboard.\n");
325
        cpu_halt();
326
    }
327
    if (ch == '\r')
328
        return '\n';
329
    if (ch == 0x7f)
330
        return '\b';
331
    return ch;
332
}
333
 
575 palkovsky 334
static void arc_write(chardev_t *dev, const char ch)
335
{
336
    arc_putchar(ch);
337
}
338
 
339
static void arc_enable(chardev_t *dev)
340
{
577 palkovsky 341
    kbd_polling_enabled = true;
575 palkovsky 342
}
343
 
344
static void arc_disable(chardev_t *dev)
345
{
577 palkovsky 346
    kbd_polling_enabled = false;
575 palkovsky 347
}
348
 
349
static chardev_operations_t arc_ops = {
350
    .resume = arc_enable,
351
    .suspend = arc_disable,
610 palkovsky 352
    .write = arc_write,
353
    .read = arc_read
575 palkovsky 354
};
355
 
356
iroutine old_timer;
357
/** Do polling on timer interrupt */
958 jermar 358
static void timer_replace(int n, istate_t *istate)
575 palkovsky 359
{
360
    arc_keyboard_poll();
958 jermar 361
    old_timer(n, istate);
575 palkovsky 362
    arc_keyboard_poll();
363
}
364
 
606 palkovsky 365
void arc_console(void)
575 palkovsky 366
{
577 palkovsky 367
    kbd_polling_enabled = true;
575 palkovsky 368
 
369
    chardev_initialize("arc_console", &console, &arc_ops);
590 palkovsky 370
    old_timer = int_register(TIMER_IRQ, "arc_kb_poll", timer_replace);
606 palkovsky 371
    stdin = &console;
372
    stdout = &console;
575 palkovsky 373
}
374
 
573 palkovsky 375
/* Initialize frame zones from ARC firmware.
376
 * In the future we may use even the FirmwareTemporary regions,
377
 * currently we use the FreeMemory (what about the LoadedProgram?)
378
 */
379
void arc_frame_init(void)
380
{
381
    arc_memdescriptor_t *desc;
382
    int total = 0;
605 palkovsky 383
    __address base;
384
    size_t basesize;
573 palkovsky 385
 
386
    desc = arc_entry->getmemorydescriptor(NULL);
387
    while (desc) {
388
        if (desc->type == FreeMemory ||
389
            desc->type == FreeContiguous) {
605 palkovsky 390
            base = desc->basepage*ARC_FRAME;
391
            basesize = desc->basecount*ARC_FRAME;
392
 
393
            if (base % FRAME_SIZE ) {
394
                basesize -= FRAME_SIZE - (base % FRAME_SIZE);
395
                base = ALIGN_UP(base, FRAME_SIZE);
396
            }
397
            basesize = ALIGN_DOWN(basesize, FRAME_SIZE);
398
 
399
            total += basesize;
814 palkovsky 400
 
852 palkovsky 401
            zone_create(ADDR2PFN(base), SIZE2FRAMES(basesize),
402
                    ADDR2PFN(base), 0);
573 palkovsky 403
        }
404
        desc = arc_entry->getmemorydescriptor(desc);
405
    }
406
 
407
    config.memory_size = total;
408
}
409
 
1702 cejka 410
 
411
 /** @}
412
 */
413