1/** 2 * \file drm_stub.h 3 * Stub support 4 * 5 * \author Rickard E. (Rik) Faith <faith@valinux.com> 6 */ 7 8/* 9 * Created: Fri Jan 19 10:48:35 2001 by faith@acm.org 10 * 11 * Copyright 2001 VA Linux Systems, Inc., Sunnyvale, California. 12 * All Rights Reserved. 13 * 14 * Permission is hereby granted, free of charge, to any person obtaining a 15 * copy of this software and associated documentation files (the "Software"), 16 * to deal in the Software without restriction, including without limitation 17 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 18 * and/or sell copies of the Software, and to permit persons to whom the 19 * Software is furnished to do so, subject to the following conditions: 20 * 21 * The above copyright notice and this permission notice (including the next 22 * paragraph) shall be included in all copies or substantial portions of the 23 * Software. 24 * 25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 26 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 27 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 28 * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 29 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 30 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 31 * DEALINGS IN THE SOFTWARE. 32 */ 33 34#include <linux/module.h> 35#include <linux/moduleparam.h> 36#include "drmP.h" 37#include "drm_core.h" 38 39unsigned int drm_cards_limit = 16; /* Enough for one machine */ 40unsigned int drm_debug = 0; /* 1 to enable debug output */ 41EXPORT_SYMBOL(drm_debug); 42 43MODULE_AUTHOR(CORE_AUTHOR); 44MODULE_DESCRIPTION(CORE_DESC); 45MODULE_LICENSE("GPL and additional rights"); 46MODULE_PARM_DESC(cards_limit, "Maximum number of graphics cards"); 47MODULE_PARM_DESC(debug, "Enable debug output"); 48 49module_param_named(cards_limit, drm_cards_limit, int, 0444); 50module_param_named(debug, drm_debug, int, 0600); 51 52drm_head_t **drm_heads; 53struct class *drm_class; 54struct proc_dir_entry *drm_proc_root; 55 56static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev, 57 const struct pci_device_id *ent, 58 struct drm_driver *driver) 59{ 60 int retcode; 61 62 spin_lock_init(&dev->count_lock); 63 spin_lock_init(&dev->drw_lock); 64 spin_lock_init(&dev->tasklet_lock); 65 spin_lock_init(&dev->lock.spinlock); 66 init_timer(&dev->timer); 67 mutex_init(&dev->struct_mutex); 68 mutex_init(&dev->ctxlist_mutex); 69 70 dev->pdev = pdev; 71 dev->pci_device = pdev->device; 72 dev->pci_vendor = pdev->vendor; 73 74#ifdef __alpha__ 75 dev->hose = pdev->sysdata; 76#endif 77 dev->irq = pdev->irq; 78 79 dev->maplist = drm_calloc(1, sizeof(*dev->maplist), DRM_MEM_MAPS); 80 if (dev->maplist == NULL) 81 return -ENOMEM; 82 INIT_LIST_HEAD(&dev->maplist->head); 83 if (drm_ht_create(&dev->map_hash, 12)) { 84 drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS); 85 return -ENOMEM; 86 } 87 88 /* the DRM has 6 basic counters */ 89 dev->counters = 6; 90 dev->types[0] = _DRM_STAT_LOCK; 91 dev->types[1] = _DRM_STAT_OPENS; 92 dev->types[2] = _DRM_STAT_CLOSES; 93 dev->types[3] = _DRM_STAT_IOCTLS; 94 dev->types[4] = _DRM_STAT_LOCKS; 95 dev->types[5] = _DRM_STAT_UNLOCKS; 96 97 dev->driver = driver; 98 99 if (dev->driver->load) 100 if ((retcode = dev->driver->load(dev, ent->driver_data))) 101 goto error_out_unreg; 102 103 if (drm_core_has_AGP(dev)) { 104 if (drm_device_is_agp(dev)) 105 dev->agp = drm_agp_init(dev); 106 if (drm_core_check_feature(dev, DRIVER_REQUIRE_AGP) 107 && (dev->agp == NULL)) { 108 DRM_ERROR("Cannot initialize the agpgart module.\n"); 109 retcode = -EINVAL; 110 goto error_out_unreg; 111 } 112 if (drm_core_has_MTRR(dev)) { 113 if (dev->agp) 114 dev->agp->agp_mtrr = 115 mtrr_add(dev->agp->agp_info.aper_base, 116 dev->agp->agp_info.aper_size * 117 1024 * 1024, MTRR_TYPE_WRCOMB, 1); 118 } 119 } 120 121 retcode = drm_ctxbitmap_init(dev); 122 if (retcode) { 123 DRM_ERROR("Cannot allocate memory for context bitmap.\n"); 124 goto error_out_unreg; 125 } 126 127 return 0; 128 129 error_out_unreg: 130 drm_lastclose(dev); 131 return retcode; 132} 133 134 135/** 136 * Get a secondary minor number. 137 * 138 * \param dev device data structure 139 * \param sec-minor structure to hold the assigned minor 140 * \return negative number on failure. 141 * 142 * Search an empty entry and initialize it to the given parameters, and 143 * create the proc init entry via proc_init(). This routines assigns 144 * minor numbers to secondary heads of multi-headed cards 145 */ 146static int drm_get_head(drm_device_t * dev, drm_head_t * head) 147{ 148 drm_head_t **heads = drm_heads; 149 int ret; 150 int minor; 151 152 DRM_DEBUG("\n"); 153 154 for (minor = 0; minor < drm_cards_limit; minor++, heads++) { 155 if (!*heads) { 156 157 *head = (drm_head_t) { 158 .dev = dev,.device = 159 MKDEV(DRM_MAJOR, minor),.minor = minor,}; 160 161 if ((ret = 162 drm_proc_init(dev, minor, drm_proc_root, 163 &head->dev_root))) { 164 printk(KERN_ERR 165 "DRM: Failed to initialize /proc/dri.\n"); 166 goto err_g1; 167 } 168 169 head->dev_class = drm_sysfs_device_add(drm_class, head); 170 if (IS_ERR(head->dev_class)) { 171 printk(KERN_ERR 172 "DRM: Error sysfs_device_add.\n"); 173 ret = PTR_ERR(head->dev_class); 174 goto err_g2; 175 } 176 *heads = head; 177 178 DRM_DEBUG("new minor assigned %d\n", minor); 179 return 0; 180 } 181 } 182 DRM_ERROR("out of minors\n"); 183 return -ENOMEM; 184 err_g2: 185 drm_proc_cleanup(minor, drm_proc_root, head->dev_root); 186 err_g1: 187 *head = (drm_head_t) { 188 .dev = NULL}; 189 return ret; 190} 191 192/** 193 * Register. 194 * 195 * \param pdev - PCI device structure 196 * \param ent entry from the PCI ID table with device type flags 197 * \return zero on success or a negative number on failure. 198 * 199 * Attempt to gets inter module "drm" information. If we are first 200 * then register the character device and inter module information. 201 * Try and register, if we fail to register, backout previous work. 202 */ 203int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent, 204 struct drm_driver *driver) 205{ 206 drm_device_t *dev; 207 int ret; 208 209 DRM_DEBUG("\n"); 210 211 dev = drm_calloc(1, sizeof(*dev), DRM_MEM_STUB); 212 if (!dev) 213 return -ENOMEM; 214 215 ret = pci_enable_device(pdev); 216 if (ret) 217 goto err_g1; 218 219 if ((ret = drm_fill_in_dev(dev, pdev, ent, driver))) { 220 printk(KERN_ERR "DRM: Fill_in_dev failed.\n"); 221 goto err_g2; 222 } 223 if ((ret = drm_get_head(dev, &dev->primary))) 224 goto err_g2; 225 226 DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n", 227 driver->name, driver->major, driver->minor, driver->patchlevel, 228 driver->date, dev->primary.minor); 229 230 return 0; 231 232err_g2: 233 pci_disable_device(pdev); 234err_g1: 235 drm_free(dev, sizeof(*dev), DRM_MEM_STUB); 236 return ret; 237} 238 239/** 240 * Put a device minor number. 241 * 242 * \param dev device data structure 243 * \return always zero 244 * 245 * Cleans up the proc resources. If it is the last minor then release the foreign 246 * "drm" data, otherwise unregisters the "drm" data, frees the dev list and 247 * unregisters the character device. 248 */ 249int drm_put_dev(drm_device_t * dev) 250{ 251 DRM_DEBUG("release primary %s\n", dev->driver->pci_driver.name); 252 253 if (dev->unique) { 254 drm_free(dev->unique, strlen(dev->unique) + 1, DRM_MEM_DRIVER); 255 dev->unique = NULL; 256 dev->unique_len = 0; 257 } 258 if (dev->devname) { 259 drm_free(dev->devname, strlen(dev->devname) + 1, 260 DRM_MEM_DRIVER); 261 dev->devname = NULL; 262 } 263 drm_free(dev, sizeof(*dev), DRM_MEM_STUB); 264 return 0; 265} 266 267/** 268 * Put a secondary minor number. 269 * 270 * \param sec_minor - structure to be released 271 * \return always zero 272 * 273 * Cleans up the proc resources. Not legal for this to be the 274 * last minor released. 275 * 276 */ 277int drm_put_head(drm_head_t * head) 278{ 279 int minor = head->minor; 280 281 DRM_DEBUG("release secondary minor %d\n", minor); 282 283 drm_proc_cleanup(minor, drm_proc_root, head->dev_root); 284 drm_sysfs_device_remove(head->dev_class); 285 286 *head = (drm_head_t) {.dev = NULL}; 287 288 drm_heads[minor] = NULL; 289 290 return 0; 291} 292