#include <linux/workqueue.h>
#include "pciback.h"
+#define DRV_NAME "xen-pciback"
#define INVALID_EVTCHN_IRQ (-1)
-struct workqueue_struct *pciback_wq;
+struct workqueue_struct *xen_pcibk_wq;
-static struct pciback_device *alloc_pdev(struct xenbus_device *xdev)
+static struct xen_pcibk_device *alloc_pdev(struct xenbus_device *xdev)
{
- struct pciback_device *pdev;
+ struct xen_pcibk_device *pdev;
- pdev = kzalloc(sizeof(struct pciback_device), GFP_KERNEL);
+ pdev = kzalloc(sizeof(struct xen_pcibk_device), GFP_KERNEL);
if (pdev == NULL)
goto out;
dev_dbg(&xdev->dev, "allocated pdev @ 0x%p\n", pdev);
pdev->evtchn_irq = INVALID_EVTCHN_IRQ;
pdev->be_watching = 0;
- INIT_WORK(&pdev->op_work, pciback_do_op);
+ INIT_WORK(&pdev->op_work, xen_pcibk_do_op);
- if (pciback_init_devices(pdev)) {
+ if (xen_pcibk_init_devices(pdev)) {
kfree(pdev);
pdev = NULL;
}
return pdev;
}
-static void pciback_disconnect(struct pciback_device *pdev)
+static void xen_pcibk_disconnect(struct xen_pcibk_device *pdev)
{
spin_lock(&pdev->dev_lock);
* before releasing the shared memory */
/* Note, the workqueue does not use spinlocks at all.*/
- flush_workqueue(pciback_wq);
+ flush_workqueue(xen_pcibk_wq);
spin_lock(&pdev->dev_lock);
if (pdev->sh_info != NULL) {
}
-static void free_pdev(struct pciback_device *pdev)
+static void free_pdev(struct xen_pcibk_device *pdev)
{
if (pdev->be_watching) {
unregister_xenbus_watch(&pdev->be_watch);
pdev->be_watching = 0;
}
- pciback_disconnect(pdev);
+ xen_pcibk_disconnect(pdev);
- pciback_release_devices(pdev);
+ xen_pcibk_release_devices(pdev);
dev_set_drvdata(&pdev->xdev->dev, NULL);
pdev->xdev = NULL;
kfree(pdev);
}
-static int pciback_do_attach(struct pciback_device *pdev, int gnt_ref,
+static int xen_pcibk_do_attach(struct xen_pcibk_device *pdev, int gnt_ref,
int remote_evtchn)
{
int err = 0;
spin_unlock(&pdev->dev_lock);
err = bind_interdomain_evtchn_to_irqhandler(
- pdev->xdev->otherend_id, remote_evtchn, pciback_handle_event,
- 0, "pciback", pdev);
+ pdev->xdev->otherend_id, remote_evtchn, xen_pcibk_handle_event,
+ 0, DRV_NAME, pdev);
if (err < 0) {
xenbus_dev_fatal(pdev->xdev, err,
"Error binding event channel to IRQ");
return err;
}
-static int pciback_attach(struct pciback_device *pdev)
+static int xen_pcibk_attach(struct xen_pcibk_device *pdev)
{
int err = 0;
int gnt_ref, remote_evtchn;
if (magic == NULL || strcmp(magic, XEN_PCI_MAGIC) != 0) {
xenbus_dev_fatal(pdev->xdev, -EFAULT,
"version mismatch (%s/%s) with pcifront - "
- "halting pciback",
+ "halting xen_pcibk",
magic, XEN_PCI_MAGIC);
goto out;
}
- err = pciback_do_attach(pdev, gnt_ref, remote_evtchn);
+ err = xen_pcibk_do_attach(pdev, gnt_ref, remote_evtchn);
if (err)
goto out;
return err;
}
-static int pciback_publish_pci_dev(struct pciback_device *pdev,
+static int xen_pcibk_publish_pci_dev(struct xen_pcibk_device *pdev,
unsigned int domain, unsigned int bus,
unsigned int devfn, unsigned int devid)
{
return err;
}
-static int pciback_export_device(struct pciback_device *pdev,
+static int xen_pcibk_export_device(struct xen_pcibk_device *pdev,
int domain, int bus, int slot, int func,
int devid)
{
goto out;
}
- err = pciback_add_pci_dev(pdev, dev, devid, pciback_publish_pci_dev);
+ err = xen_pcibk_add_pci_dev(pdev, dev, devid,
+ xen_pcibk_publish_pci_dev);
if (err)
goto out;
return err;
}
-static int pciback_remove_device(struct pciback_device *pdev,
+static int xen_pcibk_remove_device(struct xen_pcibk_device *pdev,
int domain, int bus, int slot, int func)
{
int err = 0;
dev_dbg(&pdev->xdev->dev, "removing dom %x bus %x slot %x func %x\n",
domain, bus, slot, func);
- dev = pciback_get_pci_dev(pdev, domain, bus, PCI_DEVFN(slot, func));
+ dev = xen_pcibk_get_pci_dev(pdev, domain, bus, PCI_DEVFN(slot, func));
if (!dev) {
err = -EINVAL;
dev_dbg(&pdev->xdev->dev, "Couldn't locate PCI device "
dev_dbg(&dev->dev, "unregistering for %d\n", pdev->xdev->otherend_id);
xen_unregister_device_domain_owner(dev);
- pciback_release_pci_dev(pdev, dev);
+ xen_pcibk_release_pci_dev(pdev, dev);
out:
return err;
}
-static int pciback_publish_pci_root(struct pciback_device *pdev,
+static int xen_pcibk_publish_pci_root(struct xen_pcibk_device *pdev,
unsigned int domain, unsigned int bus)
{
unsigned int d, b;
return err;
}
-static int pciback_reconfigure(struct pciback_device *pdev)
+static int xen_pcibk_reconfigure(struct xen_pcibk_device *pdev)
{
int err = 0;
int num_devs;
goto out;
}
- err = pciback_export_device(pdev, domain, bus, slot,
+ err = xen_pcibk_export_device(pdev, domain, bus, slot,
func, i);
if (err)
goto out;
/* Publish pci roots. */
- err = pciback_publish_pci_roots(pdev,
- pciback_publish_pci_root);
+ err = xen_pcibk_publish_pci_roots(pdev,
+ xen_pcibk_publish_pci_root);
if (err) {
xenbus_dev_fatal(pdev->xdev, err,
"Error while publish PCI root"
goto out;
}
- err = pciback_remove_device(pdev, domain, bus, slot,
+ err = xen_pcibk_remove_device(pdev, domain, bus, slot,
func);
if (err)
goto out;
return 0;
}
-static void pciback_frontend_changed(struct xenbus_device *xdev,
+static void xen_pcibk_frontend_changed(struct xenbus_device *xdev,
enum xenbus_state fe_state)
{
- struct pciback_device *pdev = dev_get_drvdata(&xdev->dev);
+ struct xen_pcibk_device *pdev = dev_get_drvdata(&xdev->dev);
dev_dbg(&xdev->dev, "fe state changed %d\n", fe_state);
switch (fe_state) {
case XenbusStateInitialised:
- pciback_attach(pdev);
+ xen_pcibk_attach(pdev);
break;
case XenbusStateReconfiguring:
- pciback_reconfigure(pdev);
+ xen_pcibk_reconfigure(pdev);
break;
case XenbusStateConnected:
break;
case XenbusStateClosing:
- pciback_disconnect(pdev);
+ xen_pcibk_disconnect(pdev);
xenbus_switch_state(xdev, XenbusStateClosing);
break;
case XenbusStateClosed:
- pciback_disconnect(pdev);
+ xen_pcibk_disconnect(pdev);
xenbus_switch_state(xdev, XenbusStateClosed);
if (xenbus_dev_is_online(xdev))
break;
}
}
-static int pciback_setup_backend(struct pciback_device *pdev)
+static int xen_pcibk_setup_backend(struct xen_pcibk_device *pdev)
{
/* Get configuration from xend (if available now) */
int domain, bus, slot, func;
goto out;
}
- err = pciback_export_device(pdev, domain, bus, slot, func, i);
+ err = xen_pcibk_export_device(pdev, domain, bus, slot, func, i);
if (err)
goto out;
}
}
- err = pciback_publish_pci_roots(pdev, pciback_publish_pci_root);
+ err = xen_pcibk_publish_pci_roots(pdev, xen_pcibk_publish_pci_root);
if (err) {
xenbus_dev_fatal(pdev->xdev, err,
"Error while publish PCI root buses "
out:
if (!err)
/* see if pcifront is already configured (if not, we'll wait) */
- pciback_attach(pdev);
+ xen_pcibk_attach(pdev);
return err;
}
-static void pciback_be_watch(struct xenbus_watch *watch,
+static void xen_pcibk_be_watch(struct xenbus_watch *watch,
const char **vec, unsigned int len)
{
- struct pciback_device *pdev =
- container_of(watch, struct pciback_device, be_watch);
+ struct xen_pcibk_device *pdev =
+ container_of(watch, struct xen_pcibk_device, be_watch);
switch (xenbus_read_driver_state(pdev->xdev->nodename)) {
case XenbusStateInitWait:
- pciback_setup_backend(pdev);
+ xen_pcibk_setup_backend(pdev);
break;
default:
}
}
-static int pciback_xenbus_probe(struct xenbus_device *dev,
+static int xen_pcibk_xenbus_probe(struct xenbus_device *dev,
const struct xenbus_device_id *id)
{
int err = 0;
- struct pciback_device *pdev = alloc_pdev(dev);
+ struct xen_pcibk_device *pdev = alloc_pdev(dev);
if (pdev == NULL) {
err = -ENOMEM;
xenbus_dev_fatal(dev, err,
- "Error allocating pciback_device struct");
+ "Error allocating xen_pcibk_device struct");
goto out;
}
/* watch the backend node for backend configuration information */
err = xenbus_watch_path(dev, dev->nodename, &pdev->be_watch,
- pciback_be_watch);
+ xen_pcibk_be_watch);
if (err)
goto out;
/* We need to force a call to our callback here in case
* xend already configured us!
*/
- pciback_be_watch(&pdev->be_watch, NULL, 0);
+ xen_pcibk_be_watch(&pdev->be_watch, NULL, 0);
out:
return err;
}
-static int pciback_xenbus_remove(struct xenbus_device *dev)
+static int xen_pcibk_xenbus_remove(struct xenbus_device *dev)
{
- struct pciback_device *pdev = dev_get_drvdata(&dev->dev);
+ struct xen_pcibk_device *pdev = dev_get_drvdata(&dev->dev);
if (pdev != NULL)
free_pdev(pdev);
{""},
};
-static struct xenbus_driver xenbus_pciback_driver = {
- .name = "pciback",
+static struct xenbus_driver xenbus_xen_pcibk_driver = {
+ .name = DRV_NAME,
.owner = THIS_MODULE,
.ids = xenpci_ids,
- .probe = pciback_xenbus_probe,
- .remove = pciback_xenbus_remove,
- .otherend_changed = pciback_frontend_changed,
+ .probe = xen_pcibk_xenbus_probe,
+ .remove = xen_pcibk_xenbus_remove,
+ .otherend_changed = xen_pcibk_frontend_changed,
};
-int __init pciback_xenbus_register(void)
+int __init xen_pcibk_xenbus_register(void)
{
- pciback_wq = create_workqueue("pciback_workqueue");
- if (!pciback_wq) {
+ xen_pcibk_wq = create_workqueue("xen_pciback_workqueue");
+ if (!xen_pcibk_wq) {
printk(KERN_ERR "%s: create"
- "pciback_workqueue failed\n", __func__);
+ "xen_pciback_workqueue failed\n", __func__);
return -EFAULT;
}
- return xenbus_register_backend(&xenbus_pciback_driver);
+ return xenbus_register_backend(&xenbus_xen_pcibk_driver);
}
-void __exit pciback_xenbus_unregister(void)
+void __exit xen_pcibk_xenbus_unregister(void)
{
- destroy_workqueue(pciback_wq);
- xenbus_unregister_driver(&xenbus_pciback_driver);
+ destroy_workqueue(xen_pcibk_wq);
+ xenbus_unregister_driver(&xenbus_xen_pcibk_driver);
}
git.openpandora.org / pandora-kernel.git / blobdiff