It wouldn't be processor dependent but BIOS dependent... BIOS is 16bit realmode and usually extremely slow, so it's not much use for "real world" stuff. And you typically can't call BIOS from modern OS'es

I have written a vesa demo to go to and from pmode for mode switching that may help, let me know if you want to see the fasm code .

NoKey:        xor   eax,eax        in    AL,60h        cmp   al,0x50        jne   NoKey1;do something here        jmp   NoKeyNoKey1:        cmp   al,0x48        jne   NoKey2;do something here        jmp   NoKeyNoKey2:        cmp   al,0x1c        jne   NoKey  ;do something here        jmp   NoKey    

How to get into protected mode? First, you need a GLOBAL DESCRIPTOR
TABLE (GDT). There is one at the end of this file, at address "gdt:"
The GDT contains 8-byte DESCRIPTORS for each protected-mode segment.
Each descriptor contains a 32-bit segment base address, a 20-bit segment
limit, and 12 bits describing the segment type. The descriptors look
like this:

MSB bit 6 bit 5 bit 4 bit 3 bit 2 bit 1 LSB
+-------+-------+-------+-------+-------+-------+-------+-------+
byte 0 | bit 7<---------------- segment limit------------------->bit 0 |
+-------+-------+-------+-------+-------+-------+-------+-------+

+-------+-------+-------+-------+-------+-------+-------+-------+
byte 1 |bit 15<---------------- segment limit------------------->bit 8 |
+-------+-------+-------+-------+-------+-------+-------+-------+

+-------+-------+-------+-------+-------+-------+-------+-------+
byte 2 | bit 7<---------------- segment base-------------------->bit 0 |
+-------+-------+-------+-------+-------+-------+-------+-------+

+-------+-------+-------+-------+-------+-------+-------+-------+
byte 3 |bit 15<---------------- segment base-------------------->bit 8 |
+-------+-------+-------+-------+-------+-------+-------+-------+

+-------+-------+-------+-------+-------+-------+-------+-------+
byte 4 |bit 23<---------------- segment base-------------------->bit 16|
+-------+-------+-------+-------+-------+-------+-------+-------+

+-------+-------+-------+-------+-------+-------+-------+-------+
byte 5 | P | DPL | <----------- segment type ----------> |
+-------+-------+-------+-------+-------+-------+-------+-------+

P is the Segment Present bit. It should always be 1.

DPL is the DESCRIPTOR PRIVILEGE LEVEL. For simple code like this, these
two bits should always be zeroes.

Segment Type (again, for simple code like this) is hex 12 for data
segments, hex 1A for code segments.

+-------+-------+-------+-------+-------+-------+-------+-------+
byte 6 | G | B | 0 | avail | bit 19<-- seg limit--->bit 16 |
+-------+-------+-------+-------+-------+-------+-------+-------+

G is the Limit Granularity. If zero, the segment limit is in bytes
(0 to 1M, in 1-byte increments). If one, the segment limit is in 4K PAGES
(0 to 4G, in 4K increments). For simple code, set this bit to 1, and
set the segment limit to its highest value (FFFFF hex). You now have
segments that are 4G in size! The Intel CPUs can address no more than
4G of memory, so this is like having no segments at all. No wonder
protected mode is popular.

B is the Big bit; also called the D (Default) bit. For code segments,
all instructions will use 32-bit operands and addresses by default
(BITS 32, in NASM syntax, USE32 in Microsoft syntax) if this bit is set.
16-bit protected mode is not very interesting, so set this bit to 1.

None of these notes apply to the NULL descriptor. All of its bytes
should be set to zero.

+-------+-------+-------+-------+-------+-------+-------+-------+
byte 7 |bit 31<---------------- segment base------------------->bit 24 |
+-------+-------+-------+-------+-------+-------+-------+-------+

Build a simple GDT with four descriptors: NULL (all zeroes), linear data
(lets you use 32-bit addresses), code, and data/stack. (An extra
descriptor or two is needed to return to real mode.) For simplicity,
the limits of all descriptors (except NULL and the real-mode descriptors)
are FFFFF hex, the largest possible limit.

In a real-mode .COM file, CS=DS. To make addressing identical in real
mode and protected mode, we set the base of the code and data descriptors
to DS * 16. This number is computed at run-time; the other numbers in
the GDT can be done at assemble-time.

Note: also in pmode you can not use any bios ints, eg: int 13h,

print_str:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Input : ESI = ASCIIZ string address   ;;;;         BH  = Y coordinate (Y>=0)     ;;;;         BL  = X coordinate            ;;;;         textattr = color attribute    ;;;; Output: None, registers are preserved ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;    push      es    pushad    mov       ax, 18h    mov       es, ax    shl       ebx, 1                   ; y*=2, x*=2    movzx     edi, bh                  ; edi = y*2    shl       edi, 4                   ; edi = (y*2)*16    mov       eax, edi                 ; eax = (y*2)*16    shl       edi, 2                   ; edi = (y*2)*64    add       edi, eax                 ; edi = (y*2)*80    movzx     ebx, bl                  ; ebx = x*2    add       edi, ebx                 ; edi = (y*80+x)*2    add       edi, [video_addr]    mov       ah, [textattr]           ; background color    cld.1:    lodsb    or        al, al    jz        .2    stosw    jmp       .1.2:    popad    pop       es    ret