]>
Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
96de0e25 | 2 | * Copyright 2003 José Fonseca. |
1da177e4 LT |
3 | * Copyright 2003 Leif Delgass. |
4 | * All Rights Reserved. | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a | |
7 | * copy of this software and associated documentation files (the "Software"), | |
8 | * to deal in the Software without restriction, including without limitation | |
9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
10 | * and/or sell copies of the Software, and to permit persons to whom the | |
11 | * Software is furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice (including the next | |
14 | * paragraph) shall be included in all copies or substantial portions of the | |
15 | * Software. | |
16 | * | |
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
19 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
20 | * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | |
21 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | |
22 | * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
23 | */ | |
24 | ||
195b3a2d | 25 | #include <linux/dma-mapping.h> |
2d1a8a48 | 26 | #include <linux/export.h> |
0500c04e SR |
27 | #include <linux/pci.h> |
28 | #include <linux/slab.h> | |
29 | ||
30 | #include <drm/drm.h> | |
31 | #include <drm/drm_agpsupport.h> | |
32 | #include <drm/drm_drv.h> | |
23ef59ef | 33 | #include <drm/drm_pci.h> |
0500c04e SR |
34 | #include <drm/drm_print.h> |
35 | ||
43fc884e | 36 | #include "drm_internal.h" |
ba8286fa | 37 | #include "drm_legacy.h" |
1da177e4 | 38 | |
1da177e4 | 39 | /** |
c6a1af8a TR |
40 | * drm_pci_alloc - Allocate a PCI consistent memory block, for DMA. |
41 | * @dev: DRM device | |
42 | * @size: size of block to allocate | |
43 | * @align: alignment of block | |
44 | * | |
23ef59ef DV |
45 | * FIXME: This is a needless abstraction of the Linux dma-api and should be |
46 | * removed. | |
47 | * | |
c6a1af8a TR |
48 | * Return: A handle to the allocated memory block on success or NULL on |
49 | * failure. | |
1da177e4 | 50 | */ |
e6be8d9d | 51 | drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t align) |
1da177e4 | 52 | { |
9c8da5eb | 53 | drm_dma_handle_t *dmah; |
ddf19b97 DA |
54 | unsigned long addr; |
55 | size_t sz; | |
1da177e4 LT |
56 | |
57 | /* pci_alloc_consistent only guarantees alignment to the smallest | |
58 | * PAGE_SIZE order which is greater than or equal to the requested size. | |
59 | * Return NULL here for now to make sure nobody tries for larger alignment | |
60 | */ | |
61 | if (align > size) | |
62 | return NULL; | |
63 | ||
9c8da5eb DA |
64 | dmah = kmalloc(sizeof(drm_dma_handle_t), GFP_KERNEL); |
65 | if (!dmah) | |
66 | return NULL; | |
b5e89ed5 | 67 | |
9c8da5eb | 68 | dmah->size = size; |
750afb08 LC |
69 | dmah->vaddr = dma_alloc_coherent(&dev->pdev->dev, size, |
70 | &dmah->busaddr, | |
71 | GFP_KERNEL | __GFP_COMP); | |
1da177e4 | 72 | |
9c8da5eb DA |
73 | if (dmah->vaddr == NULL) { |
74 | kfree(dmah); | |
1da177e4 | 75 | return NULL; |
9c8da5eb | 76 | } |
1da177e4 | 77 | |
ddf19b97 DA |
78 | /* XXX - Is virt_to_page() legal for consistent mem? */ |
79 | /* Reserve */ | |
80 | for (addr = (unsigned long)dmah->vaddr, sz = size; | |
81 | sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) { | |
e1e78533 | 82 | SetPageReserved(virt_to_page((void *)addr)); |
ddf19b97 DA |
83 | } |
84 | ||
9c8da5eb | 85 | return dmah; |
1da177e4 | 86 | } |
b5e89ed5 | 87 | |
1da177e4 LT |
88 | EXPORT_SYMBOL(drm_pci_alloc); |
89 | ||
c6a1af8a TR |
90 | /* |
91 | * Free a PCI consistent memory block without freeing its descriptor. | |
9c8da5eb DA |
92 | * |
93 | * This function is for internal use in the Linux-specific DRM core code. | |
1da177e4 | 94 | */ |
1c96e84e | 95 | void __drm_legacy_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah) |
1da177e4 | 96 | { |
ddf19b97 DA |
97 | unsigned long addr; |
98 | size_t sz; | |
1da177e4 | 99 | |
9a298b2a | 100 | if (dmah->vaddr) { |
ddf19b97 DA |
101 | /* XXX - Is virt_to_page() legal for consistent mem? */ |
102 | /* Unreserve */ | |
103 | for (addr = (unsigned long)dmah->vaddr, sz = dmah->size; | |
104 | sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) { | |
e1e78533 | 105 | ClearPageReserved(virt_to_page((void *)addr)); |
ddf19b97 DA |
106 | } |
107 | dma_free_coherent(&dev->pdev->dev, dmah->size, dmah->vaddr, | |
108 | dmah->busaddr); | |
1da177e4 | 109 | } |
1da177e4 | 110 | } |
9c8da5eb DA |
111 | |
112 | /** | |
c6a1af8a TR |
113 | * drm_pci_free - Free a PCI consistent memory block |
114 | * @dev: DRM device | |
115 | * @dmah: handle to memory block | |
23ef59ef DV |
116 | * |
117 | * FIXME: This is a needless abstraction of the Linux dma-api and should be | |
118 | * removed. | |
9c8da5eb | 119 | */ |
84b1fd10 | 120 | void drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah) |
9c8da5eb | 121 | { |
1c96e84e | 122 | __drm_legacy_pci_free(dev, dmah); |
9c8da5eb DA |
123 | kfree(dmah); |
124 | } | |
b5e89ed5 | 125 | |
1da177e4 LT |
126 | EXPORT_SYMBOL(drm_pci_free); |
127 | ||
dcdb1674 | 128 | #ifdef CONFIG_PCI |
8410ea3b DA |
129 | |
130 | static int drm_get_pci_domain(struct drm_device *dev) | |
131 | { | |
132 | #ifndef __alpha__ | |
133 | /* For historical reasons, drm_get_pci_domain() is busticated | |
134 | * on most archs and has to remain so for userspace interface | |
135 | * < 1.4, except on alpha which was right from the beginning | |
136 | */ | |
137 | if (dev->if_version < 0x10004) | |
138 | return 0; | |
139 | #endif /* __alpha__ */ | |
140 | ||
141 | return pci_domain_nr(dev->pdev->bus); | |
142 | } | |
143 | ||
915b4d11 | 144 | int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master) |
8410ea3b | 145 | { |
d0a39164 DH |
146 | master->unique = kasprintf(GFP_KERNEL, "pci:%04x:%02x:%02x.%d", |
147 | drm_get_pci_domain(dev), | |
148 | dev->pdev->bus->number, | |
149 | PCI_SLOT(dev->pdev->devfn), | |
150 | PCI_FUNC(dev->pdev->devfn)); | |
151 | if (!master->unique) | |
8410ea3b DA |
152 | return -ENOMEM; |
153 | ||
d0a39164 | 154 | master->unique_len = strlen(master->unique); |
8410ea3b | 155 | return 0; |
8410ea3b DA |
156 | } |
157 | ||
45e97ab6 | 158 | static int drm_pci_irq_by_busid(struct drm_device *dev, struct drm_irq_busid *p) |
8410ea3b DA |
159 | { |
160 | if ((p->busnum >> 8) != drm_get_pci_domain(dev) || | |
161 | (p->busnum & 0xff) != dev->pdev->bus->number || | |
162 | p->devnum != PCI_SLOT(dev->pdev->devfn) || p->funcnum != PCI_FUNC(dev->pdev->devfn)) | |
163 | return -EINVAL; | |
164 | ||
165 | p->irq = dev->pdev->irq; | |
166 | ||
167 | DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum, | |
168 | p->irq); | |
169 | return 0; | |
170 | } | |
171 | ||
eaaf8f0f | 172 | /** |
c6a1af8a TR |
173 | * drm_irq_by_busid - Get interrupt from bus ID |
174 | * @dev: DRM device | |
175 | * @data: IOCTL parameter pointing to a drm_irq_busid structure | |
176 | * @file_priv: DRM file private. | |
eaaf8f0f DV |
177 | * |
178 | * Finds the PCI device with the specified bus id and gets its IRQ number. | |
179 | * This IOCTL is deprecated, and will now return EINVAL for any busid not equal | |
180 | * to that of the device that this DRM instance attached to. | |
c6a1af8a TR |
181 | * |
182 | * Return: 0 on success or a negative error code on failure. | |
eaaf8f0f DV |
183 | */ |
184 | int drm_irq_by_busid(struct drm_device *dev, void *data, | |
185 | struct drm_file *file_priv) | |
186 | { | |
187 | struct drm_irq_busid *p = data; | |
188 | ||
fa538645 | 189 | if (!drm_core_check_feature(dev, DRIVER_LEGACY)) |
69fdf420 | 190 | return -EOPNOTSUPP; |
eaaf8f0f DV |
191 | |
192 | /* UMS was only ever support on PCI devices. */ | |
193 | if (WARN_ON(!dev->pdev)) | |
194 | return -EINVAL; | |
195 | ||
196 | if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ)) | |
69fdf420 | 197 | return -EOPNOTSUPP; |
eaaf8f0f DV |
198 | |
199 | return drm_pci_irq_by_busid(dev, p); | |
200 | } | |
201 | ||
8da79ccd | 202 | static void drm_pci_agp_init(struct drm_device *dev) |
8410ea3b | 203 | { |
d9906753 | 204 | if (drm_core_check_feature(dev, DRIVER_USE_AGP)) { |
2ce0264d | 205 | if (pci_find_capability(dev->pdev, PCI_CAP_ID_AGP)) |
8410ea3b | 206 | dev->agp = drm_agp_init(dev); |
28185647 DV |
207 | if (dev->agp) { |
208 | dev->agp->agp_mtrr = arch_phys_wc_add( | |
209 | dev->agp->agp_info.aper_base, | |
210 | dev->agp->agp_info.aper_size * | |
211 | 1024 * 1024); | |
8410ea3b DA |
212 | } |
213 | } | |
8410ea3b DA |
214 | } |
215 | ||
4efafebe | 216 | void drm_pci_agp_destroy(struct drm_device *dev) |
28ec711c | 217 | { |
d9906753 | 218 | if (dev->agp) { |
28185647 | 219 | arch_phys_wc_del(dev->agp->agp_mtrr); |
366884b1 | 220 | drm_legacy_agp_clear(dev); |
d6e4b28b | 221 | kfree(dev->agp); |
28ec711c DH |
222 | dev->agp = NULL; |
223 | } | |
224 | } | |
225 | ||
dcdb1674 | 226 | /** |
c6a1af8a TR |
227 | * drm_get_pci_dev - Register a PCI device with the DRM subsystem |
228 | * @pdev: PCI device | |
229 | * @ent: entry from the PCI ID table that matches @pdev | |
230 | * @driver: DRM device driver | |
dcdb1674 JC |
231 | * |
232 | * Attempt to gets inter module "drm" information. If we are first | |
233 | * then register the character device and inter module information. | |
234 | * Try and register, if we fail to register, backout previous work. | |
c6a1af8a | 235 | * |
6e3f797c | 236 | * NOTE: This function is deprecated, please use drm_dev_alloc() and |
ef40cbf9 | 237 | * drm_dev_register() instead and remove your &drm_driver.load callback. |
6e3f797c | 238 | * |
c6a1af8a | 239 | * Return: 0 on success or a negative error code on failure. |
dcdb1674 JC |
240 | */ |
241 | int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent, | |
242 | struct drm_driver *driver) | |
243 | { | |
244 | struct drm_device *dev; | |
245 | int ret; | |
246 | ||
247 | DRM_DEBUG("\n"); | |
248 | ||
1bb72532 | 249 | dev = drm_dev_alloc(driver, &pdev->dev); |
0f288605 TG |
250 | if (IS_ERR(dev)) |
251 | return PTR_ERR(dev); | |
dcdb1674 JC |
252 | |
253 | ret = pci_enable_device(pdev); | |
254 | if (ret) | |
c22f0ace | 255 | goto err_free; |
dcdb1674 | 256 | |
dcdb1674 | 257 | dev->pdev = pdev; |
dcdb1674 JC |
258 | #ifdef __alpha__ |
259 | dev->hose = pdev->sysdata; | |
260 | #endif | |
261 | ||
c22f0ace | 262 | if (drm_core_check_feature(dev, DRIVER_MODESET)) |
dcdb1674 | 263 | pci_set_drvdata(pdev, dev); |
1793126f | 264 | |
2c695fa0 | 265 | drm_pci_agp_init(dev); |
2c695fa0 | 266 | |
c22f0ace DH |
267 | ret = drm_dev_register(dev, ent->driver_data); |
268 | if (ret) | |
2c695fa0 | 269 | goto err_agp; |
dcdb1674 | 270 | |
b3f2333d DV |
271 | /* No locking needed since shadow-attach is single-threaded since it may |
272 | * only be called from the per-driver module init hook. */ | |
fa538645 | 273 | if (drm_core_check_feature(dev, DRIVER_LEGACY)) |
b3f2333d DV |
274 | list_add_tail(&dev->legacy_dev_list, &driver->legacy_dev_list); |
275 | ||
dcdb1674 JC |
276 | return 0; |
277 | ||
2c695fa0 | 278 | err_agp: |
2c695fa0 | 279 | drm_pci_agp_destroy(dev); |
dcdb1674 | 280 | pci_disable_device(pdev); |
c22f0ace | 281 | err_free: |
ffeeeed0 | 282 | drm_dev_put(dev); |
dcdb1674 JC |
283 | return ret; |
284 | } | |
285 | EXPORT_SYMBOL(drm_get_pci_dev); | |
286 | ||
287 | /** | |
10631d72 | 288 | * drm_legacy_pci_init - shadow-attach a legacy DRM PCI driver |
c6a1af8a TR |
289 | * @driver: DRM device driver |
290 | * @pdriver: PCI device driver | |
dcdb1674 | 291 | * |
10631d72 | 292 | * This is only used by legacy dri1 drivers and deprecated. |
6e3f797c | 293 | * |
c6a1af8a | 294 | * Return: 0 on success or a negative error code on failure. |
dcdb1674 | 295 | */ |
10631d72 | 296 | int drm_legacy_pci_init(struct drm_driver *driver, struct pci_driver *pdriver) |
dcdb1674 JC |
297 | { |
298 | struct pci_dev *pdev = NULL; | |
299 | const struct pci_device_id *pid; | |
300 | int i; | |
301 | ||
8410ea3b DA |
302 | DRM_DEBUG("\n"); |
303 | ||
10631d72 DV |
304 | if (WARN_ON(!(driver->driver_features & DRIVER_LEGACY))) |
305 | return -EINVAL; | |
dcdb1674 JC |
306 | |
307 | /* If not using KMS, fall back to stealth mode manual scanning. */ | |
b3f2333d | 308 | INIT_LIST_HEAD(&driver->legacy_dev_list); |
8410ea3b DA |
309 | for (i = 0; pdriver->id_table[i].vendor != 0; i++) { |
310 | pid = &pdriver->id_table[i]; | |
dcdb1674 JC |
311 | |
312 | /* Loop around setting up a DRM device for each PCI device | |
313 | * matching our ID and device class. If we had the internal | |
314 | * function that pci_get_subsys and pci_get_class used, we'd | |
315 | * be able to just pass pid in instead of doing a two-stage | |
316 | * thing. | |
317 | */ | |
318 | pdev = NULL; | |
319 | while ((pdev = | |
320 | pci_get_subsys(pid->vendor, pid->device, pid->subvendor, | |
321 | pid->subdevice, pdev)) != NULL) { | |
322 | if ((pdev->class & pid->class_mask) != pid->class) | |
323 | continue; | |
324 | ||
325 | /* stealth mode requires a manual probe */ | |
326 | pci_dev_get(pdev); | |
327 | drm_get_pci_dev(pdev, pid, driver); | |
328 | } | |
329 | } | |
330 | return 0; | |
331 | } | |
10631d72 | 332 | EXPORT_SYMBOL(drm_legacy_pci_init); |
dcdb1674 | 333 | |
93711d8b BH |
334 | #else |
335 | ||
4efafebe | 336 | void drm_pci_agp_destroy(struct drm_device *dev) {} |
eaaf8f0f DV |
337 | |
338 | int drm_irq_by_busid(struct drm_device *dev, void *data, | |
339 | struct drm_file *file_priv) | |
340 | { | |
341 | return -EINVAL; | |
342 | } | |
93711d8b BH |
343 | #endif |
344 | ||
c6a1af8a | 345 | /** |
10631d72 | 346 | * drm_legacy_pci_exit - unregister shadow-attach legacy DRM driver |
c6a1af8a TR |
347 | * @driver: DRM device driver |
348 | * @pdriver: PCI device driver | |
349 | * | |
10631d72 DV |
350 | * Unregister a DRM driver shadow-attached through drm_legacy_pci_init(). This |
351 | * is deprecated and only used by dri1 drivers. | |
c6a1af8a | 352 | */ |
10631d72 | 353 | void drm_legacy_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver) |
93711d8b BH |
354 | { |
355 | struct drm_device *dev, *tmp; | |
356 | DRM_DEBUG("\n"); | |
357 | ||
fa538645 | 358 | if (!(driver->driver_features & DRIVER_LEGACY)) { |
10631d72 | 359 | WARN_ON(1); |
93711d8b | 360 | } else { |
b3f2333d DV |
361 | list_for_each_entry_safe(dev, tmp, &driver->legacy_dev_list, |
362 | legacy_dev_list) { | |
b3f2333d | 363 | list_del(&dev->legacy_dev_list); |
c94adc4a | 364 | drm_put_dev(dev); |
b3f2333d | 365 | } |
93711d8b BH |
366 | } |
367 | DRM_INFO("Module unloaded\n"); | |
368 | } | |
10631d72 | 369 | EXPORT_SYMBOL(drm_legacy_pci_exit); |