Thema: Keyboard treiber und C/C++

[matthieuriolo]

Hey zusammen
ICh habe das problem das mein Linker meckert. Und es liegt daran (jedenfalls im C++ code) das er eine Methode nicht aufrufen kann.

Hier mal die Source:
C

Code: [Auswählen]

#include "Keyboard.h"
#include "Port.h"
#include "Pic.h"
#include "gdt.h"
#include "idt.h"

void ulong_strcnv();

#define LED_NUM_LOCK 2
#define LED_SCROLL_LOCK 1
#define LED_CAPS_LOCK 4

unsigned char led_status = 0;

/* keyboard_buffer stores every key typed */
unsigned char keyboard_buffer[255];
/* keyboard_buffer_size stores the number of keys in the buffer */
unsigned char keyboard_buffer_size = 0;

unsigned char control_keys = 0;

#define CK_SHIFT 1
#define CK_ALT 2
#define CK_CTRL 4

unsigned int scan2ascii_table[][8] =
{
/* ASCII - Shift - Ctrl - Alt - Num - Caps - Shift Caps - Shift Num */
{   0, 0, 0, 0, 0, 0, 0, 0},
{ 0x1B, 0x1B, 0x1B, 0, 0x1B, 0x1B, 0x1B, 0x1B},
/* 1 -> 9 */
{ 0x31, 0x21, 0, 0x7800, 0x31, 0x31, 0x21, 0x21},
{ 0x32, 0x40, 0x0300, 0x7900, 0x32, 0x32, 0x40, 0x40},
{ 0x33, 0x23, 0, 0x7A00, 0x33, 0x33, 0x23, 0x23},
{ 0x34, 0x24, 0, 0x7B00, 0x34, 0x34, 0x24, 0x24},
{ 0x35, 0x25, 0, 0x7C00, 0x35, 0x35, 0x25, 0x25},
{ 0x36, 0x5E, 0x1E, 0x7D00, 0x36, 0x36, 0x5E, 0x5E},
{ 0x37, 0x26, 0, 0x7E00, 0x37, 0x37, 0x26, 0x26},
{ 0x38, 0x2A, 0, 0x7F00, 0x38, 0x38, 0x2A, 0x2A},
{ 0x39, 0x28, 0, 0x8000, 0x39, 0x39, 0x28, 0x28},
{ 0x30, 0x29, 0, 0x8100, 0x30, 0x30, 0x29, 0x29},
/* -, =, Bksp, Tab */
{ 0x2D, 0x5F, 0x1F, 0x8200, 0x2D, 0x2D, 0x5F, 0x5F},
{ 0x3D, 0x2B, 0, 0x8300, 0x3D, 0x3D, 0x2B, 0x2B},
{ 0x08, 0x08, 0x7F, 0, 0x08, 0x08, 0x08, 0x08},
{ 0x09, 0x0F00, 0, 0, 0x09, 0x09, 0x0F00, 0x0F00},
/* QWERTYUIOP[] */
{ 0x71, 0x51, 0x11, 0x1000, 0x71, 0x51, 0x71, 0x51},
{ 0x77, 0x57, 0x17, 0x1100, 0x77, 0x57, 0x77, 0x57},
{ 0x65, 0x45, 0x05, 0x1200, 0x65, 0x45, 0x65, 0x45},
{ 0x72, 0x52, 0x12, 0x1300, 0x72, 0x52, 0x72, 0x52},
{ 0x74, 0x54, 0x14, 0x1400, 0x74, 0x54, 0x74, 0x54},
{ 0x79, 0x59, 0x19, 0x1500, 0x79, 0x59, 0x79, 0x59},
{ 0x75, 0x55, 0x15, 0x1600, 0x75, 0x55, 0x75, 0x55},
{ 0x69, 0x49, 0x09, 0x1700, 0x69, 0x49, 0x69, 0x49},
{ 0x6F, 0x4F, 0x0F, 0x1800, 0x6F, 0x4F, 0x6F, 0x4F},
{ 0x70, 0x50, 0x10, 0x1900, 0x70, 0x50, 0x70, 0x50},
{ 0x5B, 0x7B, 0x1B, 0x0, 0x5B, 0x5B, 0x7B, 0x7B},
{ 0x5D, 0x7D, 0x1D, 0, 0x5D, 0x5D, 0x7D, 0x7D},
/* ENTER, CTRL */
{ 0x0A, 0x0A, 0x0D, 0, 0x0A, 0x0A, 0x0D, 0x0D},
{ 0, 0, 0, 0, 0, 0, 0, 0},
/* ASDFGHJKL;'~ */
{ 0x61, 0x41, 0x01, 0x1E00, 0x61, 0x41, 0x61, 0x41},
{ 0x73, 0x53, 0x13, 0x1F00, 0x73, 0x53, 0x73, 0x53},
{ 0x64, 0x44, 0x04, 0x2000, 0x64, 0x44, 0x64, 0x44},
{ 0x66, 0x46, 0x06, 0x2100, 0x66, 0x46, 0x66, 0x46},
{ 0x67, 0x47, 0x07, 0x2200, 0x67, 0x47, 0x67, 0x47},
{ 0x68, 0x48, 0x08, 0x2300, 0x68, 0x48, 0x68, 0x48},
{ 0x6A, 0x4A, 0x0A, 0x2400, 0x6A, 0x4A, 0x6A, 0x4A},
{ 0x6B, 0x4B, 0x0B, 0x3500, 0x6B, 0x4B, 0x6B, 0x4B},
{ 0x6C, 0x4C, 0x0C, 0x2600, 0x6C, 0x4C, 0x6C, 0x4C},
{ 0x3B, 0x3A, 0, 0, 0x3B, 0x3B, 0x3A, 0x3A},
{ 0x27, 0x22, 0, 0, 0x27, 0x27, 0x22, 0x22},
{ 0x60, 0x7E, 0, 0, 0x60, 0x60, 0x7E, 0x7E},
/* Left Shift*/
{ 0x2A, 0, 0, 0, 0, 0, 0, 0},
/* \ZXCVBNM,./ */
{ 0x5C, 0x7C, 0x1C, 0, 0x5C, 0x5C, 0x7C, 0x7C},
{ 0x7A, 0x5A, 0x1A, 0x2C00, 0x7A, 0x5A, 0x7A, 0x5A},
{ 0x78, 0x58, 0x18, 0x2D00, 0x78, 0x58, 0x78, 0x58},
{ 0x63, 0x43, 0x03, 0x2E00, 0x63, 0x43, 0x63, 0x43},
{ 0x76, 0x56, 0x16, 0x2F00, 0x76, 0x56, 0x76, 0x56},
{ 0x62, 0x42, 0x02, 0x3000, 0x62, 0x42, 0x62, 0x42},
{ 0x6E, 0x4E, 0x0E, 0x3100, 0x6E, 0x4E, 0x6E, 0x4E},
{ 0x6D, 0x4D, 0x0D, 0x3200, 0x6D, 0x4D, 0x6D, 0x4D},
{ 0x2C, 0x3C, 0, 0, 0x2C, 0x2C, 0x3C, 0x3C},
{ 0x2E, 0x3E, 0, 0, 0x2E, 0x2E, 0x3E, 0x3E},
{ 0x2F, 0x3F, 0, 0, 0x2F, 0x2F, 0x3F, 0x3F},
/* Right Shift */
{ 0, 0, 0, 0, 0, 0, 0, 0},
/* Print Screen */
{ 0, 0, 0, 0, 0, 0, 0, 0},
/* Alt  */
{ 0, 0, 0, 0, 0, 0, 0, 0},
/* Space */
{ 0x20, 0x20, 0x20, 0, 0x20, 0x20, 0x20, 0x20},
/* Caps */
{ 0, 0, 0, 0, 0, 0, 0, 0},
/* F1-F10 */
{ 0x3B00, 0x5400, 0x5E00, 0x6800, 0x3B00, 0x3B00, 0x5400, 0x5400},
{ 0x3C00, 0x5500, 0x5F00, 0x6900, 0x3C00, 0x3C00, 0x5500, 0x5500},
{ 0x3D00, 0x5600, 0x6000, 0x6A00, 0x3D00, 0x3D00, 0x5600, 0x5600},
{ 0x3E00, 0x5700, 0x6100, 0x6B00, 0x3E00, 0x3E00, 0x5700, 0x5700},
{ 0x3F00, 0x5800, 0x6200, 0x6C00, 0x3F00, 0x3F00, 0x5800, 0x5800},
{ 0x4000, 0x5900, 0x6300, 0x6D00, 0x4000, 0x4000, 0x5900, 0x5900},
{ 0x4100, 0x5A00, 0x6400, 0x6E00, 0x4100, 0x4100, 0x5A00, 0x5A00},
{ 0x4200, 0x5B00, 0x6500, 0x6F00, 0x4200, 0x4200, 0x5B00, 0x5B00},
{ 0x4300, 0x5C00, 0x6600, 0x7000, 0x4300, 0x4300, 0x5C00, 0x5C00},
{ 0x4400, 0x5D00, 0x6700, 0x7100, 0x4400, 0x4400, 0x5D00, 0x5D00},
/* Num Lock, Scrl Lock */
{ 0, 0, 0, 0, 0, 0, 0, 0},
{ 0, 0, 0, 0, 0, 0, 0, 0},
/* HOME, Up, Pgup, -kpad, left, center, right, +keypad, end, down, pgdn, ins, del */
{ 0x4700, 0x37, 0x7700, 0, 0x37, 0x4700, 0x37, 0x4700},
{ 0x4800, 0x38, 0, 0, 0x38, 0x4800, 0x38, 0x4800},
{ 0x4900, 0x39, 0x8400, 0, 0x39, 0x4900, 0x39, 0x4900},
{ 0x2D, 0x2D, 0, 0, 0x2D, 0x2D, 0x2D, 0x2D},
{ 0x4B00, 0x34, 0x7300, 0, 0x34, 0x4B00, 0x34, 0x4B00},
{ 0x4C00, 0x35, 0, 0, 0x35, 0x4C00, 0x35, 0x4C00},
{ 0x4D00, 0x36, 0x7400, 0, 0x36, 0x4D00, 0x36, 0x4D00},
{ 0x2B, 0x2B, 0, 0, 0x2B, 0x2B, 0x2B, 0x2B},
{ 0x4F00, 0x31, 0x7500, 0, 0x31, 0x4F00, 0x31, 0x4F00},
{ 0x5000, 0x32, 0, 0, 0x32, 0x5000, 0x32, 0x5000},
{ 0x5100, 0x33, 0x7600, 0, 0x33, 0x5100, 0x33, 0x5100},
{ 0x5200, 0x30, 0, 0, 0x30, 0x5200, 0x30, 0x5200},
{ 0x5300, 0x2E, 0, 0, 0x2E, 0x5300, 0x2E, 0x5300}
};
extern void keyb_ISR();

