1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <drm/drmP.h>
23#include <drm/drm.h>
24#include <drm/gma_drm.h>
25#include "psb_drv.h"
26#include "framebuffer.h"
27#include "psb_reg.h"
28#include "psb_intel_reg.h"
29#include "intel_bios.h"
30#include "mid_bios.h"
31#include <drm/drm_pciids.h>
32#include "power.h"
33#include <linux/cpu.h>
34#include <linux/notifier.h>
35#include <linux/spinlock.h>
36#include <linux/pm_runtime.h>
37#include <acpi/video.h>
38#include <linux/module.h>
39
40static int drm_psb_trap_pagefaults;
41
42static int psb_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
43
44MODULE_PARM_DESC(trap_pagefaults, "Error and reset on MMU pagefaults");
45module_param_named(trap_pagefaults, drm_psb_trap_pagefaults, int, 0600);
46
47
48static DEFINE_PCI_DEVICE_TABLE(pciidlist) = {
49 { 0x8086, 0x8108, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &psb_chip_ops },
50 { 0x8086, 0x8109, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &psb_chip_ops },
51#if defined(CONFIG_DRM_GMA600)
52 { 0x8086, 0x4100, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &oaktrail_chip_ops},
53 { 0x8086, 0x4101, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &oaktrail_chip_ops},
54 { 0x8086, 0x4102, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &oaktrail_chip_ops},
55 { 0x8086, 0x4103, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &oaktrail_chip_ops},
56 { 0x8086, 0x4104, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &oaktrail_chip_ops},
57 { 0x8086, 0x4105, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &oaktrail_chip_ops},
58 { 0x8086, 0x4106, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &oaktrail_chip_ops},
59 { 0x8086, 0x4107, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &oaktrail_chip_ops},
60
61 { 0x8086, 0x4108, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &oaktrail_chip_ops},
62#endif
63#if defined(CONFIG_DRM_MEDFIELD)
64 {0x8086, 0x0130, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &mdfld_chip_ops},
65 {0x8086, 0x0131, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &mdfld_chip_ops},
66 {0x8086, 0x0132, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &mdfld_chip_ops},
67 {0x8086, 0x0133, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &mdfld_chip_ops},
68 {0x8086, 0x0134, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &mdfld_chip_ops},
69 {0x8086, 0x0135, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &mdfld_chip_ops},
70 {0x8086, 0x0136, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &mdfld_chip_ops},
71 {0x8086, 0x0137, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &mdfld_chip_ops},
72#endif
73#if defined(CONFIG_DRM_GMA3600)
74 { 0x8086, 0x0be0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
75 { 0x8086, 0x0be1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
76 { 0x8086, 0x0be2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
77 { 0x8086, 0x0be3, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
78 { 0x8086, 0x0be4, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
79 { 0x8086, 0x0be5, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
80 { 0x8086, 0x0be6, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
81 { 0x8086, 0x0be7, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
82 { 0x8086, 0x0be8, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
83 { 0x8086, 0x0be9, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
84 { 0x8086, 0x0bea, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
85 { 0x8086, 0x0beb, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
86 { 0x8086, 0x0bec, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
87 { 0x8086, 0x0bed, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
88 { 0x8086, 0x0bee, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
89 { 0x8086, 0x0bef, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (long) &cdv_chip_ops},
90#endif
91 { 0, }
92};
93MODULE_DEVICE_TABLE(pci, pciidlist);
94
95
96
97
98
99#define DRM_IOCTL_GMA_ADB \
100 DRM_IOWR(DRM_GMA_ADB + DRM_COMMAND_BASE, uint32_t)
101#define DRM_IOCTL_GMA_MODE_OPERATION \
102 DRM_IOWR(DRM_GMA_MODE_OPERATION + DRM_COMMAND_BASE, \
103 struct drm_psb_mode_operation_arg)
104#define DRM_IOCTL_GMA_STOLEN_MEMORY \
105 DRM_IOWR(DRM_GMA_STOLEN_MEMORY + DRM_COMMAND_BASE, \
106 struct drm_psb_stolen_memory_arg)
107#define DRM_IOCTL_GMA_GAMMA \
108 DRM_IOWR(DRM_GMA_GAMMA + DRM_COMMAND_BASE, \
109 struct drm_psb_dpst_lut_arg)
110#define DRM_IOCTL_GMA_DPST_BL \
111 DRM_IOWR(DRM_GMA_DPST_BL + DRM_COMMAND_BASE, \
112 uint32_t)
113#define DRM_IOCTL_GMA_GET_PIPE_FROM_CRTC_ID \
114 DRM_IOWR(DRM_GMA_GET_PIPE_FROM_CRTC_ID + DRM_COMMAND_BASE, \
115 struct drm_psb_get_pipe_from_crtc_id_arg)
116#define DRM_IOCTL_GMA_GEM_CREATE \
117 DRM_IOWR(DRM_GMA_GEM_CREATE + DRM_COMMAND_BASE, \
118 struct drm_psb_gem_create)
119#define DRM_IOCTL_GMA_GEM_MMAP \
120 DRM_IOWR(DRM_GMA_GEM_MMAP + DRM_COMMAND_BASE, \
121 struct drm_psb_gem_mmap)
122
123static int psb_adb_ioctl(struct drm_device *dev, void *data,
124 struct drm_file *file_priv);
125static int psb_mode_operation_ioctl(struct drm_device *dev, void *data,
126 struct drm_file *file_priv);
127static int psb_stolen_memory_ioctl(struct drm_device *dev, void *data,
128 struct drm_file *file_priv);
129static int psb_gamma_ioctl(struct drm_device *dev, void *data,
130 struct drm_file *file_priv);
131static int psb_dpst_bl_ioctl(struct drm_device *dev, void *data,
132 struct drm_file *file_priv);
133
134static const struct drm_ioctl_desc psb_ioctls[] = {
135 DRM_IOCTL_DEF_DRV(GMA_ADB, psb_adb_ioctl, DRM_AUTH),
136 DRM_IOCTL_DEF_DRV(GMA_MODE_OPERATION, psb_mode_operation_ioctl,
137 DRM_AUTH),
138 DRM_IOCTL_DEF_DRV(GMA_STOLEN_MEMORY, psb_stolen_memory_ioctl,
139 DRM_AUTH),
140 DRM_IOCTL_DEF_DRV(GMA_GAMMA, psb_gamma_ioctl, DRM_AUTH),
141 DRM_IOCTL_DEF_DRV(GMA_DPST_BL, psb_dpst_bl_ioctl, DRM_AUTH),
142 DRM_IOCTL_DEF_DRV(GMA_GET_PIPE_FROM_CRTC_ID,
143 psb_intel_get_pipe_from_crtc_id, 0),
144 DRM_IOCTL_DEF_DRV(GMA_GEM_CREATE, psb_gem_create_ioctl,
145 DRM_UNLOCKED | DRM_AUTH),
146 DRM_IOCTL_DEF_DRV(GMA_GEM_MMAP, psb_gem_mmap_ioctl,
147 DRM_UNLOCKED | DRM_AUTH),
148};
149
150static void psb_lastclose(struct drm_device *dev)
151{
152 int ret;
153 struct drm_psb_private *dev_priv = dev->dev_private;
154 struct psb_fbdev *fbdev = dev_priv->fbdev;
155
156 drm_modeset_lock_all(dev);
157 ret = drm_fb_helper_restore_fbdev_mode(&fbdev->psb_fb_helper);
158 if (ret)
159 DRM_DEBUG("failed to restore crtc mode\n");
160 drm_modeset_unlock_all(dev);
161
162 return;
163}
164
165static int psb_do_init(struct drm_device *dev)
166{
167 struct drm_psb_private *dev_priv = dev->dev_private;
168 struct psb_gtt *pg = &dev_priv->gtt;
169
170 uint32_t stolen_gtt;
171
172 int ret = -ENOMEM;
173
174 if (pg->mmu_gatt_start & 0x0FFFFFFF) {
175 dev_err(dev->dev, "Gatt must be 256M aligned. This is a bug.\n");
176 ret = -EINVAL;
177 goto out_err;
178 }
179
180
181 stolen_gtt = (pg->stolen_size >> PAGE_SHIFT) * 4;
182 stolen_gtt = (stolen_gtt + PAGE_SIZE - 1) >> PAGE_SHIFT;
183 stolen_gtt =
184 (stolen_gtt < pg->gtt_pages) ? stolen_gtt : pg->gtt_pages;
185
186 dev_priv->gatt_free_offset = pg->mmu_gatt_start +
187 (stolen_gtt << PAGE_SHIFT) * 1024;
188
189 spin_lock_init(&dev_priv->irqmask_lock);
190 spin_lock_init(&dev_priv->lock_2d);
191
192 PSB_WSGX32(0x00000000, PSB_CR_BIF_BANK0);
193 PSB_WSGX32(0x00000000, PSB_CR_BIF_BANK1);
194 PSB_RSGX32(PSB_CR_BIF_BANK1);
195 PSB_WSGX32(PSB_RSGX32(PSB_CR_BIF_CTRL) | _PSB_MMU_ER_MASK,
196 PSB_CR_BIF_CTRL);
197 psb_spank(dev_priv);
198
199
200 PSB_WSGX32(pg->gatt_start, PSB_CR_BIF_TWOD_REQ_BASE);
201 return 0;
202out_err:
203 return ret;
204}
205
206static int psb_driver_unload(struct drm_device *dev)
207{
208 struct drm_psb_private *dev_priv = dev->dev_private;
209
210
211
212
213 if (dev_priv) {
214 if (dev_priv->backlight_device)
215 gma_backlight_exit(dev);
216 psb_modeset_cleanup(dev);
217
218 if (dev_priv->ops->chip_teardown)
219 dev_priv->ops->chip_teardown(dev);
220
221 psb_intel_opregion_fini(dev);
222
223 if (dev_priv->pf_pd) {
224 psb_mmu_free_pagedir(dev_priv->pf_pd);
225 dev_priv->pf_pd = NULL;
226 }
227 if (dev_priv->mmu) {
228 struct psb_gtt *pg = &dev_priv->gtt;
229
230 down_read(&pg->sem);
231 psb_mmu_remove_pfn_sequence(
232 psb_mmu_get_default_pd
233 (dev_priv->mmu),
234 pg->mmu_gatt_start,
235 dev_priv->vram_stolen_size >> PAGE_SHIFT);
236 up_read(&pg->sem);
237 psb_mmu_driver_takedown(dev_priv->mmu);
238 dev_priv->mmu = NULL;
239 }
240 psb_gtt_takedown(dev);
241 if (dev_priv->scratch_page) {
242 set_pages_wb(dev_priv->scratch_page, 1);
243 __free_page(dev_priv->scratch_page);
244 dev_priv->scratch_page = NULL;
245 }
246 if (dev_priv->vdc_reg) {
247 iounmap(dev_priv->vdc_reg);
248 dev_priv->vdc_reg = NULL;
249 }
250 if (dev_priv->sgx_reg) {
251 iounmap(dev_priv->sgx_reg);
252 dev_priv->sgx_reg = NULL;
253 }
254 if (dev_priv->aux_reg) {
255 iounmap(dev_priv->aux_reg);
256 dev_priv->aux_reg = NULL;
257 }
258 if (dev_priv->aux_pdev)
259 pci_dev_put(dev_priv->aux_pdev);
260
261
262 psb_intel_destroy_bios(dev);
263
264 kfree(dev_priv);
265 dev->dev_private = NULL;
266 }
267 gma_power_uninit(dev);
268 return 0;
269}
270
271
272static int psb_driver_load(struct drm_device *dev, unsigned long chipset)
273{
274 struct drm_psb_private *dev_priv;
275 unsigned long resource_start, resource_len;
276 unsigned long irqflags;
277 int ret = -ENOMEM;
278 struct drm_connector *connector;
279 struct gma_encoder *gma_encoder;
280
281 dev_priv = kzalloc(sizeof(*dev_priv), GFP_KERNEL);
282 if (dev_priv == NULL)
283 return -ENOMEM;
284
285 dev_priv->ops = (struct psb_ops *)chipset;
286 dev_priv->dev = dev;
287 dev->dev_private = (void *) dev_priv;
288
289 pci_set_master(dev->pdev);
290
291 dev_priv->num_pipe = dev_priv->ops->pipes;
292
293 resource_start = pci_resource_start(dev->pdev, PSB_MMIO_RESOURCE);
294
295 dev_priv->vdc_reg =
296 ioremap(resource_start + PSB_VDC_OFFSET, PSB_VDC_SIZE);
297 if (!dev_priv->vdc_reg)
298 goto out_err;
299
300 dev_priv->sgx_reg = ioremap(resource_start + dev_priv->ops->sgx_offset,
301 PSB_SGX_SIZE);
302 if (!dev_priv->sgx_reg)
303 goto out_err;
304
305 if (IS_MRST(dev)) {
306 dev_priv->aux_pdev = pci_get_bus_and_slot(0, PCI_DEVFN(3, 0));
307
308 if (dev_priv->aux_pdev) {
309 resource_start = pci_resource_start(dev_priv->aux_pdev,
310 PSB_AUX_RESOURCE);
311 resource_len = pci_resource_len(dev_priv->aux_pdev,
312 PSB_AUX_RESOURCE);
313 dev_priv->aux_reg = ioremap_nocache(resource_start,
314 resource_len);
315 if (!dev_priv->aux_reg)
316 goto out_err;
317
318 DRM_DEBUG_KMS("Found aux vdc");
319 } else {
320
321 dev_priv->aux_reg = dev_priv->vdc_reg;
322 DRM_DEBUG_KMS("Couldn't find aux pci device");
323 }
324 dev_priv->gmbus_reg = dev_priv->aux_reg;
325 } else {
326 dev_priv->gmbus_reg = dev_priv->vdc_reg;
327 }
328
329 psb_intel_opregion_setup(dev);
330
331 ret = dev_priv->ops->chip_setup(dev);
332 if (ret)
333 goto out_err;
334
335
336 gma_power_init(dev);
337
338 ret = -ENOMEM;
339
340 dev_priv->scratch_page = alloc_page(GFP_DMA32 | __GFP_ZERO);
341 if (!dev_priv->scratch_page)
342 goto out_err;
343
344 set_pages_uc(dev_priv->scratch_page, 1);
345
346 ret = psb_gtt_init(dev, 0);
347 if (ret)
348 goto out_err;
349
350 dev_priv->mmu = psb_mmu_driver_init((void *)0,
351 drm_psb_trap_pagefaults, 0,
352 dev_priv);
353 if (!dev_priv->mmu)
354 goto out_err;
355
356 dev_priv->pf_pd = psb_mmu_alloc_pd(dev_priv->mmu, 1, 0);
357 if (!dev_priv->pf_pd)
358 goto out_err;
359
360 psb_mmu_set_pd_context(psb_mmu_get_default_pd(dev_priv->mmu), 0);
361 psb_mmu_set_pd_context(dev_priv->pf_pd, 1);
362
363 ret = psb_do_init(dev);
364 if (ret)
365 return ret;
366
367 PSB_WSGX32(0x20000000, PSB_CR_PDS_EXEC_BASE);
368 PSB_WSGX32(0x30000000, PSB_CR_BIF_3D_REQ_BASE);
369
370 acpi_video_register();
371
372 ret = drm_vblank_init(dev, dev_priv->num_pipe);
373 if (ret)
374 goto out_err;
375
376
377
378
379
380 dev_priv->vdc_irq_mask = 0;
381 dev_priv->pipestat[0] = 0;
382 dev_priv->pipestat[1] = 0;
383 dev_priv->pipestat[2] = 0;
384 spin_lock_irqsave(&dev_priv->irqmask_lock, irqflags);
385 PSB_WVDC32(0xFFFFFFFF, PSB_HWSTAM);
386 PSB_WVDC32(0x00000000, PSB_INT_ENABLE_R);
387 PSB_WVDC32(0xFFFFFFFF, PSB_INT_MASK_R);
388 spin_unlock_irqrestore(&dev_priv->irqmask_lock, irqflags);
389
390 drm_irq_install(dev);
391
392 dev->vblank_disable_allowed = true;
393
394 dev->max_vblank_count = 0xffffff;
395
396 dev->driver->get_vblank_counter = psb_get_vblank_counter;
397
398 psb_modeset_init(dev);
399 psb_fbdev_init(dev);
400 drm_kms_helper_poll_init(dev);
401
402
403 list_for_each_entry(connector, &dev->mode_config.connector_list,
404 head) {
405 gma_encoder = gma_attached_encoder(connector);
406
407 switch (gma_encoder->type) {
408 case INTEL_OUTPUT_LVDS:
409 case INTEL_OUTPUT_MIPI:
410 ret = gma_backlight_init(dev);
411 break;
412 }
413 }
414
415 if (ret)
416 return ret;
417 psb_intel_opregion_enable_asle(dev);
418#if 0
419
420 pm_runtime_enable(&dev->pdev->dev);
421 pm_runtime_set_active(&dev->pdev->dev);
422#endif
423
424 return 0;
425out_err:
426 psb_driver_unload(dev);
427 return ret;
428}
429
430static int psb_driver_device_is_agp(struct drm_device *dev)
431{
432 return 0;
433}
434
435static inline void get_brightness(struct backlight_device *bd)
436{
437#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
438 if (bd) {
439 bd->props.brightness = bd->ops->get_brightness(bd);
440 backlight_update_status(bd);
441 }
442#endif
443}
444
445static int psb_dpst_bl_ioctl(struct drm_device *dev, void *data,
446 struct drm_file *file_priv)
447{
448 struct drm_psb_private *dev_priv = psb_priv(dev);
449 uint32_t *arg = data;
450
451 dev_priv->blc_adj2 = *arg;
452 get_brightness(dev_priv->backlight_device);
453 return 0;
454}
455
456static int psb_adb_ioctl(struct drm_device *dev, void *data,
457 struct drm_file *file_priv)
458{
459 struct drm_psb_private *dev_priv = psb_priv(dev);
460 uint32_t *arg = data;
461
462 dev_priv->blc_adj1 = *arg;
463 get_brightness(dev_priv->backlight_device);
464 return 0;
465}
466
467static int psb_gamma_ioctl(struct drm_device *dev, void *data,
468 struct drm_file *file_priv)
469{
470 struct drm_psb_dpst_lut_arg *lut_arg = data;
471 struct drm_mode_object *obj;
472 struct drm_crtc *crtc;
473 struct drm_connector *connector;
474 struct gma_crtc *gma_crtc;
475 int i = 0;
476 int32_t obj_id;
477
478 obj_id = lut_arg->output_id;
479 obj = drm_mode_object_find(dev, obj_id, DRM_MODE_OBJECT_CONNECTOR);
480 if (!obj) {
481 dev_dbg(dev->dev, "Invalid Connector object.\n");
482 return -ENOENT;
483 }
484
485 connector = obj_to_connector(obj);
486 crtc = connector->encoder->crtc;
487 gma_crtc = to_gma_crtc(crtc);
488
489 for (i = 0; i < 256; i++)
490 gma_crtc->lut_adj[i] = lut_arg->lut[i];
491
492 gma_crtc_load_lut(crtc);
493
494 return 0;
495}
496
497static int psb_mode_operation_ioctl(struct drm_device *dev, void *data,
498 struct drm_file *file_priv)
499{
500 uint32_t obj_id;
501 uint16_t op;
502 struct drm_mode_modeinfo *umode;
503 struct drm_display_mode *mode = NULL;
504 struct drm_psb_mode_operation_arg *arg;
505 struct drm_mode_object *obj;
506 struct drm_connector *connector;
507 struct drm_connector_helper_funcs *connector_funcs;
508 int ret = 0;
509 int resp = MODE_OK;
510
511 arg = (struct drm_psb_mode_operation_arg *)data;
512 obj_id = arg->obj_id;
513 op = arg->operation;
514
515 switch (op) {
516 case PSB_MODE_OPERATION_MODE_VALID:
517 umode = &arg->mode;
518
519 drm_modeset_lock_all(dev);
520
521 obj = drm_mode_object_find(dev, obj_id,
522 DRM_MODE_OBJECT_CONNECTOR);
523 if (!obj) {
524 ret = -ENOENT;
525 goto mode_op_out;
526 }
527
528 connector = obj_to_connector(obj);
529
530 mode = drm_mode_create(dev);
531 if (!mode) {
532 ret = -ENOMEM;
533 goto mode_op_out;
534 }
535
536
537 {
538 mode->clock = umode->clock;
539 mode->hdisplay = umode->hdisplay;
540 mode->hsync_start = umode->hsync_start;
541 mode->hsync_end = umode->hsync_end;
542 mode->htotal = umode->htotal;
543 mode->hskew = umode->hskew;
544 mode->vdisplay = umode->vdisplay;
545 mode->vsync_start = umode->vsync_start;
546 mode->vsync_end = umode->vsync_end;
547 mode->vtotal = umode->vtotal;
548 mode->vscan = umode->vscan;
549 mode->vrefresh = umode->vrefresh;
550 mode->flags = umode->flags;
551 mode->type = umode->type;
552 strncpy(mode->name, umode->name, DRM_DISPLAY_MODE_LEN);
553 mode->name[DRM_DISPLAY_MODE_LEN-1] = 0;
554 }
555
556 connector_funcs = (struct drm_connector_helper_funcs *)
557 connector->helper_private;
558
559 if (connector_funcs->mode_valid) {
560 resp = connector_funcs->mode_valid(connector, mode);
561 arg->data = resp;
562 }
563
564
565 if (mode)
566 drm_mode_destroy(dev, mode);
567mode_op_out:
568 drm_modeset_unlock_all(dev);
569 return ret;
570
571 default:
572 dev_dbg(dev->dev, "Unsupported psb mode operation\n");
573 return -EOPNOTSUPP;
574 }
575
576 return 0;
577}
578
579static int psb_stolen_memory_ioctl(struct drm_device *dev, void *data,
580 struct drm_file *file_priv)
581{
582 struct drm_psb_private *dev_priv = psb_priv(dev);
583 struct drm_psb_stolen_memory_arg *arg = data;
584
585 arg->base = dev_priv->stolen_base;
586 arg->size = dev_priv->vram_stolen_size;
587
588 return 0;
589}
590
591static int psb_driver_open(struct drm_device *dev, struct drm_file *priv)
592{
593 return 0;
594}
595
596static void psb_driver_close(struct drm_device *dev, struct drm_file *priv)
597{
598}
599
600static long psb_unlocked_ioctl(struct file *filp, unsigned int cmd,
601 unsigned long arg)
602{
603 struct drm_file *file_priv = filp->private_data;
604 struct drm_device *dev = file_priv->minor->dev;
605 struct drm_psb_private *dev_priv = dev->dev_private;
606 static unsigned int runtime_allowed;
607
608 if (runtime_allowed == 1 && dev_priv->is_lvds_on) {
609 runtime_allowed++;
610 pm_runtime_allow(&dev->pdev->dev);
611 dev_priv->rpm_enabled = 1;
612 }
613 return drm_ioctl(filp, cmd, arg);
614
615}
616
617
618
619
620
621static void psb_driver_preclose(struct drm_device *dev, struct drm_file *priv)
622{
623}
624
625static void psb_remove(struct pci_dev *pdev)
626{
627 struct drm_device *dev = pci_get_drvdata(pdev);
628 drm_put_dev(dev);
629}
630
631static const struct dev_pm_ops psb_pm_ops = {
632 .resume = gma_power_resume,
633 .suspend = gma_power_suspend,
634 .thaw = gma_power_thaw,
635 .freeze = gma_power_freeze,
636 .restore = gma_power_restore,
637 .runtime_suspend = psb_runtime_suspend,
638 .runtime_resume = psb_runtime_resume,
639 .runtime_idle = psb_runtime_idle,
640};
641
642static const struct vm_operations_struct psb_gem_vm_ops = {
643 .fault = psb_gem_fault,
644 .open = drm_gem_vm_open,
645 .close = drm_gem_vm_close,
646};
647
648static const struct file_operations psb_gem_fops = {
649 .owner = THIS_MODULE,
650 .open = drm_open,
651 .release = drm_release,
652 .unlocked_ioctl = psb_unlocked_ioctl,
653 .mmap = drm_gem_mmap,
654 .poll = drm_poll,
655 .read = drm_read,
656};
657
658static struct drm_driver driver = {
659 .driver_features = DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | \
660 DRIVER_MODESET | DRIVER_GEM ,
661 .load = psb_driver_load,
662 .unload = psb_driver_unload,
663
664 .ioctls = psb_ioctls,
665 .num_ioctls = DRM_ARRAY_SIZE(psb_ioctls),
666 .device_is_agp = psb_driver_device_is_agp,
667 .irq_preinstall = psb_irq_preinstall,
668 .irq_postinstall = psb_irq_postinstall,
669 .irq_uninstall = psb_irq_uninstall,
670 .irq_handler = psb_irq_handler,
671 .enable_vblank = psb_enable_vblank,
672 .disable_vblank = psb_disable_vblank,
673 .get_vblank_counter = psb_get_vblank_counter,
674 .lastclose = psb_lastclose,
675 .open = psb_driver_open,
676 .preclose = psb_driver_preclose,
677 .postclose = psb_driver_close,
678
679 .gem_free_object = psb_gem_free_object,
680 .gem_vm_ops = &psb_gem_vm_ops,
681 .dumb_create = psb_gem_dumb_create,
682 .dumb_map_offset = psb_gem_dumb_map_gtt,
683 .dumb_destroy = drm_gem_dumb_destroy,
684 .fops = &psb_gem_fops,
685 .name = DRIVER_NAME,
686 .desc = DRIVER_DESC,
687 .date = PSB_DRM_DRIVER_DATE,
688 .major = PSB_DRM_DRIVER_MAJOR,
689 .minor = PSB_DRM_DRIVER_MINOR,
690 .patchlevel = PSB_DRM_DRIVER_PATCHLEVEL
691};
692
693static struct pci_driver psb_pci_driver = {
694 .name = DRIVER_NAME,
695 .id_table = pciidlist,
696 .probe = psb_probe,
697 .remove = psb_remove,
698 .driver = {
699 .pm = &psb_pm_ops,
700 }
701};
702
703static int psb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
704{
705 return drm_get_pci_dev(pdev, ent, &driver);
706}
707
708static int __init psb_init(void)
709{
710 return drm_pci_init(&driver, &psb_pci_driver);
711}
712
713static void __exit psb_exit(void)
714{
715 drm_pci_exit(&driver, &psb_pci_driver);
716}
717
718late_initcall(psb_init);
719module_exit(psb_exit);
720
721MODULE_AUTHOR("Alan Cox <alan@linux.intel.com> and others");
722MODULE_DESCRIPTION(DRIVER_DESC);
723MODULE_LICENSE("GPL");
724
