;===========================================================================
;
;                                   smt
;
;===========================================================================

;---------------;
; max constants ;
;---------------;

MAX_STACK       equ 512 ;number of words in each stack
MAX_TASKS       equ 8

;-------------;
; task states ;
;-------------;

STATE_FREE      equ 0 ;dead, available task slot
STATE_READY     equ 1 ;running, no ipc activity
STATE_SEND      equ 2 ;sending an ipc message
STATE_RECV      equ 3 ;awaiting an ipc message
STATE_SREQ      equ 4 ;requesting an ipc service

;------------;
; task stack ;
;------------;

TSS_SIZE        equ 24 ;structure size (not on stack)
TSS_FLAGS       equ 22
TSS_CS          equ 20
TSS_IP          equ 18
TSS_AX          equ 16
TSS_BX          equ 14
TSS_CX          equ 12
TSS_DX          equ 10
TSS_SI          equ 8
TSS_DI          equ 6
TSS_BP          equ 4
TSS_DS          equ 2
TSS_ES          equ 0

;---------------;
; service types ;
;---------------;

SERVICE_NONE    equ 0 ;intermediate service (Ex: idle,console,hello)
SERVICE_GETC    equ 1 ;character input service (Ex: stdin)
SERVICE_PUTC    equ 2 ;character output service (Ex: stdout)

;-------------;
; irq offsets ;
;-------------;

IRQ0_IP         equ (08h*4)
IRQ0_CS         equ (08h*4+2)

;===========================================================================
; boot entry point
;===========================================================================

use16
org 7c00h

        ;-------------------;
        ; setup known cs:ip ;
        ;-------------------;

        jmp 0:start

;===========================================================================
; kernel entry point
;===========================================================================

start:  ;cs:ip = 0x0000:0x7c05

        ;--------------------;
        ; disable interrupts ;
        ;--------------------;

        cli

        ;---------------------;
        ; init kernel context ;
        ;---------------------;

        mov ax,cs
        mov ds,ax
        mov es,ax
        mov ss,ax
        mov sp,7c00h

        ;----------------;
        ; zero .bss data ;
        ;----------------;

        cld
        mov di,BSS_START
        mov cx,BSS_SIZE
        ;al = 0
        rep stosb

        ;-----------------;
        ; chain into irq0 ;
        ;-----------------;

        mov ax,[ds:IRQ0_IP]             ;get old ip
        mov [ds:old_irq0_ip],ax         ;store old ip
        mov [ds:IRQ0_IP],word irq0      ;write new ip

        mov ax,[ds:IRQ0_CS]             ;get old cs
        mov [ds:old_irq0_cs],ax         ;store old cs
        mov [ds:IRQ0_CS],cs             ;set new cs

        ;--------------------;
        ; start system tasks ;
        ;--------------------;

        mov ax,server_idle      ;task entry point offset
        mov cl,SERVICE_NONE     ;services the task can provide
        call sys_exec           ;input: ax = offset, cl = services
                                ;output: bx = handle

        mov ax,server_console   ;task entry point offset
        mov cl,SERVICE_NONE     ;services the task can provide
        call sys_exec           ;input: ax = offset, cl = services
                                ;output: bx = handle

        ;---------------------------------;
        ; map kernel into idle task space ;
        ;---------------------------------;

        mov [ds:active_task],MAX_TASKS*2-2 ;first task handle
        mov sp,MAX_STACK*2*MAX_TASKS+task_stacks

        sti ;enable scheduler
;       jmp server_idle

;===========================================================================
; system servers
;===========================================================================

;---------------------------------------------------------------------------

server_idle:

        hlt
        jmp server_idle

;---------------------------------------------------------------------------

server_video:

        ;-----------------------------;
        ; await video service request ;
        ;-----------------------------;

  .await_request:

        call sys_recv           ;out: bx = handle, dx = message, ax = packet

        ;------------------------------;
        ; handle video service request ;
        ;------------------------------;

        cmp dx,SERVICE_PUTC     ;only service we provide
        jne .await_request      ;go wait for more work

        ;---------------------------------------;
        ; provide teletype video output service ;
        ;---------------------------------------;

  .on_putc:

        mov ah,0eh              ;teletype output
        mov bh,0                ;video page number

        ;handle backspace characters properly

        cmp al,8
        jne .do_it
        int 10h                 ;BIOS video service
        mov al,32               ;print a space char
        int 10h                 ;BIOS video service
        mov al,8

  .do_it:

        int 10h                 ;BIOS video service

        ;compliment carriage-return with line-feed

        sub al,3
        cmp al,10
        je .do_it

        jmp .await_request      ;go wait for more work