asm (
   ".globl keyb_ISR        \n"
   "keyb_ISR:              \n"
   "   pusha               \n" /* Save all registers               */
   "   pushw %ds           \n" /* Set up the data segment          */
   "   pushw %es           \n"
   "   pushw %ss           \n" /* Note that ss is always valid     */
   "   pushw %ss           \n"
   "   popw %ds            \n"
   "   popw %es            \n"
   "                       \n"
   "   call keyb_handler   \n"
   "                       \n"
   "   popw %es            \n"
   "   popw %ds            \n" /* Restore registers                */
   "   popa                \n"
   "   iret                \n" /* Exit interrupt                   */
);

void setleds()
{
outportb(0x60, 0xED);
while(inportb(0x64) & 2);
outportb(0x60, led_status);
while(inportb(0x64) & 2);
}

void InitKeyboard()
{
    set_vector(M_VEC+1, D_PRESENT + D_INT + D_DPL3); /* IRQ1 Handler */
    enable_irq(1);

led_status = 0; /* All leds off */
setleds();
}

void keyb_handler(void)
{
unsigned int key = inportb(0x60);
unsigned int key_ascii = 0;

if((control_keys & (CK_CTRL+CK_ALT)) && key==0x53)
{
while(inportb(0x64) & 2);

outportb(0x64, 0xFE);

asm ("cli;hlt");
}

/* 'LED Keys', ie, Scroll lock, Num lock, and Caps lock */
if(key == 0x3A) /* Caps Lock */
{
led_status ^= LED_CAPS_LOCK;
setleds();
}
if(key == 0x45) /* Num Lock */
{
led_status ^= LED_NUM_LOCK;
setleds();
}
if(key == 0x46) /* Scroll Lock */
{
led_status ^= LED_SCROLL_LOCK;
setleds();
}


if(key == 0x1D && !(control_keys & CK_CTRL)) /* Ctrl key */
control_keys |= CK_CTRL;
if(key == 0x80 + 0x1D) /* Ctrl key depressed */
control_keys &= (0xFF - CK_CTRL);
if((key == 0x2A || key == 0x36) && !(control_keys & CK_SHIFT)) /* Shift key */
control_keys |= CK_SHIFT;
if((key == 0x80 + 0x2A) || (key == 0x80 + 0x36)) /* Shift key depressed */
control_keys &= (0xFF - CK_SHIFT);
if(key == 0x38 && (!control_keys & CK_ALT))
control_keys |= CK_ALT;
if(key == 0x80 + 0x38)
control_keys &= (0xFF - CK_ALT);

if((control_keys & CK_SHIFT) && (led_status & LED_CAPS_LOCK)) key_ascii = scan2ascii_table[key][6];
else if(control_keys & CK_SHIFT) key_ascii = scan2ascii_table[key][1];
else if(control_keys & CK_CTRL) key_ascii = scan2ascii_table[key][2];
else if(control_keys & CK_ALT) key_ascii = scan2ascii_table[key][3];
else if((control_keys & CK_SHIFT) && (led_status & LED_NUM_LOCK)) key_ascii = scan2ascii_table[key][7];
else if(led_status & LED_CAPS_LOCK) key_ascii = scan2ascii_table[key][5];
else if(led_status & LED_NUM_LOCK) key_ascii = scan2ascii_table[key][4];
else if(control_keys == 0) key_ascii = scan2ascii_table[key][0];

if(key_ascii != 0)
{
if(key_ascii <= 0xFF)
{
keyboard_buffer[keyboard_buffer_size] = key_ascii;
keyboard_buffer_size++;
}
else
{
keyboard_buffer[keyboard_buffer_size] = (key_ascii & 0xFF);
keyboard_buffer[keyboard_buffer_size+1] = (key_ascii & 0xFF00);
keyboard_buffer_size += 2;
}
}

outportb(M_PIC, EOI);
}

