tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
drm/gma500: Replace references to dev_private with helper function
Replace most references to struct drm_device.dev_private with the new
helper function to_drm_psb_private(). The only references left are in
assignments and the helper itself.
Signed-off-by: Thomas Zimmermann <tzimmermann@suse.de>
Reviewed-by: Patrik Jakobsson <patrik.r.jakobsson@gmail.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20210920141051.30988-2-tzimmermann@suse.de
+178
-184
+6
-6
drivers/gpu/drm/gma500/backlight.c
+6
-6
drivers/gpu/drm/gma500/backlight.c
···
16
16
#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
17
17
static void do_gma_backlight_set(struct drm_device *dev)
18
18
{
19
-
struct drm_psb_private *dev_priv = dev->dev_private;
19
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
20
20
backlight_update_status(dev_priv->backlight_device);
21
21
}
22
22
#endif
···
24
24
void gma_backlight_enable(struct drm_device *dev)
25
25
{
26
26
#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
27
-
struct drm_psb_private *dev_priv = dev->dev_private;
27
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
28
28
dev_priv->backlight_enabled = true;
29
29
if (dev_priv->backlight_device) {
30
30
dev_priv->backlight_device->props.brightness = dev_priv->backlight_level;
···
36
36
void gma_backlight_disable(struct drm_device *dev)
37
37
{
38
38
#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
39
-
struct drm_psb_private *dev_priv = dev->dev_private;
39
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
40
40
dev_priv->backlight_enabled = false;
41
41
if (dev_priv->backlight_device) {
42
42
dev_priv->backlight_device->props.brightness = 0;
···
48
48
void gma_backlight_set(struct drm_device *dev, int v)
49
49
{
50
50
#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
51
-
struct drm_psb_private *dev_priv = dev->dev_private;
51
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
52
52
dev_priv->backlight_level = v;
53
53
if (dev_priv->backlight_device && dev_priv->backlight_enabled) {
54
54
dev_priv->backlight_device->props.brightness = v;
···
60
60
int gma_backlight_init(struct drm_device *dev)
61
61
{
62
62
#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
63
-
struct drm_psb_private *dev_priv = dev->dev_private;
63
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
64
64
dev_priv->backlight_enabled = true;
65
65
return dev_priv->ops->backlight_init(dev);
66
66
#else
···
71
71
void gma_backlight_exit(struct drm_device *dev)
72
72
{
73
73
#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
74
-
struct drm_psb_private *dev_priv = dev->dev_private;
74
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
75
75
if (dev_priv->backlight_device) {
76
76
dev_priv->backlight_device->props.brightness = 0;
77
77
backlight_update_status(dev_priv->backlight_device);
+11
-11
drivers/gpu/drm/gma500/cdv_device.c
+11
-11
drivers/gpu/drm/gma500/cdv_device.c
···
38
38
39
39
static int cdv_output_init(struct drm_device *dev)
40
40
{
41
-
struct drm_psb_private *dev_priv = dev->dev_private;
41
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
42
42
43
43
drm_mode_create_scaling_mode_property(dev);
44
44
···
146
146
147
147
static int cdv_backlight_init(struct drm_device *dev)
148
148
{
149
-
struct drm_psb_private *dev_priv = dev->dev_private;
149
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
150
150
struct backlight_properties props;
151
151
152
152
memset(&props, 0, sizeof(struct backlight_properties));
···
206
206
207
207
static void cdv_init_pm(struct drm_device *dev)
208
208
{
209
-
struct drm_psb_private *dev_priv = dev->dev_private;
209
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
210
210
struct pci_dev *pdev = to_pci_dev(dev->dev);
211
211
u32 pwr_cnt;
212
212
int domain = pci_domain_nr(pdev->bus);
···
259
259
*/
260
260
static int cdv_save_display_registers(struct drm_device *dev)
261
261
{
262
-
struct drm_psb_private *dev_priv = dev->dev_private;
262
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
263
263
struct pci_dev *pdev = to_pci_dev(dev->dev);
264
264
struct psb_save_area *regs = &dev_priv->regs;
265
265
struct drm_connector *connector;
···
314
314
*/
315
315
static int cdv_restore_display_registers(struct drm_device *dev)
316
316
{
317
-
struct drm_psb_private *dev_priv = dev->dev_private;
317
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
318
318
struct pci_dev *pdev = to_pci_dev(dev->dev);
319
319
struct psb_save_area *regs = &dev_priv->regs;
320
320
struct drm_connector *connector;
···
383
383
384
384
static int cdv_power_down(struct drm_device *dev)
385
385
{
386
-
struct drm_psb_private *dev_priv = dev->dev_private;
386
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
387
387
u32 pwr_cnt, pwr_mask, pwr_sts;
388
388
int tries = 5;
389
389
···
405
405
406
406
static int cdv_power_up(struct drm_device *dev)
407
407
{
408
-
struct drm_psb_private *dev_priv = dev->dev_private;
408
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
409
409
u32 pwr_cnt, pwr_mask, pwr_sts;
410
410
int tries = 5;
411
411
···
440
440
441
441
static int cdv_hotplug_event(struct drm_device *dev)
442
442
{
443
-
struct drm_psb_private *dev_priv = dev->dev_private;
443
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
444
444
schedule_work(&dev_priv->hotplug_work);
445
445
REG_WRITE(PORT_HOTPLUG_STAT, REG_READ(PORT_HOTPLUG_STAT));
446
446
return 1;
···
468
468
void cdv_intel_attach_force_audio_property(struct drm_connector *connector)
469
469
{
470
470
struct drm_device *dev = connector->dev;
471
-
struct drm_psb_private *dev_priv = dev->dev_private;
471
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
472
472
struct drm_property *prop;
473
473
int i;
474
474
···
497
497
void cdv_intel_attach_broadcast_rgb_property(struct drm_connector *connector)
498
498
{
499
499
struct drm_device *dev = connector->dev;
500
-
struct drm_psb_private *dev_priv = dev->dev_private;
500
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
501
501
struct drm_property *prop;
502
502
int i;
503
503
···
574
574
575
575
static int cdv_chip_setup(struct drm_device *dev)
576
576
{
577
-
struct drm_psb_private *dev_priv = dev->dev_private;
577
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
578
578
struct pci_dev *pdev = to_pci_dev(dev->dev);
579
579
INIT_WORK(&dev_priv->hotplug_work, cdv_hotplug_work_func);
580
580
+5
-5
drivers/gpu/drm/gma500/cdv_intel_display.c
+5
-5
drivers/gpu/drm/gma500/cdv_intel_display.c
···
455
455
static bool cdv_intel_pipe_enabled(struct drm_device *dev, int pipe)
456
456
{
457
457
struct drm_crtc *crtc;
458
-
struct drm_psb_private *dev_priv = dev->dev_private;
458
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
459
459
struct gma_crtc *gma_crtc = NULL;
460
460
461
461
crtc = dev_priv->pipe_to_crtc_mapping[pipe];
···
489
489
490
490
void cdv_update_wm(struct drm_device *dev, struct drm_crtc *crtc)
491
491
{
492
-
struct drm_psb_private *dev_priv = dev->dev_private;
492
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
493
493
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
494
494
495
495
/* Is only one pipe enabled? */
···
574
574
struct drm_framebuffer *old_fb)
575
575
{
576
576
struct drm_device *dev = crtc->dev;
577
-
struct drm_psb_private *dev_priv = dev->dev_private;
577
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
578
578
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
579
579
int pipe = gma_crtc->pipe;
580
580
const struct psb_offset *map = &dev_priv->regmap[pipe];
···
829
829
static int cdv_intel_crtc_clock_get(struct drm_device *dev,
830
830
struct drm_crtc *crtc)
831
831
{
832
-
struct drm_psb_private *dev_priv = dev->dev_private;
832
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
833
833
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
834
834
int pipe = gma_crtc->pipe;
835
835
const struct psb_offset *map = &dev_priv->regmap[pipe];
···
910
910
{
911
911
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
912
912
int pipe = gma_crtc->pipe;
913
-
struct drm_psb_private *dev_priv = dev->dev_private;
913
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
914
914
struct psb_pipe *p = &dev_priv->regs.pipe[pipe];
915
915
const struct psb_offset *map = &dev_priv->regmap[pipe];
916
916
struct drm_display_mode *mode;
+6
-6
drivers/gpu/drm/gma500/cdv_intel_dp.c
+6
-6
drivers/gpu/drm/gma500/cdv_intel_dp.c
···
515
515
struct cdv_intel_dp *intel_dp = encoder->dev_priv;
516
516
int max_link_clock = cdv_intel_dp_link_clock(cdv_intel_dp_max_link_bw(encoder));
517
517
int max_lanes = cdv_intel_dp_max_lane_count(encoder);
518
-
struct drm_psb_private *dev_priv = connector->dev->dev_private;
518
+
struct drm_psb_private *dev_priv = to_drm_psb_private(connector->dev);
519
519
520
520
if (is_edp(encoder) && intel_dp->panel_fixed_mode) {
521
521
if (mode->hdisplay > intel_dp->panel_fixed_mode->hdisplay)
···
896
896
cdv_intel_dp_mode_fixup(struct drm_encoder *encoder, const struct drm_display_mode *mode,
897
897
struct drm_display_mode *adjusted_mode)
898
898
{
899
-
struct drm_psb_private *dev_priv = encoder->dev->dev_private;
899
+
struct drm_psb_private *dev_priv = to_drm_psb_private(encoder->dev);
900
900
struct gma_encoder *intel_encoder = to_gma_encoder(encoder);
901
901
struct cdv_intel_dp *intel_dp = intel_encoder->dev_priv;
902
902
int lane_count, clock;
···
988
988
struct drm_display_mode *adjusted_mode)
989
989
{
990
990
struct drm_device *dev = crtc->dev;
991
-
struct drm_psb_private *dev_priv = dev->dev_private;
991
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
992
992
struct drm_mode_config *mode_config = &dev->mode_config;
993
993
struct drm_encoder *encoder;
994
994
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
···
1744
1744
1745
1745
if (is_edp(intel_encoder)) {
1746
1746
struct drm_device *dev = connector->dev;
1747
-
struct drm_psb_private *dev_priv = dev->dev_private;
1747
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
1748
1748
1749
1749
cdv_intel_edp_panel_vdd_off(intel_encoder);
1750
1750
if (ret) {
···
1809
1809
struct drm_property *property,
1810
1810
uint64_t val)
1811
1811
{
1812
-
struct drm_psb_private *dev_priv = connector->dev->dev_private;
1812
+
struct drm_psb_private *dev_priv = to_drm_psb_private(connector->dev);
1813
1813
struct gma_encoder *encoder = gma_attached_encoder(connector);
1814
1814
struct cdv_intel_dp *intel_dp = encoder->dev_priv;
1815
1815
int ret;
···
1908
1908
/* check the VBT to see whether the eDP is on DP-D port */
1909
1909
static bool cdv_intel_dpc_is_edp(struct drm_device *dev)
1910
1910
{
1911
-
struct drm_psb_private *dev_priv = dev->dev_private;
1911
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
1912
1912
struct child_device_config *p_child;
1913
1913
int i;
1914
1914
+11
-11
drivers/gpu/drm/gma500/cdv_intel_lvds.c
+11
-11
drivers/gpu/drm/gma500/cdv_intel_lvds.c
···
57
57
*/
58
58
static u32 cdv_intel_lvds_get_max_backlight(struct drm_device *dev)
59
59
{
60
-
struct drm_psb_private *dev_priv = dev->dev_private;
60
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
61
61
u32 retval;
62
62
63
63
if (gma_power_begin(dev, false)) {
···
81
81
*/
82
82
static void cdv_intel_lvds_set_backlight(struct drm_device *dev, int level)
83
83
{
84
-
struct drm_psb_private *dev_priv = dev->dev_private;
84
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
85
85
u32 blc_pwm_ctl;
86
86
87
87
if (gma_power_begin(dev, false)) {
···
105
105
static void cdv_intel_lvds_set_power(struct drm_device *dev,
106
106
struct drm_encoder *encoder, bool on)
107
107
{
108
-
struct drm_psb_private *dev_priv = dev->dev_private;
108
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
109
109
u32 pp_status;
110
110
111
111
if (!gma_power_begin(dev, true))
···
154
154
struct drm_display_mode *mode)
155
155
{
156
156
struct drm_device *dev = connector->dev;
157
-
struct drm_psb_private *dev_priv = dev->dev_private;
157
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
158
158
struct drm_display_mode *fixed_mode =
159
159
dev_priv->mode_dev.panel_fixed_mode;
160
160
···
180
180
struct drm_display_mode *adjusted_mode)
181
181
{
182
182
struct drm_device *dev = encoder->dev;
183
-
struct drm_psb_private *dev_priv = dev->dev_private;
183
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
184
184
struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
185
185
struct drm_encoder *tmp_encoder;
186
186
struct drm_display_mode *panel_fixed_mode = mode_dev->panel_fixed_mode;
···
227
227
static void cdv_intel_lvds_prepare(struct drm_encoder *encoder)
228
228
{
229
229
struct drm_device *dev = encoder->dev;
230
-
struct drm_psb_private *dev_priv = dev->dev_private;
230
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
231
231
struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
232
232
233
233
if (!gma_power_begin(dev, true))
···
245
245
static void cdv_intel_lvds_commit(struct drm_encoder *encoder)
246
246
{
247
247
struct drm_device *dev = encoder->dev;
248
-
struct drm_psb_private *dev_priv = dev->dev_private;
248
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
249
249
struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
250
250
251
251
if (mode_dev->backlight_duty_cycle == 0)
···
260
260
struct drm_display_mode *adjusted_mode)
261
261
{
262
262
struct drm_device *dev = encoder->dev;
263
-
struct drm_psb_private *dev_priv = dev->dev_private;
263
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
264
264
struct gma_crtc *gma_crtc = to_gma_crtc(encoder->crtc);
265
265
u32 pfit_control;
266
266
···
297
297
static int cdv_intel_lvds_get_modes(struct drm_connector *connector)
298
298
{
299
299
struct drm_device *dev = connector->dev;
300
-
struct drm_psb_private *dev_priv = dev->dev_private;
300
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
301
301
struct gma_encoder *gma_encoder = gma_attached_encoder(connector);
302
302
struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
303
303
int ret;
···
428
428
static bool lvds_is_present_in_vbt(struct drm_device *dev,
429
429
u8 *i2c_pin)
430
430
{
431
-
struct drm_psb_private *dev_priv = dev->dev_private;
431
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
432
432
int i;
433
433
434
434
if (!dev_priv->child_dev_num)
···
486
486
struct drm_encoder *encoder;
487
487
struct drm_display_mode *scan;
488
488
struct drm_crtc *crtc;
489
-
struct drm_psb_private *dev_priv = dev->dev_private;
489
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
490
490
u32 lvds;
491
491
int pipe;
492
492
u8 pin;
+8
-8
drivers/gpu/drm/gma500/framebuffer.c
+8
-8
drivers/gpu/drm/gma500/framebuffer.c
···
81
81
struct vm_area_struct *vma = vmf->vma;
82
82
struct drm_framebuffer *fb = vma->vm_private_data;
83
83
struct drm_device *dev = fb->dev;
84
-
struct drm_psb_private *dev_priv = dev->dev_private;
84
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
85
85
struct gtt_range *gtt = to_gtt_range(fb->obj[0]);
86
86
int page_num;
87
87
int i;
···
261
261
struct drm_fb_helper_surface_size *sizes)
262
262
{
263
263
struct drm_device *dev = fb_helper->dev;
264
-
struct drm_psb_private *dev_priv = dev->dev_private;
264
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
265
265
struct pci_dev *pdev = to_pci_dev(dev->dev);
266
266
struct fb_info *info;
267
267
struct drm_framebuffer *fb;
···
374
374
struct drm_fb_helper_surface_size *sizes)
375
375
{
376
376
struct drm_device *dev = fb_helper->dev;
377
-
struct drm_psb_private *dev_priv = dev->dev_private;
377
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
378
378
unsigned int fb_size;
379
379
int bytespp;
380
380
···
422
422
int psb_fbdev_init(struct drm_device *dev)
423
423
{
424
424
struct drm_fb_helper *fb_helper;
425
-
struct drm_psb_private *dev_priv = dev->dev_private;
425
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
426
426
int ret;
427
427
428
428
fb_helper = kzalloc(sizeof(*fb_helper), GFP_KERNEL);
···
457
457
458
458
static void psb_fbdev_fini(struct drm_device *dev)
459
459
{
460
-
struct drm_psb_private *dev_priv = dev->dev_private;
460
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
461
461
462
462
if (!dev_priv->fb_helper)
463
463
return;
···
474
474
475
475
static void psb_setup_outputs(struct drm_device *dev)
476
476
{
477
-
struct drm_psb_private *dev_priv = dev->dev_private;
477
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
478
478
struct drm_connector *connector;
479
479
480
480
drm_mode_create_scaling_mode_property(dev);
···
533
533
534
534
void psb_modeset_init(struct drm_device *dev)
535
535
{
536
-
struct drm_psb_private *dev_priv = dev->dev_private;
536
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
537
537
struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
538
538
struct pci_dev *pdev = to_pci_dev(dev->dev);
539
539
int i;
···
566
566
567
567
void psb_modeset_cleanup(struct drm_device *dev)
568
568
{
569
-
struct drm_psb_private *dev_priv = dev->dev_private;
569
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
570
570
if (dev_priv->modeset) {
571
571
drm_kms_helper_poll_fini(dev);
572
572
psb_fbdev_fini(dev);
+1
-1
drivers/gpu/drm/gma500/gem.c
+1
-1
drivers/gpu/drm/gma500/gem.c
+1
-1
drivers/gpu/drm/gma500/gma_device.c
+1
-1
drivers/gpu/drm/gma500/gma_device.c
···
15
15
struct pci_dev *pci_root =
16
16
pci_get_domain_bus_and_slot(pci_domain_nr(pdev->bus),
17
17
0, 0);
18
-
struct drm_psb_private *dev_priv = dev->dev_private;
18
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
19
19
20
20
/*pci_write_config_dword(pci_root, 0xD4, 0x00C32004);*/
21
21
/*pci_write_config_dword(pci_root, 0xD0, 0xE0033000);*/
+7
-7
drivers/gpu/drm/gma500/gma_display.c
+7
-7
drivers/gpu/drm/gma500/gma_display.c
···
51
51
struct drm_framebuffer *old_fb)
52
52
{
53
53
struct drm_device *dev = crtc->dev;
54
-
struct drm_psb_private *dev_priv = dev->dev_private;
54
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
55
55
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
56
56
struct drm_framebuffer *fb = crtc->primary->fb;
57
57
struct gtt_range *gtt;
···
136
136
void gma_crtc_load_lut(struct drm_crtc *crtc)
137
137
{
138
138
struct drm_device *dev = crtc->dev;
139
-
struct drm_psb_private *dev_priv = dev->dev_private;
139
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
140
140
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
141
141
const struct psb_offset *map = &dev_priv->regmap[gma_crtc->pipe];
142
142
int palreg = map->palette;
···
189
189
void gma_crtc_dpms(struct drm_crtc *crtc, int mode)
190
190
{
191
191
struct drm_device *dev = crtc->dev;
192
-
struct drm_psb_private *dev_priv = dev->dev_private;
192
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
193
193
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
194
194
int pipe = gma_crtc->pipe;
195
195
const struct psb_offset *map = &dev_priv->regmap[pipe];
···
324
324
uint32_t width, uint32_t height)
325
325
{
326
326
struct drm_device *dev = crtc->dev;
327
-
struct drm_psb_private *dev_priv = dev->dev_private;
327
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
328
328
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
329
329
int pipe = gma_crtc->pipe;
330
330
uint32_t control = (pipe == 0) ? CURACNTR : CURBCNTR;
···
553
553
struct drm_modeset_acquire_ctx *ctx)
554
554
{
555
555
struct drm_device *dev = set->crtc->dev;
556
-
struct drm_psb_private *dev_priv = dev->dev_private;
556
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
557
557
int ret;
558
558
559
559
if (!dev_priv->rpm_enabled)
···
572
572
void gma_crtc_save(struct drm_crtc *crtc)
573
573
{
574
574
struct drm_device *dev = crtc->dev;
575
-
struct drm_psb_private *dev_priv = dev->dev_private;
575
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
576
576
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
577
577
struct psb_intel_crtc_state *crtc_state = gma_crtc->crtc_state;
578
578
const struct psb_offset *map = &dev_priv->regmap[gma_crtc->pipe];
···
615
615
void gma_crtc_restore(struct drm_crtc *crtc)
616
616
{
617
617
struct drm_device *dev = crtc->dev;
618
-
struct drm_psb_private *dev_priv = dev->dev_private;
618
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
619
619
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
620
620
struct psb_intel_crtc_state *crtc_state = gma_crtc->crtc_state;
621
621
const struct psb_offset *map = &dev_priv->regmap[gma_crtc->pipe];
+9
-9
drivers/gpu/drm/gma500/gtt.c
+9
-9
drivers/gpu/drm/gma500/gtt.c
···
53
53
*/
54
54
static u32 __iomem *psb_gtt_entry(struct drm_device *dev, struct gtt_range *r)
55
55
{
56
-
struct drm_psb_private *dev_priv = dev->dev_private;
56
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
57
57
unsigned long offset;
58
58
59
59
offset = r->resource.start - dev_priv->gtt_mem->start;
···
118
118
*/
119
119
static void psb_gtt_remove(struct drm_device *dev, struct gtt_range *r)
120
120
{
121
-
struct drm_psb_private *dev_priv = dev->dev_private;
121
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
122
122
u32 __iomem *gtt_slot;
123
123
u32 pte;
124
124
int i;
···
188
188
{
189
189
int ret = 0;
190
190
struct drm_device *dev = gt->gem.dev;
191
-
struct drm_psb_private *dev_priv = dev->dev_private;
191
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
192
192
u32 gpu_base = dev_priv->gtt.gatt_start;
193
193
194
194
mutex_lock(&dev_priv->gtt_mutex);
···
226
226
void psb_gtt_unpin(struct gtt_range *gt)
227
227
{
228
228
struct drm_device *dev = gt->gem.dev;
229
-
struct drm_psb_private *dev_priv = dev->dev_private;
229
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
230
230
u32 gpu_base = dev_priv->gtt.gatt_start;
231
231
232
232
mutex_lock(&dev_priv->gtt_mutex);
···
266
266
struct gtt_range *psb_gtt_alloc_range(struct drm_device *dev, int len,
267
267
const char *name, int backed, u32 align)
268
268
{
269
-
struct drm_psb_private *dev_priv = dev->dev_private;
269
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
270
270
struct gtt_range *gt;
271
271
struct resource *r = dev_priv->gtt_mem;
272
272
int ret;
···
322
322
323
323
static void psb_gtt_alloc(struct drm_device *dev)
324
324
{
325
-
struct drm_psb_private *dev_priv = dev->dev_private;
325
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
326
326
init_rwsem(&dev_priv->gtt.sem);
327
327
}
328
328
329
329
void psb_gtt_takedown(struct drm_device *dev)
330
330
{
331
-
struct drm_psb_private *dev_priv = dev->dev_private;
331
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
332
332
struct pci_dev *pdev = to_pci_dev(dev->dev);
333
333
334
334
if (dev_priv->gtt_map) {
···
347
347
348
348
int psb_gtt_init(struct drm_device *dev, int resume)
349
349
{
350
-
struct drm_psb_private *dev_priv = dev->dev_private;
350
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
351
351
struct pci_dev *pdev = to_pci_dev(dev->dev);
352
352
unsigned gtt_pages;
353
353
unsigned long stolen_size, vram_stolen_size;
···
496
496
497
497
int psb_gtt_restore(struct drm_device *dev)
498
498
{
499
-
struct drm_psb_private *dev_priv = dev->dev_private;
499
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
500
500
struct resource *r = dev_priv->gtt_mem->child;
501
501
struct gtt_range *range;
502
502
unsigned int restored = 0, total = 0, size = 0;
+2
-2
drivers/gpu/drm/gma500/intel_bios.c
+2
-2
drivers/gpu/drm/gma500/intel_bios.c
···
515
515
*/
516
516
int psb_intel_init_bios(struct drm_device *dev)
517
517
{
518
-
struct drm_psb_private *dev_priv = dev->dev_private;
518
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
519
519
struct pci_dev *pdev = to_pci_dev(dev->dev);
520
520
struct vbt_header *vbt = NULL;
521
521
struct bdb_header *bdb = NULL;
···
579
579
*/
580
580
void psb_intel_destroy_bios(struct drm_device *dev)
581
581
{
582
-
struct drm_psb_private *dev_priv = dev->dev_private;
582
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
583
583
584
584
kfree(dev_priv->sdvo_lvds_vbt_mode);
585
585
kfree(dev_priv->lfp_lvds_vbt_mode);
+3
-3
drivers/gpu/drm/gma500/intel_gmbus.c
+3
-3
drivers/gpu/drm/gma500/intel_gmbus.c
···
75
75
void
76
76
gma_intel_i2c_reset(struct drm_device *dev)
77
77
{
78
-
struct drm_psb_private *dev_priv = dev->dev_private;
78
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
79
79
GMBUS_REG_WRITE(GMBUS0, 0);
80
80
}
81
81
···
394
394
"reserved",
395
395
"dpd",
396
396
};
397
-
struct drm_psb_private *dev_priv = dev->dev_private;
397
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
398
398
int ret, i;
399
399
400
400
dev_priv->gmbus = kcalloc(GMBUS_NUM_PORTS, sizeof(struct intel_gmbus),
···
480
480
481
481
void gma_intel_teardown_gmbus(struct drm_device *dev)
482
482
{
483
-
struct drm_psb_private *dev_priv = dev->dev_private;
483
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
484
484
int i;
485
485
486
486
if (dev_priv->gmbus == NULL)
+2
-2
drivers/gpu/drm/gma500/mid_bios.c
+2
-2
drivers/gpu/drm/gma500/mid_bios.c
···
18
18
19
19
static void mid_get_fuse_settings(struct drm_device *dev)
20
20
{
21
-
struct drm_psb_private *dev_priv = dev->dev_private;
21
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
22
22
struct pci_dev *pdev = to_pci_dev(dev->dev);
23
23
struct pci_dev *pci_root =
24
24
pci_get_domain_bus_and_slot(pci_domain_nr(pdev->bus),
···
325
325
326
326
int mid_chip_setup(struct drm_device *dev)
327
327
{
328
-
struct drm_psb_private *dev_priv = dev->dev_private;
328
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
329
329
mid_get_fuse_settings(dev);
330
330
mid_get_vbt_data(dev_priv);
331
331
mid_get_pci_revID(dev_priv);
+6
-6
drivers/gpu/drm/gma500/mmu.c
+6
-6
drivers/gpu/drm/gma500/mmu.c
···
66
66
static void psb_mmu_flush_pd_locked(struct psb_mmu_driver *driver, int force)
67
67
{
68
68
struct drm_device *dev = driver->dev;
69
-
struct drm_psb_private *dev_priv = dev->dev_private;
69
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
70
70
71
71
if (atomic_read(&driver->needs_tlbflush) || force) {
72
72
uint32_t val = PSB_RSGX32(PSB_CR_BIF_CTRL);
···
94
94
void psb_mmu_flush(struct psb_mmu_driver *driver)
95
95
{
96
96
struct drm_device *dev = driver->dev;
97
-
struct drm_psb_private *dev_priv = dev->dev_private;
97
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
98
98
uint32_t val;
99
99
100
100
down_write(&driver->sem);
···
120
120
void psb_mmu_set_pd_context(struct psb_mmu_pd *pd, int hw_context)
121
121
{
122
122
struct drm_device *dev = pd->driver->dev;
123
-
struct drm_psb_private *dev_priv = dev->dev_private;
123
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
124
124
uint32_t offset = (hw_context == 0) ? PSB_CR_BIF_DIR_LIST_BASE0 :
125
125
PSB_CR_BIF_DIR_LIST_BASE1 + hw_context * 4;
126
126
···
230
230
{
231
231
struct psb_mmu_driver *driver = pd->driver;
232
232
struct drm_device *dev = driver->dev;
233
-
struct drm_psb_private *dev_priv = dev->dev_private;
233
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
234
234
struct psb_mmu_pt *pt;
235
235
int i;
236
236
···
409
409
void psb_mmu_driver_takedown(struct psb_mmu_driver *driver)
410
410
{
411
411
struct drm_device *dev = driver->dev;
412
-
struct drm_psb_private *dev_priv = dev->dev_private;
412
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
413
413
414
414
PSB_WSGX32(driver->bif_ctrl, PSB_CR_BIF_CTRL);
415
415
psb_mmu_free_pagedir(driver->default_pd);
···
422
422
atomic_t *msvdx_mmu_invaldc)
423
423
{
424
424
struct psb_mmu_driver *driver;
425
-
struct drm_psb_private *dev_priv = dev->dev_private;
425
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
426
426
427
427
driver = kmalloc(sizeof(*driver), GFP_KERNEL);
428
428
+4
-4
drivers/gpu/drm/gma500/oaktrail_crtc.c
+4
-4
drivers/gpu/drm/gma500/oaktrail_crtc.c
···
82
82
{
83
83
const struct gma_limit_t *limit = NULL;
84
84
struct drm_device *dev = crtc->dev;
85
-
struct drm_psb_private *dev_priv = dev->dev_private;
85
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
86
86
87
87
if (gma_pipe_has_type(crtc, INTEL_OUTPUT_LVDS)
88
88
|| gma_pipe_has_type(crtc, INTEL_OUTPUT_MIPI)) {
···
214
214
static void oaktrail_crtc_dpms(struct drm_crtc *crtc, int mode)
215
215
{
216
216
struct drm_device *dev = crtc->dev;
217
-
struct drm_psb_private *dev_priv = dev->dev_private;
217
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
218
218
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
219
219
int pipe = gma_crtc->pipe;
220
220
const struct psb_offset *map = &dev_priv->regmap[pipe];
···
361
361
{
362
362
struct drm_device *dev = crtc->dev;
363
363
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
364
-
struct drm_psb_private *dev_priv = dev->dev_private;
364
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
365
365
int pipe = gma_crtc->pipe;
366
366
const struct psb_offset *map = &dev_priv->regmap[pipe];
367
367
int refclk = 0;
···
589
589
int x, int y, struct drm_framebuffer *old_fb)
590
590
{
591
591
struct drm_device *dev = crtc->dev;
592
-
struct drm_psb_private *dev_priv = dev->dev_private;
592
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
593
593
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
594
594
struct drm_framebuffer *fb = crtc->primary->fb;
595
595
int pipe = gma_crtc->pipe;
+10
-10
drivers/gpu/drm/gma500/oaktrail_device.c
+10
-10
drivers/gpu/drm/gma500/oaktrail_device.c
···
20
20
21
21
static int oaktrail_output_init(struct drm_device *dev)
22
22
{
23
-
struct drm_psb_private *dev_priv = dev->dev_private;
23
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
24
24
if (dev_priv->iLVDS_enable)
25
25
oaktrail_lvds_init(dev, &dev_priv->mode_dev);
26
26
else
···
51
51
static int oaktrail_set_brightness(struct backlight_device *bd)
52
52
{
53
53
struct drm_device *dev = bl_get_data(oaktrail_backlight_device);
54
-
struct drm_psb_private *dev_priv = dev->dev_private;
54
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
55
55
int level = bd->props.brightness;
56
56
u32 blc_pwm_ctl;
57
57
u32 max_pwm_blc;
···
96
96
97
97
static int device_backlight_init(struct drm_device *dev)
98
98
{
99
-
struct drm_psb_private *dev_priv = dev->dev_private;
99
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
100
100
unsigned long core_clock;
101
101
u16 bl_max_freq;
102
102
uint32_t value;
···
133
133
134
134
static int oaktrail_backlight_init(struct drm_device *dev)
135
135
{
136
-
struct drm_psb_private *dev_priv = dev->dev_private;
136
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
137
137
int ret;
138
138
struct backlight_properties props;
139
139
···
175
175
*/
176
176
static int oaktrail_save_display_registers(struct drm_device *dev)
177
177
{
178
-
struct drm_psb_private *dev_priv = dev->dev_private;
178
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
179
179
struct psb_save_area *regs = &dev_priv->regs;
180
180
struct psb_pipe *p = ®s->pipe[0];
181
181
int i;
···
289
289
*/
290
290
static int oaktrail_restore_display_registers(struct drm_device *dev)
291
291
{
292
-
struct drm_psb_private *dev_priv = dev->dev_private;
292
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
293
293
struct psb_save_area *regs = &dev_priv->regs;
294
294
struct psb_pipe *p = ®s->pipe[0];
295
295
u32 pp_stat;
···
404
404
*/
405
405
static int oaktrail_power_down(struct drm_device *dev)
406
406
{
407
-
struct drm_psb_private *dev_priv = dev->dev_private;
407
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
408
408
u32 pwr_mask ;
409
409
u32 pwr_sts;
410
410
···
428
428
*/
429
429
static int oaktrail_power_up(struct drm_device *dev)
430
430
{
431
-
struct drm_psb_private *dev_priv = dev->dev_private;
431
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
432
432
u32 pwr_mask = PSB_PWRGT_DISPLAY_MASK;
433
433
u32 pwr_sts, pwr_cnt;
434
434
···
500
500
501
501
static int oaktrail_chip_setup(struct drm_device *dev)
502
502
{
503
-
struct drm_psb_private *dev_priv = dev->dev_private;
503
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
504
504
struct pci_dev *pdev = to_pci_dev(dev->dev);
505
505
int ret;
506
506
···
524
524
525
525
static void oaktrail_teardown(struct drm_device *dev)
526
526
{
527
-
struct drm_psb_private *dev_priv = dev->dev_private;
527
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
528
528
529
529
gma_intel_teardown_gmbus(dev);
530
530
oaktrail_hdmi_teardown(dev);
+9
-9
drivers/gpu/drm/gma500/oaktrail_hdmi.c
+9
-9
drivers/gpu/drm/gma500/oaktrail_hdmi.c
···
130
130
131
131
static void oaktrail_hdmi_audio_enable(struct drm_device *dev)
132
132
{
133
-
struct drm_psb_private *dev_priv = dev->dev_private;
133
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
134
134
struct oaktrail_hdmi_dev *hdmi_dev = dev_priv->hdmi_priv;
135
135
136
136
HDMI_WRITE(HDMI_HCR, 0x67);
···
145
145
146
146
static void oaktrail_hdmi_audio_disable(struct drm_device *dev)
147
147
{
148
-
struct drm_psb_private *dev_priv = dev->dev_private;
148
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
149
149
struct oaktrail_hdmi_dev *hdmi_dev = dev_priv->hdmi_priv;
150
150
151
151
HDMI_WRITE(0x51a8, 0x0);
···
264
264
struct drm_framebuffer *old_fb)
265
265
{
266
266
struct drm_device *dev = crtc->dev;
267
-
struct drm_psb_private *dev_priv = dev->dev_private;
267
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
268
268
struct oaktrail_hdmi_dev *hdmi_dev = dev_priv->hdmi_priv;
269
269
int pipe = 1;
270
270
int htot_reg = (pipe == 0) ? HTOTAL_A : HTOTAL_B;
···
494
494
static int dpms_mode = -1;
495
495
496
496
struct drm_device *dev = encoder->dev;
497
-
struct drm_psb_private *dev_priv = dev->dev_private;
497
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
498
498
struct oaktrail_hdmi_dev *hdmi_dev = dev_priv->hdmi_priv;
499
499
u32 temp;
500
500
···
529
529
{
530
530
enum drm_connector_status status;
531
531
struct drm_device *dev = connector->dev;
532
-
struct drm_psb_private *dev_priv = dev->dev_private;
532
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
533
533
struct oaktrail_hdmi_dev *hdmi_dev = dev_priv->hdmi_priv;
534
534
u32 temp;
535
535
···
665
665
666
666
void oaktrail_hdmi_setup(struct drm_device *dev)
667
667
{
668
-
struct drm_psb_private *dev_priv = dev->dev_private;
668
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
669
669
struct pci_dev *pdev;
670
670
struct oaktrail_hdmi_dev *hdmi_dev;
671
671
int ret;
···
718
718
719
719
void oaktrail_hdmi_teardown(struct drm_device *dev)
720
720
{
721
-
struct drm_psb_private *dev_priv = dev->dev_private;
721
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
722
722
struct oaktrail_hdmi_dev *hdmi_dev = dev_priv->hdmi_priv;
723
723
struct pci_dev *pdev;
724
724
···
735
735
/* save HDMI register state */
736
736
void oaktrail_hdmi_save(struct drm_device *dev)
737
737
{
738
-
struct drm_psb_private *dev_priv = dev->dev_private;
738
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
739
739
struct oaktrail_hdmi_dev *hdmi_dev = dev_priv->hdmi_priv;
740
740
struct psb_state *regs = &dev_priv->regs.psb;
741
741
struct psb_pipe *pipeb = &dev_priv->regs.pipe[1];
···
788
788
/* restore HDMI register state */
789
789
void oaktrail_hdmi_restore(struct drm_device *dev)
790
790
{
791
-
struct drm_psb_private *dev_priv = dev->dev_private;
791
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
792
792
struct oaktrail_hdmi_dev *hdmi_dev = dev_priv->hdmi_priv;
793
793
struct psb_state *regs = &dev_priv->regs.psb;
794
794
struct psb_pipe *pipeb = &dev_priv->regs.pipe[1];
+7
-7
drivers/gpu/drm/gma500/oaktrail_lvds.c
+7
-7
drivers/gpu/drm/gma500/oaktrail_lvds.c
···
37
37
bool on)
38
38
{
39
39
u32 pp_status;
40
-
struct drm_psb_private *dev_priv = dev->dev_private;
40
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
41
41
42
42
if (!gma_power_begin(dev, true))
43
43
return;
···
83
83
struct drm_display_mode *adjusted_mode)
84
84
{
85
85
struct drm_device *dev = encoder->dev;
86
-
struct drm_psb_private *dev_priv = dev->dev_private;
86
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
87
87
struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
88
88
struct drm_mode_config *mode_config = &dev->mode_config;
89
89
struct drm_connector *connector = NULL;
···
155
155
static void oaktrail_lvds_prepare(struct drm_encoder *encoder)
156
156
{
157
157
struct drm_device *dev = encoder->dev;
158
-
struct drm_psb_private *dev_priv = dev->dev_private;
158
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
159
159
struct gma_encoder *gma_encoder = to_gma_encoder(encoder);
160
160
struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
161
161
···
171
171
172
172
static u32 oaktrail_lvds_get_max_backlight(struct drm_device *dev)
173
173
{
174
-
struct drm_psb_private *dev_priv = dev->dev_private;
174
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
175
175
u32 ret;
176
176
177
177
if (gma_power_begin(dev, false)) {
···
191
191
static void oaktrail_lvds_commit(struct drm_encoder *encoder)
192
192
{
193
193
struct drm_device *dev = encoder->dev;
194
-
struct drm_psb_private *dev_priv = dev->dev_private;
194
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
195
195
struct gma_encoder *gma_encoder = to_gma_encoder(encoder);
196
196
struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
197
197
···
215
215
struct psb_intel_mode_device *mode_dev)
216
216
{
217
217
struct drm_display_mode *mode = NULL;
218
-
struct drm_psb_private *dev_priv = dev->dev_private;
218
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
219
219
struct oaktrail_timing_info *ti = &dev_priv->gct_data.DTD;
220
220
221
221
mode_dev->panel_fixed_mode = NULL;
···
294
294
struct gma_connector *gma_connector;
295
295
struct drm_connector *connector;
296
296
struct drm_encoder *encoder;
297
-
struct drm_psb_private *dev_priv = dev->dev_private;
297
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
298
298
struct edid *edid;
299
299
struct i2c_adapter *i2c_adap;
300
300
struct drm_display_mode *scan; /* *modes, *bios_mode; */
+1
-1
drivers/gpu/drm/gma500/oaktrail_lvds_i2c.c
+1
-1
drivers/gpu/drm/gma500/oaktrail_lvds_i2c.c
···
133
133
{
134
134
struct drm_device *dev = encoder->dev;
135
135
struct gma_encoder *gma_encoder = to_gma_encoder(encoder);
136
-
struct drm_psb_private *dev_priv = dev->dev_private;
136
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
137
137
struct psb_intel_i2c_chan *chan;
138
138
139
139
chan = kzalloc(sizeof(struct psb_intel_i2c_chan), GFP_KERNEL);
+6
-6
drivers/gpu/drm/gma500/opregion.c
+6
-6
drivers/gpu/drm/gma500/opregion.c
···
147
147
148
148
static u32 asle_set_backlight(struct drm_device *dev, u32 bclp)
149
149
{
150
-
struct drm_psb_private *dev_priv = dev->dev_private;
150
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
151
151
struct opregion_asle *asle = dev_priv->opregion.asle;
152
152
struct backlight_device *bd = dev_priv->backlight_device;
153
153
···
198
198
199
199
void psb_intel_opregion_asle_intr(struct drm_device *dev)
200
200
{
201
-
struct drm_psb_private *dev_priv = dev->dev_private;
201
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
202
202
203
203
if (dev_priv->opregion.asle)
204
204
schedule_work(&dev_priv->opregion.asle_work);
···
211
211
212
212
void psb_intel_opregion_enable_asle(struct drm_device *dev)
213
213
{
214
-
struct drm_psb_private *dev_priv = dev->dev_private;
214
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
215
215
struct opregion_asle *asle = dev_priv->opregion.asle;
216
216
217
217
if (asle && system_opregion ) {
···
258
258
259
259
void psb_intel_opregion_init(struct drm_device *dev)
260
260
{
261
-
struct drm_psb_private *dev_priv = dev->dev_private;
261
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
262
262
struct psb_intel_opregion *opregion = &dev_priv->opregion;
263
263
264
264
if (!opregion->header)
···
278
278
279
279
void psb_intel_opregion_fini(struct drm_device *dev)
280
280
{
281
-
struct drm_psb_private *dev_priv = dev->dev_private;
281
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
282
282
struct psb_intel_opregion *opregion = &dev_priv->opregion;
283
283
284
284
if (!opregion->header)
···
304
304
305
305
int psb_intel_opregion_setup(struct drm_device *dev)
306
306
{
307
-
struct drm_psb_private *dev_priv = dev->dev_private;
307
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
308
308
struct pci_dev *pdev = to_pci_dev(dev->dev);
309
309
struct psb_intel_opregion *opregion = &dev_priv->opregion;
310
310
u32 opregion_phy, mboxes;
+10
-10
drivers/gpu/drm/gma500/power.c
+10
-10
drivers/gpu/drm/gma500/power.c
···
47
47
*/
48
48
void gma_power_init(struct drm_device *dev)
49
49
{
50
-
struct drm_psb_private *dev_priv = dev->dev_private;
50
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
51
51
52
52
/* FIXME: Move APM/OSPM base into relevant device code */
53
53
dev_priv->apm_base = dev_priv->apm_reg & 0xffff;
···
82
82
*/
83
83
static void gma_suspend_display(struct drm_device *dev)
84
84
{
85
-
struct drm_psb_private *dev_priv = dev->dev_private;
85
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
86
86
87
87
if (dev_priv->suspended)
88
88
return;
···
101
101
static void gma_resume_display(struct pci_dev *pdev)
102
102
{
103
103
struct drm_device *dev = pci_get_drvdata(pdev);
104
-
struct drm_psb_private *dev_priv = dev->dev_private;
104
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
105
105
106
106
/* turn on the display power island */
107
107
dev_priv->ops->power_up(dev);
···
125
125
static void gma_suspend_pci(struct pci_dev *pdev)
126
126
{
127
127
struct drm_device *dev = pci_get_drvdata(pdev);
128
-
struct drm_psb_private *dev_priv = dev->dev_private;
128
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
129
129
int bsm, vbt;
130
130
131
131
if (dev_priv->suspended)
···
155
155
static bool gma_resume_pci(struct pci_dev *pdev)
156
156
{
157
157
struct drm_device *dev = pci_get_drvdata(pdev);
158
-
struct drm_psb_private *dev_priv = dev->dev_private;
158
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
159
159
int ret;
160
160
161
161
if (!dev_priv->suspended)
···
189
189
{
190
190
struct pci_dev *pdev = to_pci_dev(_dev);
191
191
struct drm_device *dev = pci_get_drvdata(pdev);
192
-
struct drm_psb_private *dev_priv = dev->dev_private;
192
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
193
193
194
194
mutex_lock(&power_mutex);
195
195
if (!dev_priv->suspended) {
···
234
234
*/
235
235
bool gma_power_is_on(struct drm_device *dev)
236
236
{
237
-
struct drm_psb_private *dev_priv = dev->dev_private;
237
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
238
238
return dev_priv->display_power;
239
239
}
240
240
···
248
248
*/
249
249
bool gma_power_begin(struct drm_device *dev, bool force_on)
250
250
{
251
-
struct drm_psb_private *dev_priv = dev->dev_private;
251
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
252
252
struct pci_dev *pdev = to_pci_dev(dev->dev);
253
253
int ret;
254
254
unsigned long flags;
···
288
288
*/
289
289
void gma_power_end(struct drm_device *dev)
290
290
{
291
-
struct drm_psb_private *dev_priv = dev->dev_private;
291
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
292
292
unsigned long flags;
293
293
spin_lock_irqsave(&power_ctrl_lock, flags);
294
294
dev_priv->display_count--;
···
310
310
int psb_runtime_idle(struct device *dev)
311
311
{
312
312
struct drm_device *drmdev = pci_get_drvdata(to_pci_dev(dev));
313
-
struct drm_psb_private *dev_priv = drmdev->dev_private;
313
+
struct drm_psb_private *dev_priv = to_drm_psb_private(drmdev);
314
314
if (dev_priv->display_count)
315
315
return 0;
316
316
else
+8
-8
drivers/gpu/drm/gma500/psb_device.c
+8
-8
drivers/gpu/drm/gma500/psb_device.c
···
18
18
19
19
static int psb_output_init(struct drm_device *dev)
20
20
{
21
-
struct drm_psb_private *dev_priv = dev->dev_private;
21
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
22
22
psb_intel_lvds_init(dev, &dev_priv->mode_dev);
23
23
psb_intel_sdvo_init(dev, SDVOB);
24
24
return 0;
···
55
55
56
56
static int psb_backlight_setup(struct drm_device *dev)
57
57
{
58
-
struct drm_psb_private *dev_priv = dev->dev_private;
58
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
59
59
unsigned long core_clock;
60
60
/* u32 bl_max_freq; */
61
61
/* unsigned long value; */
···
110
110
111
111
static int psb_backlight_init(struct drm_device *dev)
112
112
{
113
-
struct drm_psb_private *dev_priv = dev->dev_private;
113
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
114
114
int ret;
115
115
struct backlight_properties props;
116
116
···
149
149
150
150
static void psb_init_pm(struct drm_device *dev)
151
151
{
152
-
struct drm_psb_private *dev_priv = dev->dev_private;
152
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
153
153
154
154
u32 gating = PSB_RSGX32(PSB_CR_CLKGATECTL);
155
155
gating &= ~3; /* Disable 2D clock gating */
···
167
167
*/
168
168
static int psb_save_display_registers(struct drm_device *dev)
169
169
{
170
-
struct drm_psb_private *dev_priv = dev->dev_private;
170
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
171
171
struct drm_crtc *crtc;
172
172
struct gma_connector *connector;
173
173
struct psb_state *regs = &dev_priv->regs.psb;
···
205
205
*/
206
206
static int psb_restore_display_registers(struct drm_device *dev)
207
207
{
208
-
struct drm_psb_private *dev_priv = dev->dev_private;
208
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
209
209
struct drm_crtc *crtc;
210
210
struct gma_connector *connector;
211
211
struct psb_state *regs = &dev_priv->regs.psb;
···
300
300
301
301
static int psb_chip_setup(struct drm_device *dev)
302
302
{
303
-
struct drm_psb_private *dev_priv = dev->dev_private;
303
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
304
304
dev_priv->regmap = psb_regmap;
305
305
gma_get_core_freq(dev);
306
306
gma_intel_setup_gmbus(dev);
···
311
311
312
312
static void psb_chip_teardown(struct drm_device *dev)
313
313
{
314
-
struct drm_psb_private *dev_priv = dev->dev_private;
314
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
315
315
psb_lid_timer_takedown(dev_priv);
316
316
gma_intel_teardown_gmbus(dev);
317
317
}
+3
-3
drivers/gpu/drm/gma500/psb_drv.c
+3
-3
drivers/gpu/drm/gma500/psb_drv.c
···
124
124
125
125
static int psb_do_init(struct drm_device *dev)
126
126
{
127
-
struct drm_psb_private *dev_priv = dev->dev_private;
127
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
128
128
struct psb_gtt *pg = &dev_priv->gtt;
129
129
130
130
uint32_t stolen_gtt;
···
163
163
164
164
static void psb_driver_unload(struct drm_device *dev)
165
165
{
166
-
struct drm_psb_private *dev_priv = dev->dev_private;
166
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
167
167
168
168
/* TODO: Kill vblank etc here */
169
169
···
431
431
{
432
432
struct drm_file *file_priv = filp->private_data;
433
433
struct drm_device *dev = file_priv->minor->dev;
434
-
struct drm_psb_private *dev_priv = dev->dev_private;
434
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
435
435
static unsigned int runtime_allowed;
436
436
437
437
if (runtime_allowed == 1 && dev_priv->is_lvds_on) {
+10
-11
drivers/gpu/drm/gma500/psb_drv.h
+10
-11
drivers/gpu/drm/gma500/psb_drv.h
···
567
567
uint8_t panel_type;
568
568
};
569
569
570
+
static inline struct drm_psb_private *to_drm_psb_private(struct drm_device *dev)
571
+
{
572
+
return dev->dev_private;
573
+
}
570
574
571
575
/* Operations for each board type */
572
576
struct psb_ops {
···
621
617
622
618
extern int drm_crtc_probe_output_modes(struct drm_device *dev, int, int);
623
619
extern int drm_pick_crtcs(struct drm_device *dev);
624
-
625
-
static inline struct drm_psb_private *psb_priv(struct drm_device *dev)
626
-
{
627
-
return (struct drm_psb_private *) dev->dev_private;
628
-
}
629
620
630
621
/* psb_irq.c */
631
622
extern void psb_irq_uninstall_islands(struct drm_device *dev, int hw_islands);
···
728
729
729
730
static inline uint32_t REGISTER_READ(struct drm_device *dev, uint32_t reg)
730
731
{
731
-
struct drm_psb_private *dev_priv = dev->dev_private;
732
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
732
733
return ioread32(dev_priv->vdc_reg + reg);
733
734
}
734
735
735
736
static inline uint32_t REGISTER_READ_AUX(struct drm_device *dev, uint32_t reg)
736
737
{
737
-
struct drm_psb_private *dev_priv = dev->dev_private;
738
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
738
739
return ioread32(dev_priv->aux_reg + reg);
739
740
}
740
741
···
760
761
static inline void REGISTER_WRITE(struct drm_device *dev, uint32_t reg,
761
762
uint32_t val)
762
763
{
763
-
struct drm_psb_private *dev_priv = dev->dev_private;
764
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
764
765
iowrite32((val), dev_priv->vdc_reg + (reg));
765
766
}
766
767
767
768
static inline void REGISTER_WRITE_AUX(struct drm_device *dev, uint32_t reg,
768
769
uint32_t val)
769
770
{
770
-
struct drm_psb_private *dev_priv = dev->dev_private;
771
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
771
772
iowrite32((val), dev_priv->aux_reg + (reg));
772
773
}
773
774
···
788
789
static inline void REGISTER_WRITE16(struct drm_device *dev,
789
790
uint32_t reg, uint32_t val)
790
791
{
791
-
struct drm_psb_private *dev_priv = dev->dev_private;
792
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
792
793
iowrite16((val), dev_priv->vdc_reg + (reg));
793
794
}
794
795
···
797
798
static inline void REGISTER_WRITE8(struct drm_device *dev,
798
799
uint32_t reg, uint32_t val)
799
800
{
800
-
struct drm_psb_private *dev_priv = dev->dev_private;
801
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
801
802
iowrite8((val), dev_priv->vdc_reg + (reg));
802
803
}
803
804
+5
-5
drivers/gpu/drm/gma500/psb_intel_display.c
+5
-5
drivers/gpu/drm/gma500/psb_intel_display.c
···
95
95
struct drm_framebuffer *old_fb)
96
96
{
97
97
struct drm_device *dev = crtc->dev;
98
-
struct drm_psb_private *dev_priv = dev->dev_private;
98
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
99
99
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
100
100
const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
101
101
int pipe = gma_crtc->pipe;
···
298
298
struct drm_crtc *crtc)
299
299
{
300
300
struct gma_crtc *gma_crtc = to_gma_crtc(crtc);
301
-
struct drm_psb_private *dev_priv = dev->dev_private;
301
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
302
302
int pipe = gma_crtc->pipe;
303
303
const struct psb_offset *map = &dev_priv->regmap[pipe];
304
304
u32 dpll;
···
380
380
int hsync;
381
381
int vtot;
382
382
int vsync;
383
-
struct drm_psb_private *dev_priv = dev->dev_private;
383
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
384
384
struct psb_pipe *p = &dev_priv->regs.pipe[pipe];
385
385
const struct psb_offset *map = &dev_priv->regmap[pipe];
386
386
···
451
451
static void psb_intel_cursor_init(struct drm_device *dev,
452
452
struct gma_crtc *gma_crtc)
453
453
{
454
-
struct drm_psb_private *dev_priv = dev->dev_private;
454
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
455
455
u32 control[3] = { CURACNTR, CURBCNTR, CURCCNTR };
456
456
u32 base[3] = { CURABASE, CURBBASE, CURCBASE };
457
457
struct gtt_range *cursor_gt;
···
481
481
void psb_intel_crtc_init(struct drm_device *dev, int pipe,
482
482
struct psb_intel_mode_device *mode_dev)
483
483
{
484
-
struct drm_psb_private *dev_priv = dev->dev_private;
484
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
485
485
struct gma_crtc *gma_crtc;
486
486
int i;
487
487
+14
-17
drivers/gpu/drm/gma500/psb_intel_lvds.c
+14
-17
drivers/gpu/drm/gma500/psb_intel_lvds.c
···
59
59
*/
60
60
static u32 psb_intel_lvds_get_max_backlight(struct drm_device *dev)
61
61
{
62
-
struct drm_psb_private *dev_priv = dev->dev_private;
62
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
63
63
u32 ret;
64
64
65
65
if (gma_power_begin(dev, false)) {
···
88
88
static int psb_lvds_i2c_set_brightness(struct drm_device *dev,
89
89
unsigned int level)
90
90
{
91
-
struct drm_psb_private *dev_priv =
92
-
(struct drm_psb_private *)dev->dev_private;
91
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
93
92
94
93
struct psb_intel_i2c_chan *lvds_i2c_bus = dev_priv->lvds_i2c_bus;
95
94
u8 out_buf[2];
···
127
128
128
129
static int psb_lvds_pwm_set_brightness(struct drm_device *dev, int level)
129
130
{
130
-
struct drm_psb_private *dev_priv =
131
-
(struct drm_psb_private *)dev->dev_private;
131
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
132
132
133
133
u32 max_pwm_blc;
134
134
u32 blc_pwm_duty_cycle;
···
159
161
*/
160
162
void psb_intel_lvds_set_brightness(struct drm_device *dev, int level)
161
163
{
162
-
struct drm_psb_private *dev_priv = dev->dev_private;
164
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
163
165
164
166
dev_dbg(dev->dev, "backlight level is %d\n", level);
165
167
···
181
183
*/
182
184
static void psb_intel_lvds_set_backlight(struct drm_device *dev, int level)
183
185
{
184
-
struct drm_psb_private *dev_priv = dev->dev_private;
186
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
185
187
u32 blc_pwm_ctl;
186
188
187
189
if (gma_power_begin(dev, false)) {
···
206
208
*/
207
209
static void psb_intel_lvds_set_power(struct drm_device *dev, bool on)
208
210
{
209
-
struct drm_psb_private *dev_priv = dev->dev_private;
211
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
210
212
struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
211
213
u32 pp_status;
212
214
···
252
254
static void psb_intel_lvds_save(struct drm_connector *connector)
253
255
{
254
256
struct drm_device *dev = connector->dev;
255
-
struct drm_psb_private *dev_priv =
256
-
(struct drm_psb_private *)dev->dev_private;
257
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
257
258
struct gma_encoder *gma_encoder = gma_attached_encoder(connector);
258
259
struct psb_intel_lvds_priv *lvds_priv =
259
260
(struct psb_intel_lvds_priv *)gma_encoder->dev_priv;
···
332
335
enum drm_mode_status psb_intel_lvds_mode_valid(struct drm_connector *connector,
333
336
struct drm_display_mode *mode)
334
337
{
335
-
struct drm_psb_private *dev_priv = connector->dev->dev_private;
338
+
struct drm_psb_private *dev_priv = to_drm_psb_private(connector->dev);
336
339
struct gma_encoder *gma_encoder = gma_attached_encoder(connector);
337
340
struct drm_display_mode *fixed_mode =
338
341
dev_priv->mode_dev.panel_fixed_mode;
···
362
365
struct drm_display_mode *adjusted_mode)
363
366
{
364
367
struct drm_device *dev = encoder->dev;
365
-
struct drm_psb_private *dev_priv = dev->dev_private;
368
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
366
369
struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
367
370
struct gma_crtc *gma_crtc = to_gma_crtc(encoder->crtc);
368
371
struct drm_encoder *tmp_encoder;
···
423
426
static void psb_intel_lvds_prepare(struct drm_encoder *encoder)
424
427
{
425
428
struct drm_device *dev = encoder->dev;
426
-
struct drm_psb_private *dev_priv = dev->dev_private;
429
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
427
430
struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
428
431
429
432
if (!gma_power_begin(dev, true))
···
441
444
static void psb_intel_lvds_commit(struct drm_encoder *encoder)
442
445
{
443
446
struct drm_device *dev = encoder->dev;
444
-
struct drm_psb_private *dev_priv = dev->dev_private;
447
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
445
448
struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
446
449
447
450
if (mode_dev->backlight_duty_cycle == 0)
···
456
459
struct drm_display_mode *adjusted_mode)
457
460
{
458
461
struct drm_device *dev = encoder->dev;
459
-
struct drm_psb_private *dev_priv = dev->dev_private;
462
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
460
463
u32 pfit_control;
461
464
462
465
/*
···
490
493
static int psb_intel_lvds_get_modes(struct drm_connector *connector)
491
494
{
492
495
struct drm_device *dev = connector->dev;
493
-
struct drm_psb_private *dev_priv = dev->dev_private;
496
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
494
497
struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
495
498
struct gma_encoder *gma_encoder = gma_attached_encoder(connector);
496
499
struct psb_intel_lvds_priv *lvds_priv = gma_encoder->dev_priv;
···
638
641
struct drm_encoder *encoder;
639
642
struct drm_display_mode *scan; /* *modes, *bios_mode; */
640
643
struct drm_crtc *crtc;
641
-
struct drm_psb_private *dev_priv = dev->dev_private;
644
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
642
645
u32 lvds;
643
646
int pipe;
644
647
+5
-5
drivers/gpu/drm/gma500/psb_intel_sdvo.c
+5
-5
drivers/gpu/drm/gma500/psb_intel_sdvo.c
···
1217
1217
static struct edid *
1218
1218
psb_intel_sdvo_get_analog_edid(struct drm_connector *connector)
1219
1219
{
1220
-
struct drm_psb_private *dev_priv = connector->dev->dev_private;
1220
+
struct drm_psb_private *dev_priv = to_drm_psb_private(connector->dev);
1221
1221
1222
1222
return drm_get_edid(connector,
1223
1223
&dev_priv->gmbus[dev_priv->crt_ddc_pin].adapter);
···
1486
1486
static void psb_intel_sdvo_get_lvds_modes(struct drm_connector *connector)
1487
1487
{
1488
1488
struct psb_intel_sdvo *psb_intel_sdvo = intel_attached_sdvo(connector);
1489
-
struct drm_psb_private *dev_priv = connector->dev->dev_private;
1489
+
struct drm_psb_private *dev_priv = to_drm_psb_private(connector->dev);
1490
1490
struct drm_display_mode *newmode;
1491
1491
1492
1492
/*
···
1570
1570
{
1571
1571
struct psb_intel_sdvo *psb_intel_sdvo = intel_attached_sdvo(connector);
1572
1572
struct psb_intel_sdvo_connector *psb_intel_sdvo_connector = to_psb_intel_sdvo_connector(connector);
1573
-
struct drm_psb_private *dev_priv = connector->dev->dev_private;
1573
+
struct drm_psb_private *dev_priv = to_drm_psb_private(connector->dev);
1574
1574
uint16_t temp_value;
1575
1575
uint8_t cmd;
1576
1576
int ret;
···
1878
1878
static u8
1879
1879
psb_intel_sdvo_get_slave_addr(struct drm_device *dev, int sdvo_reg)
1880
1880
{
1881
-
struct drm_psb_private *dev_priv = dev->dev_private;
1881
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
1882
1882
struct sdvo_device_mapping *my_mapping, *other_mapping;
1883
1883
1884
1884
if (IS_SDVOB(sdvo_reg)) {
···
2415
2415
2416
2416
bool psb_intel_sdvo_init(struct drm_device *dev, int sdvo_reg)
2417
2417
{
2418
-
struct drm_psb_private *dev_priv = dev->dev_private;
2418
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
2419
2419
struct gma_encoder *gma_encoder;
2420
2420
struct psb_intel_sdvo *psb_intel_sdvo;
2421
2421
int i;
+8
-10
drivers/gpu/drm/gma500/psb_irq.c
+8
-10
drivers/gpu/drm/gma500/psb_irq.c
···
107
107
*/
108
108
static void mid_pipe_event_handler(struct drm_device *dev, int pipe)
109
109
{
110
-
struct drm_psb_private *dev_priv =
111
-
(struct drm_psb_private *) dev->dev_private;
110
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
112
111
113
112
uint32_t pipe_stat_val = 0;
114
113
uint32_t pipe_stat_reg = psb_pipestat(pipe);
···
177
178
*/
178
179
static void psb_sgx_interrupt(struct drm_device *dev, u32 stat_1, u32 stat_2)
179
180
{
180
-
struct drm_psb_private *dev_priv = dev->dev_private;
181
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
181
182
u32 val, addr;
182
183
183
184
if (stat_1 & _PSB_CE_TWOD_COMPLETE)
···
225
226
static irqreturn_t psb_irq_handler(int irq, void *arg)
226
227
{
227
228
struct drm_device *dev = arg;
228
-
struct drm_psb_private *dev_priv = dev->dev_private;
229
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
229
230
uint32_t vdc_stat, dsp_int = 0, sgx_int = 0, hotplug_int = 0;
230
231
u32 sgx_stat_1, sgx_stat_2;
231
232
int handled = 0;
···
276
277
277
278
void psb_irq_preinstall(struct drm_device *dev)
278
279
{
279
-
struct drm_psb_private *dev_priv =
280
-
(struct drm_psb_private *) dev->dev_private;
280
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
281
281
unsigned long irqflags;
282
282
283
283
spin_lock_irqsave(&dev_priv->irqmask_lock, irqflags);
···
305
307
306
308
void psb_irq_postinstall(struct drm_device *dev)
307
309
{
308
-
struct drm_psb_private *dev_priv = dev->dev_private;
310
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
309
311
unsigned long irqflags;
310
312
unsigned int i;
311
313
···
354
356
355
357
void psb_irq_uninstall(struct drm_device *dev)
356
358
{
357
-
struct drm_psb_private *dev_priv = dev->dev_private;
359
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
358
360
struct pci_dev *pdev = to_pci_dev(dev->dev);
359
361
unsigned long irqflags;
360
362
unsigned int i;
···
395
397
{
396
398
struct drm_device *dev = crtc->dev;
397
399
unsigned int pipe = crtc->index;
398
-
struct drm_psb_private *dev_priv = dev->dev_private;
400
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
399
401
unsigned long irqflags;
400
402
uint32_t reg_val = 0;
401
403
uint32_t pipeconf_reg = mid_pipeconf(pipe);
···
431
433
{
432
434
struct drm_device *dev = crtc->dev;
433
435
unsigned int pipe = crtc->index;
434
-
struct drm_psb_private *dev_priv = dev->dev_private;
436
+
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
435
437
unsigned long irqflags;
436
438
437
439
spin_lock_irqsave(&dev_priv->irqmask_lock, irqflags);