This has the potential disadvantage, however, that as a platform develops over the years and more physical address space becomes available, there might not be enough space is the OS's reserved region to map all of physical memory.
For OSes designed for platforms where the available virtual address space vastly exceeds the amount of physical address space the motherboard can provide (typical these days on 64-bit systems, typical 30 years ago on 32-bit systems), and where devices have hard-coded physical MMIO addresses (I'm not sure how many such platforms exist anymore), The OS might just map the whole physical address space into its reserved area of the virtual address space at an ABI-specified offset, and then the driver will know, from the ABI of the OS and the hard-coded physical address of its own device, what address to use. This depends on the OS, and the nature of the device and the platform. How does a device driver writer know which address is free for them to use?
xv6 sets it up as one of the reserved addresses for the OS that programs can't access, and has reserved that area to map the physical memory for MMIO devices, so that the OS and drivers can interact with the devices. The address of 0xfe000000 that you're asking about, though, is not a physical address, it's a virtual address. And, because it was the IBM PC that started the whole PC-compatible market, the decisions that IBM made when they were still making PC-architecture systems had a huge impact on the layout of later PCs from other manufacturers. So it's not AMD and Intel, primarily, that determine the MMIO layout on PCs, its Dell, HP, Acer, etc. For markets like the modern PC market, where a bunch of different manufacturers are building a bunch of different models that are all compatible with each other, what the manufacturer can choose to do is constrained by industry standards, whether formal (i.e, a written document), or informal (i.e, everybody's already doing A, so we have to do A too, if we do B we won't be compatible). The *physical* address that I/O devices appear at is generally determined by the computer manufacturer, not the CPU manufacturer (although before personal computers took off, when computers were desk- or room-sized affairs with price tags that only businesses could afford, these were often the same company). The OS generally maps itself, and the resources it needs, into the upper part of each program's address space, but with permissions set so that the program can't read from or write to that area, or interact with the OS in any way other than calling the system calls that the OS exposes to programs (sometimes OSes will expose a small area that programs can read, but not write, with useful, non-sensitive data like the system time in it, so that programs can access that data without needing to make a system call). The physical memory pages for other programs aren't mapped into the address space assigned to the currently running program (at least, not with permissions that anything but the OS can access), so a bug in one program can't cause another to crash. The reason paging is useful is that it allows the OS to present a program with the illusion that it has the entire computer to itself: when a given program is running, all that program can see on the system, without asking the OS, is itself. The address the CPU gets from the lookup table is called the physical address, and is the address that the CPU actually places on the bus to get the attention of the appropriate RAM module or memory-mapped I/O device. The address that a program uses is called a virtual address, because it's not the address that's directly used to access physical memory, the CPU has to check the lookup table first. This allows the operating system to cause a given page of physical memory to be accessible at an address of its choosing. This divides the physical address space into small chunks (4kB on x86) called pages, and, when a program references a given address, the CPU consults a lookup table that tells the CPU which page of physical memory it should access. Modern CPUs generally have a feature called paging. I'm posting it as is so that I don't have to rewrite the whole thing, and in the hope that it may be useful to others in the future.
From the image he linked, this is the virtual address where the developers of the xv6 kernel have chosen to map the physical MMIO I began writing this before you posted your last post, which seems to indicate a bit more understanding about the difference between physical and virtual memory than I had initially assumed. No, he's asking about the choice of address 0xFE000000 for MMIO devices. Basically, the range is hard wired into the hardware. Behind the virtual address is a physical address.