1 /* drm_pci.h -- PCI DMA memory management wrappers for DRM -*- linux-c -*- */
2 /**
3 * \file drm_pci.c
4 * \brief Functions and ioctls to manage PCI memory
5 *
6 * \warning These interfaces aren't stable yet.
7 *
8 * \todo Implement the remaining ioctl's for the PCI pools.
9 * \todo The wrappers here are so thin that they would be better off inlined..
10 *
11 * \author José Fonseca <jrfonseca@tungstengraphics.com>
12 * \author Leif Delgass <ldelgass@retinalburn.net>
13 */
14
15 /*
16 * Copyright 2003 José Fonseca.
17 * Copyright 2003 Leif Delgass.
18 * All Rights Reserved.
19 *
20 * Permission is hereby granted, free of charge, to any person obtaining a
21 * copy of this software and associated documentation files (the "Software"),
22 * to deal in the Software without restriction, including without limitation
23 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
24 * and/or sell copies of the Software, and to permit persons to whom the
25 * Software is furnished to do so, subject to the following conditions:
26 *
27 * The above copyright notice and this permission notice (including the next
28 * paragraph) shall be included in all copies or substantial portions of the
29 * Software.
30 *
31 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
32 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
33 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
34 * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
35 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
36 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
37 */
38
39 #include <linux/pci.h>
40 #include <linux/slab.h>
41 #include <linux/dma-mapping.h>
42 #include <linux/export.h>
43 #include <drm/drmP.h>
44
45 /**********************************************************************/
46 /** \name PCI memory */
47 /*@{*/
48
49 /**
50 * \brief Allocate a PCI consistent memory block, for DMA.
51 */
drm_pci_alloc(struct drm_device * dev,size_t size,size_t align)52 drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t align)
53 {
54 drm_dma_handle_t *dmah;
55 unsigned long addr;
56 size_t sz;
57
58 /* pci_alloc_consistent only guarantees alignment to the smallest
59 * PAGE_SIZE order which is greater than or equal to the requested size.
60 * Return NULL here for now to make sure nobody tries for larger alignment
61 */
62 if (align > size)
63 return NULL;
64
65 dmah = kmalloc(sizeof(drm_dma_handle_t), GFP_KERNEL);
66 if (!dmah)
67 return NULL;
68
69 dmah->size = size;
70 dmah->vaddr = dma_alloc_coherent(&dev->pdev->dev, size, &dmah->busaddr, GFP_KERNEL | __GFP_COMP);
71
72 if (dmah->vaddr == NULL) {
73 kfree(dmah);
74 return NULL;
75 }
76
77 memset(dmah->vaddr, 0, size);
78
79 /* XXX - Is virt_to_page() legal for consistent mem? */
80 /* Reserve */
81 for (addr = (unsigned long)dmah->vaddr, sz = size;
82 sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) {
83 SetPageReserved(virt_to_page((void *)addr));
84 }
85
86 return dmah;
87 }
88
89 EXPORT_SYMBOL(drm_pci_alloc);
90
91 /**
92 * \brief Free a PCI consistent memory block without freeing its descriptor.
93 *
94 * This function is for internal use in the Linux-specific DRM core code.
95 */
__drm_pci_free(struct drm_device * dev,drm_dma_handle_t * dmah)96 void __drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
97 {
98 unsigned long addr;
99 size_t sz;
100
101 if (dmah->vaddr) {
102 /* XXX - Is virt_to_page() legal for consistent mem? */
103 /* Unreserve */
104 for (addr = (unsigned long)dmah->vaddr, sz = dmah->size;
105 sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) {
106 ClearPageReserved(virt_to_page((void *)addr));
107 }
108 dma_free_coherent(&dev->pdev->dev, dmah->size, dmah->vaddr,
109 dmah->busaddr);
110 }
111 }
112
113 /**
114 * \brief Free a PCI consistent memory block
115 */
drm_pci_free(struct drm_device * dev,drm_dma_handle_t * dmah)116 void drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
117 {
118 __drm_pci_free(dev, dmah);
119 kfree(dmah);
120 }
121
122 EXPORT_SYMBOL(drm_pci_free);
123
124 #ifdef CONFIG_PCI
125
drm_get_pci_domain(struct drm_device * dev)126 static int drm_get_pci_domain(struct drm_device *dev)
127 {
128 #ifndef __alpha__
129 /* For historical reasons, drm_get_pci_domain() is busticated
130 * on most archs and has to remain so for userspace interface
131 * < 1.4, except on alpha which was right from the beginning
132 */
133 if (dev->if_version < 0x10004)
134 return 0;
135 #endif /* __alpha__ */
136
137 return pci_domain_nr(dev->pdev->bus);
138 }
139
drm_pci_get_irq(struct drm_device * dev)140 static int drm_pci_get_irq(struct drm_device *dev)
141 {
142 return dev->pdev->irq;
143 }
144
drm_pci_get_name(struct drm_device * dev)145 static const char *drm_pci_get_name(struct drm_device *dev)
146 {
147 struct pci_driver *pdriver = dev->driver->kdriver.pci;
148 return pdriver->name;
149 }
150
drm_pci_set_busid(struct drm_device * dev,struct drm_master * master)151 static int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master)
152 {
153 int len, ret;
154 struct pci_driver *pdriver = dev->driver->kdriver.pci;
155 master->unique_len = 40;
156 master->unique_size = master->unique_len;
157 master->unique = kmalloc(master->unique_size, GFP_KERNEL);
158 if (master->unique == NULL)
159 return -ENOMEM;
160
161
162 len = snprintf(master->unique, master->unique_len,
163 "pci:%04x:%02x:%02x.%d",
164 drm_get_pci_domain(dev),
165 dev->pdev->bus->number,
166 PCI_SLOT(dev->pdev->devfn),
167 PCI_FUNC(dev->pdev->devfn));
168
169 if (len >= master->unique_len) {
170 DRM_ERROR("buffer overflow");
171 ret = -EINVAL;
172 goto err;
173 } else
174 master->unique_len = len;
175
176 size_t devlen = strlen(pdriver->name) + master->unique_len + 2;
177 dev->devname = kmalloc(dev->devlen, GFP_KERNEL);
178
179 if (dev->devname == NULL) {
180 ret = -ENOMEM;
181 goto err;
182 }
183
184 snprintf(dev->devname, devlen, "%s@%s", pdriver->name,
185 master->unique);
186
187 return 0;
188 err:
189 return ret;
190 }
191
drm_pci_set_unique(struct drm_device * dev,struct drm_master * master,struct drm_unique * u)192 static int drm_pci_set_unique(struct drm_device *dev,
193 struct drm_master *master,
194 struct drm_unique *u)
195 {
196 int domain, bus, slot, func, ret;
197 const char *bus_name;
198
199 master->unique_len = u->unique_len;
200 master->unique_size = u->unique_len + 1;
201 master->unique = kmalloc(master->unique_size, GFP_KERNEL);
202 if (!master->unique) {
203 ret = -ENOMEM;
204 goto err;
205 }
206
207 if (copy_from_user(master->unique, u->unique, master->unique_len)) {
208 ret = -EFAULT;
209 goto err;
210 }
211
212 master->unique[master->unique_len] = '\0';
213
214 bus_name = dev->driver->bus->get_name(dev);
215 size_t devlen = strlen(bus_name) + strlen(master->unique) + 2;
216 dev->devname = kmalloc(devlen, GFP_KERNEL);
217 if (!dev->devname) {
218 ret = -ENOMEM;
219 goto err;
220 }
221
222 snprintf(dev->devname, devlen, "%s@%s", bus_name,
223 master->unique);
224
225 /* Return error if the busid submitted doesn't match the device's actual
226 * busid.
227 */
228 ret = sscanf(master->unique, "PCI:%d:%d:%d", &bus, &slot, &func);
229 if (ret != 3) {
230 ret = -EINVAL;
231 goto err;
232 }
233
234 domain = bus >> 8;
235 bus &= 0xff;
236
237 if ((domain != drm_get_pci_domain(dev)) ||
238 (bus != dev->pdev->bus->number) ||
239 (slot != PCI_SLOT(dev->pdev->devfn)) ||
240 (func != PCI_FUNC(dev->pdev->devfn))) {
241 ret = -EINVAL;
242 goto err;
243 }
244 return 0;
245 err:
246 return ret;
247 }
248
249
drm_pci_irq_by_busid(struct drm_device * dev,struct drm_irq_busid * p)250 static int drm_pci_irq_by_busid(struct drm_device *dev, struct drm_irq_busid *p)
251 {
252 if ((p->busnum >> 8) != drm_get_pci_domain(dev) ||
253 (p->busnum & 0xff) != dev->pdev->bus->number ||
254 p->devnum != PCI_SLOT(dev->pdev->devfn) || p->funcnum != PCI_FUNC(dev->pdev->devfn))
255 return -EINVAL;
256
257 p->irq = dev->pdev->irq;
258
259 DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum,
260 p->irq);
261 return 0;
262 }
263
drm_pci_agp_init(struct drm_device * dev)264 static void drm_pci_agp_init(struct drm_device *dev)
265 {
266 if (drm_core_check_feature(dev, DRIVER_USE_AGP)) {
267 if (drm_pci_device_is_agp(dev))
268 dev->agp = drm_agp_init(dev);
269 if (dev->agp) {
270 dev->agp->agp_mtrr = arch_phys_wc_add(
271 dev->agp->agp_info.aper_base,
272 dev->agp->agp_info.aper_size *
273 1024 * 1024);
274 }
275 }
276 }
277
drm_pci_agp_destroy(struct drm_device * dev)278 void drm_pci_agp_destroy(struct drm_device *dev)
279 {
280 if (dev->agp) {
281 arch_phys_wc_del(dev->agp->agp_mtrr);
282 drm_agp_clear(dev);
283 kfree(dev->agp);
284 dev->agp = NULL;
285 }
286 }
287
288 static struct drm_bus drm_pci_bus = {
289 .bus_type = DRIVER_BUS_PCI,
290 .get_irq = drm_pci_get_irq,
291 .get_name = drm_pci_get_name,
292 .set_busid = drm_pci_set_busid,
293 .set_unique = drm_pci_set_unique,
294 .irq_by_busid = drm_pci_irq_by_busid,
295 };
296
297 /**
298 * Register.
299 *
300 * \param pdev - PCI device structure
301 * \param ent entry from the PCI ID table with device type flags
302 * \return zero on success or a negative number on failure.
303 *
304 * Attempt to gets inter module "drm" information. If we are first
305 * then register the character device and inter module information.
306 * Try and register, if we fail to register, backout previous work.
307 */
drm_get_pci_dev(struct pci_dev * pdev,const struct pci_device_id * ent,struct drm_driver * driver)308 int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
309 struct drm_driver *driver)
310 {
311 struct drm_device *dev;
312 int ret;
313
314 DRM_DEBUG("\n");
315
316 dev = drm_dev_alloc(driver, &pdev->dev);
317 if (!dev)
318 return -ENOMEM;
319
320 ret = pci_enable_device(pdev);
321 if (ret)
322 goto err_free;
323
324 dev->pdev = pdev;
325 #ifdef __alpha__
326 dev->hose = pdev->sysdata;
327 #endif
328
329 if (drm_core_check_feature(dev, DRIVER_MODESET))
330 pci_set_drvdata(pdev, dev);
331
332 drm_pci_agp_init(dev);
333
334 ret = drm_dev_register(dev, ent->driver_data);
335 if (ret)
336 goto err_agp;
337
338 DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
339 driver->name, driver->major, driver->minor, driver->patchlevel,
340 driver->date, pci_name(pdev), dev->primary->index);
341
342 /* No locking needed since shadow-attach is single-threaded since it may
343 * only be called from the per-driver module init hook. */
344 if (!drm_core_check_feature(dev, DRIVER_MODESET))
345 list_add_tail(&dev->legacy_dev_list, &driver->legacy_dev_list);
346
347 return 0;
348
349 err_agp:
350 drm_pci_agp_destroy(dev);
351 pci_disable_device(pdev);
352 err_free:
353 drm_dev_unref(dev);
354 return ret;
355 }
356 EXPORT_SYMBOL(drm_get_pci_dev);
357
358 /**
359 * PCI device initialization. Called direct from modules at load time.
360 *
361 * \return zero on success or a negative number on failure.
362 *
363 * Initializes a drm_device structures,registering the
364 * stubs and initializing the AGP device.
365 *
366 * Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and
367 * after the initialization for driver customization.
368 */
drm_pci_init(struct drm_driver * driver,struct pci_driver * pdriver)369 int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver)
370 {
371 struct pci_dev *pdev = NULL;
372 const struct pci_device_id *pid;
373 int i;
374
375 DRM_DEBUG("\n");
376
377 driver->kdriver.pci = pdriver;
378 driver->bus = &drm_pci_bus;
379
380 if (driver->driver_features & DRIVER_MODESET)
381 return pci_register_driver(pdriver);
382
383 /* If not using KMS, fall back to stealth mode manual scanning. */
384 INIT_LIST_HEAD(&driver->legacy_dev_list);
385 for (i = 0; pdriver->id_table[i].vendor != 0; i++) {
386 pid = &pdriver->id_table[i];
387
388 /* Loop around setting up a DRM device for each PCI device
389 * matching our ID and device class. If we had the internal
390 * function that pci_get_subsys and pci_get_class used, we'd
391 * be able to just pass pid in instead of doing a two-stage
392 * thing.
393 */
394 pdev = NULL;
395 while ((pdev =
396 pci_get_subsys(pid->vendor, pid->device, pid->subvendor,
397 pid->subdevice, pdev)) != NULL) {
398 if ((pdev->class & pid->class_mask) != pid->class)
399 continue;
400
401 /* stealth mode requires a manual probe */
402 pci_dev_get(pdev);
403 drm_get_pci_dev(pdev, pid, driver);
404 }
405 }
406 return 0;
407 }
408
drm_pcie_get_speed_cap_mask(struct drm_device * dev,u32 * mask)409 int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *mask)
410 {
411 struct pci_dev *root;
412 u32 lnkcap, lnkcap2;
413
414 *mask = 0;
415 if (!dev->pdev)
416 return -EINVAL;
417
418 root = dev->pdev->bus->self;
419
420 /* we've been informed via and serverworks don't make the cut */
421 if (root->vendor == PCI_VENDOR_ID_VIA ||
422 root->vendor == PCI_VENDOR_ID_SERVERWORKS)
423 return -EINVAL;
424
425 pcie_capability_read_dword(root, PCI_EXP_LNKCAP, &lnkcap);
426 pcie_capability_read_dword(root, PCI_EXP_LNKCAP2, &lnkcap2);
427
428 if (lnkcap2) { /* PCIe r3.0-compliant */
429 if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_2_5GB)
430 *mask |= DRM_PCIE_SPEED_25;
431 if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_5_0GB)
432 *mask |= DRM_PCIE_SPEED_50;
433 if (lnkcap2 & PCI_EXP_LNKCAP2_SLS_8_0GB)
434 *mask |= DRM_PCIE_SPEED_80;
435 } else { /* pre-r3.0 */
436 if (lnkcap & PCI_EXP_LNKCAP_SLS_2_5GB)
437 *mask |= DRM_PCIE_SPEED_25;
438 if (lnkcap & PCI_EXP_LNKCAP_SLS_5_0GB)
439 *mask |= (DRM_PCIE_SPEED_25 | DRM_PCIE_SPEED_50);
440 }
441
442 DRM_INFO("probing gen 2 caps for device %x:%x = %x/%x\n", root->vendor, root->device, lnkcap, lnkcap2);
443 return 0;
444 }
445 EXPORT_SYMBOL(drm_pcie_get_speed_cap_mask);
446
447 #else
448
drm_pci_init(struct drm_driver * driver,struct pci_driver * pdriver)449 int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver)
450 {
451 return -1;
452 }
453
drm_pci_agp_destroy(struct drm_device * dev)454 void drm_pci_agp_destroy(struct drm_device *dev) {}
455 #endif
456
457 EXPORT_SYMBOL(drm_pci_init);
458
459 /*@}*/
drm_pci_exit(struct drm_driver * driver,struct pci_driver * pdriver)460 void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver)
461 {
462 struct drm_device *dev, *tmp;
463 DRM_DEBUG("\n");
464
465 if (driver->driver_features & DRIVER_MODESET) {
466 pci_unregister_driver(pdriver);
467 } else {
468 list_for_each_entry_safe(dev, tmp, &driver->legacy_dev_list,
469 legacy_dev_list) {
470 list_del(&dev->legacy_dev_list);
471 drm_put_dev(dev);
472 }
473 }
474 DRM_INFO("Module unloaded\n");
475 }
476 EXPORT_SYMBOL(drm_pci_exit);
477