Angel Pons | c74dae9 | 2020-04-02 23:48:16 +0200 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 2 | |
Edward O'Callaghan | 91810dd | 2014-07-30 13:53:04 +1000 | [diff] [blame] | 3 | #include <arch/registers.h> |
| 4 | #include <console/console.h> |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 5 | #include <device/pci.h> |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 6 | #include <device/pci_ops.h> |
Edward O'Callaghan | 91810dd | 2014-07-30 13:53:04 +1000 | [diff] [blame] | 7 | |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 8 | /* we use x86emu's register file representation */ |
| 9 | #include <x86emu/regs.h> |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 10 | |
Edward O'Callaghan | 91810dd | 2014-07-30 13:53:04 +1000 | [diff] [blame] | 11 | #include "x86.h" |
| 12 | |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 13 | // errors go in AH. Just set these up so that word assigns |
| 14 | // will work. KISS. |
| 15 | enum { |
Mark Marshall | d08e69d | 2009-11-05 09:03:04 +0000 | [diff] [blame] | 16 | PCIBIOS_SUCCESSFUL = 0x0000, |
| 17 | PCIBIOS_UNSUPPORTED = 0x8100, |
| 18 | PCIBIOS_BADVENDOR = 0x8300, |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 19 | PCIBIOS_NODEV = 0x8600, |
| 20 | PCIBIOS_BADREG = 0x8700 |
| 21 | }; |
| 22 | |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 23 | int int10_handler(void) |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 24 | { |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 25 | int res=0; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 26 | static u8 cursor_row=0, cursor_col=0; |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 27 | switch((X86_EAX & 0xff00)>>8) { |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 28 | case 0x01: // Set cursor shape |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 29 | res = 1; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 30 | break; |
| 31 | case 0x02: // Set cursor position |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 32 | if (cursor_row != ((X86_EDX >> 8) & 0xff) || |
| 33 | cursor_col >= (X86_EDX & 0xff)) { |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 34 | printk(BIOS_INFO, "\n"); |
| 35 | } |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 36 | cursor_row = (X86_EDX >> 8) & 0xff; |
| 37 | cursor_col = X86_EDX & 0xff; |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 38 | res = 1; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 39 | break; |
| 40 | case 0x03: // Get cursor position |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 41 | X86_EAX &= 0x00ff; |
| 42 | X86_ECX = 0x0607; |
| 43 | X86_EDX = (cursor_row << 8) | cursor_col; |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 44 | res = 1; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 45 | break; |
| 46 | case 0x06: // Scroll up |
| 47 | printk(BIOS_INFO, "\n"); |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 48 | res = 1; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 49 | break; |
| 50 | case 0x08: // Get Character and Mode at Cursor Position |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 51 | X86_EAX = 0x0f00 | 'A'; // White on black 'A' |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 52 | res = 1; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 53 | break; |
| 54 | case 0x09: // Write Character and attribute |
Stefan Reinauer | 20d9de3 | 2011-12-13 23:08:03 +0100 | [diff] [blame] | 55 | case 0x0e: // Write Character |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 56 | printk(BIOS_INFO, "%c", X86_EAX & 0xff); |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 57 | res = 1; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 58 | break; |
| 59 | case 0x0f: // Get video mode |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 60 | X86_EAX = 0x5002; //80x25 |
| 61 | X86_EBX &= 0x00ff; |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 62 | res = 1; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 63 | break; |
| 64 | default: |
| 65 | printk(BIOS_WARNING, "Unknown INT10 function %04x!\n", |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 66 | X86_EAX & 0xffff); |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 67 | break; |
| 68 | } |
| 69 | return res; |
| 70 | } |
Maciej Pijanka | ea92185 | 2009-10-27 14:29:29 +0000 | [diff] [blame] | 71 | |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 72 | int int12_handler(void) |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 73 | { |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 74 | X86_EAX = 64 * 1024; |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 75 | return 1; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 76 | } |
| 77 | |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 78 | int int16_handler(void) |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 79 | { |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 80 | int res=0; |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 81 | switch((X86_EAX & 0xff00)>>8) { |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 82 | case 0x00: // Check for Keystroke |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 83 | X86_EAX = 0x6120; // Space Bar, Space |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 84 | res = 1; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 85 | break; |
| 86 | case 0x01: // Check for Keystroke |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 87 | X86_EFLAGS |= 1<<6; // Zero Flag set (no key available) |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 88 | res = 1; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 89 | break; |
| 90 | default: |
| 91 | printk(BIOS_WARNING, "Unknown INT16 function %04x!\n", |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 92 | X86_EAX & 0xffff); |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 93 | break; |
| 94 | } |
| 95 | return res; |
| 96 | } |
| 97 | |
Stefan Reinauer | 607cdf6 | 2010-04-26 12:08:51 +0000 | [diff] [blame] | 98 | #define PCI_CONFIG_SPACE_TYPE1 (1 << 0) |
Stefan Reinauer | 607cdf6 | 2010-04-26 12:08:51 +0000 | [diff] [blame] | 99 | #define PCI_SPECIAL_CYCLE_TYPE1 (1 << 4) |
Stefan Reinauer | 607cdf6 | 2010-04-26 12:08:51 +0000 | [diff] [blame] | 100 | |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 101 | int int1a_handler(void) |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 102 | { |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 103 | unsigned short func = (unsigned short)X86_EAX; |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 104 | int retval = 1; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 105 | unsigned short devid, vendorid, devfn; |
Martin Roth | 63373ed | 2013-07-08 16:24:19 -0600 | [diff] [blame] | 106 | /* Use short to get rid of garbage in upper half of 32-bit register */ |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 107 | short devindex; |
| 108 | unsigned char bus; |
| 109 | struct device *dev; |
Stefan Reinauer | 46634e7 | 2009-11-05 12:44:50 +0000 | [diff] [blame] | 110 | u32 dword; |
| 111 | u16 word; |
| 112 | u8 byte, reg; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 113 | |
Mark Marshall | d08e69d | 2009-11-05 09:03:04 +0000 | [diff] [blame] | 114 | switch (func) { |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 115 | case 0xb101: /* PCIBIOS Check */ |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 116 | X86_EDX = 0x20494350; /* ' ICP' */ |
| 117 | X86_EAX &= 0xffff0000; /* Clear AH / AL */ |
| 118 | X86_EAX |= PCI_CONFIG_SPACE_TYPE1 | PCI_SPECIAL_CYCLE_TYPE1; |
Stefan Reinauer | 607cdf6 | 2010-04-26 12:08:51 +0000 | [diff] [blame] | 119 | // last bus in the system. Hard code to 255 for now. |
Martin Roth | 63373ed | 2013-07-08 16:24:19 -0600 | [diff] [blame] | 120 | // dev_enumerate() does not seem to tell us (publicly) |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 121 | X86_ECX = 0xff; |
| 122 | X86_EDI = 0x00000000; /* protected mode entry */ |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 123 | retval = 1; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 124 | break; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 125 | case 0xb102: /* Find Device */ |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 126 | devid = X86_ECX; |
| 127 | vendorid = X86_EDX; |
| 128 | devindex = X86_ESI; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 129 | dev = 0; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 130 | while ((dev = dev_find_device(vendorid, devid, dev))) { |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 131 | if (devindex <= 0) |
| 132 | break; |
| 133 | devindex--; |
| 134 | } |
| 135 | if (dev) { |
| 136 | unsigned short busdevfn; |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 137 | X86_EAX &= 0xffff00ff; /* Clear AH */ |
| 138 | X86_EAX |= PCIBIOS_SUCCESSFUL; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 139 | // busnum is an unsigned char; |
| 140 | // devfn is an int, so we mask it off. |
Arthur Heymans | 7fcd4d5 | 2023-08-24 15:12:19 +0200 | [diff] [blame^] | 141 | busdevfn = (dev->upstream->secondary << 8) |
Mark Marshall | d08e69d | 2009-11-05 09:03:04 +0000 | [diff] [blame] | 142 | | (dev->path.pci.devfn & 0xff); |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 143 | printk(BIOS_DEBUG, "0x%x: return 0x%x\n", func, busdevfn); |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 144 | X86_EBX = busdevfn; |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 145 | retval = 1; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 146 | } else { |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 147 | X86_EAX &= 0xffff00ff; /* Clear AH */ |
| 148 | X86_EAX |= PCIBIOS_NODEV; |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 149 | retval = 0; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 150 | } |
Mark Marshall | d08e69d | 2009-11-05 09:03:04 +0000 | [diff] [blame] | 151 | break; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 152 | case 0xb10a: /* Read Config Dword */ |
| 153 | case 0xb109: /* Read Config Word */ |
| 154 | case 0xb108: /* Read Config Byte */ |
| 155 | case 0xb10d: /* Write Config Dword */ |
| 156 | case 0xb10c: /* Write Config Word */ |
| 157 | case 0xb10b: /* Write Config Byte */ |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 158 | devfn = X86_EBX & 0xff; |
| 159 | bus = X86_EBX >> 8; |
| 160 | reg = X86_EDI; |
Kyösti Mälkki | 98d1957 | 2019-07-04 13:15:01 +0300 | [diff] [blame] | 161 | dev = pcidev_path_on_bus(bus, devfn); |
Mark Marshall | d08e69d | 2009-11-05 09:03:04 +0000 | [diff] [blame] | 162 | if (!dev) { |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 163 | printk(BIOS_DEBUG, "0x%x: BAD DEVICE bus %d devfn 0x%x\n", func, bus, devfn); |
Stefan Reinauer | 607cdf6 | 2010-04-26 12:08:51 +0000 | [diff] [blame] | 164 | // Or are we supposed to return PCIBIOS_NODEV? |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 165 | X86_EAX &= 0xffff00ff; /* Clear AH */ |
| 166 | X86_EAX |= PCIBIOS_BADREG; |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 167 | retval = 0; |
Mark Marshall | d08e69d | 2009-11-05 09:03:04 +0000 | [diff] [blame] | 168 | return retval; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 169 | } |
Mark Marshall | d08e69d | 2009-11-05 09:03:04 +0000 | [diff] [blame] | 170 | switch (func) { |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 171 | case 0xb108: /* Read Config Byte */ |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 172 | byte = pci_read_config8(dev, reg); |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 173 | X86_ECX = byte; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 174 | break; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 175 | case 0xb109: /* Read Config Word */ |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 176 | word = pci_read_config16(dev, reg); |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 177 | X86_ECX = word; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 178 | break; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 179 | case 0xb10a: /* Read Config Dword */ |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 180 | dword = pci_read_config32(dev, reg); |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 181 | X86_ECX = dword; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 182 | break; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 183 | case 0xb10b: /* Write Config Byte */ |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 184 | byte = X86_ECX; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 185 | pci_write_config8(dev, reg, byte); |
| 186 | break; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 187 | case 0xb10c: /* Write Config Word */ |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 188 | word = X86_ECX; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 189 | pci_write_config16(dev, reg, word); |
| 190 | break; |
Stefan Reinauer | 216fa46 | 2011-10-12 14:25:07 -0700 | [diff] [blame] | 191 | case 0xb10d: /* Write Config Dword */ |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 192 | dword = X86_ECX; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 193 | pci_write_config32(dev, reg, dword); |
| 194 | break; |
| 195 | } |
| 196 | |
Julius Werner | cd49cce | 2019-03-05 16:53:33 -0800 | [diff] [blame] | 197 | #if CONFIG(REALMODE_DEBUG) |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 198 | printk(BIOS_DEBUG, "0x%x: bus %d devfn 0x%x reg 0x%x val 0x%x\n", |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 199 | func, bus, devfn, reg, X86_ECX); |
Myles Watson | 6c9bc01 | 2010-09-07 22:30:15 +0000 | [diff] [blame] | 200 | #endif |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 201 | X86_EAX &= 0xffff00ff; /* Clear AH */ |
| 202 | X86_EAX |= PCIBIOS_SUCCESSFUL; |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 203 | retval = 1; |
Mark Marshall | d08e69d | 2009-11-05 09:03:04 +0000 | [diff] [blame] | 204 | break; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 205 | default: |
Mark Marshall | d08e69d | 2009-11-05 09:03:04 +0000 | [diff] [blame] | 206 | printk(BIOS_ERR, "UNSUPPORTED PCIBIOS FUNCTION 0x%x\n", func); |
Patrick Georgi | 199b09c | 2012-11-22 12:46:12 +0100 | [diff] [blame] | 207 | X86_EAX &= 0xffff00ff; /* Clear AH */ |
| 208 | X86_EAX |= PCIBIOS_UNSUPPORTED; |
Patrick Georgi | 503af72 | 2012-11-22 10:48:18 +0100 | [diff] [blame] | 209 | retval = 0; |
Stefan Reinauer | 38cd29e | 2009-08-11 21:28:25 +0000 | [diff] [blame] | 210 | break; |
| 211 | } |
| 212 | |
| 213 | return retval; |
| 214 | } |