Commit ae0b9318 authored by Patrik Jakobsson's avatar Patrik Jakobsson
Browse files

drm/gma500: Remove unused ioctls 



All of these ioctls are unused and most of them just duplicate what drm
already provides.

Signed-off-by: default avatarPatrik Jakobsson <patrik.r.jakobsson@gmail.com>
parent 8f394872

drivers/gpu/drm/gma500/gem.c

+0 −44
Original line number Diff line number Diff line
@@ -229,47 +229,3 @@ int psb_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 
		return VM_FAULT_SIGBUS;

	}

}
 


static int psb_gem_create_stolen(struct drm_file *file, struct drm_device *dev,

						int size, u32 *handle)

{

	struct gtt_range *gtt = psb_gtt_alloc_range(dev, size, "gem", 1);

	if (gtt == NULL)

		return -ENOMEM;



	drm_gem_private_object_init(dev, &gtt->gem, size);

	if (drm_gem_handle_create(file, &gtt->gem, handle) == 0)

		return 0;



	drm_gem_object_release(&gtt->gem);

	psb_gtt_free_range(dev, gtt);

	return -ENOMEM;

}



/*

 *	GEM interfaces for our specific client

 */

int psb_gem_create_ioctl(struct drm_device *dev, void *data,

					struct drm_file *file)

{

	struct drm_psb_gem_create *args = data;

	int ret;

	if (args->flags & GMA_GEM_CREATE_STOLEN) {

		ret = psb_gem_create_stolen(file, dev, args->size,

							&args->handle);

		if (ret == 0)

			return 0;

		/* Fall throguh */

		args->flags &= ~GMA_GEM_CREATE_STOLEN;

	}

	return psb_gem_create(file, dev, args->size, &args->handle);

}



int psb_gem_mmap_ioctl(struct drm_device *dev, void *data,

					struct drm_file *file)

{

	struct drm_psb_gem_mmap *args = data;

	return dev->driver->dumb_map_offset(file, dev,

						args->handle, &args->offset);

}

drivers/gpu/drm/gma500/psb_drv.c

+0 −196
Original line number Diff line number Diff line
@@ -21,7 +21,6 @@ 


#include <drm/drmP.h>

#include <drm/drm.h>

#include <drm/gma_drm.h>

#include "psb_drv.h"

#include "framebuffer.h"

#include "psb_reg.h"
@@ -89,56 +88,7 @@ MODULE_DEVICE_TABLE(pci, pciidlist); 
/*

 * Standard IOCTLs.

 */



#define DRM_IOCTL_GMA_ADB	\

		DRM_IOWR(DRM_GMA_ADB + DRM_COMMAND_BASE, uint32_t)

#define DRM_IOCTL_GMA_MODE_OPERATION	\

		DRM_IOWR(DRM_GMA_MODE_OPERATION + DRM_COMMAND_BASE, \

			 struct drm_psb_mode_operation_arg)

#define DRM_IOCTL_GMA_STOLEN_MEMORY	\

		DRM_IOWR(DRM_GMA_STOLEN_MEMORY + DRM_COMMAND_BASE, \

			 struct drm_psb_stolen_memory_arg)

#define DRM_IOCTL_GMA_GAMMA	\

		DRM_IOWR(DRM_GMA_GAMMA + DRM_COMMAND_BASE, \

			 struct drm_psb_dpst_lut_arg)

#define DRM_IOCTL_GMA_DPST_BL	\

		DRM_IOWR(DRM_GMA_DPST_BL + DRM_COMMAND_BASE, \

			 uint32_t)

#define DRM_IOCTL_GMA_GET_PIPE_FROM_CRTC_ID	\

		DRM_IOWR(DRM_GMA_GET_PIPE_FROM_CRTC_ID + DRM_COMMAND_BASE, \

			 struct drm_psb_get_pipe_from_crtc_id_arg)

