2 * Copyright (C) 2012 Red Hat
4 * based in parts on udlfb.c:
5 * Copyright (C) 2009 Roberto De Ioris <roberto@unbit.it>
6 * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml@gmail.com>
7 * Copyright (C) 2009 Bernie Thompson <bernie@plugable.com>
9 * This file is subject to the terms and conditions of the GNU General Public
10 * License v2. See the file COPYING in the main directory of this archive for
16 /* -BULK_SIZE as per usb-skeleton. Can we get full page and avoid overhead? */
19 #define NR_USB_REQUEST_CHANNEL 0x12
21 #define MAX_TRANSFER (PAGE_SIZE*16 - BULK_SIZE)
22 #define WRITES_IN_FLIGHT (4)
23 #define MAX_VENDOR_DESCRIPTOR_SIZE 256
25 #define GET_URB_TIMEOUT HZ
26 #define FREE_URB_TIMEOUT (HZ*2)
28 static int udl_parse_vendor_descriptor(struct drm_device
*dev
,
29 struct usb_device
*usbdev
)
31 struct udl_device
*udl
= dev
->dev_private
;
38 buf
= kzalloc(MAX_VENDOR_DESCRIPTOR_SIZE
, GFP_KERNEL
);
43 total_len
= usb_get_descriptor(usbdev
, 0x5f, /* vendor specific */
44 0, desc
, MAX_VENDOR_DESCRIPTOR_SIZE
);
46 DRM_INFO("vendor descriptor length:%x data:%11ph\n",
49 if ((desc
[0] != total_len
) || /* descriptor length */
50 (desc
[1] != 0x5f) || /* vendor descriptor type */
51 (desc
[2] != 0x01) || /* version (2 bytes) */
53 (desc
[4] != total_len
- 2)) /* length after type */
56 desc_end
= desc
+ total_len
;
57 desc
+= 5; /* the fixed header we've already parsed */
59 while (desc
< desc_end
) {
63 key
= le16_to_cpu(*((u16
*) desc
));
69 case 0x0200: { /* max_area */
71 max_area
= le32_to_cpu(*((u32
*)desc
));
72 DRM_DEBUG("DL chip limited to %d pixel modes\n",
74 udl
->sku_pixel_limit
= max_area
;
87 /* allow udlfb to load for now even if firmware unrecognized */
88 DRM_ERROR("Unrecognized vendor firmware descriptor\n");
96 * Need to ensure a channel is selected before submitting URBs
98 static int udl_select_std_channel(struct udl_device
*udl
)
101 u8 set_def_chn
[] = {0x57, 0xCD, 0xDC, 0xA7,
102 0x1C, 0x88, 0x5E, 0x15,
103 0x60, 0xFE, 0xC6, 0x97,
104 0x16, 0x3D, 0x47, 0xF2};
106 ret
= usb_control_msg(udl
->udev
,
107 usb_sndctrlpipe(udl
->udev
, 0),
108 NR_USB_REQUEST_CHANNEL
,
109 (USB_DIR_OUT
| USB_TYPE_VENDOR
), 0, 0,
110 set_def_chn
, sizeof(set_def_chn
),
111 USB_CTRL_SET_TIMEOUT
);
112 return ret
< 0 ? ret
: 0;
115 static void udl_release_urb_work(struct work_struct
*work
)
117 struct urb_node
*unode
= container_of(work
, struct urb_node
,
118 release_urb_work
.work
);
120 up(&unode
->dev
->urbs
.limit_sem
);
123 void udl_urb_completion(struct urb
*urb
)
125 struct urb_node
*unode
= urb
->context
;
126 struct udl_device
*udl
= unode
->dev
;
129 /* sync/async unlink faults aren't errors */
131 if (!(urb
->status
== -ENOENT
||
132 urb
->status
== -ECONNRESET
||
133 urb
->status
== -ESHUTDOWN
)) {
134 DRM_ERROR("%s - nonzero write bulk status received: %d\n",
135 __func__
, urb
->status
);
136 atomic_set(&udl
->lost_pixels
, 1);
140 urb
->transfer_buffer_length
= udl
->urbs
.size
; /* reset to actual */
142 spin_lock_irqsave(&udl
->urbs
.lock
, flags
);
143 list_add_tail(&unode
->entry
, &udl
->urbs
.list
);
144 udl
->urbs
.available
++;
145 spin_unlock_irqrestore(&udl
->urbs
.lock
, flags
);
149 * When using fb_defio, we deadlock if up() is called
150 * while another is waiting. So queue to another process.
153 schedule_delayed_work(&unode
->release_urb_work
, 0);
156 up(&udl
->urbs
.limit_sem
);
159 static void udl_free_urb_list(struct drm_device
*dev
)
161 struct udl_device
*udl
= dev
->dev_private
;
162 int count
= udl
->urbs
.count
;
163 struct list_head
*node
;
164 struct urb_node
*unode
;
169 DRM_DEBUG("Waiting for completes and freeing all render urbs\n");
171 /* keep waiting and freeing, until we've got 'em all */
174 /* Getting interrupted means a leak, but ok at shutdown*/
175 ret
= down_interruptible(&udl
->urbs
.limit_sem
);
179 spin_lock_irqsave(&udl
->urbs
.lock
, flags
);
181 node
= udl
->urbs
.list
.next
; /* have reserved one with sem */
184 spin_unlock_irqrestore(&udl
->urbs
.lock
, flags
);
186 unode
= list_entry(node
, struct urb_node
, entry
);
189 /* Free each separately allocated piece */
190 usb_free_coherent(urb
->dev
, udl
->urbs
.size
,
191 urb
->transfer_buffer
, urb
->transfer_dma
);
198 static int udl_alloc_urb_list(struct drm_device
*dev
, int count
, size_t size
)
200 struct udl_device
*udl
= dev
->dev_private
;
203 struct urb_node
*unode
;
206 spin_lock_init(&udl
->urbs
.lock
);
208 udl
->urbs
.size
= size
;
209 INIT_LIST_HEAD(&udl
->urbs
.list
);
212 unode
= kzalloc(sizeof(struct urb_node
), GFP_KERNEL
);
217 INIT_DELAYED_WORK(&unode
->release_urb_work
,
218 udl_release_urb_work
);
220 urb
= usb_alloc_urb(0, GFP_KERNEL
);
227 buf
= usb_alloc_coherent(udl
->udev
, MAX_TRANSFER
, GFP_KERNEL
,
235 /* urb->transfer_buffer_length set to actual before submit */
236 usb_fill_bulk_urb(urb
, udl
->udev
, usb_sndbulkpipe(udl
->udev
, 1),
237 buf
, size
, udl_urb_completion
, unode
);
238 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
240 list_add_tail(&unode
->entry
, &udl
->urbs
.list
);
245 sema_init(&udl
->urbs
.limit_sem
, i
);
247 udl
->urbs
.available
= i
;
249 DRM_DEBUG("allocated %d %d byte urbs\n", i
, (int) size
);
254 struct urb
*udl_get_urb(struct drm_device
*dev
)
256 struct udl_device
*udl
= dev
->dev_private
;
258 struct list_head
*entry
;
259 struct urb_node
*unode
;
260 struct urb
*urb
= NULL
;
263 /* Wait for an in-flight buffer to complete and get re-queued */
264 ret
= down_timeout(&udl
->urbs
.limit_sem
, GET_URB_TIMEOUT
);
266 atomic_set(&udl
->lost_pixels
, 1);
267 DRM_INFO("wait for urb interrupted: %x available: %d\n",
268 ret
, udl
->urbs
.available
);
272 spin_lock_irqsave(&udl
->urbs
.lock
, flags
);
274 BUG_ON(list_empty(&udl
->urbs
.list
)); /* reserved one with limit_sem */
275 entry
= udl
->urbs
.list
.next
;
276 list_del_init(entry
);
277 udl
->urbs
.available
--;
279 spin_unlock_irqrestore(&udl
->urbs
.lock
, flags
);
281 unode
= list_entry(entry
, struct urb_node
, entry
);
288 int udl_submit_urb(struct drm_device
*dev
, struct urb
*urb
, size_t len
)
290 struct udl_device
*udl
= dev
->dev_private
;
293 BUG_ON(len
> udl
->urbs
.size
);
295 urb
->transfer_buffer_length
= len
; /* set to actual payload len */
296 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
298 udl_urb_completion(urb
); /* because no one else will */
299 atomic_set(&udl
->lost_pixels
, 1);
300 DRM_ERROR("usb_submit_urb error %x\n", ret
);
305 int udl_driver_load(struct drm_device
*dev
, unsigned long flags
)
307 struct usb_device
*udev
= (void*)flags
;
308 struct udl_device
*udl
;
312 udl
= kzalloc(sizeof(struct udl_device
), GFP_KERNEL
);
318 dev
->dev_private
= udl
;
320 if (!udl_parse_vendor_descriptor(dev
, udl
->udev
)) {
322 DRM_ERROR("firmware not recognized. Assume incompatible device\n");
326 if (udl_select_std_channel(udl
))
327 DRM_ERROR("Selecting channel failed\n");
329 if (!udl_alloc_urb_list(dev
, WRITES_IN_FLIGHT
, MAX_TRANSFER
)) {
330 DRM_ERROR("udl_alloc_urb_list failed\n");
335 ret
= udl_modeset_init(dev
);
339 ret
= udl_fbdev_init(dev
);
343 ret
= drm_vblank_init(dev
, 1);
349 udl_fbdev_cleanup(dev
);
352 udl_free_urb_list(dev
);
354 DRM_ERROR("%d\n", ret
);
358 int udl_drop_usb(struct drm_device
*dev
)
360 udl_free_urb_list(dev
);
364 int udl_driver_unload(struct drm_device
*dev
)
366 struct udl_device
*udl
= dev
->dev_private
;
368 drm_vblank_cleanup(dev
);
371 udl_free_urb_list(dev
);
373 udl_fbdev_cleanup(dev
);
374 udl_modeset_cleanup(dev
);