;---------------------------------------------------------------------------

server_keyboard:

        ;--------------------------------;
        ; await keyboard service request ;
        ;--------------------------------;

  .await_request:

        call sys_recv           ;out: bx = handle, dx = message, ax = packet

        ;---------------------------------;
        ; handle keyboard service request ;
        ;---------------------------------;

        cmp dx,SERVICE_GETC     ;only service we provide
        jne .await_request      ;go wait for more work

        ;--------------------------------;
        ; provide keyboard input service ;
        ;--------------------------------;

  .on_getc:

        ;check keyboard buffer for keystroke

        mov ah,01h              ;check keystroke
        int 16h                 ;BIOS keyboard service

        ;if there is no keystroke available we wait for one

        jz .on_getc_wait

        ;remove keystroke from keyboard buffer

        xor ah,ah               ;get keystroke
        int 16h                 ;BIOS keyboard service

        ;send service request reply with data packet

        call sys_send           ;in: bx = handle, dx = message, ax = packet

        jmp .await_request      ;go wait for more work

  .on_getc_wait:

        ;an input request is still pending

        ;TODO: It would be better here to give up our time slice to next task.

        hlt             ;dont poll continuously
        jmp .on_getc    ;try again next schedule

;---------------------------------------------------------------------------

server_console:

        ;--------------------;
        ; start video server ;
        ;--------------------;

        mov ax,server_video             ;code entry point offset
        mov cl,SERVICE_PUTC             ;services the task can provide
        call sys_exec                   ;in: ax = offset, cl = services
                                        ;out: bx = handle

        ;TODO: Verify task handle and try agin later if no slots available.
        ;      This should never happen since its the third task started.

        mov [ds:console_stdout],bx      ;store stdout handle

        ;-----------------------;
        ; start keyboard server ;
        ;-----------------------;

        mov ax,server_keyboard          ;code entry point offset
        mov cl,SERVICE_GETC             ;services the task can provide
        call sys_exec                   ;in: ax = offset, cl = services
                                        ;out: bx = handle

        ;TODO: Verify task handle and try agin later if no slots available.
        ;      This should never happen since its the fourth task started.

        mov [ds:console_stdin],bx       ;store stdin handle

        ;--------------------------;
        ; start hello world server ;
        ;--------------------------;

  .say_hello:

        mov ax,server_hello             ;task entry point offset
        mov cl,SERVICE_NONE             ;services the task can provide
        call sys_exec                   ;in: ax = offset, cl = services
                                        ;out: bx = handle

        ;TODO: Verify task handle and try agin later if no slots available.
        ;      At the moment we just ignore the request and go on living.

        ;--------------------------------;
        ; acquire and process user input ;
        ;--------------------------------;

  .wait_input:

        ;send input service request message to keyboard server

        mov dx,SERVICE_GETC             ;service request
        mov bx,[ds:console_stdin]       ;send to stdin
        call sys_send                   ;in: bx = handle, dx = message

        ;wait for keyboard server to reply

        call sys_recv                   ;out: bx = handle, dx = message, ax = packet

        ;TODO: Verify reply service by testing handle in bx (should be equal to service_stdin)

        ;an 'H' character spawns new hello world application

        cmp al,'H'
        je .say_hello

        ;any other data gets sent to stdout server

        mov dx,SERVICE_PUTC             ;service request
        mov bx,[ds:console_stdout]      ;send to stdout
        call sys_send                   ;in: bx = handle, dx = message, ax = packet

        jmp .wait_input ;go wait for more work

;---------------------------------------------------------------------------

str_hello db 'Hello World!',0