#define DRM_IOCTL_GMA_GEM_CREATE	\

		DRM_IOWR(DRM_GMA_GEM_CREATE + DRM_COMMAND_BASE, \

			 struct drm_psb_gem_create)

#define DRM_IOCTL_GMA_GEM_MMAP	\

		DRM_IOWR(DRM_GMA_GEM_MMAP + DRM_COMMAND_BASE, \

			 struct drm_psb_gem_mmap)



static int psb_adb_ioctl(struct drm_device *dev, void *data,

			 struct drm_file *file_priv);

static int psb_mode_operation_ioctl(struct drm_device *dev, void *data,

				    struct drm_file *file_priv);

static int psb_stolen_memory_ioctl(struct drm_device *dev, void *data,

				   struct drm_file *file_priv);

static int psb_gamma_ioctl(struct drm_device *dev, void *data,

			   struct drm_file *file_priv);

static int psb_dpst_bl_ioctl(struct drm_device *dev, void *data,

			     struct drm_file *file_priv);



static const struct drm_ioctl_desc psb_ioctls[] = {

	DRM_IOCTL_DEF_DRV(GMA_ADB, psb_adb_ioctl, DRM_AUTH),

	DRM_IOCTL_DEF_DRV(GMA_MODE_OPERATION, psb_mode_operation_ioctl,

		      DRM_AUTH),

	DRM_IOCTL_DEF_DRV(GMA_STOLEN_MEMORY, psb_stolen_memory_ioctl,

		      DRM_AUTH),

	DRM_IOCTL_DEF_DRV(GMA_GAMMA, psb_gamma_ioctl, DRM_AUTH),

	DRM_IOCTL_DEF_DRV(GMA_DPST_BL, psb_dpst_bl_ioctl, DRM_AUTH),

	DRM_IOCTL_DEF_DRV(GMA_GET_PIPE_FROM_CRTC_ID,

					psb_intel_get_pipe_from_crtc_id, 0),

	DRM_IOCTL_DEF_DRV(GMA_GEM_CREATE, psb_gem_create_ioctl,

						DRM_UNLOCKED | DRM_AUTH),

	DRM_IOCTL_DEF_DRV(GMA_GEM_MMAP, psb_gem_mmap_ioctl,

						DRM_UNLOCKED | DRM_AUTH),

};



static void psb_lastclose(struct drm_device *dev)
@@ -451,152 +401,6 @@ static inline void get_brightness(struct backlight_device *bd) 
#endif

}



static int psb_dpst_bl_ioctl(struct drm_device *dev, void *data,

		       struct drm_file *file_priv)

{

	struct drm_psb_private *dev_priv = psb_priv(dev);

	uint32_t *arg = data;



	dev_priv->blc_adj2 = *arg;

	get_brightness(dev_priv->backlight_device);

	return 0;

}



static int psb_adb_ioctl(struct drm_device *dev, void *data,

			struct drm_file *file_priv)

{

	struct drm_psb_private *dev_priv = psb_priv(dev);

	uint32_t *arg = data;



	dev_priv->blc_adj1 = *arg;

	get_brightness(dev_priv->backlight_device);

	return 0;

}



static int psb_gamma_ioctl(struct drm_device *dev, void *data,

			   struct drm_file *file_priv)

{

	struct drm_psb_dpst_lut_arg *lut_arg = data;

	struct drm_mode_object *obj;

	struct drm_crtc *crtc;

	struct drm_connector *connector;

	struct gma_crtc *gma_crtc;

	int i = 0;

	int32_t obj_id;



	obj_id = lut_arg->output_id;

	obj = drm_mode_object_find(dev, obj_id, DRM_MODE_OBJECT_CONNECTOR);

	if (!obj) {

		dev_dbg(dev->dev, "Invalid Connector object.\n");

		return -ENOENT;

	}



	connector = obj_to_connector(obj);

	crtc = connector->encoder->crtc;