unsigned char getch()
{
unsigned char ret_key=0;
unsigned int loop=0;

while(keyboard_buffer_size == 0);

ret_key = keyboard_buffer[0];
keyboard_buffer_size--;

for(loop=0; loop<254; loop++)
keyboard_buffer[loop] = keyboard_buffer[loop+1];

return ret_key;
}

unsigned char kbhit()
{
if(keyboard_buffer_size == 0) return 0;

return 1;
}


c++

Code: [Auswählen]

#include "Keyboard.h"
#include "Port.h"
#include "Pic.h"
#include "gdt.h"
#include "idt.h"


Keyboard::Keyboard()
{
       
}

Keyboard::~Keyboard() {}

#define LED_NUM_LOCK        2
#define LED_SCROLL_LOCK     1
#define LED_CAPS_LOCK       4

unsigned char led_status = 0;


unsigned char keyboard_buffer[255];

unsigned char keyboard_buffer_size = 0;

unsigned char control_keys = 0;

#define CK_SHIFT    1
#define CK_ALT      2
#define CK_CTRL     4

unsigned int scan2ascii_table[][8] =
{
/*  ASCII - Shift - Ctrl -  Alt -   Num -   Caps -  Shift Caps -    Shift Num */
{   0,  0,  0,  0,  0,  0,  0,      0},
{   0x1B,   0x1B,   0x1B,   0,  0x1B,   0x1B,   0x1B,       0x1B},
/* 1 -> 9 */
{   0x31,   0x21,   0,  0x7800, 0x31,   0x31,   0x21,       0x21},
{   0x32,   0x40,   0x0300, 0x7900, 0x32,   0x32,   0x40,       0x40},
{   0x33,   0x23,   0,  0x7A00, 0x33,   0x33,   0x23,       0x23},
{   0x34,   0x24,   0,  0x7B00, 0x34,   0x34,   0x24,       0x24},
{   0x35,   0x25,   0,  0x7C00, 0x35,   0x35,   0x25,       0x25},
{   0x36,   0x5E,   0x1E,   0x7D00, 0x36,   0x36,   0x5E,       0x5E},
{   0x37,   0x26,   0,  0x7E00, 0x37,   0x37,   0x26,       0x26},
{   0x38,   0x2A,   0,  0x7F00, 0x38,   0x38,   0x2A,       0x2A},
{   0x39,   0x28,   0,  0x8000, 0x39,   0x39,   0x28,       0x28},
{   0x30,   0x29,   0,  0x8100, 0x30,   0x30,   0x29,       0x29},
/* -, =, Bksp, Tab */
{   0x2D,   0x5F,   0x1F,   0x8200, 0x2D,   0x2D,   0x5F,       0x5F},
{   0x3D,   0x2B,   0,  0x8300, 0x3D,   0x3D,   0x2B,       0x2B},
{   0x08,   0x08,   0x7F,   0,  0x08,   0x08,   0x08,       0x08},
{   0x09,   0x0F00, 0,  0,  0x09,   0x09,   0x0F00,     0x0F00},
/*  QWERTYUIOP[] */
{   0x71,   0x51,   0x11,   0x1000, 0x71,   0x51,   0x71,       0x51},
{   0x77,   0x57,   0x17,   0x1100, 0x77,   0x57,   0x77,       0x57},
{   0x65,   0x45,   0x05,   0x1200, 0x65,   0x45,   0x65,       0x45},
{   0x72,   0x52,   0x12,   0x1300, 0x72,   0x52,   0x72,       0x52},
{   0x74,   0x54,   0x14,   0x1400, 0x74,   0x54,   0x74,       0x54},
{   0x79,   0x59,   0x19,   0x1500, 0x79,   0x59,   0x79,       0x59},
{   0x75,   0x55,   0x15,   0x1600, 0x75,   0x55,   0x75,       0x55},
{   0x69,   0x49,   0x09,   0x1700, 0x69,   0x49,   0x69,       0x49},
{   0x6F,   0x4F,   0x0F,   0x1800, 0x6F,   0x4F,   0x6F,       0x4F},
{   0x70,   0x50,   0x10,   0x1900, 0x70,   0x50,   0x70,       0x50},
{   0x5B,   0x7B,   0x1B,   0x0,    0x5B,   0x5B,   0x7B,       0x7B},
{   0x5D,   0x7D,   0x1D,   0,  0x5D,   0x5D,   0x7D,       0x7D},
/* ENTER, CTRL */
{   0x0A,   0x0A,   0x0D,   0,  0x0A,   0x0A,   0x0D,       0x0D},
{   0,  0,  0,  0,  0,  0,  0,      0},
/* ASDFGHJKL;'~ */
{   0x61,   0x41,   0x01,   0x1E00, 0x61,   0x41,   0x61,       0x41},
{   0x73,   0x53,   0x13,   0x1F00, 0x73,   0x53,   0x73,       0x53},
{   0x64,   0x44,   0x04,   0x2000, 0x64,   0x44,   0x64,       0x44},
{   0x66,   0x46,   0x06,   0x2100, 0x66,   0x46,   0x66,       0x46},
{   0x67,   0x47,   0x07,   0x2200, 0x67,   0x47,   0x67,       0x47},
{   0x68,   0x48,   0x08,   0x2300, 0x68,   0x48,   0x68,       0x48},
{   0x6A,   0x4A,   0x0A,   0x2400, 0x6A,   0x4A,   0x6A,       0x4A},
{   0x6B,   0x4B,   0x0B,   0x3500, 0x6B,   0x4B,   0x6B,       0x4B},
{   0x6C,   0x4C,   0x0C,   0x2600, 0x6C,   0x4C,   0x6C,       0x4C},
{   0x3B,   0x3A,   0,  0,  0x3B,   0x3B,   0x3A,       0x3A},
{   0x27,   0x22,   0,  0,  0x27,   0x27,   0x22,       0x22},
{   0x60,   0x7E,   0,  0,  0x60,   0x60,   0x7E,       0x7E},
/* Left Shift*/
{   0x2A,   0,  0,  0,  0,  0,  0,      0},
/* \ZXCVBNM,./ */
{   0x5C,   0x7C,   0x1C,   0,  0x5C,   0x5C,   0x7C,       0x7C},
{   0x7A,   0x5A,   0x1A,   0x2C00, 0x7A,   0x5A,   0x7A,       0x5A},
{   0x78,   0x58,   0x18,   0x2D00, 0x78,   0x58,   0x78,       0x58},
{   0x63,   0x43,   0x03,   0x2E00, 0x63,   0x43,   0x63,       0x43},
{   0x76,   0x56,   0x16,   0x2F00, 0x76,   0x56,   0x76,       0x56},
{   0x62,   0x42,   0x02,   0x3000, 0x62,   0x42,   0x62,       0x42},
{   0x6E,   0x4E,   0x0E,   0x3100, 0x6E,   0x4E,   0x6E,       0x4E},
{   0x6D,   0x4D,   0x0D,   0x3200, 0x6D,   0x4D,   0x6D,       0x4D},
{   0x2C,   0x3C,   0,  0,  0x2C,   0x2C,   0x3C,       0x3C},
{   0x2E,   0x3E,   0,  0,  0x2E,   0x2E,   0x3E,       0x3E},
{   0x2F,   0x3F,   0,  0,  0x2F,   0x2F,   0x3F,       0x3F},
/* Right Shift */
{   0,  0,  0,  0,  0,  0,  0,      0},
/* Print Screen */
{   0,  0,  0,  0,  0,  0,  0,      0},
/* Alt  */
{   0,  0,  0,  0,  0,  0,  0,      0},
/* Space */
{   0x20,   0x20,   0x20,   0,  0x20,   0x20,   0x20,       0x20},
/* Caps */
{   0,  0,  0,  0,  0,  0,  0,      0},
/* F1-F10 */
{   0x3B00, 0x5400, 0x5E00, 0x6800, 0x3B00, 0x3B00, 0x5400,     0x5400},
{   0x3C00, 0x5500, 0x5F00, 0x6900, 0x3C00, 0x3C00, 0x5500,     0x5500},
{   0x3D00, 0x5600, 0x6000, 0x6A00, 0x3D00, 0x3D00, 0x5600,     0x5600},
{   0x3E00, 0x5700, 0x6100, 0x6B00, 0x3E00, 0x3E00, 0x5700,     0x5700},
{   0x3F00, 0x5800, 0x6200, 0x6C00, 0x3F00, 0x3F00, 0x5800,     0x5800},
{   0x4000, 0x5900, 0x6300, 0x6D00, 0x4000, 0x4000, 0x5900,     0x5900},
{   0x4100, 0x5A00, 0x6400, 0x6E00, 0x4100, 0x4100, 0x5A00,     0x5A00},
{   0x4200, 0x5B00, 0x6500, 0x6F00, 0x4200, 0x4200, 0x5B00,     0x5B00},
{   0x4300, 0x5C00, 0x6600, 0x7000, 0x4300, 0x4300, 0x5C00,     0x5C00},
{   0x4400, 0x5D00, 0x6700, 0x7100, 0x4400, 0x4400, 0x5D00,     0x5D00},
/* Num Lock, Scrl Lock */
{   0,  0,  0,  0,  0,  0,  0,      0},
{   0,  0,  0,  0,  0,  0,  0,      0},
/* HOME, Up, Pgup, -kpad, left, center, right, +keypad, end, down, pgdn, ins, del */
{   0x4700, 0x37,   0x7700, 0,  0x37,   0x4700, 0x37,       0x4700},
{   0x4800, 0x38,   0,  0,  0x38,   0x4800, 0x38,       0x4800},
{   0x4900, 0x39,   0x8400, 0,  0x39,   0x4900, 0x39,       0x4900},
{   0x2D,   0x2D,   0,  0,  0x2D,   0x2D,   0x2D,       0x2D},
{   0x4B00, 0x34,   0x7300, 0,  0x34,   0x4B00, 0x34,       0x4B00},
{   0x4C00, 0x35,   0,  0,  0x35,   0x4C00, 0x35,       0x4C00},
{   0x4D00, 0x36,   0x7400, 0,  0x36,   0x4D00, 0x36,       0x4D00},
{   0x2B,   0x2B,   0,  0,  0x2B,   0x2B,   0x2B,       0x2B},
{   0x4F00, 0x31,   0x7500, 0,  0x31,   0x4F00, 0x31,       0x4F00},
{   0x5000, 0x32,   0,  0,  0x32,   0x5000, 0x32,       0x5000},
{   0x5100, 0x33,   0x7600, 0,  0x33,   0x5100, 0x33,       0x5100},
{   0x5200, 0x30,   0,  0,  0x30,   0x5200, 0x30,       0x5200},
{   0x5300, 0x2E,   0,  0,  0x2E,   0x5300, 0x2E,       0x5300}
};
//extern void keyb_ISR();

