d0f7acf9eb
An x86-64 operating system built from xv6, now largely rewritten: SMP, a copy-on-write root filesystem (SchFS), PCI/USB/virtio drivers, a TTF rasteriser, and a Linux-numbered syscall ABI. No history before this point -- the tree was never under version control. This commit exists so the rename that follows has something to undo to.
114 lines
4.3 KiB
C
114 lines
4.3 KiB
C
// The driver registry.
|
|
//
|
|
// One table, one line per driver. This is the same shape as
|
|
// kernel/sys/table.inc and kernel/dev/cdev.c's devsw: a single place that
|
|
// lists what exists, so a driver cannot be half-registered.
|
|
//
|
|
// It is a plain array rather than the linker-section trick a bigger kernel
|
|
// would use (a __attribute__((section(".drivers"))) entry per driver, walked
|
|
// between __start_ and __stop_ symbols). That approach lets a driver register
|
|
// itself by existing, which is genuinely nicer -- but it also means the list
|
|
// of what is in your kernel is not written down anywhere you can read, and
|
|
// a driver silently dropped by the linker looks exactly like one that was
|
|
// never written. At this size, being able to read the list wins.
|
|
//
|
|
// To add a driver: write kernel/drivers/<name>.c exporting a struct
|
|
// pci_driver, declare it here, and add it to the array and to the Makefile's
|
|
// KERN_DRIVERS.
|
|
|
|
#include "types.h"
|
|
#include "defs.h"
|
|
#include "param.h"
|
|
#include "spinlock.h"
|
|
#include "sleeplock.h"
|
|
#include "fs.h"
|
|
#include "file.h"
|
|
#include "pci.h"
|
|
|
|
#include "usb.h"
|
|
#include "device.h"
|
|
|
|
extern const struct pci_driver vga_pci_driver;
|
|
extern const struct pci_driver xhci_driver;
|
|
extern const struct pci_driver virtio_gpu_driver;
|
|
extern const struct pci_driver e1000_driver;
|
|
|
|
// Order matters here in one respect: virtio-gpu is offered the bus before the
|
|
// VBE framebuffer driver, so that on a machine with both, the device with real
|
|
// mode setting and an explicit flush wins the display class. vga_pci still
|
|
// claims the stdvga card underneath, which is what the boot splash and the
|
|
// text console are drawn on.
|
|
static const struct pci_driver *drivers[] = {
|
|
&virtio_gpu_driver,
|
|
&vga_pci_driver,
|
|
&e1000_driver,
|
|
&xhci_driver,
|
|
};
|
|
|
|
void
|
|
pci_bind_all(void)
|
|
{
|
|
for (unsigned i = 0; i < sizeof(drivers) / sizeof(drivers[0]); i++)
|
|
pci_bind(drivers[i]);
|
|
}
|
|
|
|
// USB class drivers, same arrangement and for the same reason. These are not
|
|
// found on the PCI bus -- they are offered a device by the USB core once its
|
|
// interface descriptor has been read -- but a driver you cannot find in a
|
|
// list is a driver nobody knows is there, whichever bus it sits on.
|
|
//
|
|
// To add one: write kernel/drivers/usb_<name>.c exporting a struct
|
|
// usb_driver, declare it here, add it to the array and to KERN_DRIVERS.
|
|
|
|
extern const struct usb_driver usb_hid_driver;
|
|
extern const struct usb_driver usb_storage_driver;
|
|
extern const struct usb_driver usb_hub_driver;
|
|
|
|
static const struct usb_driver *usb_drivers[] = {
|
|
&usb_hid_driver,
|
|
&usb_storage_driver,
|
|
&usb_hub_driver,
|
|
};
|
|
|
|
int usb_offer(const struct usb_driver *, struct usb_dev *);
|
|
|
|
void
|
|
usb_bind_all(struct usb_dev *dev)
|
|
{
|
|
for (unsigned i = 0; i < sizeof(usb_drivers) / sizeof(usb_drivers[0]); i++)
|
|
if (usb_offer(usb_drivers[i], dev)) {
|
|
// Same as the PCI path: publish it in the bus-agnostic list so that
|
|
// "what is attached" has one answer covering every bus. Class comes from
|
|
// the driver that claimed it rather than the USB class code, because a
|
|
// driver knows what it made of the device and the descriptor only says
|
|
// what the device claims to be.
|
|
const char *n = usb_drivers[i]->name;
|
|
struct device *d = device_add(n, DEVBUS_USB, usb_drivers[i]->devclass, n);
|
|
if (d)
|
|
device_set_desc(d, usb_drivers[i]->name);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Devices that are not enumerated by any bus -- they are simply known to be
|
|
// there on a PC, and the driver pokes fixed I/O ports to find out whether it
|
|
// is right. Listing them matters because a device manager that shows the
|
|
// graphics card but not the keyboard is not showing the machine.
|
|
//
|
|
// Registered here rather than inside each driver's init so that the whole set
|
|
// is visible in one place, which is the same reasoning as the driver arrays
|
|
// above.
|
|
void
|
|
platform_register_devices(void)
|
|
{
|
|
struct device *d;
|
|
|
|
if ((d = device_add("kbd", DEVBUS_PLATFORM, DEVCLASS_INPUT, "ps2kbd")))
|
|
device_set_desc(d, "PS/2 keyboard");
|
|
if ((d = device_add("mouse", DEVBUS_PLATFORM, DEVCLASS_INPUT, "ps2mouse")))
|
|
device_set_desc(d, "PS/2 mouse");
|
|
if ((d = device_add("uart", DEVBUS_PLATFORM, DEVCLASS_OTHER, "uart8250")))
|
|
device_set_desc(d, "16550 serial port");
|
|
if ((d = device_add("ide", DEVBUS_PLATFORM, DEVCLASS_STORAGE, "ide")))
|
|
device_set_desc(d, "ATA disk controller");
|
|
}
|