server_hello:

        ;--------------------------------------;
        ; display hello world message and quit ;
        ;--------------------------------------;

        mov si,str_hello

  .print:

        lodsb

        cmp al,0
        je .done

        ;This task has no idea of who provides video services
        ;so we must ask the system to try and find a handler.

        mov dx,SERVICE_PUTC             ;service request
        call sys_sreq                   ;in: dx = message, ax = packet
                                        ;out: bx = handle, dx = message, ax = packet

        ;If no video server was found, quit this task.

        or bx,bx                        ;compare bx to -2
        jns .print

  .done:

        ;This task exits upon completion of displaying its message.

;       call sys_exit   ;never returns

;===========================================================================
; system api
;===========================================================================

;---------------------------------------------------------------------------
; sys_exit -- exits a task
; in: no parameters
; out: never returns
; uses: bx
;---------------------------------------------------------------------------

sys_exit:

        mov bx,[ds:active_task]
        mov byte[ds:bx+task_states],STATE_FREE
        jmp $

;---------------------------------------------------------------------------
; sys_exec -- starts a new task
; in: ax = task offset, cl = ipc services
; out: bx = task handle (-2 = out of task slots)
; uses: di,dx
; notes: If no test slots are available it is up to the caller to try again
;        later, rather than hanging it while waiting for an open slot.
;---------------------------------------------------------------------------

sys_exec:

        pushf   ;disable interrupts only within this context
        cli

        mov bx,MAX_TASKS*2 ;allocate task handles from top down
        mov di,MAX_TASKS*2*MAX_STACK+task_stacks+MAX_STACK*2-TSS_SIZE ;allocate task stacks from top down

  .find_free_slot:

        sub di,MAX_STACK*2

        dec bx
        dec bx
        js .no_free_slot ;-2 = no task slots available

        cmp byte[ds:bx+task_states],STATE_FREE
        jne .find_free_slot

        mov [ds:bx+stack_ptrs],di

        pushf
        pop dx
        or dx,512 ;'IRQ enable' bit in the flags register

        mov [ds:di+TSS_FLAGS],dx
        mov [ds:di+TSS_CS],cs
        mov [ds:di+TSS_IP],ax
;       mov [ds:di+TSS_AX],0   ;no need to initialize these
;       mov [ds:di+TSS_BX],0
;       mov [ds:di+TSS_CX],0
;       mov [ds:di+TSS_DX],0
;       mov [ds:di+TSS_SI],0
;       mov [ds:di+TSS_DI],0
;       mov [ds:di+TSS_BP],0
        mov [ds:di+TSS_DS],cs
        mov [ds:di+TSS_ES],cs

        mov byte[ds:bx+ipc_services],cl
        mov byte[ds:bx+task_states],STATE_READY

  .no_free_slot:

        popf
        ret

;---------------------------------------------------------------------------
; sys_send -- sends an ipc message
; in: bx = ipc target handle, dx = message to send, ax = data packet to send
; out: no parameters
; uses: bp,cl
;---------------------------------------------------------------------------

sys_send:

        mov cl,STATE_SEND
        jmp ipc_squak

;---------------------------------------------------------------------------
; sys_recv -- receives an ipc message
; in: no parameters
; out: bx = source handle, dx = message to recv, ax = data packet to recv
; uses: bp,cl
;---------------------------------------------------------------------------

sys_recv:

        mov cl,STATE_RECV
        jmp ipc_squak

;---------------------------------------------------------------------------
; sys_sreq -- requests an ipc service
; in: dx = message, ax = data packet
; out: bx = ipc service handle (-2 = no handler found)
; uses: bp,cl
;---------------------------------------------------------------------------

sys_sreq:

        mov cl,STATE_SREQ
;       jmp ipc_squak

;---------------------------------------------------------------------------
; ipc_squak -- setup an ipc connection
; in: bx = handle, dx = message, ax = packet, cl = new state
; out: bx = handle, dx = message, ax = packet
; uses: bp
;---------------------------------------------------------------------------

ipc_squak:

        mov bp,[ds:active_task]

        mov [ss:bp+ipc_links],bx
        mov [ss:bp+ipc_messages],dx
        mov [ss:bp+ipc_packets],ax

        mov byte[ss:bp+task_states],cl

  .wait:

        cmp byte[ss:bp+task_states],STATE_READY
        jne .wait

        mov bx,[ss:bp+ipc_links]
        mov dx,[ss:bp+ipc_messages]
        mov ax,[ss:bp+ipc_packets]

        ret

;===========================================================================
; IRQ0 hook
;===========================================================================

