| 84,7 → 84,331 |
|---|
| return dmah; |
| } |
| |
| EXPORT_SYMBOL(drm_pci_alloc); |
| |
| #if 0 |
| /** |
| * \brief Free a PCI consistent memory block without freeing its descriptor. |
| * |
| * This function is for internal use in the Linux-specific DRM core code. |
| */ |
| void __drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah) |
| { |
| unsigned long addr; |
| size_t sz; |
| |
| if (dmah->vaddr) { |
| /* XXX - Is virt_to_page() legal for consistent mem? */ |
| /* Unreserve */ |
| for (addr = (unsigned long)dmah->vaddr, sz = dmah->size; |
| sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) { |
| ClearPageReserved(virt_to_page(addr)); |
| } |
| dma_free_coherent(&dev->pdev->dev, dmah->size, dmah->vaddr, |
| dmah->busaddr); |
| } |
| } |
| |
| /** |
| * \brief Free a PCI consistent memory block |
| */ |
| void drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah) |
| { |
| __drm_pci_free(dev, dmah); |
| kfree(dmah); |
| } |
| |
| EXPORT_SYMBOL(drm_pci_free); |
| |
| |
| static int drm_get_pci_domain(struct drm_device *dev) |
| { |
| #ifndef __alpha__ |
| /* For historical reasons, drm_get_pci_domain() is busticated |
| * on most archs and has to remain so for userspace interface |
| * < 1.4, except on alpha which was right from the beginning |
| */ |
| if (dev->if_version < 0x10004) |
| return 0; |
| #endif /* __alpha__ */ |
| |
| return pci_domain_nr(dev->pdev->bus); |
| } |
| |
| static int drm_pci_get_irq(struct drm_device *dev) |
| { |
| return dev->pdev->irq; |
| } |
| |
| static const char *drm_pci_get_name(struct drm_device *dev) |
| { |
| struct pci_driver *pdriver = dev->driver->kdriver.pci; |
| return pdriver->name; |
| } |
| |
| static int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master) |
| { |
| int len, ret; |
| struct pci_driver *pdriver = dev->driver->kdriver.pci; |
| master->unique_len = 40; |
| master->unique_size = master->unique_len; |
| master->unique = kmalloc(master->unique_size, GFP_KERNEL); |
| if (master->unique == NULL) |
| return -ENOMEM; |
| |
| |
| len = snprintf(master->unique, master->unique_len, |
| "pci:%04x:%02x:%02x.%d", |
| drm_get_pci_domain(dev), |
| dev->pdev->bus->number, |
| PCI_SLOT(dev->pdev->devfn), |
| PCI_FUNC(dev->pdev->devfn)); |
| |
| if (len >= master->unique_len) { |
| DRM_ERROR("buffer overflow"); |
| ret = -EINVAL; |
| goto err; |
| } else |
| master->unique_len = len; |
| |
| dev->devname = |
| kmalloc(strlen(pdriver->name) + |
| master->unique_len + 2, GFP_KERNEL); |
| |
| if (dev->devname == NULL) { |
| ret = -ENOMEM; |
| goto err; |
| } |
| |
| sprintf(dev->devname, "%s@%s", pdriver->name, |
| master->unique); |
| |
| return 0; |
| err: |
| return ret; |
| } |
| |
| static int drm_pci_set_unique(struct drm_device *dev, |
| struct drm_master *master, |
| struct drm_unique *u) |
| { |
| int domain, bus, slot, func, ret; |
| const char *bus_name; |
| |
| master->unique_len = u->unique_len; |
| master->unique_size = u->unique_len + 1; |
| master->unique = kmalloc(master->unique_size, GFP_KERNEL); |
| if (!master->unique) { |
| ret = -ENOMEM; |
| goto err; |
| } |
| |
| if (copy_from_user(master->unique, u->unique, master->unique_len)) { |
| ret = -EFAULT; |
| goto err; |
| } |
| |
| master->unique[master->unique_len] = '\0'; |
| |
| bus_name = dev->driver->bus->get_name(dev); |
| dev->devname = kmalloc(strlen(bus_name) + |
| strlen(master->unique) + 2, GFP_KERNEL); |
| if (!dev->devname) { |
| ret = -ENOMEM; |
| goto err; |
| } |
| |
| sprintf(dev->devname, "%s@%s", bus_name, |
| master->unique); |
| |
| /* Return error if the busid submitted doesn't match the device's actual |
| * busid. |
| */ |
| ret = sscanf(master->unique, "PCI:%d:%d:%d", &bus, &slot, &func); |
| if (ret != 3) { |
| ret = -EINVAL; |
| goto err; |
| } |
| |
| domain = bus >> 8; |
| bus &= 0xff; |
| |
| if ((domain != drm_get_pci_domain(dev)) || |
| (bus != dev->pdev->bus->number) || |
| (slot != PCI_SLOT(dev->pdev->devfn)) || |
| (func != PCI_FUNC(dev->pdev->devfn))) { |
| ret = -EINVAL; |
| goto err; |
| } |
| return 0; |
| err: |
| return ret; |
| } |
| |
| |
| static int drm_pci_irq_by_busid(struct drm_device *dev, struct drm_irq_busid *p) |
| { |
| if ((p->busnum >> 8) != drm_get_pci_domain(dev) || |
| (p->busnum & 0xff) != dev->pdev->bus->number || |
| p->devnum != PCI_SLOT(dev->pdev->devfn) || p->funcnum != PCI_FUNC(dev->pdev->devfn)) |
| return -EINVAL; |
| |
| p->irq = dev->pdev->irq; |
| |
| DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum, |
| p->irq); |
| return 0; |
| } |
| |
| static int drm_pci_agp_init(struct drm_device *dev) |
| { |
| if (drm_core_has_AGP(dev)) { |
| if (drm_pci_device_is_agp(dev)) |
| dev->agp = drm_agp_init(dev); |
| if (drm_core_check_feature(dev, DRIVER_REQUIRE_AGP) |
| && (dev->agp == NULL)) { |
| DRM_ERROR("Cannot initialize the agpgart module.\n"); |
| return -EINVAL; |
| } |
| if (dev->agp) { |
| dev->agp->agp_mtrr = arch_phys_wc_add( |
| dev->agp->agp_info.aper_base, |
| dev->agp->agp_info.aper_size * |
| 1024 * 1024); |
| } |
| } |
| return 0; |
| } |
| |
| static void drm_pci_agp_destroy(struct drm_device *dev) |
| { |
| if (drm_core_has_AGP(dev) && dev->agp) { |
| arch_phys_wc_del(dev->agp->agp_mtrr); |
| drm_agp_clear(dev); |
| drm_agp_destroy(dev->agp); |
| dev->agp = NULL; |
| } |
| } |
| |
| static struct drm_bus drm_pci_bus = { |
| .bus_type = DRIVER_BUS_PCI, |
| .get_irq = drm_pci_get_irq, |
| .get_name = drm_pci_get_name, |
| .set_busid = drm_pci_set_busid, |
| .set_unique = drm_pci_set_unique, |
| .irq_by_busid = drm_pci_irq_by_busid, |
| .agp_init = drm_pci_agp_init, |
| .agp_destroy = drm_pci_agp_destroy, |
| }; |
| #endif |
| |
| /** |
| * Register. |
| * |
| * \param pdev - PCI device structure |
| * \param ent entry from the PCI ID table with device type flags |
| * \return zero on success or a negative number on failure. |
| * |
| * Attempt to gets inter module "drm" information. If we are first |
| * then register the character device and inter module information. |
| * Try and register, if we fail to register, backout previous work. |
| */ |
| int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent, |
| struct drm_driver *driver) |
| { |
| static struct drm_device drm_dev; |
| static struct drm_file drm_file; |
| |
| struct drm_device *dev; |
| struct drm_file *priv; |
| |
| int ret; |
| |
| dev = &drm_dev; |
| priv = &drm_file; |
| |
| drm_file_handlers[0] = priv; |
| |
| // ret = pci_enable_device(pdev); |
| // if (ret) |
| // goto err_g1; |
| |
| pci_set_master(pdev); |
| |
| if ((ret = drm_fill_in_dev(dev, ent, driver))) { |
| printk(KERN_ERR "DRM: Fill_in_dev failed.\n"); |
| goto err_g2; |
| } |
| |
| DRM_DEBUG("\n"); |
| |
| |
| dev->pdev = pdev; |
| dev->pci_device = pdev->device; |
| dev->pci_vendor = pdev->vendor; |
| |
| #ifdef __alpha__ |
| dev->hose = pdev->sysdata; |
| #endif |
| |
| // mutex_lock(&drm_global_mutex); |
| |
| if ((ret = drm_fill_in_dev(dev, ent, driver))) { |
| printk(KERN_ERR "DRM: Fill_in_dev failed.\n"); |
| goto err_g2; |
| } |
| |
| #if 0 |
| if (drm_core_check_feature(dev, DRIVER_MODESET)) { |
| pci_set_drvdata(pdev, dev); |
| ret = drm_get_minor(dev, &dev->control, DRM_MINOR_CONTROL); |
| if (ret) |
| goto err_g2; |
| } |
| |
| if (drm_core_check_feature(dev, DRIVER_RENDER) && drm_rnodes) { |
| ret = drm_get_minor(dev, &dev->render, DRM_MINOR_RENDER); |
| if (ret) |
| goto err_g21; |
| } |
| |
| if ((ret = drm_get_minor(dev, &dev->primary, DRM_MINOR_LEGACY))) |
| goto err_g3; |
| #endif |
| |
| if (dev->driver->load) { |
| ret = dev->driver->load(dev, ent->driver_data); |
| if (ret) |
| goto err_g4; |
| } |
| |
| if (dev->driver->open) { |
| ret = dev->driver->open(dev, priv); |
| if (ret < 0) |
| goto err_g4; |
| } |
| |
| |
| // mutex_unlock(&drm_global_mutex); |
| return 0; |
| |
| err_g4: |
| // drm_put_minor(&dev->primary); |
| err_g3: |
| // if (dev->render) |
| // drm_put_minor(&dev->render); |
| err_g21: |
| // if (drm_core_check_feature(dev, DRIVER_MODESET)) |
| // drm_put_minor(&dev->control); |
| err_g2: |
| // pci_disable_device(pdev); |
| err_g1: |
| // kfree(dev); |
| // mutex_unlock(&drm_global_mutex); |
| return ret; |
| } |
| EXPORT_SYMBOL(drm_get_pci_dev); |
| |
| int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *mask) |
| { |
| struct pci_dev *root; |