asm (
   ".globl keyb_ISR        \n"
   "keyb_ISR:              \n"
   "   pusha               \n" /* Save all registers               */
   "   pushw %ds           \n" /* Set up the data segment          */
   "   pushw %es           \n"
   "   pushw %ss           \n" /* Note that ss is always valid     */
   "   pushw %ss           \n"
   "   popw %ds            \n"
   "   popw %es            \n"
   "                       \n"
   "   call keyb_handler   \n"
   "                       \n"
   "   popw %es            \n"
   "   popw %ds            \n" /* Restore registers                */
   "   popa                \n"
   "   iret                \n" /* Exit interrupt                   */
);

void Keyboard::setleds()
{
    outportb(0x60, 0xED);
    while(inportb(0x64) & 2);
    outportb(0x60, led_status);
    while(inportb(0x64) & 2);
}

void Keyboard::InitKeyboard()
{
    set_vector(M_VEC+1, D_PRESENT + D_INT + D_DPL3); /* IRQ1 Handler */
    enable_irq(1);

    led_status = 0; /* All leds off */
    setleds();
}

void Keyboard::keyb_handler()
{
    unsigned int key = inportb(0x60);
    unsigned int key_ascii = 0;
   
    if((control_keys & (CK_CTRL+CK_ALT)) && key==0x53)
    {
        while(inportb(0x64) & 2);
       
        outportb(0x64, 0xFE);
       
        asm ("cli;hlt");
    }      
   
    // 'LED Keys', ie, Scroll lock, Num lock, and Caps lock
    if(key == 0x3A) // Caps Lock
    {
        led_status ^= LED_CAPS_LOCK;
        setleds();
    }
    if(key == 0x45) // Num Lock
    {
        led_status ^= LED_NUM_LOCK;
        setleds();
    }
    if(key == 0x46) // Scroll Lock
    {
        led_status ^= LED_SCROLL_LOCK;
        setleds();
    }


    if(key == 0x1D && !(control_keys & CK_CTRL))    // Ctrl key
        control_keys |= CK_CTRL;
    if(key == 0x80 + 0x1D)  // Ctrl key depressed
        control_keys &= (0xFF - CK_CTRL);
    if((key == 0x2A || key == 0x36) && !(control_keys & CK_SHIFT))  // Shift key
        control_keys |= CK_SHIFT;
    if((key == 0x80 + 0x2A) || (key == 0x80 + 0x36))    //Shift key depressed
        control_keys &= (0xFF - CK_SHIFT);
    if(key == 0x38 && (!control_keys & CK_ALT))
        control_keys |= CK_ALT;
    if(key == 0x80 + 0x38)
        control_keys &= (0xFF - CK_ALT);
       
    if((control_keys & CK_SHIFT) && (led_status & LED_CAPS_LOCK)) key_ascii = scan2ascii_table[key][6];
    else if(control_keys & CK_SHIFT) key_ascii = scan2ascii_table[key][1];
    else if(control_keys & CK_CTRL) key_ascii = scan2ascii_table[key][2];
    else if(control_keys & CK_ALT) key_ascii = scan2ascii_table[key][3];    
    else if((control_keys & CK_SHIFT) && (led_status & LED_NUM_LOCK)) key_ascii = scan2ascii_table[key][7];
    else if(led_status & LED_CAPS_LOCK) key_ascii = scan2ascii_table[key][5];
    else if(led_status & LED_NUM_LOCK) key_ascii = scan2ascii_table[key][4];
    else if(control_keys == 0) key_ascii = scan2ascii_table[key][0];

    if(key_ascii != 0)
    {
        if(key_ascii <= 0xFF)
        {
            keyboard_buffer[keyboard_buffer_size] = key_ascii;
            keyboard_buffer_size++;
        }
        else
        {
            keyboard_buffer[keyboard_buffer_size] = (key_ascii & 0xFF);
            keyboard_buffer[keyboard_buffer_size+1] = (key_ascii & 0xFF00);
            keyboard_buffer_size += 2;
        }
    }

    outportb(M_PIC, EOI);
}