	gma_crtc = to_gma_crtc(crtc);



	for (i = 0; i < 256; i++)

		gma_crtc->lut_adj[i] = lut_arg->lut[i];



	gma_crtc_load_lut(crtc);



	return 0;

}



static int psb_mode_operation_ioctl(struct drm_device *dev, void *data,

				struct drm_file *file_priv)

{

	uint32_t obj_id;

	uint16_t op;

	struct drm_mode_modeinfo *umode;

	struct drm_display_mode *mode = NULL;

	struct drm_psb_mode_operation_arg *arg;

	struct drm_mode_object *obj;

	struct drm_connector *connector;

	struct drm_connector_helper_funcs *connector_funcs;

	int ret = 0;

	int resp = MODE_OK;



	arg = (struct drm_psb_mode_operation_arg *)data;

	obj_id = arg->obj_id;

	op = arg->operation;



	switch (op) {

	case PSB_MODE_OPERATION_MODE_VALID:

		umode = &arg->mode;



		drm_modeset_lock_all(dev);



		obj = drm_mode_object_find(dev, obj_id,

					DRM_MODE_OBJECT_CONNECTOR);

		if (!obj) {

			ret = -ENOENT;

			goto mode_op_out;

		}



		connector = obj_to_connector(obj);



		mode = drm_mode_create(dev);

		if (!mode) {

			ret = -ENOMEM;

			goto mode_op_out;

		}



		/* drm_crtc_convert_umode(mode, umode); */

		{

			mode->clock = umode->clock;

			mode->hdisplay = umode->hdisplay;

			mode->hsync_start = umode->hsync_start;

			mode->hsync_end = umode->hsync_end;

			mode->htotal = umode->htotal;

			mode->hskew = umode->hskew;

			mode->vdisplay = umode->vdisplay;

			mode->vsync_start = umode->vsync_start;

			mode->vsync_end = umode->vsync_end;

			mode->vtotal = umode->vtotal;

			mode->vscan = umode->vscan;

			mode->vrefresh = umode->vrefresh;

			mode->flags = umode->flags;

			mode->type = umode->type;

			strncpy(mode->name, umode->name, DRM_DISPLAY_MODE_LEN);

			mode->name[DRM_DISPLAY_MODE_LEN-1] = 0;

		}



		connector_funcs = (struct drm_connector_helper_funcs *)

				   connector->helper_private;



		if (connector_funcs->mode_valid) {

			resp = connector_funcs->mode_valid(connector, mode);

			arg->data = resp;

		}



		/*do some clean up work*/

		if (mode)

			drm_mode_destroy(dev, mode);

mode_op_out:

		drm_modeset_unlock_all(dev);

		return ret;



	default:

		dev_dbg(dev->dev, "Unsupported psb mode operation\n");

		return -EOPNOTSUPP;

	}



	return 0;

}



static int psb_stolen_memory_ioctl(struct drm_device *dev, void *data,

				   struct drm_file *file_priv)

{

	struct drm_psb_private *dev_priv = psb_priv(dev);

	struct drm_psb_stolen_memory_arg *arg = data;



	arg->base = dev_priv->stolen_base;

	arg->size = dev_priv->vram_stolen_size;



	return 0;

}



static int psb_driver_open(struct drm_device *dev, struct drm_file *priv)

