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