dev: implement generic devices

generic devices don't have a type (char, block, etc) and are created
by bus drivers to represent the device until a suitable driver is found.

generic devices are registered by the bus driver. once a more suitable
driver is found, that driver will re-register the device under itself.

dev/block.c

@@ -11,3 +11,9 @@ struct block_device *block_device_create(void)
 
 	return BLOCK_DEVICE(dev);
 }
+
+struct block_device *block_device_from_generic(struct device *dev)
+{
+	dev->dev_type = DEV_TYPE_BLOCK;
+	return BLOCK_DEVICE(dev);
+}

dev/char.c

@@ -11,3 +11,9 @@ struct char_device *char_device_create(void)
 
 	return CHAR_DEVICE(dev);
 }
+
+struct char_device *char_device_from_generic(struct device *dev)
+{
+	dev->dev_type = DEV_TYPE_CHAR;
+	return CHAR_DEVICE(dev);
+}

dev/core.c

@@ -228,6 +228,19 @@ kern_status_t device_register(struct device *dev, struct driver *owner, struct d
 {
 	unsigned long flags;
 	device_lock_irqsave(dev, &flags);
+
+	if (dev->dev_owner) {
+		struct driver *prev_owner = dev->dev_owner;
+
+		/* migrate device to new driver */
+		driver_lock(prev_owner);
+		driver_remove_device(prev_owner, dev);
+		driver_free_minor(prev_owner, dev->dev_minor);
+		dev->dev_minor = DEV_MINOR_INVALID;
+		dev->dev_owner = NULL;
+		driver_unlock(prev_owner);
+	}
+
 	driver_lock(owner);
 
 	if (owner->drv_major == DEV_MAJOR_INVALID) {

dev/driver.c

@@ -44,13 +44,10 @@ struct driver *driver_create(struct kext *self, const char *name)
 		return NULL;
 	}
 
-	memset(driver, 0x0, sizeof *driver);
-
-	driver->drv_owner = self;
-	strncpy(driver->drv_name, name, sizeof driver->drv_name - 1);
-	driver->drv_name[sizeof driver->drv_name - 1] = 0;
-
-	bitmap_set(driver->drv_minors, DEV_MINOR_INVALID);
+	if (driver_init(driver, self, name) != KERN_OK) {
+		vm_cache_free(&driver_cache, driver);
+		return NULL;
+	}
 
 	return driver;
 }
@@ -61,6 +58,30 @@ kern_status_t driver_destroy(struct driver *driver)
 		return KERN_BUSY;
 	}
 
+	kern_status_t status = driver_deinit(driver);
+	if (status != KERN_OK) {
+		return status;
+	}
+
+	vm_cache_free(&driver_cache, driver);
+	return KERN_OK;
+}
+
+kern_status_t driver_init(struct driver *driver, struct kext *self, const char *name)
+{
+	memset(driver, 0x0, sizeof *driver);
+
+	driver->drv_owner = self;
+	strncpy(driver->drv_name, name, sizeof driver->drv_name - 1);
+	driver->drv_name[sizeof driver->drv_name - 1] = 0;
+
+	bitmap_set(driver->drv_minors, DEV_MINOR_INVALID);
+	return KERN_OK;
+}
+
+kern_status_t driver_deinit(struct driver *driver)
+{
+	/* TODO */
 	return KERN_UNIMPLEMENTED;
 }
 
@@ -91,7 +112,7 @@ kern_status_t driver_register(struct driver *driver)
 	put_driver(&drivers, driver);
 
 	spin_unlock_irqrestore(&drivers_lock, flags);
-	return KERN_UNIMPLEMENTED;
+	return KERN_OK;
 }
 
 kern_status_t driver_unregister(struct driver *driver)
@@ -147,3 +168,9 @@ kern_status_t driver_add_device(struct driver *driver, struct device *dev)
 
 	return KERN_OK;
 }
+
+kern_status_t driver_remove_device(struct driver *driver, struct device *dev)
+{
+	btree_delete(&driver->drv_children, &dev->dev_driverent);
+	return KERN_OK;
+}

dev/fb.c

@@ -17,6 +17,12 @@ struct framebuffer_device *framebuffer_device_create(void)
 	return FRAMEBUFFER_DEVICE(dev);
 }
 
+struct framebuffer_device *framebuffer_device_from_generic(struct device *dev)
+{
+	dev->dev_type = DEV_TYPE_FRAMEBUFFER;
+	return FRAMEBUFFER_DEVICE(dev);
+}
+
 static kern_status_t generate_name(struct framebuffer_device *dev, char out[DEV_NAME_MAX])
 {
 	snprintf(out, DEV_NAME_MAX, "fb%u", dev->fb_id);
@@ -42,6 +48,31 @@ kern_status_t framebuffer_device_register(struct device *dev)
 	return object_namespace_create_link(global_namespace(), path, &dev->dev_base);
 }
 
+kern_status_t framebuffer_get_varinfo(struct device *dev, struct framebuffer_varinfo *varinfo)
+{
+	struct framebuffer_device *fbdev = FRAMEBUFFER_DEVICE(dev);
+	if (!fbdev) {
+		return KERN_INVALID_ARGUMENT;
+	}
+
+	memcpy(varinfo, &fbdev->fb_varinfo, sizeof *varinfo);
+	return KERN_OK;
+}
+
+kern_status_t framebuffer_set_varinfo(struct device *dev, const struct framebuffer_varinfo *varinfo)
+{
+	struct framebuffer_device *fbdev = FRAMEBUFFER_DEVICE(dev);
+	if (!fbdev) {
+		return KERN_INVALID_ARGUMENT;
+	}
+
+	if (!fbdev->fb_ops || !fbdev->fb_ops->set_varinfo) {
+		return KERN_UNSUPPORTED;
+	}
+
+	return fbdev->fb_ops->set_varinfo(dev, varinfo);
+}
+
 struct device_type_ops framebuffer_type_ops = {
 	.register_device = framebuffer_device_register,
 };

dev/input.c

@@ -24,6 +24,12 @@ struct input_device *input_device_create(void)
 	return INPUT_DEVICE(dev);
 }
 
+struct input_device *input_device_from_generic(struct device *dev)
+{
+	dev->dev_type = DEV_TYPE_INPUT;
+	return INPUT_DEVICE(dev);
+}
+
 kern_status_t input_device_report_event(struct input_device *dev, const struct input_event *ev, bool noblock)
 {
 	struct ringbuffer *event_queue = &dev->i_events;

dev/net.c

@@ -11,3 +11,9 @@ struct net_device *net_device_create(void)
 
 	return NET_DEVICE(dev);
 }
+
+struct net_device *net_device_from_generic(struct device *dev)
+{
+	dev->dev_type = DEV_TYPE_NET;
+	return NET_DEVICE(dev);
+}