Changes in / [9df6b0f:dc5a1f26] in mainline


Ignore:
Files:
32 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    r9df6b0f rdc5a1f26  
    609609! [CONFIG_DEBUG=y] CONFIG_TEST_DRIVERS (n/y)
    610610
     611% Load disk drivers on startup
     612! CONFIG_START_BD (n/y)
     613
     614% Mount /data on startup
     615! [CONFIG_START_BD=y] CONFIG_MOUNT_DATA (n/y)
     616
    611617% Write core files
    612618! CONFIG_WRITE_CORE_FILES (n/y)

  • boot/arch/ia64/Makefile.inc

    r9df6b0f rdc5a1f26  
    7474        arch/$(BARCH)/src/ski.c
    7575endif
    76 
    77 RD_DRVS_ESSENTIAL += \
    78         infrastructure/rootpc \
    79         bus/pci/pciintel \
    80         bus/isa \
    81         char/i8042 \
    82         char/xtkbd
    83 
    84 RD_DRVS_NON_ESSENTIAL += \
    85         char/ns8250 \
    86         time/cmos-rtc \
    87         bus/usb/ehci\
    88         bus/usb/ohci \
    89         bus/usb/uhci \
    90         bus/usb/uhcirh \
    91         bus/usb/usbflbk \
    92         bus/usb/usbhub \
    93         bus/usb/usbhid \
    94         bus/usb/usbmast \
    95         bus/usb/usbmid \
    96         bus/usb/vhc
    97 
    98 RD_DRV_CFG += \
    99         bus/isa
    100 

  • defaults/amd64/Makefile.config

    r9df6b0f rdc5a1f26  
    5959CONFIG_BFB_BPP = 16
    6060
     61# Load disk drivers on startup
     62CONFIG_START_BD = n
     63
     64# Mount /data on startup
     65CONFIG_MOUNT_DATA = n
     66
    6167# OHCI root hub power switch, ganged is enough
    6268OHCI_POWER_SWITCH = ganged

  • defaults/arm32/Makefile.config

    r9df6b0f rdc5a1f26  
    3434# What is your output device?
    3535CONFIG_HID_OUT = generic
     36
     37# Load disk drivers on startup
     38CONFIG_START_BD = n
     39
     40# Mount /data on startup
     41CONFIG_MOUNT_DATA = n
     42

  • defaults/ia32/Makefile.config

    r9df6b0f rdc5a1f26  
    6565CONFIG_BFB_BPP = 16
    6666
     67# Load disk drivers on startup
     68CONFIG_START_BD = n
     69
     70# Mount /data on startup
     71CONFIG_MOUNT_DATA = n
     72
    6773# OHCI root hub power switch, ganged is enough
    6874OHCI_POWER_SWITCH = ganged

  • defaults/ia64/Makefile.config

    r9df6b0f rdc5a1f26  
    4646# Output device class
    4747CONFIG_HID_OUT = generic
     48
     49# Load disk drivers on startup
     50CONFIG_START_BD = n
     51
     52# Mount /data on startup
     53CONFIG_MOUNT_DATA = n
     54

  • defaults/mips32/Makefile.config

    r9df6b0f rdc5a1f26  
    4141CONFIG_HID_OUT = generic
    4242
     43# Load disk drivers on startup
     44CONFIG_START_BD = n
     45
     46# Mount /data on startup
     47CONFIG_MOUNT_DATA = n
     48
    4349# Barebone build with essential binaries only
    4450CONFIG_BAREBONE = y

  • defaults/mips64/Makefile.config

    r9df6b0f rdc5a1f26  
    4040# Output device class
    4141CONFIG_HID_OUT = generic
     42
     43# Load disk drivers on startup
     44CONFIG_START_BD = n
     45
     46# Mount /data on startup
     47CONFIG_MOUNT_DATA = n
     48

  • defaults/ppc32/Makefile.config

    r9df6b0f rdc5a1f26  
    3838CONFIG_FB = y
    3939
     40# Load disk drivers on startup
     41CONFIG_START_BD = n
     42
     43# Mount /data on startup
     44CONFIG_MOUNT_DATA = n
     45
    4046# OHCI root hub power switch, ganged is enough
    4147OHCI_POWER_SWITCH = ganged

  • defaults/sparc32/Makefile.config

    r9df6b0f rdc5a1f26  
    5252# Start AP processors by the loader
    5353CONFIG_AP = y
     54
     55# Load disk drivers on startup
     56CONFIG_START_BD = n
     57
     58# Mount /data on startup
     59CONFIG_MOUNT_DATA = n
     60

  • defaults/sparc64/Makefile.config

    r9df6b0f rdc5a1f26  
    5252# Start AP processors by the loader
    5353CONFIG_AP = y
     54
     55# Load disk drivers on startup
     56CONFIG_START_BD = n
     57
     58# Mount /data on startup
     59CONFIG_MOUNT_DATA = n
     60

  • defaults/special/Makefile.config

    r9df6b0f rdc5a1f26  
    2828# Compile kernel tests
    2929CONFIG_TEST = y
     30
     31# Load disk drivers on startup
     32CONFIG_START_BD = n
     33

  • kernel/arch/ia64/src/drivers/ski.c

    r9df6b0f rdc5a1f26  
    6161static outdev_operations_t skidev_ops = {
    6262        .write = ski_putchar,
    63         .redraw = NULL,
    64         .scroll_up = NULL,
    65         .scroll_down = NULL
     63        .redraw = NULL
    6664};
    6765

  • kernel/arch/mips32/src/mach/malta/malta.c

    r9df6b0f rdc5a1f26  
    9292static outdev_operations_t yamon_outdev_ops = {
    9393        .write = yamon_putchar,
    94         .redraw = NULL,
    95         .scroll_up = NULL,
    96         .scroll_down = NULL
     94        .redraw = NULL
    9795};
    9896

  • kernel/arch/sparc64/src/drivers/niagara.c

    r9df6b0f rdc5a1f26  
    6363static outdev_operations_t niagara_ops = {
    6464        .write = niagara_putchar,
    65         .redraw = NULL,
    66         .scroll_up = NULL,
    67         .scroll_down = NULL
     65        .redraw = NULL
    6866};
    6967

  • kernel/genarch/include/genarch/fb/fb.h

    r9df6b0f rdc5a1f26  
    6666} fb_properties_t;
    6767
    68 extern outdev_t *fb_init(fb_properties_t *props);
     68outdev_t *fb_init(fb_properties_t *props);
    6969
    7070#endif

  • kernel/genarch/src/drivers/dsrln/dsrlnout.c

    r9df6b0f rdc5a1f26  
    6363static outdev_operations_t dsrlndev_ops = {
    6464        .write = dsrlnout_putchar,
    65         .redraw = NULL,
    66         .scroll_up = NULL,
    67         .scroll_down = NULL
     65        .redraw = NULL
    6866};
    6967

  • kernel/genarch/src/drivers/ega/ega.c

    r9df6b0f rdc5a1f26  
    7676static outdev_operations_t egadev_ops = {
    7777        .write = ega_putchar,
    78         .redraw = ega_redraw,
    79         .scroll_up = NULL,
    80         .scroll_down = NULL
     78        .redraw = ega_redraw
    8179};
    8280

  • kernel/genarch/src/drivers/grlib/uart.c

    r9df6b0f rdc5a1f26  
    100100static outdev_operations_t grlib_uart_ops = {
    101101        .write = grlib_uart_putchar,
    102         .redraw = NULL,
    103         .scroll_up = NULL,
    104         .scroll_down = NULL
     102        .redraw = NULL
    105103};
    106104

  • kernel/genarch/src/drivers/omap/uart.c

    r9df6b0f rdc5a1f26  
    6161
    6262static outdev_operations_t omap_uart_ops = {
     63        .redraw = NULL,
    6364        .write = omap_uart_putchar,
    64         .redraw = NULL,
    65         .scroll_up = NULL,
    66         .scroll_down = NULL
    6765};
    6866

  • kernel/genarch/src/drivers/pl011/pl011.c

    r9df6b0f rdc5a1f26  
    7272        .write = pl011_uart_putchar,
    7373        .redraw = NULL,
    74         .scroll_up = NULL,
    75         .scroll_down = NULL
    7674};
    7775

  • kernel/genarch/src/drivers/s3c24xx/uart.c

    r9df6b0f rdc5a1f26  
    9595static outdev_operations_t s3c24xx_uart_ops = {
    9696        .write = s3c24xx_uart_putchar,
    97         .redraw = NULL,
    98         .scroll_up = NULL,
    99         .scroll_down = NULL
     97        .redraw = NULL
    10098};
    10199

  • kernel/genarch/src/fb/fb.c

    r9df6b0f rdc5a1f26  
    5656#define INV_COLOR    0xaaaaaa
    5757
    58 #define FB_PAGES  8
    59 
    6058#define RED(x, bits)    (((x) >> (8 + 8 + 8 - (bits))) & ((1 << (bits)) - 1))
    6159#define GREEN(x, bits)  (((x) >> (8 + 8 - (bits))) & ((1 << (bits)) - 1))
    … …  
    7270
    7371#define BB_POS(instance, col, row) \
    74         ((((instance)->start_row + (row)) % (instance)->rows) * \
    75             (instance)->cols + (col))
     72        ((row) * (instance)->cols + (col))
    7673
    7774#define GLYPH_POS(instance, glyph, y) \
    … …  
    9592        unsigned int yres;
    9693       
    97         /** Number of rows that fit on framebuffer */
    9894        unsigned int rowtrim;
    9995       
    … …  
    105101        unsigned int bgscanbytes;
    106102       
    107         /** Number of columns in the backbuffer */
    108103        unsigned int cols;
    109         /** Number of rows in the backbuffer */
    110104        unsigned int rows;
    111105       
    112         /** Starting row in the cyclic backbuffer */
    113         unsigned int start_row;
    114        
    115         /** Top-most visible row (relative to start_row) */
    116         unsigned int offset_row;
    117        
    118         /** Current backbuffer position */
    119106        unsigned int position;
    120107} fb_instance_t;
    121108
    122 static void fb_putchar(outdev_t *, wchar_t);
    123 static void fb_redraw(outdev_t *);
    124 static void fb_scroll_up(outdev_t *);
    125 static void fb_scroll_down(outdev_t *);
     109static void fb_putchar(outdev_t *dev, wchar_t ch);
     110static void fb_redraw_internal(fb_instance_t *instance);
     111static void fb_redraw(outdev_t *dev);
    126112
    127113static outdev_operations_t fbdev_ops = {
    128114        .write = fb_putchar,
    129         .redraw = fb_redraw,
    130         .scroll_up = fb_scroll_up,
    131         .scroll_down = fb_scroll_down
     115        .redraw = fb_redraw
    132116};
    133117
    … …  
    232216    unsigned int col, unsigned int row, bool overlay)
    233217{
     218        unsigned int x = COL2X(col);
     219        unsigned int y = ROW2Y(row);
     220        unsigned int yd;
     221       
    234222        if (!overlay)
    235223                instance->backbuf[BB_POS(instance, col, row)] = glyph;
    236224       
    237         /* Do not output if the framebuffer is used by user space */
    238         if ((instance->parea.mapped) && (!console_override))
    239                 return;
    240        
    241         /* Check whether the glyph should be visible */
    242         if (row < instance->offset_row)
    243                 return;
    244        
    245         unsigned int rel_row = row - instance->offset_row;
    246         if (rel_row >= instance->rowtrim)
    247                 return;
    248        
    249         unsigned int x = COL2X(col);
    250         unsigned int y = ROW2Y(rel_row);
    251        
    252         for (unsigned int yd = 0; yd < FONT_SCANLINES; yd++)
    253                 memcpy(&instance->addr[FB_POS(instance, x, y + yd)],
    254                     &instance->glyphs[GLYPH_POS(instance, glyph, yd)],
    255                     instance->glyphscanline);
     225        if ((!instance->parea.mapped) || (console_override)) {
     226                for (yd = 0; yd < FONT_SCANLINES; yd++)
     227                        memcpy(&instance->addr[FB_POS(instance, x, y + yd)],
     228                            &instance->glyphs[GLYPH_POS(instance, glyph, yd)],
     229                            instance->glyphscanline);
     230        }
    256231}
    257232
    258233/** Scroll screen down by one row
    259234 *
     235 *
    260236 */
    261237static void screen_scroll(fb_instance_t *instance)
    262238{
    263239        if ((!instance->parea.mapped) || (console_override)) {
    264                 for (unsigned int rel_row = 0; rel_row < instance->rowtrim; rel_row++) {
    265                         unsigned int y = ROW2Y(rel_row);
    266                         unsigned int row = rel_row + instance->offset_row;
     240                unsigned int row;
     241               
     242                for (row = 0; row < instance->rows; row++) {
     243                        unsigned int y = ROW2Y(row);
     244                        unsigned int yd;
    267245                       
    268                         for (unsigned int yd = 0; yd < FONT_SCANLINES; yd++) {
     246                        for (yd = 0; yd < FONT_SCANLINES; yd++) {
    269247                                unsigned int x;
    270248                                unsigned int col;
    … …  
    291269        }
    292270       
    293         /*
    294          * Implement backbuffer scrolling by wrapping around
    295          * the cyclic buffer.
    296          */
    297        
    298         instance->start_row++;
    299         if (instance->start_row == instance->rows)
    300                 instance->start_row = 0;
    301        
     271        memmove(instance->backbuf, &instance->backbuf[BB_POS(instance, 0, 1)],
     272            instance->cols * (instance->rows - 1) * sizeof(uint16_t));
    302273        memsetw(&instance->backbuf[BB_POS(instance, 0, instance->rows - 1)],
    303274            instance->cols, 0);
    … …  
    363334}
    364335
     336/** Print character to screen
     337 *
     338 * Emulate basic terminal commands.
     339 *
     340 */
     341static void fb_putchar(outdev_t *dev, wchar_t ch)
     342{
     343        fb_instance_t *instance = (fb_instance_t *) dev->data;
     344        spinlock_lock(&instance->lock);
     345       
     346        switch (ch) {
     347        case '\n':
     348                cursor_remove(instance);
     349                instance->position += instance->cols;
     350                instance->position -= instance->position % instance->cols;
     351                break;
     352        case '\r':
     353                cursor_remove(instance);
     354                instance->position -= instance->position % instance->cols;
     355                break;
     356        case '\b':
     357                cursor_remove(instance);
     358                if (instance->position % instance->cols)
     359                        instance->position--;
     360                break;
     361        case '\t':
     362                cursor_remove(instance);
     363                do {
     364                        glyph_draw(instance, fb_font_glyph(' '),
     365                            instance->position % instance->cols,
     366                            instance->position / instance->cols, false);
     367                        instance->position++;
     368                } while (((instance->position % instance->cols) % 8 != 0) &&
     369                    (instance->position < instance->cols * instance->rows));
     370                break;
     371        default:
     372                glyph_draw(instance, fb_font_glyph(ch),
     373                    instance->position % instance->cols,
     374                    instance->position / instance->cols, false);
     375                instance->position++;
     376        }
     377       
     378        if (instance->position >= instance->cols * instance->rows) {
     379                instance->position -= instance->cols;
     380                screen_scroll(instance);
     381        }
     382       
     383        cursor_put(instance);
     384       
     385        spinlock_unlock(&instance->lock);
     386}
     387
    365388static void fb_redraw_internal(fb_instance_t *instance)
    366389{
    367         for (unsigned int rel_row = 0; rel_row < instance->rowtrim; rel_row++) {
    368                 unsigned int y = ROW2Y(rel_row);
    369                 unsigned int row = rel_row + instance->offset_row;
    370                
    371                 for (unsigned int yd = 0; yd < FONT_SCANLINES; yd++) {
     390        unsigned int row;
     391       
     392        for (row = 0; row < instance->rowtrim; row++) {
     393                unsigned int y = ROW2Y(row);
     394                unsigned int yd;
     395               
     396                for (yd = 0; yd < FONT_SCANLINES; yd++) {
    372397                        unsigned int x;
    373398                        unsigned int col;
    … …  
    403428}
    404429
    405 /** Print character to screen
    406  *
    407  * Emulate basic terminal commands.
    408  *
    409  */
    410 static void fb_putchar(outdev_t *dev, wchar_t ch)
    411 {
    412         fb_instance_t *instance = (fb_instance_t *) dev->data;
    413         spinlock_lock(&instance->lock);
    414        
    415         switch (ch) {
    416         case '\n':
    417                 cursor_remove(instance);
    418                 instance->position += instance->cols;
    419                 instance->position -= instance->position % instance->cols;
    420                 break;
    421         case '\r':
    422                 cursor_remove(instance);
    423                 instance->position -= instance->position % instance->cols;
    424                 break;
    425         case '\b':
    426                 cursor_remove(instance);
    427                 if (instance->position % instance->cols)
    428                         instance->position--;
    429                 break;
    430         case '\t':
    431                 cursor_remove(instance);
    432                 do {
    433                         glyph_draw(instance, fb_font_glyph(' '),
    434                             instance->position % instance->cols,
    435                             instance->position / instance->cols, false);
    436                         instance->position++;
    437                 } while (((instance->position % instance->cols) % 8 != 0) &&
    438                     (instance->position < instance->cols * instance->rows));
    439                 break;
    440         default:
    441                 glyph_draw(instance, fb_font_glyph(ch),
    442                     instance->position % instance->cols,
    443                     instance->position / instance->cols, false);
    444                 instance->position++;
    445         }
    446        
    447         if (instance->position >= instance->cols * instance->rows) {
    448                 instance->position -= instance->cols;
    449                 screen_scroll(instance);
    450         }
    451        
    452         cursor_put(instance);
    453        
    454         spinlock_unlock(&instance->lock);
    455 }
    456 
    457 /** Scroll the framebuffer up
    458  *
    459  */
    460 static void fb_scroll_up(outdev_t *dev)
    461 {
    462         fb_instance_t *instance = (fb_instance_t *) dev->data;
    463         spinlock_lock(&instance->lock);
    464        
    465         if (instance->offset_row >= instance->rowtrim / 2)
    466                 instance->offset_row -= instance->rowtrim / 2;
    467         else
    468                 instance->offset_row = 0;
    469        
    470         fb_redraw_internal(instance);
    471         cursor_put(instance);
    472        
    473         spinlock_unlock(&instance->lock);
    474 }
    475 
    476 /** Scroll the framebuffer down
    477  *
    478  */
    479 static void fb_scroll_down(outdev_t *dev)
    480 {
    481         fb_instance_t *instance = (fb_instance_t *) dev->data;
    482         spinlock_lock(&instance->lock);
    483        
    484         if (instance->offset_row + instance->rowtrim / 2 <=
    485             instance->rows - instance->rowtrim)
    486                 instance->offset_row += instance->rowtrim / 2;
    487         else
    488                 instance->offset_row = instance->rows - instance->rowtrim;
    489        
    490         fb_redraw_internal(instance);
    491         cursor_put(instance);
    492        
    493         spinlock_unlock(&instance->lock);
    494 }
    495 
    496430/** Refresh the screen
    497431 *
    … …  
    589523        instance->yres = props->y;
    590524        instance->scanline = props->scan;
    591        
    592         instance->rowtrim = Y2ROW(instance->yres);
     525        instance->position = 0;
    593526       
    594527        instance->cols = X2COL(instance->xres);
    595         instance->rows = FB_PAGES * instance->rowtrim;
    596        
    597         instance->start_row = instance->rows - instance->rowtrim;
    598         instance->offset_row = instance->start_row;
    599         instance->position = instance->start_row * instance->cols;
     528        instance->rows = Y2ROW(instance->yres);
     529       
     530        instance->rowtrim = instance->rows;
    600531       
    601532        instance->glyphscanline = FONT_WIDTH * instance->pixelbytes;

  • kernel/genarch/src/kbrd/kbrd.c

    r9df6b0f rdc5a1f26  
    5656#include <arch.h>
    5757#include <macros.h>
    58 #include <str.h>
    5958
    6059#define IGNORE_CODE  0x7f
    … …  
    6665
    6766static indev_operations_t kbrd_raw_ops = {
    68         .poll = NULL,
    69         .signal = NULL
     67        .poll = NULL
    7068};
    7169
    … …  
    106104        bool shift;
    107105        bool capslock;
    108         wchar_t ch;
    109106       
    110107        spinlock_lock(&instance->keylock);
    … …  
    130127               
    131128                if (shift)
    132                         ch = sc_secondary_map[sc];
     129                        indev_push_character(instance->sink, sc_secondary_map[sc]);
    133130                else
    134                         ch = sc_primary_map[sc];
    135                
    136                 switch (ch) {
    137                 case U_PAGE_UP:
    138                         indev_signal(instance->sink, INDEV_SIGNAL_SCROLL_UP);
    139                         break;
    140                 case U_PAGE_DOWN:
    141                         indev_signal(instance->sink, INDEV_SIGNAL_SCROLL_DOWN);
    142                         break;
    143                 default:
    144                         indev_push_character(instance->sink, ch);
    145                 }
    146                
     131                        indev_push_character(instance->sink, sc_primary_map[sc]);
    147132                break;
    148133        }

  • kernel/genarch/src/srln/srln.c

    r9df6b0f rdc5a1f26  
    4343
    4444static indev_operations_t srln_raw_ops = {
    45         .poll = NULL,
    46         .signal = NULL
     45        .poll = NULL
    4746};
    4847

  • kernel/generic/include/console/chardev.h

    r9df6b0f rdc5a1f26  
    4343#define INDEV_BUFLEN  512
    4444
    45 /** Input character device out-of-band signal type. */
    46 typedef enum {
    47         INDEV_SIGNAL_SCROLL_UP = 0,
    48         INDEV_SIGNAL_SCROLL_DOWN
    49 } indev_signal_t;
    50 
    5145struct indev;
    5246
    53 /** Input character device operations interface. */
     47/* Input character device operations interface. */
    5448typedef struct {
    5549        /** Read character directly from device, assume interrupts disabled. */
    5650        wchar_t (* poll)(struct indev *);
    57        
    58         /** Signal out-of-band condition. */
    59         void (* signal)(struct indev *, indev_signal_t);
    6051} indev_operations_t;
    6152
    … …  
    7667} indev_t;
    7768
     69
    7870struct outdev;
    7971
    80 /** Output character device operations interface. */
     72/* Output character device operations interface. */
    8173typedef struct {
    8274        /** Write character to output. */
    … …  
    8577        /** Redraw any previously cached characters. */
    8678        void (* redraw)(struct outdev *);
    87        
    88         /** Scroll up in the device cache. */
    89         void (* scroll_up)(struct outdev *);
    90        
    91         /** Scroll down in the device cache. */
    92         void (* scroll_down)(struct outdev *);
    9379} outdev_operations_t;
    9480
    … …  
    11399extern void indev_push_character(indev_t *, wchar_t);
    114100extern wchar_t indev_pop_character(indev_t *);
    115 extern void indev_signal(indev_t *, indev_signal_t);
    116101
    117102extern void outdev_initialize(const char *, outdev_t *,

  • kernel/generic/src/console/chardev.c

    r9df6b0f rdc5a1f26  
    9494{
    9595        if (atomic_get(&haltstate)) {
    96                 /*
    97                  * If we are here, we are hopefully on the processor that
     96                /* If we are here, we are hopefully on the processor that
    9897                 * issued the 'halt' command, so proceed to read the character
    9998                 * directly from input
    … …  
    116115        waitq_sleep(&indev->wq);
    117116        irq_spinlock_lock(&indev->lock, true);
    118         wchar_t ch = indev->buffer[(indev->index - indev->counter) %
    119             INDEV_BUFLEN];
     117        wchar_t ch = indev->buffer[(indev->index - indev->counter) % INDEV_BUFLEN];
    120118        indev->counter--;
    121119        irq_spinlock_unlock(&indev->lock, true);
    122120       
    123121        return ch;
    124 }
    125 
    126 /** Signal out-of-band condition
    127  *
    128  * @param indev  Input character device.
    129  * @param signal Out-of-band condition to signal.
    130  *
    131  */
    132 void indev_signal(indev_t *indev, indev_signal_t signal)
    133 {
    134         if ((indev != NULL) && (indev->op != NULL) &&
    135             (indev->op->signal != NULL))
    136                 indev->op->signal(indev, signal);
    137122}
    138123

  • kernel/generic/src/console/console.c

    r9df6b0f rdc5a1f26  
    8484static outdev_t stdout_source;
    8585
    86 static void stdin_signal(indev_t *, indev_signal_t);
    87 
    8886static indev_operations_t stdin_ops = {
    89         .poll = NULL,
    90         .signal = stdin_signal
     87        .poll = NULL
    9188};
    9289
    9390static void stdout_write(outdev_t *, wchar_t);
    9491static void stdout_redraw(outdev_t *);
    95 static void stdout_scroll_up(outdev_t *);
    96 static void stdout_scroll_down(outdev_t *);
    9792
    9893static outdev_operations_t stdout_ops = {
    9994        .write = stdout_write,
    100         .redraw = stdout_redraw,
    101         .scroll_up = stdout_scroll_up,
    102         .scroll_down = stdout_scroll_down
     95        .redraw = stdout_redraw
    10396};
    10497
    … …  
    120113}
    121114
    122 static void stdin_signal(indev_t *indev, indev_signal_t signal)
    123 {
    124         switch (signal) {
    125         case INDEV_SIGNAL_SCROLL_UP:
    126                 if (stdout != NULL)
    127                         stdout_scroll_up(stdout);
    128                 break;
    129         case INDEV_SIGNAL_SCROLL_DOWN:
    130                 if (stdout != NULL)
    131                         stdout_scroll_down(stdout);
    132                 break;
    133         }
    134 }
    135 
    136115void stdout_wire(outdev_t *outdev)
    137116{
    … …  
    157136                if ((sink) && (sink->op->redraw))
    158137                        sink->op->redraw(sink);
    159         }
    160 }
    161 
    162 static void stdout_scroll_up(outdev_t *dev)
    163 {
    164         list_foreach(dev->list, link, outdev_t, sink) {
    165                 if ((sink) && (sink->op->scroll_up))
    166                         sink->op->scroll_up(sink);
    167         }
    168 }
    169 
    170 static void stdout_scroll_down(outdev_t *dev)
    171 {
    172         list_foreach(dev->list, link, outdev_t, sink) {
    173                 if ((sink) && (sink->op->scroll_down))
    174                         sink->op->scroll_down(sink);
    175138        }
    176139}
    … …  
    266229                        }
    267230                }
    268                
    269231                if (chr_encode(ch, buf, &offset, buflen - 1) == EOK) {
    270232                        putchar(ch);
    … …  
    302264
    303265/** Flush characters that are stored in the output buffer
    304  *
     266 * 
    305267 */
    306268void kio_flush(void)
    … …  
    332294
    333295/** Put a character into the output buffer.
    334  *
     296 * 
    335297 * The caller is required to hold kio_lock
    336298 */

  • uspace/Makefile

    r9df6b0f rdc5a1f26  
    176176#
    177177
    178 ifeq ($(UARCH), $(filter $(UARCH),amd64 ia32 ia64))
     178ifeq ($(UARCH),amd64)
     179        DIRS += \
     180                drv/infrastructure/rootpc \
     181                drv/bus/pci/pciintel \
     182                drv/bus/isa \
     183                drv/char/ns8250 \
     184                drv/time/cmos-rtc \
     185                srv/hw/irc/apic \
     186                srv/hw/irc/i8259
     187endif
     188
     189ifeq ($(UARCH),ia32)
    179190        DIRS += \
    180191                drv/infrastructure/rootpc \

  • uspace/app/init/init.c

    r9df6b0f rdc5a1f26  
    5959#define TMPFS_FS_TYPE      "tmpfs"
    6060#define TMPFS_MOUNT_POINT  "/tmp"
     61
     62#define DATA_FS_TYPE      "fat"
     63#define DATA_DEVICE       "bd/ata1disk0"
     64#define DATA_MOUNT_POINT  "/data"
    6165
    6266#define SRV_CONSOLE  "/srv/console"
    … …  
    312316}
    313317
     318static bool mount_data(void)
     319{
     320        int rc = mount(DATA_FS_TYPE, DATA_MOUNT_POINT, DATA_DEVICE, "wtcache", 0, 0);
     321        return mount_report("Data filesystem", DATA_MOUNT_POINT, DATA_FS_TYPE,
     322            DATA_DEVICE, rc);
     323}
     324
    314325int main(int argc, char *argv[])
    315326{
    … …  
    355366        srv_start("/srv/clipboard");
    356367        srv_start("/srv/remcons");
     368       
     369        /*
     370         * Start these synchronously so that mount_data() can be
     371         * non-blocking.
     372         */
     373#ifdef CONFIG_START_BD
     374        srv_start("/srv/ata_bd");
     375#endif
     376       
     377#ifdef CONFIG_MOUNT_DATA
     378        /* Make sure fat is running. */
     379        if (str_cmp(STRING(RDFMT), "fat") != 0)
     380                srv_start("/srv/fat");
     381       
     382        mount_data();
     383#else
     384        (void) mount_data;
     385#endif
    357386       
    358387        srv_start("/srv/input", HID_INPUT);

  • uspace/drv/bus/usb/uhci/hc.c

    r9df6b0f rdc5a1f26  
    123123        memcpy(cmds, uhci_irq_commands, sizeof(uhci_irq_commands));
    124124        uhci_regs_t *registers = (uhci_regs_t *) RNGABSPTR(*regs);
    125         cmds[0].addr = (void *) &registers->usbsts;
    126         cmds[3].addr = (void *) &registers->usbsts;
     125        cmds[0].addr = &registers->usbsts;
     126        cmds[3].addr = &registers->usbsts;
    127127
    128128        return EOK;

  • uspace/drv/bus/usb/uhci/hc.h

    r9df6b0f rdc5a1f26  
    4646typedef struct uhci_regs {
    4747        /** Command register, controls HC behaviour */
    48         ioport16_t usbcmd;
     48        uint16_t usbcmd;
    4949#define UHCI_CMD_MAX_PACKET (1 << 7)
    5050#define UHCI_CMD_CONFIGURE  (1 << 6)
    … …  
    5757
    5858        /** Status register, 1 means interrupt is asserted (if enabled) */
    59         ioport16_t usbsts;
     59        uint16_t usbsts;
    6060#define UHCI_STATUS_HALTED (1 << 5)
    6161#define UHCI_STATUS_PROCESS_ERROR (1 << 4)
    … …  
    6868
    6969        /** Interrupt enabled registers */
    70         ioport16_t usbintr;
     70        uint16_t usbintr;
    7171#define UHCI_INTR_SHORT_PACKET (1 << 3)
    7272#define UHCI_INTR_COMPLETE (1 << 2)
    … …  
    7575
    7676        /** Register stores frame number used in SOF packet */
    77         ioport16_t frnum;
     77        uint16_t frnum;
    7878
    7979        /** Pointer(physical) to the Frame List */
    80         ioport32_t flbaseadd;
     80        uint32_t flbaseadd;
    8181
    8282        /** SOF modification to match external timers */
    83         ioport8_t sofmod;
     83        uint8_t sofmod;
    8484} uhci_regs_t;
    8585
Note: See TracChangeset for help on using the changeset viewer.