unsigned char Keyboard::getch()
{
    unsigned char ret_key=0;
    unsigned int loop=0;
   
    while(keyboard_buffer_size == 0);
   
    ret_key = keyboard_buffer[0];
    keyboard_buffer_size--;
   
    for(loop=0; loop<254; loop++)
        keyboard_buffer[loop] = keyboard_buffer[loop+1];
   
    return ret_key;
}

unsigned char Keyboard::kbhit()
{
    if(keyboard_buffer_size == 0) return 0;
   
    return 1;
}


Compilieren kann ich beide ohne Problem! Nur eben der LInker meckert, wobei der  c Code mehr Error's von sich gibt Ein vogel hat mir zugezwitschert das es in C++ ned möglich sein per asm eine Methode aufzurufen ...


PS: Der Code könnte auch bekannt vorkommen, aber keine Angst werde ihn schon noch umändern (und zwar gewahltig ... )

[n3Ro]

Probier mal die Methode/Funktion als extern "C" zu deklarieren, könnte mir nämlich vorstellen, das dein Compiler sonst für die Funktion einen C++ Namen benutzt, der leicht merkwürdig aussehen kann

[matthieuriolo]

Ne die Errors bleiben. Es sind auch Methoden darunter die von keyboard.c geladen werden. Hab die auch als extern angegeben aber sie bleiben als Error. Was nun?