{

	return 0;

drivers/gpu/drm/gma500/psb_intel_display.c

+0 −27
Original line number Diff line number Diff line
@@ -554,33 +554,6 @@ void psb_intel_crtc_init(struct drm_device *dev, int pipe, 
	gma_crtc->active = true;

}



int psb_intel_get_pipe_from_crtc_id(struct drm_device *dev, void *data,

				struct drm_file *file_priv)

{

	struct drm_psb_private *dev_priv = dev->dev_private;

	struct drm_psb_get_pipe_from_crtc_id_arg *pipe_from_crtc_id = data;

	struct drm_mode_object *drmmode_obj;

	struct gma_crtc *crtc;



	if (!dev_priv) {

		dev_err(dev->dev, "called with no initialization\n");

		return -EINVAL;

	}



	drmmode_obj = drm_mode_object_find(dev, pipe_from_crtc_id->crtc_id,

			DRM_MODE_OBJECT_CRTC);



	if (!drmmode_obj) {

		dev_err(dev->dev, "no such CRTC id\n");

		return -ENOENT;

	}



	crtc = to_gma_crtc(obj_to_crtc(drmmode_obj));

	pipe_from_crtc_id->pipe = crtc->pipe;



	return 0;

}



struct drm_crtc *psb_intel_get_crtc_from_pipe(struct drm_device *dev, int pipe)

{

	struct drm_crtc *crtc = NULL;

drivers/gpu/drm/gma500/psb_intel_drv.h

+0 −2
Original line number Diff line number Diff line
@@ -238,8 +238,6 @@ static inline struct gma_encoder *gma_attached_encoder( 


extern struct drm_display_mode *psb_intel_crtc_mode_get(struct drm_device *dev,

						    struct drm_crtc *crtc);

extern int psb_intel_get_pipe_from_crtc_id(struct drm_device *dev, void *data,

				struct drm_file *file_priv);

extern struct drm_crtc *psb_intel_get_crtc_from_pipe(struct drm_device *dev,

						 int pipe);

extern struct drm_connector *psb_intel_sdvo_find(struct drm_device *dev,

include/drm/gma_drm.h

+2 −68
Original line number Diff line number Diff line
@@ -19,73 +19,7 @@ 
 *

 **************************************************************************/



#ifndef _PSB_DRM_H_

#define _PSB_DRM_H_



/*

 *	Manage the LUT for an output

 */

struct drm_psb_dpst_lut_arg {

	uint8_t lut[256];

	int output_id;

};



/*

 *	Validate modes

 */

struct drm_psb_mode_operation_arg {

	u32 obj_id;

	u16 operation;

	struct drm_mode_modeinfo mode;

	u64 data;

};



/*

 *	Query the stolen memory for smarter management of

 *	memory by the server

 */

struct drm_psb_stolen_memory_arg {

	u32 base;

	u32 size;

};



struct drm_psb_get_pipe_from_crtc_id_arg {

	/** ID of CRTC being requested **/

	u32 crtc_id;

	/** pipe of requested CRTC **/

	u32 pipe;

};



struct drm_psb_gem_create {

	__u64 size;

	__u32 handle;

	__u32 flags;

#define GMA_GEM_CREATE_STOLEN		1	/* Stolen memory can be used */

};



struct drm_psb_gem_mmap {

	__u32 handle;

	__u32 pad;

	/**

	 * Fake offset to use for subsequent mmap call

	 *

	 * This is a fixed-size type for 32/64 compatibility.

	 */

	__u64 offset;

};



/* Controlling the kernel modesetting buffers */



#define DRM_GMA_GEM_CREATE	0x00		/* Create a GEM object */

#define DRM_GMA_GEM_MMAP	0x01		/* Map GEM memory */

#define DRM_GMA_STOLEN_MEMORY	0x02		/* Report stolen memory */

#define DRM_GMA_2D_OP		0x03		/* Will be merged later */

#define DRM_GMA_GAMMA		0x04		/* Set gamma table */

#define DRM_GMA_ADB		0x05		/* Get backlight */

#define DRM_GMA_DPST_BL		0x06		/* Set backlight */

#define DRM_GMA_MODE_OPERATION	0x07		/* Mode validation/DC set */

#define 	PSB_MODE_OPERATION_MODE_VALID	0x01

#define DRM_GMA_GET_PIPE_FROM_CRTC_ID	0x08	/* CRTC to physical pipe# */



#ifndef _GMA_DRM_H_

#define _GMA_DRM_H_



#endif