udl_main.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright (C) 2012 Red Hat
  4 *
  5 * based in parts on udlfb.c:
  6 * Copyright (C) 2009 Roberto De Ioris <roberto@unbit.it>
  7 * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml@gmail.com>
  8 * Copyright (C) 2009 Bernie Thompson <bernie@plugable.com>
  9 */
 10
 11#include <linux/unaligned.h>
 12
 13#include <drm/drm.h>
 14#include <drm/drm_print.h>
 15#include <drm/drm_probe_helper.h>
 16
 17#include "udl_drv.h"
 18
 19/* -BULK_SIZE as per usb-skeleton. Can we get full page and avoid overhead? */
 20#define BULK_SIZE 512
 21
 22#define NR_USB_REQUEST_CHANNEL 0x12
 23
 24#define MAX_TRANSFER (PAGE_SIZE*16 - BULK_SIZE)
 25#define WRITES_IN_FLIGHT (20)
 26#define MAX_VENDOR_DESCRIPTOR_SIZE 256
 27
 28#define UDL_SKU_PIXEL_LIMIT_DEFAULT	2080000
 29
 30static struct urb *udl_get_urb_locked(struct udl_device *udl, long timeout);
 31
 32/*
 33 * Try to make sense of whatever we parse. Therefore return @end on
 34 * errors, but don't fail hard.
 35 */
 36static const u8 *udl_parse_key_value_pair(struct udl_device *udl, const u8 *pos, const u8 *end)
 37{
 38	u16 key;
 39	u8 len;
 40
 41	/* read key */
 42	if (pos >= end - 2)
 43		return end;
 44	key = get_unaligned_le16(pos);
 45	pos += 2;
 46
 47	/* read value length */
 48	if (pos >= end - 1)
 49		return end;
 50	len = *pos++;
 51
 52	/* read value */
 53	if (pos >= end - len)
 54		return end;
 55	switch (key) {
 56	case 0x0200: { /* maximum number of pixels */
 57		unsigned int sku_pixel_limit;
 58
 59		if (len < sizeof(__le32))
 60			break;
 61		sku_pixel_limit = get_unaligned_le32(pos);
 62		if (sku_pixel_limit >= 16 * UDL_SKU_PIXEL_LIMIT_DEFAULT)
 63			break; /* almost 100 MiB, so probably bogus */
 64		udl->sku_pixel_limit = sku_pixel_limit;
 65		break;
 66	}
 67	default:
 68		break;
 69	}
 70	pos += len;
 71
 72	return pos;
 73}
 74
 75static int udl_parse_vendor_descriptor(struct udl_device *udl)
 76{
 77	struct drm_device *dev = &udl->drm;
 78	struct usb_device *udev = udl_to_usb_device(udl);
 79	bool detected = false;
 80	void *buf;
 81	int ret;
 82	unsigned int len;
 83	const u8 *desc;
 84	const u8 *desc_end;
 85
 86	buf = kzalloc(MAX_VENDOR_DESCRIPTOR_SIZE, GFP_KERNEL);
 87	if (!buf)
 88		return -ENOMEM;
 89
 90	ret = usb_get_descriptor(udev, 0x5f, /* vendor specific */
 91				 0, buf, MAX_VENDOR_DESCRIPTOR_SIZE);
 92	if (ret < 0)
 93		goto out;
 94	len = ret;
 95
 96	if (len < 5)
 97		goto out;
 98
 99	desc = buf;
100	desc_end = desc + len;
101
102	if ((desc[0] != len) ||    /* descriptor length */
103	    (desc[1] != 0x5f) ||   /* vendor descriptor type */
104	    (desc[2] != 0x01) ||   /* version (2 bytes) */
105	    (desc[3] != 0x00) ||
106	    (desc[4] != len - 2))  /* length after type */
107		goto out;
108	desc += 5;
109
110	detected = true;
111
112	while (desc < desc_end)
113		desc = udl_parse_key_value_pair(udl, desc, desc_end);
114
115out:
116	if (!detected)
117		drm_warn(dev, "Unrecognized vendor firmware descriptor\n");
118	kfree(buf);
119
120	return 0;
121}
122
123/*
124 * Need to ensure a channel is selected before submitting URBs
125 */
126int udl_select_std_channel(struct udl_device *udl)
127{
128	static const u8 set_def_chn[] = {0x57, 0xCD, 0xDC, 0xA7,
129					 0x1C, 0x88, 0x5E, 0x15,
130					 0x60, 0xFE, 0xC6, 0x97,
131					 0x16, 0x3D, 0x47, 0xF2};
132
133	void *sendbuf;
134	int ret;
135	struct usb_device *udev = udl_to_usb_device(udl);
136
137	sendbuf = kmemdup(set_def_chn, sizeof(set_def_chn), GFP_KERNEL);
138	if (!sendbuf)
139		return -ENOMEM;
140
141	ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
142			      NR_USB_REQUEST_CHANNEL,
143			      (USB_DIR_OUT | USB_TYPE_VENDOR), 0, 0,
144			      sendbuf, sizeof(set_def_chn),
145			      USB_CTRL_SET_TIMEOUT);
146	kfree(sendbuf);
147	return ret < 0 ? ret : 0;
148}
149
150void udl_urb_completion(struct urb *urb)
151{
152	struct urb_node *unode = urb->context;
153	struct udl_device *udl = unode->dev;
154	unsigned long flags;
155
156	/* sync/async unlink faults aren't errors */
157	if (urb->status) {
158		if (!(urb->status == -ENOENT ||
159		    urb->status == -ECONNRESET ||
160		    urb->status == -EPROTO ||
161		    urb->status == -ESHUTDOWN)) {
162			DRM_ERROR("%s - nonzero write bulk status received: %d\n",
163				__func__, urb->status);
164		}
165	}
166
167	urb->transfer_buffer_length = udl->urbs.size; /* reset to actual */
168
169	spin_lock_irqsave(&udl->urbs.lock, flags);
170	list_add_tail(&unode->entry, &udl->urbs.list);
171	udl->urbs.available++;
172	spin_unlock_irqrestore(&udl->urbs.lock, flags);
173
174	wake_up(&udl->urbs.sleep);
175}
176
177static void udl_free_urb_list(struct udl_device *udl)
178{
179	struct urb_node *unode;
180	struct urb *urb;
181
182	DRM_DEBUG("Waiting for completes and freeing all render urbs\n");
183
184	/* keep waiting and freeing, until we've got 'em all */
185	while (udl->urbs.count) {
186		spin_lock_irq(&udl->urbs.lock);
187		urb = udl_get_urb_locked(udl, MAX_SCHEDULE_TIMEOUT);
188		udl->urbs.count--;
189		spin_unlock_irq(&udl->urbs.lock);
190		if (WARN_ON(!urb))
191			break;
192		unode = urb->context;
193		/* Free each separately allocated piece */
194		usb_free_coherent(urb->dev, udl->urbs.size,
195				  urb->transfer_buffer, urb->transfer_dma);
196		usb_free_urb(urb);
197		kfree(unode);
198	}
199
200	wake_up_all(&udl->urbs.sleep);
201}
202
203static int udl_alloc_urb_list(struct udl_device *udl, int count, size_t size)
204{
205	struct urb *urb;
206	struct urb_node *unode;
207	char *buf;
208	size_t wanted_size = count * size;
209	struct usb_device *udev = udl_to_usb_device(udl);
210
211	spin_lock_init(&udl->urbs.lock);
212	INIT_LIST_HEAD(&udl->urbs.list);
213	init_waitqueue_head(&udl->urbs.sleep);
214	udl->urbs.count = 0;
215	udl->urbs.available = 0;
216
217retry:
218	udl->urbs.size = size;
219
220	while (udl->urbs.count * size < wanted_size) {
221		unode = kzalloc(sizeof(struct urb_node), GFP_KERNEL);
222		if (!unode)
223			break;
224		unode->dev = udl;
225
226		urb = usb_alloc_urb(0, GFP_KERNEL);
227		if (!urb) {
228			kfree(unode);
229			break;
230		}
231		unode->urb = urb;
232
233		buf = usb_alloc_coherent(udev, size, GFP_KERNEL,
234					 &urb->transfer_dma);
235		if (!buf) {
236			kfree(unode);
237			usb_free_urb(urb);
238			if (size > PAGE_SIZE) {
239				size /= 2;
240				udl_free_urb_list(udl);
241				goto retry;
242			}
243			break;
244		}
245
246		/* urb->transfer_buffer_length set to actual before submit */
247		usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, 1),
248				  buf, size, udl_urb_completion, unode);
249		urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
250
251		list_add_tail(&unode->entry, &udl->urbs.list);
252
253		udl->urbs.count++;
254		udl->urbs.available++;
255	}
256
257	DRM_DEBUG("allocated %d %d byte urbs\n", udl->urbs.count, (int) size);
258
259	return udl->urbs.count;
260}
261
262static struct urb *udl_get_urb_locked(struct udl_device *udl, long timeout)
263{
264	struct urb_node *unode;
265
266	assert_spin_locked(&udl->urbs.lock);
267
268	/* Wait for an in-flight buffer to complete and get re-queued */
269	if (!wait_event_lock_irq_timeout(udl->urbs.sleep,
270					 !udl->urbs.count ||
271					 !list_empty(&udl->urbs.list),
272					 udl->urbs.lock, timeout)) {
273		DRM_INFO("wait for urb interrupted: available: %d\n",
274			 udl->urbs.available);
275		return NULL;
276	}
277
278	if (!udl->urbs.count)
279		return NULL;
280
281	unode = list_first_entry(&udl->urbs.list, struct urb_node, entry);
282	list_del_init(&unode->entry);
283	udl->urbs.available--;
284
285	return unode->urb;
286}
287
288#define GET_URB_TIMEOUT	HZ
289struct urb *udl_get_urb(struct udl_device *udl)
290{
291	struct urb *urb;
292
293	spin_lock_irq(&udl->urbs.lock);
294	urb = udl_get_urb_locked(udl, GET_URB_TIMEOUT);
295	spin_unlock_irq(&udl->urbs.lock);
296	return urb;
297}
298
299int udl_submit_urb(struct udl_device *udl, struct urb *urb, size_t len)
300{
301	int ret;
302
303	if (WARN_ON(len > udl->urbs.size)) {
304		ret = -EINVAL;
305		goto error;
306	}
307	urb->transfer_buffer_length = len; /* set to actual payload len */
308	ret = usb_submit_urb(urb, GFP_ATOMIC);
309 error:
310	if (ret) {
311		udl_urb_completion(urb); /* because no one else will */
312		DRM_ERROR("usb_submit_urb error %x\n", ret);
313	}
314	return ret;
315}
316
317/* wait until all pending URBs have been processed */
318void udl_sync_pending_urbs(struct udl_device *udl)
319{
320	struct drm_device *dev = &udl->drm;
321
322	spin_lock_irq(&udl->urbs.lock);
323	/* 2 seconds as a sane timeout */
324	if (!wait_event_lock_irq_timeout(udl->urbs.sleep,
325					 udl->urbs.available == udl->urbs.count,
326					 udl->urbs.lock,
327					 msecs_to_jiffies(2000)))
328		drm_err(dev, "Timeout for syncing pending URBs\n");
329	spin_unlock_irq(&udl->urbs.lock);
330}
331
332int udl_init(struct udl_device *udl)
333{
334	struct drm_device *dev = &udl->drm;
335	int ret = -ENOMEM;
336	struct device *dma_dev;
337
338	DRM_DEBUG("\n");
339
340	dma_dev = usb_intf_get_dma_device(to_usb_interface(dev->dev));
341	if (dma_dev) {
342		drm_dev_set_dma_dev(dev, dma_dev);
343		put_device(dma_dev);
344	} else {
345		drm_warn(dev, "buffer sharing not supported"); /* not an error */
346	}
347
348	/*
349	 * Not all devices provide vendor descriptors with device
350	 * information. Initialize to default values of real-world
351	 * devices. It is just enough memory for FullHD.
352	 */
353	udl->sku_pixel_limit = UDL_SKU_PIXEL_LIMIT_DEFAULT;
354
355	ret = udl_parse_vendor_descriptor(udl);
356	if (ret)
357		goto err;
358
359	if (udl_select_std_channel(udl))
360		DRM_ERROR("Selecting channel failed\n");
361
362	if (!udl_alloc_urb_list(udl, WRITES_IN_FLIGHT, MAX_TRANSFER)) {
363		DRM_ERROR("udl_alloc_urb_list failed\n");
364		ret = -ENOMEM;
365		goto err;
366	}
367
368	DRM_DEBUG("\n");
369	ret = udl_modeset_init(udl);
370	if (ret)
371		goto err;
372
373	return 0;
374
375err:
376	if (udl->urbs.count)
377		udl_free_urb_list(udl);
378	DRM_ERROR("%d\n", ret);
379	return ret;
380}
381
382int udl_drop_usb(struct udl_device *udl)
383{
384	udl_free_urb_list(udl);
385
386	return 0;
387}