[n3Ro]

poste doch mal am besten die Errors und deine Compile/Link Aufrufe, vielleicht kommt dann ja jemand drauf woran es liegt

[matthieuriolo]

Kernel.o(.text+0x11a):kernel.cpp: undefined reference to '__Z12InitKeyboardv'
Keyboard.o(.text+0xe):Keyboard.c: undefined reference to 'keyb_handler'
Keyboard.o(.text+0x71):Keyboard.c: undefined reference to '_set_vector'

Keyboard.o(.text+0x78):Keyboard.c: undefined reference to '_enable_irq'


sind die fehler beim linken

[SSJ7Gohan]

set_vector und enable_irq stehen in der kernel.cpp?
Du muss set_vector und enable_irq als extern "C" deklarieren, sonst wandelt der compiler sie in namen wie __Z12InitKeyboardv um.

[matthieuriolo]

Ne die 2 stehen ausserhalb der Kernel.cpp. Werden aber dort "geladen". Die Errors bleiben!

[Golum]

Versuch mal:

extern "C"
{
  #include "Keyboard.h"
}

Musste ich bei einer Bibliothek mach die in C geschrieben war, vielleicht ist es bei dir das selbe Problem.

[n3Ro]

Okay, ich würde mal sagen das du dich für eines von beiden entscheiden solltest, entweder C oder C++, dann um aus einer asm Datei auf deine C++ Routinen zugreifen zu können, solltest du diese als static deklarieren und schauen wie sie nach dem Compilieren / Name-Mangling heißt. Diesen Namen benutzt du dann in deiner Asm-Routine zum aufrufen, dann sollte es eigentlich keine Probleme mehr geben.

