Merge branch 'drm-udl-next' of git://people.freedesktop.org/~airlied/linux into drm-next (caca1ff0) · Commits · e / devices / android_kernel_teracube_emerald

drivers/gpu/drm/udl/udl_drv.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -113,7 +113,7 @@ udl_fb_user_fb_create(struct drm_device *dev,
	struct drm_file *file,		struct drm_file *file,
	const struct drm_mode_fb_cmd2 *mode_cmd);		const struct drm_mode_fb_cmd2 *mode_cmd);

	int udl_render_hline(struct drm_device dev, int bpp, struct urb *urb_ptr,		int udl_render_hline(struct drm_device dev, int log_bpp, struct urb *urb_ptr,
	const char front, char *urb_buf_ptr,		const char front, char *urb_buf_ptr,
	u32 byte_offset, u32 device_byte_offset, u32 byte_width,		u32 byte_offset, u32 device_byte_offset, u32 byte_width,
	int ident_ptr, int sent_ptr);		int ident_ptr, int sent_ptr);

drivers/gpu/drm/udl/udl_fb.c

+13 −10

Original line number	Original line	Diff line number	Diff line
	@@ -90,7 +90,10 @@ int udl_handle_damage(struct udl_framebuffer *fb, int x, int y,
	int bytes_identical = 0;		int bytes_identical = 0;
	struct urb *urb;		struct urb *urb;
	int aligned_x;		int aligned_x;
	int bpp = fb->base.format->cpp[0];		int log_bpp;

			BUG_ON(!is_power_of_2(fb->base.format->cpp[0]));
			log_bpp = __ffs(fb->base.format->cpp[0]);

	if (!fb->active_16)		if (!fb->active_16)
	return 0;		return 0;
	@@ -125,12 +128,12 @@ int udl_handle_damage(struct udl_framebuffer *fb, int x, int y,

	for (i = y; i < y + height ; i++) {		for (i = y; i < y + height ; i++) {
	const int line_offset = fb->base.pitches[0] * i;		const int line_offset = fb->base.pitches[0] * i;
	const int byte_offset = line_offset + (x * bpp);		const int byte_offset = line_offset + (x << log_bpp);
	const int dev_byte_offset = (fb->base.width * bpp * i) + (x * bpp);		const int dev_byte_offset = (fb->base.width * i + x) << log_bpp;
	if (udl_render_hline(dev, bpp, &urb,		if (udl_render_hline(dev, log_bpp, &urb,
	(char *) fb->obj->vmapping,		(char *) fb->obj->vmapping,
	&cmd, byte_offset, dev_byte_offset,		&cmd, byte_offset, dev_byte_offset,
	width * bpp,		width << log_bpp,
	&bytes_identical, &bytes_sent))		&bytes_identical, &bytes_sent))
	goto error;		goto error;
	}		}
	@@ -149,7 +152,7 @@ int udl_handle_damage(struct udl_framebuffer *fb, int x, int y,
	error:		error:
	atomic_add(bytes_sent, &udl->bytes_sent);		atomic_add(bytes_sent, &udl->bytes_sent);
	atomic_add(bytes_identical, &udl->bytes_identical);		atomic_add(bytes_identical, &udl->bytes_identical);
	atomic_add(widthheightbpp, &udl->bytes_rendered);		atomic_add((width * height) << log_bpp, &udl->bytes_rendered);
	end_cycles = get_cycles();		end_cycles = get_cycles();
	atomic_add(((unsigned int) ((end_cycles - start_cycles)		atomic_add(((unsigned int) ((end_cycles - start_cycles)
	>> 10)), /* Kcycles */		>> 10)), /* Kcycles */
	@@ -175,7 +178,7 @@ static int udl_fb_mmap(struct fb_info info, struct vm_area_struct vma)

	pos = (unsigned long)info->fix.smem_start + offset;		pos = (unsigned long)info->fix.smem_start + offset;

	pr_notice("mmap() framebuffer addr:%lu size:%lu\n",		pr_debug("mmap() framebuffer addr:%lu size:%lu\n",
	pos, size);		pos, size);

	/* We don't want the framebuffer to be mapped encrypted */		/* We don't want the framebuffer to be mapped encrypted */
	@@ -221,7 +224,7 @@ static int udl_fb_open(struct fb_info *info, int user)

	struct fb_deferred_io *fbdefio;		struct fb_deferred_io *fbdefio;

	fbdefio = kmalloc(sizeof(struct fb_deferred_io), GFP_KERNEL);		fbdefio = kzalloc(sizeof(struct fb_deferred_io), GFP_KERNEL);

	if (fbdefio) {		if (fbdefio) {
	fbdefio->delay = DL_DEFIO_WRITE_DELAY;		fbdefio->delay = DL_DEFIO_WRITE_DELAY;
	@@ -233,7 +236,7 @@ static int udl_fb_open(struct fb_info *info, int user)
	}		}
	#endif		#endif

	pr_notice("open /dev/fb%d user=%d fb_info=%p count=%d\n",		pr_debug("open /dev/fb%d user=%d fb_info=%p count=%d\n",
	info->node, user, info, ufbdev->fb_count);		info->node, user, info, ufbdev->fb_count);

	return 0;		return 0;
	@@ -258,7 +261,7 @@ static int udl_fb_release(struct fb_info *info, int user)
	}		}
	#endif		#endif

	pr_warn("released /dev/fb%d user=%d count=%d\n",		pr_debug("released /dev/fb%d user=%d count=%d\n",
	info->node, user, ufbdev->fb_count);		info->node, user, ufbdev->fb_count);

	return 0;		return 0;

drivers/gpu/drm/udl/udl_main.c

+23 −22

Original line number	Original line	Diff line number	Diff line
	@@ -170,25 +170,19 @@ static void udl_free_urb_list(struct drm_device *dev)
	struct list_head *node;		struct list_head *node;
	struct urb_node *unode;		struct urb_node *unode;
	struct urb *urb;		struct urb *urb;
	int ret;
	unsigned long flags;

	DRM_DEBUG("Waiting for completes and freeing all render urbs\n");		DRM_DEBUG("Waiting for completes and freeing all render urbs\n");

	/* keep waiting and freeing, until we've got 'em all */		/* keep waiting and freeing, until we've got 'em all */
	while (count--) {		while (count--) {
			down(&udl->urbs.limit_sem);

	/* Getting interrupted means a leak, but ok at shutdown*/		spin_lock_irq(&udl->urbs.lock);
	ret = down_interruptible(&udl->urbs.limit_sem);
	if (ret)
	break;

	spin_lock_irqsave(&udl->urbs.lock, flags);

	node = udl->urbs.list.next; /* have reserved one with sem */		node = udl->urbs.list.next; /* have reserved one with sem */
	list_del_init(node);		list_del_init(node);

	spin_unlock_irqrestore(&udl->urbs.lock, flags);		spin_unlock_irq(&udl->urbs.lock);

	unode = list_entry(node, struct urb_node, entry);		unode = list_entry(node, struct urb_node, entry);
	urb = unode->urb;		urb = unode->urb;
	@@ -205,17 +199,22 @@ static void udl_free_urb_list(struct drm_device *dev)
	static int udl_alloc_urb_list(struct drm_device *dev, int count, size_t size)		static int udl_alloc_urb_list(struct drm_device *dev, int count, size_t size)
	{		{
	struct udl_device *udl = dev->dev_private;		struct udl_device *udl = dev->dev_private;
	int i = 0;
	struct urb *urb;		struct urb *urb;
	struct urb_node *unode;		struct urb_node *unode;
	char *buf;		char *buf;
			size_t wanted_size = count * size;

	spin_lock_init(&udl->urbs.lock);		spin_lock_init(&udl->urbs.lock);

			retry:
	udl->urbs.size = size;		udl->urbs.size = size;
	INIT_LIST_HEAD(&udl->urbs.list);		INIT_LIST_HEAD(&udl->urbs.list);

	while (i < count) {		sema_init(&udl->urbs.limit_sem, 0);
			udl->urbs.count = 0;
			udl->urbs.available = 0;

			while (udl->urbs.count * size < wanted_size) {
	unode = kzalloc(sizeof(struct urb_node), GFP_KERNEL);		unode = kzalloc(sizeof(struct urb_node), GFP_KERNEL);
	if (!unode)		if (!unode)
	break;		break;
	@@ -231,11 +230,16 @@ static int udl_alloc_urb_list(struct drm_device *dev, int count, size_t size)
	}		}
	unode->urb = urb;		unode->urb = urb;

	buf = usb_alloc_coherent(udl->udev, MAX_TRANSFER, GFP_KERNEL,		buf = usb_alloc_coherent(udl->udev, size, GFP_KERNEL,
	&urb->transfer_dma);		&urb->transfer_dma);
	if (!buf) {		if (!buf) {
	kfree(unode);		kfree(unode);
	usb_free_urb(urb);		usb_free_urb(urb);
			if (size > PAGE_SIZE) {
			size /= 2;
			udl_free_urb_list(dev);
			goto retry;
			}
	break;		break;
	}		}

	@@ -246,16 +250,14 @@ static int udl_alloc_urb_list(struct drm_device *dev, int count, size_t size)

	list_add_tail(&unode->entry, &udl->urbs.list);		list_add_tail(&unode->entry, &udl->urbs.list);

	i++;		up(&udl->urbs.limit_sem);
			udl->urbs.count++;
			udl->urbs.available++;
	}		}

	sema_init(&udl->urbs.limit_sem, i);		DRM_DEBUG("allocated %d %d byte urbs\n", udl->urbs.count, (int) size);
	udl->urbs.count = i;
	udl->urbs.available = i;

	DRM_DEBUG("allocated %d %d byte urbs\n", i, (int) size);		return udl->urbs.count;

	return i;
	}		}

	struct urb udl_get_urb(struct drm_device dev)		struct urb udl_get_urb(struct drm_device dev)
	@@ -265,7 +267,6 @@ struct urb udl_get_urb(struct drm_device dev)
	struct list_head *entry;		struct list_head *entry;
	struct urb_node *unode;		struct urb_node *unode;
	struct urb *urb = NULL;		struct urb *urb = NULL;
	unsigned long flags;

	/* Wait for an in-flight buffer to complete and get re-queued */		/* Wait for an in-flight buffer to complete and get re-queued */
	ret = down_timeout(&udl->urbs.limit_sem, GET_URB_TIMEOUT);		ret = down_timeout(&udl->urbs.limit_sem, GET_URB_TIMEOUT);
	@@ -276,14 +277,14 @@ struct urb udl_get_urb(struct drm_device dev)
	goto error;		goto error;
	}		}

	spin_lock_irqsave(&udl->urbs.lock, flags);		spin_lock_irq(&udl->urbs.lock);

	BUG_ON(list_empty(&udl->urbs.list)); /* reserved one with limit_sem */		BUG_ON(list_empty(&udl->urbs.list)); /* reserved one with limit_sem */
	entry = udl->urbs.list.next;		entry = udl->urbs.list.next;
	list_del_init(entry);		list_del_init(entry);
	udl->urbs.available--;		udl->urbs.available--;

	spin_unlock_irqrestore(&udl->urbs.lock, flags);		spin_unlock_irq(&udl->urbs.lock);

	unode = list_entry(entry, struct urb_node, entry);		unode = list_entry(entry, struct urb_node, entry);
	urb = unode->urb;		urb = unode->urb;

drivers/gpu/drm/udl/udl_modeset.c

+3 −4

Original line number	Original line	Diff line number	Diff line
	@@ -243,7 +243,7 @@ static int udl_crtc_write_mode_to_hw(struct drm_crtc *crtc)

	memcpy(buf, udl->mode_buf, udl->mode_buf_len);		memcpy(buf, udl->mode_buf, udl->mode_buf_len);
	retval = udl_submit_urb(dev, urb, udl->mode_buf_len);		retval = udl_submit_urb(dev, urb, udl->mode_buf_len);
	DRM_INFO("write mode info %d\n", udl->mode_buf_len);		DRM_DEBUG("write mode info %d\n", udl->mode_buf_len);
	return retval;		return retval;
	}		}

	@@ -366,7 +366,6 @@ static int udl_crtc_page_flip(struct drm_crtc *crtc,
	{		{
	struct udl_framebuffer *ufb = to_udl_fb(fb);		struct udl_framebuffer *ufb = to_udl_fb(fb);
	struct drm_device *dev = crtc->dev;		struct drm_device *dev = crtc->dev;
	unsigned long flags;

	struct drm_framebuffer *old_fb = crtc->primary->fb;		struct drm_framebuffer *old_fb = crtc->primary->fb;
	if (old_fb) {		if (old_fb) {
	@@ -377,10 +376,10 @@ static int udl_crtc_page_flip(struct drm_crtc *crtc,

	udl_handle_damage(ufb, 0, 0, fb->width, fb->height);		udl_handle_damage(ufb, 0, 0, fb->width, fb->height);

	spin_lock_irqsave(&dev->event_lock, flags);		spin_lock_irq(&dev->event_lock);
	if (event)		if (event)
	drm_crtc_send_vblank_event(crtc, event);		drm_crtc_send_vblank_event(crtc, event);
	spin_unlock_irqrestore(&dev->event_lock, flags);		spin_unlock_irq(&dev->event_lock);
	crtc->primary->fb = fb;		crtc->primary->fb = fb;

	return 0;		return 0;

drivers/gpu/drm/udl/udl_transfer.c

+20 −26

Original line number	Original line	Diff line number	Diff line
	@@ -13,7 +13,6 @@
	#include <linux/module.h>		#include <linux/module.h>
	#include <linux/slab.h>		#include <linux/slab.h>
	#include <linux/fb.h>		#include <linux/fb.h>
	#include <linux/prefetch.h>
	#include <asm/unaligned.h>		#include <asm/unaligned.h>

	#include <drm/drmP.h>		#include <drm/drmP.h>
	@@ -51,9 +50,6 @@ static int udl_trim_hline(const u8 bback, const u8 bfront, int width_bytes)
	int start = width;		int start = width;
	int end = width;		int end = width;

	prefetch((void *) front);
	prefetch((void *) back);

	for (j = 0; j < width; j++) {		for (j = 0; j < width; j++) {
	if (back[j] != front[j]) {		if (back[j] != front[j]) {
	start = j;		start = j;
	@@ -83,12 +79,12 @@ static inline u16 pixel32_to_be16(const uint32_t pixel)
	((pixel >> 8) & 0xf800));		((pixel >> 8) & 0xf800));
	}		}

	static inline u16 get_pixel_val16(const uint8_t *pixel, int bpp)		static inline u16 get_pixel_val16(const uint8_t *pixel, int log_bpp)
	{		{
	u16 pixel_val16 = 0;		u16 pixel_val16;
	if (bpp == 2)		if (log_bpp == 1)
	pixel_val16 = (const uint16_t )pixel;		pixel_val16 = (const uint16_t )pixel;
	else if (bpp == 4)		else
	pixel_val16 = pixel32_to_be16((const uint32_t )pixel);		pixel_val16 = pixel32_to_be16((const uint32_t )pixel);
	return pixel_val16;		return pixel_val16;
	}		}
	@@ -125,8 +121,9 @@ static void udl_compress_hline16(
	const u8 *const pixel_end,		const u8 *const pixel_end,
	uint32_t *device_address_ptr,		uint32_t *device_address_ptr,
	uint8_t **command_buffer_ptr,		uint8_t **command_buffer_ptr,
	const uint8_t *const cmd_buffer_end, int bpp)		const uint8_t *const cmd_buffer_end, int log_bpp)
	{		{
			const int bpp = 1 << log_bpp;
	const u8 pixel = pixel_start_ptr;		const u8 pixel = pixel_start_ptr;
	uint32_t dev_addr = *device_address_ptr;		uint32_t dev_addr = *device_address_ptr;
	uint8_t cmd = command_buffer_ptr;		uint8_t cmd = command_buffer_ptr;
	@@ -139,8 +136,6 @@ static void udl_compress_hline16(
	const u8 cmd_pixel_start, cmd_pixel_end = NULL;		const u8 cmd_pixel_start, cmd_pixel_end = NULL;
	uint16_t pixel_val16;		uint16_t pixel_val16;

	prefetchw((void ) cmd); / pull in one cache line at least */

	*cmd++ = 0xaf;		*cmd++ = 0xaf;
	*cmd++ = 0x6b;		*cmd++ = 0x6b;
	*cmd++ = (uint8_t) ((dev_addr >> 16) & 0xFF);		*cmd++ = (uint8_t) ((dev_addr >> 16) & 0xFF);
	@@ -153,12 +148,11 @@ static void udl_compress_hline16(
	raw_pixels_count_byte = cmd++; /* we'll know this later */		raw_pixels_count_byte = cmd++; /* we'll know this later */
	raw_pixel_start = pixel;		raw_pixel_start = pixel;

	cmd_pixel_end = pixel + min3(MAX_CMD_PIXELS + 1UL,		cmd_pixel_end = pixel + (min3(MAX_CMD_PIXELS + 1UL,
	(unsigned long)(pixel_end - pixel) / bpp,		(unsigned long)(pixel_end - pixel) >> log_bpp,
	(unsigned long)(cmd_buffer_end - 1 - cmd) / 2) * bpp;		(unsigned long)(cmd_buffer_end - 1 - cmd) / 2) << log_bpp);

	prefetch_range((void *) pixel, cmd_pixel_end - pixel);		pixel_val16 = get_pixel_val16(pixel, log_bpp);
	pixel_val16 = get_pixel_val16(pixel, bpp);

	while (pixel < cmd_pixel_end) {		while (pixel < cmd_pixel_end) {
	const u8 *const start = pixel;		const u8 *const start = pixel;
	@@ -170,7 +164,7 @@ static void udl_compress_hline16(
	pixel += bpp;		pixel += bpp;

	while (pixel < cmd_pixel_end) {		while (pixel < cmd_pixel_end) {
	pixel_val16 = get_pixel_val16(pixel, bpp);		pixel_val16 = get_pixel_val16(pixel, log_bpp);
	if (pixel_val16 != repeating_pixel_val16)		if (pixel_val16 != repeating_pixel_val16)
	break;		break;
	pixel += bpp;		pixel += bpp;
	@@ -179,10 +173,10 @@ static void udl_compress_hline16(
	if (unlikely(pixel > start + bpp)) {		if (unlikely(pixel > start + bpp)) {
	/* go back and fill in raw pixel count */		/* go back and fill in raw pixel count */
	*raw_pixels_count_byte = (((start -		*raw_pixels_count_byte = (((start -
	raw_pixel_start) / bpp) + 1) & 0xFF;		raw_pixel_start) >> log_bpp) + 1) & 0xFF;

	/* immediately after raw data is repeat byte */		/* immediately after raw data is repeat byte */
	*cmd++ = (((pixel - start) / bpp) - 1) & 0xFF;		*cmd++ = (((pixel - start) >> log_bpp) - 1) & 0xFF;

	/* Then start another raw pixel span */		/* Then start another raw pixel span */
	raw_pixel_start = pixel;		raw_pixel_start = pixel;
	@@ -192,14 +186,14 @@ static void udl_compress_hline16(

	if (pixel > raw_pixel_start) {		if (pixel > raw_pixel_start) {
	/* finalize last RAW span */		/* finalize last RAW span */
	*raw_pixels_count_byte = ((pixel-raw_pixel_start) / bpp) & 0xFF;		*raw_pixels_count_byte = ((pixel - raw_pixel_start) >> log_bpp) & 0xFF;
	} else {		} else {
	/* undo unused byte */		/* undo unused byte */
	cmd--;		cmd--;
	}		}

	*cmd_pixels_count_byte = ((pixel - cmd_pixel_start) / bpp) & 0xFF;		*cmd_pixels_count_byte = ((pixel - cmd_pixel_start) >> log_bpp) & 0xFF;
	dev_addr += ((pixel - cmd_pixel_start) / bpp) * 2;		dev_addr += ((pixel - cmd_pixel_start) >> log_bpp) * 2;
	}		}

	if (cmd_buffer_end <= MIN_RLX_CMD_BYTES + cmd) {		if (cmd_buffer_end <= MIN_RLX_CMD_BYTES + cmd) {
	@@ -222,19 +216,19 @@ static void udl_compress_hline16(
	* (that we can only write to, slowly, and can never read), and (optionally)		* (that we can only write to, slowly, and can never read), and (optionally)
	* our shadow copy that tracks what's been sent to that hardware buffer.		* our shadow copy that tracks what's been sent to that hardware buffer.
	*/		*/
	int udl_render_hline(struct drm_device dev, int bpp, struct urb *urb_ptr,		int udl_render_hline(struct drm_device dev, int log_bpp, struct urb *urb_ptr,
	const char front, char *urb_buf_ptr,		const char front, char *urb_buf_ptr,
	u32 byte_offset, u32 device_byte_offset,		u32 byte_offset, u32 device_byte_offset,
	u32 byte_width,		u32 byte_width,
	int ident_ptr, int sent_ptr)		int ident_ptr, int sent_ptr)
	{		{
	const u8 line_start, line_end, *next_pixel;		const u8 line_start, line_end, *next_pixel;
	u32 base16 = 0 + (device_byte_offset / bpp) * 2;		u32 base16 = 0 + (device_byte_offset >> log_bpp) * 2;
	struct urb urb = urb_ptr;		struct urb urb = urb_ptr;
	u8 cmd = urb_buf_ptr;		u8 cmd = urb_buf_ptr;
	u8 cmd_end = (u8 ) urb->transfer_buffer + urb->transfer_buffer_length;		u8 cmd_end = (u8 ) urb->transfer_buffer + urb->transfer_buffer_length;

	BUG_ON(!(bpp == 2 \|\| bpp == 4));		BUG_ON(!(log_bpp == 1 \|\| log_bpp == 2));

	line_start = (u8 *) (front + byte_offset);		line_start = (u8 *) (front + byte_offset);
	next_pixel = line_start;		next_pixel = line_start;
	@@ -244,7 +238,7 @@ int udl_render_hline(struct drm_device dev, int bpp, struct urb *urb_ptr,

	udl_compress_hline16(&next_pixel,		udl_compress_hline16(&next_pixel,
	line_end, &base16,		line_end, &base16,
	(u8 *) &cmd, (u8 ) cmd_end, bpp);		(u8 *) &cmd, (u8 ) cmd_end, log_bpp);

	if (cmd >= cmd_end) {		if (cmd >= cmd_end) {
	int len = cmd - (u8 *) urb->transfer_buffer;		int len = cmd - (u8 *) urb->transfer_buffer;