Subversion Repositories HelenOS

/*

 * Copyright (c) 2008 Pavel Rimsky

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * - Redistributions of source code must retain the above copyright

 *   notice, this list of conditions and the following disclaimer.

 * - Redistributions in binary form must reproduce the above copyright

 *   notice, this list of conditions and the following disclaimer in the

 *   documentation and/or other materials provided with the distribution.

 * - The name of the author may not be used to endorse or promote products

 *   derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/** @addtogroup sparc64

 * @{

 */

/**

 * @file

 * @brief   SGCN driver.

 */

#include <arch/drivers/sgcn.h>

#include <genarch/ofw/ofw_tree.h>

#include <debug.h>

#include <func.h>

#include <print.h>

#include <mm/page.h>

#include <console/chardev.h>

#include <console/console.h>

#include <synch/spinlock.h>

/*

 * Physical address at which the SBBC starts. This value has been obtained

 * by inspecting (using Simics) memory accesses made by OBP. It is valid

 * for the Simics-simulated Serengeti machine. The author of this code is

 * not sure whether this value is valid generally.

 */

#define SBBC_START      0x63000000000

/* offset of SRAM within the SBBC memory */

#define SBBC_SRAM_OFFSET    0x900000

/* magic string contained at the beginning of SRAM */

#define SRAM_TOC_MAGIC      "TOCSRAM"

/*

 * Key into the SRAM table of contents which identifies the entry

 * describing the OBP console buffer. It is worth mentioning

 * that the OBP console buffer is not the only console buffer

 * which can be used. It is, however, used because when the kernel

 * is running, the OBP buffer is not used by OBP any more but OBP

 * has already made neccessary arangements so that the output will

 * be read from the OBP buffer and input will go to the OBP buffer.

 * Therefore HelenOS needs to make no such arrangements any more.

 */

#define CONSOLE_KEY     "OBPCONS"

/* magic string contained at the beginning of the console buffer */

#define SGCN_BUFFER_MAGIC   "CON"

/*

 * Returns a pointer to the object of a given type which is placed at the given

 * offset from the SRAM beginning.

 */

#define SRAM(type, offset)  ((type *) (sram_begin + (offset)))

/* Returns a pointer to the SRAM table of contents. */

#define SRAM_TOC        (SRAM(iosram_toc_t, 0))

/*

 * Returns a pointer to the object of a given type which is placed at the given

 * offset from the console buffer beginning.

 */

#define SGCN_BUFFER(type, offset) \

                ((type *) (sgcn_buffer_begin + (offset)))

/* Returns a pointer to the console buffer header. */

#define SGCN_BUFFER_HEADER  (SGCN_BUFFER(sgcn_buffer_header_t, 0))

/* starting address of SRAM, will be set by the init_sram_begin function */

static uintptr_t sram_begin;

/*

 * starting address of the SGCN buffer, will be set by the

 * init_sgcn_buffer_begin function

 */

static uintptr_t sgcn_buffer_begin;

/*

 * Ensures that writing to the buffer and consequent update of the write pointer

 * are together one atomic operation.

 */

SPINLOCK_INITIALIZE(sgcn_output_lock);

/*

 * Ensures that reading from the buffer and consequent update of the read

 * pointer are together one atomic operation.

 */

SPINLOCK_INITIALIZE(sgcn_input_lock);

/* functions referenced from definitions of I/O operations structures */

static void sgcn_noop(chardev_t *);

static void sgcn_putchar(chardev_t *, const char);

static char sgcn_key_read(chardev_t *);

/** character device output operations */

static chardev_operations_t sgcn_output_ops = {

    .suspend = sgcn_noop,

    .resume = sgcn_noop,

    .write = sgcn_putchar,

    .read = NULL

};

/** character device input operations */

static chardev_operations_t sgcn_input_ops = {

    .suspend = sgcn_noop,

    .resume = sgcn_noop,

    .read = sgcn_key_read

};

/** SGCN character output device */

chardev_t sgcn_stdout;

/** SGCN character input device */

chardev_t sgcn_input;

/**

 * Initializes the starting address of SRAM.

 *

 * The SRAM starts 0x900000 + C bytes behind the SBBC start in the

 * physical memory, where C is the value read from the "iosram-toc"

 * property of the "/chosen" OBP node. The sram_begin variable will

 * be set to the virtual address which maps to the SRAM physical

 * address.

 */

static void init_sram_begin(void)

{

    ofw_tree_node_t *chosen;

    ofw_tree_property_t *iosram_toc;

    chosen = ofw_tree_lookup("/chosen");

    if (!chosen)

        panic("Can't find /chosen.\n");

    iosram_toc = ofw_tree_getprop(chosen, "iosram-toc");

    if (!iosram_toc)

        panic("Can't find property \"iosram-toc\".\n");

    if (!iosram_toc->value)

        panic("Can't find SRAM TOC.\n");

    sram_begin = hw_map(

        SBBC_START + SBBC_SRAM_OFFSET

        + *((uint32_t *) iosram_toc->value),

        128 * 1024);

}