[SSJ7Gohan]

Das ist Unsinn, die Name Manglings variiren je nach Compiler und Version des Compilers, d.h. das OS wäre z.B. nicht zu neueren Versionen des GCC kompatibel als der, die der Entwickler hat.

Alle Funktionen, die von C/ASM aus aufgerufen werden, müssen als extern "C" deklariert werden. ASM und C Funktionen müssen auch in den Headern als extern "C" deklariert werden.

Ausserdem sollte man beachten, das man in ASM den Funktionen einen Unterstrich (_) voransetzt, falls man Windows benutzt. Wenn man Linux benutzt darf man das nicht, sonst findet der Linker die Funktionen nicht.

Beispiel:
C Funktion:

Code: [Auswählen]

int do_something() {
return 10;
}
CPP Funktion:

Code: [Auswählen]

extern "C" int do_something_other() {
return 20;
}
ASM Funktion (Ich gehe davon aus, das Win benutzt wird):

Code: [Auswählen]

[global _asm_function]
_asm_function:
mov eax, 30
ret

Headerfile um von C++ auf die C/ASM Funktionen aufrufen zu können:

Code: [Auswählen]

[...]
extern "C" unsigned int asm_function();
extern "C" int do_somethings();
[...]

Jetzt lassen sich sowohl die C/ASM als auch die C++ Funktionen von der jeweils anderen Sprache aufrufen.

