Re: radeon-pre-2

Alan Cox
2004-09-13T12:31:10Z

[-- Attachment #1: Type: text/plain, Size: 1060 bytes --]

On Sul, 2004-09-12 at 23:42, Dave Airlie wrote:
> The worst things that will happen for all concerened is this:
> Jon does all this work on a merged solution outside the kernel, and it
> works well, and the X team decide to do a decent X on mesa-solo on Jons
> super-DRM, now the super-DRM gets pushed via the X tree and distributions
> start relasing kernels with it merged into it

Unlikely. Its rapidly unmaintainable because the core kernel changes
will obsolete it (see for example KGI).

> I think yourself and Linus's ideas for a locking scheme look good, I also
> know they won't please Jon too much as he can see where the potential
> ineffecienes with saving/restore card state on driver swap are, especailly
> on running fbcon and X on a dual-head card with different users.

Well this is what I came up with so far. It creates a vga class so you
can bind the drivers to functions of the card (and we can add/remove
functions later as appropriate), tells functions about each other and
now implements Linux lock proposal as I understood it.

Alan

[-- Attachment #2: vga_class.c --]
[-- Type: text/x-csrc, Size: 13514 bytes --]

/*
* drivers/video/vga-driver.c
*
*/

#include <linux/pci.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <asm/semaphore.h>
#include "vga_class.h"

/*
* Registration of video drivers and handling of hot-pluggable devices.
*/

static LIST_HEAD(vga_devices); /* No I don't know why its not DECLARE_LIST_HEAD either */

/**
* vga_match_one_device - Tell if a PCI device structure has a matching
* PCI device id structure
* @id: single PCI device id structure to match
* @dev: the PCI device structure to match against
*
* Returns the matching vga_device_id structure or %NULL if there is no match.
*/

static inline const struct vga_device_id *
vga_match_one_device(const struct vga_device_id *id, const struct pci_dev *dev)
{
if ((id->vendor == PCI_ANY_ID || id->vendor == dev->vendor) &&
(id->device == PCI_ANY_ID || id->device == dev->device) &&
(id->subvendor == PCI_ANY_ID || id->subvendor == dev->subsystem_vendor) &&
(id->subdevice == PCI_ANY_ID || id->subdevice == dev->subsystem_device) &&
!((id->class ^ dev->class) & id->class_mask))
return id;
return NULL;
}

/**
* vga_match_device - Tell if a VGA device structure has a matching
* PCI device id structure
* @ids: array of PCI device id structures to search in
* @dev: the PCI device structure to match against
*
* Used by a driver to check whether a PCI device present in the
* system is in its list of supported devices.Returns the matching
* vga_device_id structure or %NULL if there is no match.
*/
static const struct vga_device_id *
vga_match_device(const struct vga_device_id *ids, const struct vga_dev *vdev)
{
struct pci_dev *pdev = vdev->pci_dev;
while (ids->vendor || ids->subvendor || ids->class_mask) {
if (vga_match_one_device(ids, pdev) && ids->unit == vdev->unit)
return ids;
ids++;
}
return NULL;
}

static void vga_device_notify_install(struct vga_dev *vdev, int type)
{
int i;
for(i = TYPE_MEM; i < TYPE_LAST; i++) {
struct vga_dev *v = vdev->shared->device[i];
if(v != NULL && v->driver && i != type)
v->driver->notify_attach(v, type);
}
}

static void vga_device_notify_remove(struct vga_dev *vdev, int type)
{
int i;
for(i = TYPE_MEM; i < TYPE_LAST; i++) {
struct vga_dev *v = vdev->shared->device[i];
if(v != NULL && v->driver && i != type)
v->driver->notify_detach(v, type);
}
}

/**
* vga_device_probe_static()
*
* returns 0 and sets vdev->driver when drv claims vdev, else error.
*/
static int
vga_device_probe_static(struct vga_driver *vdrv, struct vga_dev *vdev)
{
int error = -ENODEV;
const struct vga_device_id *id;

if (!vdrv->id_table)
return error;
id = vga_match_device(vdrv->id_table, vdev);
if (id)
error = vdrv->probe(vdev, id);
if (error >= 0) {
vdev->driver = vdrv;
down(&vdev->shared->shared_sem);
vdev->shared->users++;
vga_device_notify_install(vdev, vdev->unit);
up(&vdev->shared->shared_sem);
error = 0;
}
return error;
}

/**
* __vga_device_probe()
*
* returns 0 on success, else error.
* side-effect: vdev->driver is set to vdrv when drv claims vdev.
*/
static int
__vga_device_probe(struct vga_driver *vdrv, struct vga_dev *vdev)
{
int error = 0;

if (!vdev->driver && vdrv->probe) {
error = vga_device_probe_static(vdrv, vdev);
}
return error;
}

static int vga_device_probe(struct device *dev)
{
int error = 0;
struct vga_driver *drv;
struct vga_dev *vdev;

drv = to_vga_driver(dev->driver);
vdev = to_vga_dev(dev);
vga_dev_get(vdev);
error = __vga_device_probe(drv, vdev);
if (error)
vga_dev_put(vdev);

return error;
}

static int vga_device_remove(struct device *dev)
{
struct vga_dev *vdev = to_vga_dev(dev);
struct vga_driver *vdrv = vdev->driver;

down(&vdev->shared->shared_sem);
vdev->shared->users--;
if (vdrv) {
vga_device_notify_remove(vdev, vdev->unit);
if (vdrv->remove)
vdrv->remove(vdev, vdev->shared->count);
vdev->driver = NULL;
}
vdev->shared->device[vdev->unit] = NULL;
up(&vdev->shared->shared_sem);

vga_dev_put(vdev);
return 0;
}

static int vga_device_suspend(struct device *dev, u32 state)
{
return 0;
}

/*
* Default resume method for devices that have no driver provided resume,
* or not even a driver at all.
*/

static int vga_device_resume(struct device *dev)
{
return 0;
}

static struct kobj_type vga_driver_kobj_type = {
};

/**
* vga_register_driver - register a new pci driver
* @drv: the driver structure to register
*
* Adds the driver structure to the list of registered drivers
* Returns the number of vga devices which were claimed by the driver
* during registration. The driver remains registered even if the
* return value is zero.
*/

int vga_register_driver(struct vga_driver *drv)
{
/* initialize common driver fields */
drv->driver.name = drv->name;
drv->driver.bus = &vga_bus_type;
drv->driver.probe = vga_device_probe;
drv->driver.remove = vga_device_remove;
drv->driver.kobj.ktype = &vga_driver_kobj_type;

/* register with core */
return driver_register(&drv->driver);
}

/**
* vga_unregister_driver - unregister a pci driver
* @drv: the driver structure to unregister
*
* Deletes the driver structure from the list of registered VGA drivers,
* gives it a chance to clean up by calling its remove() function for
* each device it was responsible for, and marks those devices as
* driverless.
*/

void vga_unregister_driver(struct vga_driver *vdrv)
{
driver_unregister(&vdrv->driver);
}

/**
* vga_dev_driver - get the vga_driver of a device
* @dev: the device to query
* @type: type of device
*
* Returns the appropriate vga_driver structure or %NULL if there is no
* registered driver for the device. The shared block is used so that
* you can pass your own vdev to receive driver information about
* other attached drivers to the same PCI device. Caller must be careful
* about locking and use of shared_sem.
*/

struct vga_driver *vga_dev_driver(const struct vga_dev *vdev, int type)
{
struct vga_dev *v = vdev->shared->device[type];
if(v == NULL)
return NULL;
return v->driver;
}

/**
* vga_bus_match - Tell if a VGA device structure has a matching PCI device id structure
* @ids: array of PCI device id structures to search in
* @dev: the VGA device structure to match against
*
* Used by a driver to check whether a VGA device present in the
* system is in its list of supported devices.Returns the matching
* vga_device_id structure or %NULL if there is no match.
*/

static int vga_bus_match(struct device *dev, struct device_driver * drv)
{
const struct vga_dev *vdev = to_vga_dev(dev);
struct vga_driver *vdrv = to_vga_driver(drv);
const struct vga_device_id * ids = vdrv->id_table;
if (!ids)
return 0;
return vga_match_device(ids, vdev) ? 1 : 0;
}

/**
* vga_dev_get - increments the reference count of the pci device structure
* @dev: the device being referenced
*
* Each live reference to a device should be refcounted.
*
* Drivers for VGA devices should normally record such references in
* their probe() methods, when they bind to a device, and release
* them by calling vga_dev_put(), in their disconnect() methods.
*
* A pointer to the device with the incremented reference counter is returned.
*/
struct vga_dev *vga_dev_get(struct vga_dev *vdev)
{
struct device *tmp;

if (!vdev)
return NULL;

tmp = get_device(&vdev->dev);
if (tmp)
return to_vga_dev(tmp);
else
return NULL;
}

/**
* vga_dev_put - release a use of the vga_dev structure
* @dev: device that's been disconnected
*
* Must be called when a user of a device is finished with it. When the last
* user of the device calls this function, the memory of the device is freed.
*/
void vga_dev_put(struct vga_dev *dev)
{
if (dev)
put_device(&dev->dev);
}

/* For now */
int vga_hotplug (struct device *dev, char **envp, int num_envp,
char *buffer, int buffer_size)
{
return -ENODEV;
}

struct bus_type vga_bus_type = {
.name = "vga",
.match = vga_bus_match,
.hotplug = vga_hotplug,
.suspend = vga_device_suspend,
.resume = vga_device_resume,
};

/*
* Helper for VESAfb and friends.
*/

static int mmio_resource_overlap(struct pci_dev *dev, int i, unsigned long mmio)
{
unsigned long st = pci_resource_start(dev, i);
unsigned long size = pci_resource_len(dev, i);
unsigned long flags = pci_resource_flags(dev, i);

if(st == 0 || size == 0)
return 0;
if(st + size < mmio)
return 0;
if(st > mmio)
return 0;
if(flags & IORESOURCE_IO)
return 0;
return 1;
}

static struct pci_dev *vga_find_by_mmio(unsigned long mmio)
{
struct list_head *l;
list_for_each(l, &vga_devices) {
struct vga_dev *vdev = list_entry(l, struct vga_dev, next);
int i;
for (i = 0; i < 6; i++) {
if (mmio_resource_overlap(vdev->pci_dev, i, mmio))
return vdev->pci_dev;
}
}
/* Check ISA window routing ? */
return NULL;
}

/*
* Big locking as suggested by Linus. Drivers can of course be
* more friendly and work together on some things.
*/

void vga_take_lock(struct vga_dev *vdev, struct vga_driver *vdrv, void *context)
{
struct vga_shared *v = vdev->shared;

down(&v->shared_sem);
down(&v->fb_sem);
if(v->lock_owner != vdrv || v->lock_context != context)
{
if(v->lock_release)
v->lock_release(vdev, v->lock_context);
v->lock_release = NULL;
}
v->lock_owner = vdrv;
v->lock_context = context;
}

EXPORT_SYMBOL_GPL(vga_take_lock);

/*
* Drop the big locking
*/

void vga_drop_lock(struct vga_dev *vdev, void (*lock_release)(struct vga_dev *, void *))
{
struct vga_shared *v = vdev->shared;
v->lock_release = lock_release;
up(&v->fb_sem);
up(&v->shared_sem);
}

EXPORT_SYMBOL_GPL(vga_drop_lock);

/*
* VGA device discovery from the PCI side
*/

/**
* vga_release_dev - free a pci device structure when all users of it are finished.
* @dev: device that's been disconnected
*
* Will be called only by the device core when all users of this vga device are
* done.
*/

static void vga_release_dev(struct device *dev)
{
struct vga_dev *vdev = to_vga_dev(dev);
/* We want this very late because the remove methods might want to
use the locks */
vga_take_lock(vdev, NULL, NULL);
vga_drop_lock(vdev, NULL);
down(&vdev->shared->shared_sem);
vdev->shared->device[vdev->unit] = NULL;
vdev->shared->count --;
up(&vdev->shared->shared_sem);
if(vdev->shared->count == 0)
kfree(vdev->shared);
kfree(vdev);
}

/**
* vga_remove_one - Remove vga adapter
* @pdev: PCI device
*
* A VGA adapter has been removed. We must propogate this into the
* VGA bus world
*/

static void vga_remove_one(struct pci_dev *pdev)
{
struct vga_dev *vdev = (struct vga_dev *)pdev->dev.driver_data;
device_unregister(&vdev->dev);
/* Remove from lists etc here */
vga_dev_put(vdev);
}

/**
* vga_found_one - Add vga adapter
* @pdev: PCI device
* @ent: matching PCI entity
*
* Allocate and install a new VGA class entity set after the PCI layer
* discovers it. We create device objects for the frame buffer,
* memory manager and dri objects at the moment. Additional frame
* buffer objects (multihead) can be allocated by the callers.
*/

static int vga_found_one(struct pci_dev *pdev,
const struct pci_device_id *ent)
{
struct vga_shared *vshar = kmalloc(sizeof(*vshar), GFP_KERNEL);
int i;
if(vshar == NULL)
return -ENOMEM;

memset(vshar, 0, sizeof(*vshar));
init_MUTEX(&vshar->shared_sem);
init_MUTEX(&vshar->fb_sem);
vshar->lock_owner = NULL;

for(i = TYPE_MEM; i <= TYPE_FB0; i++)
{
struct vga_dev *vdev = kmalloc(sizeof(*vdev), GFP_KERNEL);
if(vdev == NULL)
return -ENOMEM;
memset(vdev, 0, sizeof(*vdev));

vdev->pci_dev = pdev;
vdev->shared = vshar;
vdev->unit = i;

vshar->device[i] = vdev;
vshar->count ++;

vdev->dev.bus = &vga_bus_type;
vdev->dev.parent = NULL; /* ? */
vdev->dev.driver_data = pdev;
device_initialize(&vdev->dev);
vdev->dev.release = vga_release_dev;
vdev->dev.dma_mask = pdev->dev.dma_mask;
vdev->dev.coherent_dma_mask = pdev->dev.coherent_dma_mask;
vga_dev_get(vdev);

INIT_LIST_HEAD(&vdev->next);
list_add_tail(&vdev->next, &vga_devices);
}
return 1;
}

/*
* Match all video VGA class objects
*/

static struct pci_device_id vga_id_table[] = {
{ PCI_DEVICE_CLASS(((PCI_CLASS_DISPLAY_VGA << 8) | 0x00), ~0), },
{ 0, }
};

MODULE_DEVICE_TABLE(pci, vga_id_table);

static struct pci_driver vga_driver = {
.name = "vga",
.probe = vga_found_one,
.remove = vga_remove_one,
.id_table = vga_id_table,
/* Could use suspend/resume hooks ? */
};

EXPORT_SYMBOL(vga_register_driver);
EXPORT_SYMBOL(vga_unregister_driver);
EXPORT_SYMBOL(vga_dev_driver);
EXPORT_SYMBOL(vga_bus_type);
EXPORT_SYMBOL(vga_dev_get);
EXPORT_SYMBOL(vga_dev_put);

int __init vga_driver_init(void)
{
if( bus_register(&vga_bus_type) < 0)
printk(KERN_ERR "Unable to register VGA bus type.\n");
return pci_module_init(&vga_driver);
}

postcore_initcall(vga_driver_init);

[-- Attachment #3: vga_class.h --]
[-- Type: text/x-chdr, Size: 2286 bytes --]

#define TYPE_MEM 0 /* Memory manager */
#define TYPE_DRI 1 /* Direct render agent */
#define TYPE_FB0 2 /* Frame buffer head 0 */
#define TYPE_FB1 3 /* Frame buffer head 1 */
#define TYPE_FB2 4 /* Frame buffer head 2 */
#define TYPE_FB3 5 /* Frame buffer head 3 */
#define TYPE_LAST 5
#define NUM_TYPES 6

struct vga_shared {
struct vga_dev *device[NUM_TYPES];
struct semaphore shared_sem;
int count; /* Devices */
int users; /* Active users */
struct semaphore fb_sem;
void (*lock_release)(struct vga_dev *, void *);
void *lock_context;
struct vga_driver *lock_owner;
};

struct vga_dev {
struct list_head next; /* All VGA devices */
struct list_head router_list; /* By VGA router (not yet done) */
struct vga_driver *driver;
struct pci_dev *pci_dev;
struct device dev;
int unit;
struct vga_shared *shared;
};

struct vga_device_id {
__u32 vendor, device; /* Vendor and device ID or PCI_ANY_ID*/
__u32 subvendor, subdevice; /* Subsystem ID's or PCI_ANY_ID */
__u32 class, class_mask; /* (class,subclass,prog-if) triplet */
__u32 unit; /* Logical unit for attach */
kernel_ulong_t driver_data; /* Data private to the driver */
};

#define to_vga_dev(n) container_of(n, struct vga_dev, dev)

struct vga_driver {
struct list_head node;
int type;
char *name;
int (*probe) (struct vga_dev *vdev, const struct vga_device_id *id);
void (*remove) (struct vga_dev *dev, int users); /* Device removed (NULL if not a hot-plug capable driver) */
int (*suspend) (struct vga_dev *vdev, u32 state); /* Device suspended */ int (*resume) (struct vga_dev *vdev); /* Device woken up */
void (*notify_attach) (struct vga_dev *, int);
void (*notify_detach) (struct vga_dev *, int);
struct device_driver driver;
struct vga_device_id *id_table;
};

#define to_vga_driver(drv) container_of(drv, struct vga_driver, driver)

extern struct bus_type vga_bus_type;

extern int vga_register_driver(struct vga_driver *drv);
extern void vg_unregister_driver(struct vga_driver *drv);
extern struct vga_driver *vga_dev_driver(const struct vga_dev *, int);
extern struct bus_type vga_bus_type;
extern struct vga_dev *vga_dev_get(struct vga_dev *);
extern void vga_dev_put(struct vga_dev *);