static struct udl_device *udl_driver_create(struct usb_interface *interface) { struct usb_device *udev = interface_to_usbdev(interface); struct udl_device *udl; int r; udl = kzalloc(sizeof(*udl), GFP_KERNEL); if (!udl) return ERR_PTR(-ENOMEM); r = drm_dev_init(&udl->drm, &driver, &interface->dev); if (r) { kfree(udl); return ERR_PTR(r); } udl->udev = udev; udl->drm.dev_private = udl; r = udl_init(udl); if (r) { drm_dev_fini(&udl->drm); kfree(udl); return ERR_PTR(r); } usb_set_intfdata(interface, udl); return udl; }
struct komeda_kms_dev *komeda_kms_attach(struct komeda_dev *mdev) { struct komeda_kms_dev *kms = kzalloc(sizeof(*kms), GFP_KERNEL); struct drm_device *drm; int err; if (!kms) return ERR_PTR(-ENOMEM); drm = &kms->base; err = drm_dev_init(drm, &komeda_kms_driver, mdev->dev); if (err) goto free_kms; drm->dev_private = mdev; komeda_kms_mode_config_init(kms, mdev); err = komeda_kms_add_private_objs(kms, mdev); if (err) goto cleanup_mode_config; err = komeda_kms_add_planes(kms, mdev); if (err) goto cleanup_mode_config; err = drm_vblank_init(drm, kms->n_crtcs); if (err) goto cleanup_mode_config; err = komeda_kms_add_crtcs(kms, mdev); if (err) goto cleanup_mode_config; err = component_bind_all(mdev->dev, kms); if (err) goto cleanup_mode_config; drm_mode_config_reset(drm); err = drm_dev_register(drm, 0); if (err) goto cleanup_mode_config; return kms; cleanup_mode_config: drm_mode_config_cleanup(drm); free_kms: kfree(kms); return ERR_PTR(err); }
/** * drm_dev_alloc - Allocate new DRM device * @driver: DRM driver to allocate device for * @parent: Parent device object * * Allocate and initialize a new DRM device. No device registration is done. * Call drm_dev_register() to advertice the device to user space and register it * with other core subsystems. This should be done last in the device * initialization sequence to make sure userspace can't access an inconsistent * state. * * The initial ref-count of the object is 1. Use drm_dev_ref() and * drm_dev_unref() to take and drop further ref-counts. * * Note that for purely virtual devices @parent can be NULL. * * Drivers that wish to subclass or embed struct &drm_device into their * own struct should look at using drm_dev_init() instead. * * RETURNS: * Pointer to new DRM device, or NULL if out of memory. */ struct drm_device *drm_dev_alloc(struct drm_driver *driver, struct device *parent) { struct drm_device *dev; int ret; dev = kzalloc(sizeof(*dev), GFP_KERNEL); if (!dev) return NULL; ret = drm_dev_init(dev, driver, parent); if (ret) { kfree(dev); return NULL; } return dev; }
static int __init vgem_init(void) { int ret; vgem_device = kzalloc(sizeof(*vgem_device), GFP_KERNEL); if (!vgem_device) return -ENOMEM; vgem_device->platform = platform_device_register_simple("vgem", -1, NULL, 0); if (IS_ERR(vgem_device->platform)) { ret = PTR_ERR(vgem_device->platform); goto out_free; } dma_coerce_mask_and_coherent(&vgem_device->platform->dev, DMA_BIT_MASK(64)); ret = drm_dev_init(&vgem_device->drm, &vgem_driver, &vgem_device->platform->dev); if (ret) goto out_unregister; /* Final step: expose the device/driver to userspace */ ret = drm_dev_register(&vgem_device->drm, 0); if (ret) goto out_fini; return 0; out_fini: drm_dev_fini(&vgem_device->drm); out_unregister: platform_device_unregister(vgem_device->platform); out_free: kfree(vgem_device); return ret; }
static int vbox_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { struct vbox_private *vbox; int ret = 0; if (!vbox_check_supported(VBE_DISPI_ID_HGSMI)) return -ENODEV; vbox = kzalloc(sizeof(*vbox), GFP_KERNEL); if (!vbox) return -ENOMEM; ret = drm_dev_init(&vbox->ddev, &driver, &pdev->dev); if (ret) { kfree(vbox); return ret; } vbox->ddev.pdev = pdev; vbox->ddev.dev_private = vbox; pci_set_drvdata(pdev, vbox); mutex_init(&vbox->hw_mutex); ret = pci_enable_device(pdev); if (ret) goto err_dev_put; ret = vbox_hw_init(vbox); if (ret) goto err_pci_disable; ret = vbox_mm_init(vbox); if (ret) goto err_hw_fini; ret = vbox_mode_init(vbox); if (ret) goto err_mm_fini; ret = vbox_irq_init(vbox); if (ret) goto err_mode_fini; ret = drm_fb_helper_fbdev_setup(&vbox->ddev, &vbox->fb_helper, &vbox_fb_helper_funcs, 32, vbox->num_crtcs); if (ret) goto err_irq_fini; ret = drm_dev_register(&vbox->ddev, 0); if (ret) goto err_fbdev_fini; return 0; err_fbdev_fini: vbox_fbdev_fini(vbox); err_irq_fini: vbox_irq_fini(vbox); err_mode_fini: vbox_mode_fini(vbox); err_mm_fini: vbox_mm_fini(vbox); err_hw_fini: vbox_hw_fini(vbox); err_pci_disable: pci_disable_device(pdev); err_dev_put: drm_dev_put(&vbox->ddev); return ret; }