irq0:

        ;--------------------;
        ; disable interrupts ;
        ;--------------------;

        cli

        ;----------------------;
        ; store active context ;
        ;----------------------;

        push ax
        push bx
        push cx
        push dx
        push si
        push di
        push bp
        push ds
        push es

        ;---------------------;
        ; load kernel context ;
        ;---------------------;

        mov ax,cs
        mov ds,ax
        mov es,ax
;       mov ss,ax

        ;----------------;
        ; load task info ;
        ;----------------;

        mov bx,[ds:active_task]
        mov ax,[ds:bx+task_states]
        mov di,[ds:bx+ipc_links]
        mov cx,[ds:bx+ipc_messages]
        mov dx,[ds:bx+ipc_packets]

        ;----------------------------;
        ; handle ipc service request ;
        ;----------------------------;

        cmp al,STATE_SREQ
        jne .not_sreq

        mov di,MAX_TASKS*2

  .find_service_handler:

        dec di
        dec di
        js .no_service_handler

        cmp [ds:di+ipc_services],cx ;can he handle this type of service request message
        jne .find_service_handler   ;keep looking for someone who can

        mov [ds:bx+ipc_links],di ;he can do it, so lets link ourself to him
        jmp .ipc_send            ;send package it to him

  .no_service_handler:

        mov [ds:bx+ipc_links],di ;no handler found so return -2
        jmp .task_done ;stop trying to post service request

  .not_sreq:

        ;----------------------------;
        ; handle ipc message passing ;
        ;----------------------------;

        cmp al,STATE_SEND
        jne .next_task

  .ipc_send:

        cmp byte[ds:di+task_states],STATE_RECV ;is target in recv mode?
        jne .next_task ;if not, try again later

  .ipc_copy:

        mov [ds:di+ipc_links],bx        ;tell target who sent it (us)
        mov [ds:di+ipc_messages],cx     ;put message in his mailbox
        mov [ds:di+ipc_packets],dx      ;put data in his mailbox

        mov byte[ds:di+task_states],STATE_READY ;take target out of recv mode (break his wait loop)

  .task_done:

        mov byte[ds:bx+task_states],STATE_READY ;take us out of send/sreq mode

  .next_task:

        ;------------------------;
        ; perform task sheduling ;
        ;------------------------;

        ;BX = active task handle

        ;The sheduler requires an idle task whith constant READY state to work properly.
        ;Otherwise we could end up in and endless loop trying to find a task to shedule.

        mov [ds:bx+stack_ptrs],sp

  .find_work:

        dec bx
        dec bx
        jns .check_state

        mov bx,MAX_TASKS*2-2 ;wrap around

  .check_state:

        cmp byte[ds:bx+task_states],STATE_FREE
        je .find_work ;dont schedule dead tasks

        cmp byte[ds:bx+task_states],STATE_RECV
        je .find_work ;dont schedule waiting tasks

        mov [ds:active_task],bx ;new active task handle

        ;-------------------;
        ; load task context ;
        ;-------------------;

        mov sp,[ds:bx+stack_ptrs]

        pop es
        pop ds
        pop bp
        pop di
        pop si
        pop dx
        pop cx
        pop bx
        pop ax

        ;---------------------------;
        ; jump far into old handler ;
        ;---------------------------;

            db 0eah  ;opcode: jmp far
old_irq0_ip dw 0000h ;hot-patch: ip
old_irq0_cs dw 0000h ;hot-patch: cs

;===========================================================================
; boot code finalization
;===========================================================================

db (510-($-$$)) dup(0)  ;currently at 495 bytes of code :)

dw 0aa55h

;===========================================================================
; uninitialized data
;===========================================================================

BSS_START:

  active_task           rw 1
  task_stacks           rw MAX_TASKS*MAX_STACK
  stack_ptrs            rw MAX_TASKS
  task_states           rw MAX_TASKS ;only lobyte is used
  ipc_services          rw MAX_TASKS ;only lobyte is used
  ipc_messages          rw MAX_TASKS
  ipc_links             rw MAX_TASKS
  ipc_packets           rw MAX_TASKS
  ;console server private data
  console_stdin         rw 1
  console_stdout        rw 1

BSS_SIZE = $ - BSS_START

;===========================================================================