[n3Ro]

Nur dann darf die Funktion nicht innerhalb einer Klasse geschrieben worden sein, wie das in dem Quelltext ^^ der Fall ist. Die Version des GCC kann man außerdem per Compiler-Builtin herausfinden und dann entsprechend per define den richtigen Namen wählen

[SSJ7Gohan]

Wenn man die Funktion als static deklariert darf sie auch innerhalb einer Klasse sein.

Ausserdem kann man mit NASM keine GCC Compiler Builtins benutzen.^^

[Golum]

Headerfile um von C++ auf die C/ASM Funktionen aufrufen zu können:
Code:
[...]
extern "C" unsigned int asm_function();
extern "C" int do_somethings();
[...]


Jetzt lassen sich sowohl die C/ASM als auch die C++ Funktionen von der jeweils anderen Sprache aufrufen.

Es ist einfacher ein normales C-Headerfile zu schreiben und dann einfach
extern "C"
{
#include <header.h>
}

zu machen finde ich  

Man kann natürlich auch mehrere includes in die Klammern reinschreiben ich glaube bei einem sind sie garnicht notwendig.

[matthieuriolo]

öh blöde frage aber was is wenn ich in dem C file ein C++ Methode bruache? Extern "C++"

[SSJ7Gohan]

Nein, du deklarierst sie im .cpp file als extern "C".

@Golum
Dann kannst du auch gleich im Headerfile folgendes verwenden:

Code: [Auswählen]

#ifdef __cplusplus
extern "C" {
#endif

[...]
#ifdef __cplusplus
}
#endif

[n3Ro]

Ausserdem kann man mit NASM keine GCC Compiler Builtins benutzen.

Deswegen ist auch manchmal sinnvoll  as zu benutzen

[matthieuriolo]

Und wie mach ich das am besten wenn ich diese Methode auch in einem C++ file brauche? Die Methode  2 mal anlegen, einmal für C und einmal für C++

[n3Ro]

Wieso , Funktionen die du in Asm oder C geschrieben hast, lassen sich einfach per extern "C" einbinden. Nur Methoden die in C++ geschrieben sind, und in Asm (oder C) benutzt werden sollen sind Problematisch und benötigen einen Workaround.

[matthieuriolo]

Was hat das wieder zu bedeuten?

pic.h:5: error: previous declaration of 'void enable:irq(short unsigned int)' with C++ linkage.
Pic.cpp:25: error: conlflicts with new declaration with C linkage

[SSJ7Gohan]

Du hast in der Headerfile kein extern "C" angegeben, in der C++ File schon. Du musst extern "C" in der Headerfile angeben, wenn du die Funktion in einer Headerfile deklarierst.