Changeset 3ad953c in mainline


Ignore:
Timestamp:
2008-12-30T19:55:10Z (15 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f58321c4
Parents:
6b21292
Message:

send notification to uspace console when switching from kernel console

Files:
7 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/include/console/kconsole.h

    r6b21292 r3ad953c  
    3838#include <adt/list.h>
    3939#include <synch/spinlock.h>
     40#include <ipc/irq.h>
    4041
    4142#define MAX_CMDLINE     256
     
    8485} cmd_info_t;
    8586
     87extern bool kconsole_notify;
     88extern irq_t kconsole_irq;
     89
    8690SPINLOCK_EXTERN(cmd_lock);
    8791extern link_t cmd_head;
    8892
    8993extern void kconsole_init(void);
     94extern void kconsole_notify_init(void);
    9095extern void kconsole(char *prompt, char *msg, bool kcon);
    9196extern void kconsole_thread(void *data);
  • kernel/generic/include/ipc/irq.h

    r6b21292 r3ad953c  
    5454 * ipc_irq_send_msg_m(), where m is the number of payload arguments.
    5555 */
     56#define ipc_irq_send_msg_0(irq) \
     57    ipc_irq_send_msg((irq), 0, 0, 0, 0, 0)
    5658#define ipc_irq_send_msg_1(irq, a1) \
    5759    ipc_irq_send_msg((irq), (a1), 0, 0, 0, 0)
  • kernel/generic/src/console/cmd.c

    r6b21292 r3ad953c  
    977977{
    978978        printf("The kernel will now relinquish the console.\n");
    979         printf("Use userspace controls to redraw the screen.\n");
    980979        arch_release_console();
     980       
     981        if ((kconsole_notify) && (kconsole_irq.notif_cfg.notify))
     982                ipc_irq_send_msg_0(&kconsole_irq);
     983       
    981984        return 1;
    982985}
  • kernel/generic/src/console/kconsole.c

    r6b21292 r3ad953c  
    5252#include <symtab.h>
    5353#include <macros.h>
     54#include <sysinfo/sysinfo.h>
     55#include <ddi/device.h>
    5456
    5557/** Simple kernel console.
     
    8486static char history[KCONSOLE_HISTORY][MAX_CMDLINE] = {};
    8587
    86 /** Initialize kconsole data structures. */
     88/*
     89 * For now, we use 0 as INR.
     90 * However, it is therefore desirable to have architecture specific
     91 * definition of KCONSOLE_VIRT_INR in the future.
     92 */
     93#define KCONSOLE_VIRT_INR  0
     94
     95bool kconsole_notify = false;
     96irq_t kconsole_irq;
     97
     98
     99/** Allways refuse IRQ ownership.
     100 *
     101 * This is not a real IRQ, so we always decline.
     102 *
     103 * @return Always returns IRQ_DECLINE.
     104 *
     105 */
     106static irq_ownership_t kconsole_claim(void)
     107{
     108        return IRQ_DECLINE;
     109}
     110
     111
     112/** Initialize kconsole data structures
     113 *
     114 * This is the most basic initialization, almost no
     115 * other kernel subsystem is ready yet.
     116 *
     117 */
    87118void kconsole_init(void)
    88119{
    89         int i;
     120        unsigned int i;
    90121
    91122        cmd_init();
    92123        for (i = 0; i < KCONSOLE_HISTORY; i++)
    93124                history[i][0] = '\0';
     125}
     126
     127
     128/** Initialize kconsole notification mechanism
     129 *
     130 * Initialize the virtual IRQ notification mechanism.
     131 *
     132 */
     133void kconsole_notify_init(void)
     134{
     135        devno_t devno = device_assign_devno();
     136       
     137        sysinfo_set_item_val("kconsole.present", NULL, true);
     138        sysinfo_set_item_val("kconsole.devno", NULL, devno);
     139        sysinfo_set_item_val("kconsole.inr", NULL, KCONSOLE_VIRT_INR);
     140       
     141        irq_initialize(&kconsole_irq);
     142        kconsole_irq.devno = devno;
     143        kconsole_irq.inr = KCONSOLE_VIRT_INR;
     144        kconsole_irq.claim = kconsole_claim;
     145        irq_register(&kconsole_irq);
     146       
     147        kconsole_notify = true;
    94148}
    95149
  • kernel/generic/src/main/main.c

    r6b21292 r3ad953c  
    199199            config.base, config.kernel_size, config.stack_base,
    200200            config.stack_size);
    201 
     201       
    202202#ifdef CONFIG_KCONSOLE
    203203        /*
     
    214214         */
    215215        LOG_EXEC(exc_init());
    216 
     216       
    217217        /*
    218218         * Memory management subsystems initialization.
     
    260260        LOG_EXEC(ipc_init());
    261261        LOG_EXEC(klog_init());
    262 
     262       
     263#ifdef CONFIG_KCONSOLE
     264        LOG_EXEC(kconsole_notify_init());
     265#endif
     266       
    263267        /*
    264268         * Create kernel task.
  • uspace/app/klog/klog.c

    r6b21292 r3ad953c  
    8787                return -1;
    8888        }
    89 
     89       
     90        int devno = sysinfo_value("klog.devno");
    9091        int inr = sysinfo_value("klog.inr");
    91         int devno = sysinfo_value("klog.devno");
    9292        if (ipc_register_irq(inr, devno, 0, NULL) != EOK) {
    9393                printf(NAME ": Error registering klog notifications\n");
  • uspace/srv/console/console.c

    r6b21292 r3ad953c  
    4949#include <sys/mman.h>
    5050#include <stdio.h>
     51#include <sysinfo.h>
    5152
    5253#include "gcons.h"
     
    5960 */
    6061int active_console = 0;
     62int prev_console = 0;
    6163
    6264/** Information about framebuffer
     
    208210                async_serialize_end();
    209211               
    210                 if (__SYSCALL0(SYS_DEBUG_ENABLE_CONSOLE))
     212                if (__SYSCALL0(SYS_DEBUG_ENABLE_CONSOLE)) {
     213                        prev_console = active_console;
    211214                        active_console = KERNEL_CONSOLE;
    212                 else
     215                } else
    213216                        newcons = active_console;
    214217        }
     
    236239                                }
    237240                        /* This call can preempt, but we are already at the end */
    238                         rc = async_req_0_0(fb_info.phone, FB_DRAW_TEXT_DATA);           
     241                        rc = async_req_0_0(fb_info.phone, FB_DRAW_TEXT_DATA);
    239242                }
    240243               
     
    244247                        style = &conn->screenbuffer.style;
    245248                       
    246                         for (j = 0; j < conn->screenbuffer.size_y; j++) 
     249                        for (j = 0; j < conn->screenbuffer.size_y; j++)
    247250                                for (i = 0; i < conn->screenbuffer.size_x; i++) {
    248251                                        field = get_field_at(&conn->screenbuffer, i, j);
     
    341344        ipcarg_t arg1, arg2;
    342345        connection_t *conn;
    343 
     346       
    344347        if ((consnum = find_free_connection()) == -1) {
    345348                ipc_answer_0(iid, ELIMIT);
     
    356359        /* Accept the connection */
    357360        ipc_answer_0(iid, EOK);
    358 
     361       
    359362        while (1) {
    360363                async_serialize_end();
    361364                callid = async_get_call(&call);
    362365                async_serialize_start();
    363 
     366               
    364367                arg1 = 0;
    365368                arg2 = 0;
     
    369372                       
    370373                        /* Answer all pending requests */
    371                         while (conn->keyrequest_counter > 0) {         
     374                        while (conn->keyrequest_counter > 0) {
    372375                                conn->keyrequest_counter--;
    373376                                ipc_answer_0(fifo_pop(conn->keyrequests),
     
    444447}
    445448
     449static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
     450{
     451        change_console(prev_console);
     452}
     453
    446454int main(int argc, char *argv[])
    447455{
     
    451459        int kbd_phone;
    452460        int i;
    453 
     461       
    454462        async_set_client_connection(client_connection);
    455463       
    456464        /* Connect to keyboard driver */
    457 
     465       
    458466        kbd_phone = ipc_connect_me_to(PHONE_NS, SERVICE_KEYBOARD, 0, 0);
    459467        while (kbd_phone < 0) {
     
    512520                }
    513521        }
    514 
     522       
    515523        curs_goto(0, 0);
    516524        curs_visibility(
    517525            connections[active_console].screenbuffer.is_cursor_visible);
    518 
     526       
    519527        /* Register at NS */
    520528        if (ipc_connect_to_me(PHONE_NS, SERVICE_CONSOLE, 0, 0, &phonehash) != 0)
    521529                return -1;
    522530       
     531        /* Receive kernel notifications */
     532        if (sysinfo_value("kconsole.present")) {
     533                int devno = sysinfo_value("kconsole.devno");
     534                int inr = sysinfo_value("kconsole.inr");
     535                if (ipc_register_irq(inr, devno, 0, NULL) != EOK)
     536                        printf(NAME ": Error registering kconsole notifications\n");
     537               
     538                async_set_interrupt_received(interrupt_received);
     539        }
     540       
    523541        // FIXME: avoid connectiong to itself, keep using klog
    524542        // printf(NAME ": Accepting connections\n");
    525543        async_manager();
    526 
    527         return 0;       
     544       
     545        return 0;
    528546}
    529547 
Note: See TracChangeset for help on using the changeset viewer.