/**

 * Initializes the starting address of the SGCN buffer.

 *

 * The offset of the SGCN buffer within SRAM is obtained from the

 * SRAM table of contents. The table of contents contains

 * information about several buffers, among which there is an OBP

 * console buffer - this one will be used as the SGCN buffer.

 */

static void sgcn_buffer_begin_init(void)

{

    init_sram_begin();

    ASSERT(strcmp(SRAM_TOC->magic, SRAM_TOC_MAGIC) == 0);

    /* lookup TOC entry with the correct key */

    uint32_t i;

    for (i = 0; i < MAX_TOC_ENTRIES; i++) {

        if (strcmp(SRAM_TOC->keys[i].key, CONSOLE_KEY) == 0)

            break;

    }

    ASSERT(i < MAX_TOC_ENTRIES);

    sgcn_buffer_begin = sram_begin + SRAM_TOC->keys[i].offset;

}

/**

 * Default suspend/resume operation for the input device.

 */

static void sgcn_noop(chardev_t *d)

{

}

/**

 * Writes a single character to the SGCN (circular) output buffer

 * and updates the output write pointer so that SGCN gets to know

 * that the character has been written.

 */

static void sgcn_do_putchar(const char c)

{

    uint32_t begin = SGCN_BUFFER_HEADER->out_begin;

    uint32_t end = SGCN_BUFFER_HEADER->out_end;

    uint32_t size = end - begin;

    /* we need pointers to volatile variables */

    volatile char *buf_ptr = (volatile char *)

        SGCN_BUFFER(char, SGCN_BUFFER_HEADER->out_wrptr);

    volatile uint32_t *out_wrptr_ptr = &(SGCN_BUFFER_HEADER->out_wrptr);

    volatile uint32_t *out_rdptr_ptr = &(SGCN_BUFFER_HEADER->out_rdptr);

    /*

     * Write the character and increment the write pointer modulo the

     * output buffer size. Note that if we are to rewrite a character

     * which has not been read by the SGCN controller yet (i.e. the output

     * buffer is full), we need to wait until the controller reads some more

     * characters. We wait actively, which means that all threads waiting

     * for the lock are blocked. However, this situation is

     *   1) rare - the output buffer is big, so filling the whole

     *             output buffer is improbable

     *   2) short-lasting - it will take the controller only a fraction

     *             of millisecond to pick the unread characters up

     *   3) not serious - the blocked threads are those that print something

     *             to user console, which is not a time-critical operation

     */

    uint32_t new_wrptr = (((*out_wrptr_ptr) - begin + 1) % size) + begin;

    while (*out_rdptr_ptr == new_wrptr)

        ;

    *buf_ptr = c;

    *out_wrptr_ptr = new_wrptr;

}

/**

 * SGCN output operation. Prints a single character to the SGCN. If the line

 * feed character is written ('\n'), the carriage return character ('\r') is

 * written straight away.

 */

static void sgcn_putchar(struct chardev * cd, const char c)

{

    spinlock_lock(&sgcn_output_lock);

    sgcn_do_putchar(c);

    if (c == '\n') {

        sgcn_do_putchar('\r');

    }

    spinlock_unlock(&sgcn_output_lock);

}

/**

 * Called when actively reading the character. Not implemented yet.

 */

static char sgcn_key_read(chardev_t *d)

{

    return (char) 0;

}

/**

 * Function regularly called by the keyboard polling thread. Finds out whether

 * there are some unread characters in the input queue. If so, it picks them up

 * and sends them to the upper layers of HelenOS.

 */

void sgcn_poll(void)

{

    spinlock_lock(&sgcn_input_lock);

    char c;

    uint32_t begin = SGCN_BUFFER_HEADER->in_begin;

    uint32_t end = SGCN_BUFFER_HEADER->in_end;

    uint32_t size = end - begin;

    /* we need pointers to volatile variables */

    volatile char *buf_ptr = (volatile char *)

        SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);

    volatile uint32_t *in_wrptr_ptr = &(SGCN_BUFFER_HEADER->in_wrptr);

    volatile uint32_t *in_rdptr_ptr = &(SGCN_BUFFER_HEADER->in_rdptr);

    while (*in_rdptr_ptr != *in_wrptr_ptr) {

        c = *buf_ptr;

        *in_rdptr_ptr = (((*in_rdptr_ptr) - begin + 1) % size) + begin;

        buf_ptr = (volatile char *)

            SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);

        chardev_push_character(&sgcn_input, c);

        if (c == '\r')

            chardev_push_character(&sgcn_input, '\n');

    }

    spinlock_unlock(&sgcn_input_lock);

}

/**

 * A public function which initializes I/O from/to Serengeti console

 * and sets it as a default input/output.

 */

void sgcn_init(void)

{

    sgcn_buffer_begin_init();

    chardev_initialize("sgcn_output", &sgcn_stdout, &sgcn_output_ops);

    stdout = &sgcn_stdout;

    chardev_initialize("sgcn_input", &sgcn_input, &sgcn_input_ops);

    stdin = &sgcn_input;

}

/** @}

 */