drivers/gpu/drm/mgag200/mgag200_drv.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright 2012 Red Hat
   4  *
   5  * Authors: Matthew Garrett
   6  *          Dave Airlie
   7  */
   8
   9 #include <linux/module.h>
  10 #include <linux/pci.h>
  11 #include <linux/vmalloc.h>
  12
  13 #include <drm/drm_aperture.h>
  14 #include <drm/drm_drv.h>
  15 #include <drm/drm_file.h>
  16 #include <drm/drm_ioctl.h>
  17 #include <drm/drm_managed.h>
  18 #include <drm/drm_module.h>
  19 #include <drm/drm_pciids.h>
  20
  21 #include "mgag200_drv.h"
  22
  23 int mgag200_modeset = -1;
  24 MODULE_PARM_DESC(modeset, "Disable/Enable modesetting");
  25 module_param_named(modeset, mgag200_modeset, int, 0400);
  26
  27 int mgag200_init_pci_options(struct pci_dev *pdev, u32 option, u32 option2)
  28 {
  29         struct device *dev = &pdev->dev;
  30         int err;
  31
  32         err = pci_read_config_dword(pdev, PCI_MGA_OPTION, &option);
  33         if (err != PCIBIOS_SUCCESSFUL) {
  34                 dev_err(dev, "pci_read_config_dword(PCI_MGA_OPTION) failed: %d\n", err);
  35                 return pcibios_err_to_errno(err);
  36         }
  37
  38         err = pci_write_config_dword(pdev, PCI_MGA_OPTION, option);
  39         if (err != PCIBIOS_SUCCESSFUL) {
  40                 dev_err(dev, "pci_write_config_dword(PCI_MGA_OPTION) failed: %d\n", err);
  41                 return pcibios_err_to_errno(err);
  42         }
  43
  44         err = pci_write_config_dword(pdev, PCI_MGA_OPTION2, option2);
  45         if (err != PCIBIOS_SUCCESSFUL) {
  46                 dev_err(dev, "pci_write_config_dword(PCI_MGA_OPTION2) failed: %d\n", err);
  47                 return pcibios_err_to_errno(err);
  48         }
  49
  50         return 0;
  51 }
  52
  53 /*
  54  * DRM driver
  55  */
  56
  57 DEFINE_DRM_GEM_FOPS(mgag200_driver_fops);
  58
  59 static const struct drm_driver mgag200_driver = {
  60         .driver_features = DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET,
  61         .fops = &mgag200_driver_fops,
  62         .name = DRIVER_NAME,
  63         .desc = DRIVER_DESC,
  64         .date = DRIVER_DATE,
  65         .major = DRIVER_MAJOR,
  66         .minor = DRIVER_MINOR,
  67         .patchlevel = DRIVER_PATCHLEVEL,
  68         DRM_GEM_SHMEM_DRIVER_OPS,
  69 };
  70
  71 /*
  72  * DRM device
  73  */
  74
  75 int mgag200_regs_init(struct mga_device *mdev)
  76 {
  77         struct drm_device *dev = &mdev->base;
  78         struct pci_dev *pdev = to_pci_dev(dev->dev);
  79         u8 crtcext3;
  80         int ret;
  81
  82         ret = drmm_mutex_init(dev, &mdev->rmmio_lock);
  83         if (ret)
  84                 return ret;
  85
  86         /* BAR 1 contains registers */
  87         mdev->rmmio_base = pci_resource_start(pdev, 1);
  88         mdev->rmmio_size = pci_resource_len(pdev, 1);
  89
  90         if (!devm_request_mem_region(dev->dev, mdev->rmmio_base,
  91                                      mdev->rmmio_size, "mgadrmfb_mmio")) {
  92                 drm_err(dev, "can't reserve mmio registers\n");
  93                 return -ENOMEM;
  94         }
  95
  96         mdev->rmmio = pcim_iomap(pdev, 1, 0);
  97         if (mdev->rmmio == NULL)
  98                 return -ENOMEM;
  99
 100         RREG_ECRT(0x03, crtcext3);
 101         crtcext3 |= MGAREG_CRTCEXT3_MGAMODE;
 102         WREG_ECRT(0x03, crtcext3);
 103
 104         return 0;
 105 }
 106
 107 /*
 108  * PCI driver
 109  */
 110
 111 static const struct pci_device_id mgag200_pciidlist[] = {
 112         { PCI_VENDOR_ID_MATROX, 0x520, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_PCI },
 113         { PCI_VENDOR_ID_MATROX, 0x521, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_AGP },
 114         { PCI_VENDOR_ID_MATROX, 0x522, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 115                 G200_SE_A | MGAG200_FLAG_HW_BUG_NO_STARTADD},
 116         { PCI_VENDOR_ID_MATROX, 0x524, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_SE_B },
 117         { PCI_VENDOR_ID_MATROX, 0x530, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_EV },
 118         { PCI_VENDOR_ID_MATROX, 0x532, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_WB },
 119         { PCI_VENDOR_ID_MATROX, 0x533, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_EH },
 120         { PCI_VENDOR_ID_MATROX, 0x534, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_ER },
 121         { PCI_VENDOR_ID_MATROX, 0x536, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_EW3 },
 122         { PCI_VENDOR_ID_MATROX, 0x538, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_EH3 },
 123         {0,}
 124 };
 125
 126 MODULE_DEVICE_TABLE(pci, mgag200_pciidlist);
 127
 128 static enum mga_type mgag200_type_from_driver_data(kernel_ulong_t driver_data)
 129 {
 130         return (enum mga_type)(driver_data & MGAG200_TYPE_MASK);
 131 }
 132
 133 static unsigned long mgag200_flags_from_driver_data(kernel_ulong_t driver_data)
 134 {
 135         return driver_data & MGAG200_FLAG_MASK;
 136 }
 137
 138 static int
 139 mgag200_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 140 {
 141         kernel_ulong_t driver_data = ent->driver_data;
 142         enum mga_type type = mgag200_type_from_driver_data(driver_data);
 143         unsigned long flags = mgag200_flags_from_driver_data(driver_data);
 144         struct mga_device *mdev;
 145         struct drm_device *dev;
 146         int ret;
 147
 148         ret = drm_aperture_remove_conflicting_pci_framebuffers(pdev, &mgag200_driver);
 149         if (ret)
 150                 return ret;
 151
 152         ret = pcim_enable_device(pdev);
 153         if (ret)
 154                 return ret;
 155
 156         switch (type) {
 157         case G200_PCI:
 158         case G200_AGP:
 159                 mdev = mgag200_g200_device_create(pdev, &mgag200_driver, type, flags);
 160                 break;
 161         case G200_SE_A:
 162         case G200_SE_B:
 163                 mdev = mgag200_g200se_device_create(pdev, &mgag200_driver, type, flags);
 164                 break;
 165         case G200_WB:
 166                 mdev = mgag200_g200wb_device_create(pdev, &mgag200_driver, type, flags);
 167                 break;
 168         case G200_EV:
 169                 mdev = mgag200_g200ev_device_create(pdev, &mgag200_driver, type, flags);
 170                 break;
 171         case G200_EH:
 172                 mdev = mgag200_g200eh_device_create(pdev, &mgag200_driver, type, flags);
 173                 break;
 174         case G200_EH3:
 175                 mdev = mgag200_g200eh3_device_create(pdev, &mgag200_driver, type, flags);
 176                 break;
 177         case G200_ER:
 178                 mdev = mgag200_g200er_device_create(pdev, &mgag200_driver, type, flags);
 179                 break;
 180         case G200_EW3:
 181                 mdev = mgag200_g200ew3_device_create(pdev, &mgag200_driver, type, flags);
 182                 break;
 183         default:
 184                 dev_err(&pdev->dev, "Device type %d is unsupported\n", type);
 185                 return -ENODEV;
 186         }
 187         if (IS_ERR(mdev))
 188                 return PTR_ERR(mdev);
 189         dev = &mdev->base;
 190
 191         ret = drm_dev_register(dev, 0);
 192         if (ret)
 193                 return ret;
 194
 195         drm_fbdev_generic_setup(dev, 0);
 196
 197         return 0;
 198 }
 199
 200 static void mgag200_pci_remove(struct pci_dev *pdev)
 201 {
 202         struct drm_device *dev = pci_get_drvdata(pdev);
 203
 204         drm_dev_unregister(dev);
 205 }
 206
 207 static struct pci_driver mgag200_pci_driver = {
 208         .name = DRIVER_NAME,
 209         .id_table = mgag200_pciidlist,
 210         .probe = mgag200_pci_probe,
 211         .remove = mgag200_pci_remove,
 212 };
 213
 214 drm_module_pci_driver_if_modeset(mgag200_pci_driver, mgag200_modeset);
 215
 216 MODULE_AUTHOR(DRIVER_AUTHOR);
 217 MODULE_DESCRIPTION(DRIVER_DESC);
 218 MODULE_LICENSE("GPL");