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 <drm/drm.h> 12 #include <drm/drm_print.h> 13 #include <drm/drm_probe_helper.h> 14 15 #include "udl_drv.h" 16 17 /* -BULK_SIZE as per usb-skeleton. Can we get full page and avoid overhead? */ 18 #define BULK_SIZE 512 19 20 #define NR_USB_REQUEST_CHANNEL 0x12 21 22 #define MAX_TRANSFER (PAGE_SIZE*16 - BULK_SIZE) 23 #define WRITES_IN_FLIGHT (4) 24 #define MAX_VENDOR_DESCRIPTOR_SIZE 256 25 26 static int udl_parse_vendor_descriptor(struct udl_device *udl) 27 { 28 struct usb_device *udev = udl_to_usb_device(udl); 29 char *desc; 30 char *buf; 31 char *desc_end; 32 33 u8 total_len = 0; 34 35 buf = kzalloc(MAX_VENDOR_DESCRIPTOR_SIZE, GFP_KERNEL); 36 if (!buf) 37 return false; 38 desc = buf; 39 40 total_len = usb_get_descriptor(udev, 0x5f, /* vendor specific */ 41 0, desc, MAX_VENDOR_DESCRIPTOR_SIZE); 42 if (total_len > 5) { 43 DRM_INFO("vendor descriptor length:%x data:%11ph\n", 44 total_len, desc); 45 46 if ((desc[0] != total_len) || /* descriptor length */ 47 (desc[1] != 0x5f) || /* vendor descriptor type */ 48 (desc[2] != 0x01) || /* version (2 bytes) */ 49 (desc[3] != 0x00) || 50 (desc[4] != total_len - 2)) /* length after type */ 51 goto unrecognized; 52 53 desc_end = desc + total_len; 54 desc += 5; /* the fixed header we've already parsed */ 55 56 while (desc < desc_end) { 57 u8 length; 58 u16 key; 59 60 key = le16_to_cpu(*((u16 *) desc)); 61 desc += sizeof(u16); 62 length = *desc; 63 desc++; 64 65 switch (key) { 66 case 0x0200: { /* max_area */ 67 u32 max_area; 68 max_area = le32_to_cpu(*((u32 *)desc)); 69 DRM_DEBUG("DL chip limited to %d pixel modes\n", 70 max_area); 71 udl->sku_pixel_limit = max_area; 72 break; 73 } 74 default: 75 break; 76 } 77 desc += length; 78 } 79 } 80 81 goto success; 82 83 unrecognized: 84 /* allow udlfb to load for now even if firmware unrecognized */ 85 DRM_ERROR("Unrecognized vendor firmware descriptor\n"); 86 87 success: 88 kfree(buf); 89 return true; 90 } 91 92 /* 93 * Need to ensure a channel is selected before submitting URBs 94 */ 95 static int udl_select_std_channel(struct udl_device *udl) 96 { 97 static const u8 set_def_chn[] = {0x57, 0xCD, 0xDC, 0xA7, 98 0x1C, 0x88, 0x5E, 0x15, 99 0x60, 0xFE, 0xC6, 0x97, 100 0x16, 0x3D, 0x47, 0xF2}; 101 102 void *sendbuf; 103 int ret; 104 struct usb_device *udev = udl_to_usb_device(udl); 105 106 sendbuf = kmemdup(set_def_chn, sizeof(set_def_chn), GFP_KERNEL); 107 if (!sendbuf) 108 return -ENOMEM; 109 110 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 111 NR_USB_REQUEST_CHANNEL, 112 (USB_DIR_OUT | USB_TYPE_VENDOR), 0, 0, 113 sendbuf, sizeof(set_def_chn), 114 USB_CTRL_SET_TIMEOUT); 115 kfree(sendbuf); 116 return ret < 0 ? ret : 0; 117 } 118 119 void udl_urb_completion(struct urb *urb) 120 { 121 struct urb_node *unode = urb->context; 122 struct udl_device *udl = unode->dev; 123 unsigned long flags; 124 125 /* sync/async unlink faults aren't errors */ 126 if (urb->status) { 127 if (!(urb->status == -ENOENT || 128 urb->status == -ECONNRESET || 129 urb->status == -ESHUTDOWN)) { 130 DRM_ERROR("%s - nonzero write bulk status received: %d\n", 131 __func__, urb->status); 132 } 133 } 134 135 urb->transfer_buffer_length = udl->urbs.size; /* reset to actual */ 136 137 spin_lock_irqsave(&udl->urbs.lock, flags); 138 list_move(&unode->entry, &udl->urbs.list); 139 udl->urbs.available++; 140 spin_unlock_irqrestore(&udl->urbs.lock, flags); 141 142 wake_up(&udl->urbs.sleep); 143 } 144 145 static void udl_free_urb_list(struct drm_device *dev) 146 { 147 struct udl_device *udl = to_udl(dev); 148 int count = udl->urbs.count; 149 struct urb_node *unode; 150 struct urb *urb; 151 152 DRM_DEBUG("Waiting for completes and freeing all render urbs\n"); 153 154 /* keep waiting and freeing, until we've got 'em all */ 155 while (count--) { 156 urb = udl_get_urb_timeout(dev, MAX_SCHEDULE_TIMEOUT); 157 if (WARN_ON(!urb)) 158 break; 159 unode = urb->context; 160 /* Free each separately allocated piece */ 161 usb_free_coherent(urb->dev, udl->urbs.size, 162 urb->transfer_buffer, urb->transfer_dma); 163 usb_free_urb(urb); 164 kfree(unode); 165 } 166 udl->urbs.count = 0; 167 } 168 169 static int udl_alloc_urb_list(struct drm_device *dev, int count, size_t size) 170 { 171 struct udl_device *udl = to_udl(dev); 172 struct urb *urb; 173 struct urb_node *unode; 174 char *buf; 175 size_t wanted_size = count * size; 176 struct usb_device *udev = udl_to_usb_device(udl); 177 178 spin_lock_init(&udl->urbs.lock); 179 180 retry: 181 udl->urbs.size = size; 182 INIT_LIST_HEAD(&udl->urbs.list); 183 INIT_LIST_HEAD(&udl->urbs.in_flight); 184 185 init_waitqueue_head(&udl->urbs.sleep); 186 udl->urbs.count = 0; 187 udl->urbs.available = 0; 188 189 while (udl->urbs.count * size < wanted_size) { 190 unode = kzalloc(sizeof(struct urb_node), GFP_KERNEL); 191 if (!unode) 192 break; 193 unode->dev = udl; 194 195 urb = usb_alloc_urb(0, GFP_KERNEL); 196 if (!urb) { 197 kfree(unode); 198 break; 199 } 200 unode->urb = urb; 201 202 buf = usb_alloc_coherent(udev, size, GFP_KERNEL, 203 &urb->transfer_dma); 204 if (!buf) { 205 kfree(unode); 206 usb_free_urb(urb); 207 if (size > PAGE_SIZE) { 208 size /= 2; 209 udl_free_urb_list(dev); 210 goto retry; 211 } 212 break; 213 } 214 215 /* urb->transfer_buffer_length set to actual before submit */ 216 usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, 1), 217 buf, size, udl_urb_completion, unode); 218 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 219 220 list_add_tail(&unode->entry, &udl->urbs.list); 221 222 udl->urbs.count++; 223 udl->urbs.available++; 224 } 225 226 DRM_DEBUG("allocated %d %d byte urbs\n", udl->urbs.count, (int) size); 227 228 return udl->urbs.count; 229 } 230 231 struct urb *udl_get_urb_timeout(struct drm_device *dev, long timeout) 232 { 233 struct udl_device *udl = to_udl(dev); 234 struct urb_node *unode = NULL; 235 236 if (!udl->urbs.count) 237 return NULL; 238 239 /* Wait for an in-flight buffer to complete and get re-queued */ 240 spin_lock_irq(&udl->urbs.lock); 241 if (!wait_event_lock_irq_timeout(udl->urbs.sleep, 242 !list_empty(&udl->urbs.list), 243 udl->urbs.lock, timeout)) { 244 DRM_INFO("wait for urb interrupted: available: %d\n", 245 udl->urbs.available); 246 goto unlock; 247 } 248 249 unode = list_first_entry(&udl->urbs.list, struct urb_node, entry); 250 list_move(&unode->entry, &udl->urbs.in_flight); 251 udl->urbs.available--; 252 253 unlock: 254 spin_unlock_irq(&udl->urbs.lock); 255 return unode ? unode->urb : NULL; 256 } 257 258 int udl_submit_urb(struct drm_device *dev, struct urb *urb, size_t len) 259 { 260 struct udl_device *udl = to_udl(dev); 261 int ret; 262 263 BUG_ON(len > udl->urbs.size); 264 265 urb->transfer_buffer_length = len; /* set to actual payload len */ 266 ret = usb_submit_urb(urb, GFP_ATOMIC); 267 if (ret) { 268 udl_urb_completion(urb); /* because no one else will */ 269 DRM_ERROR("usb_submit_urb error %x\n", ret); 270 } 271 return ret; 272 } 273 274 /* wait until all pending URBs have been processed */ 275 int udl_sync_pending_urbs(struct drm_device *dev) 276 { 277 struct udl_device *udl = to_udl(dev); 278 int ret = 0; 279 280 spin_lock_irq(&udl->urbs.lock); 281 /* 2 seconds as a sane timeout */ 282 if (!wait_event_lock_irq_timeout(udl->urbs.sleep, 283 list_empty(&udl->urbs.in_flight), 284 udl->urbs.lock, 285 msecs_to_jiffies(2000))) 286 ret = -ETIMEDOUT; 287 spin_unlock_irq(&udl->urbs.lock); 288 return ret; 289 } 290 291 /* kill pending URBs */ 292 void udl_kill_pending_urbs(struct drm_device *dev) 293 { 294 struct udl_device *udl = to_udl(dev); 295 struct urb_node *unode; 296 297 spin_lock_irq(&udl->urbs.lock); 298 while (!list_empty(&udl->urbs.in_flight)) { 299 unode = list_first_entry(&udl->urbs.in_flight, 300 struct urb_node, entry); 301 spin_unlock_irq(&udl->urbs.lock); 302 usb_kill_urb(unode->urb); 303 spin_lock_irq(&udl->urbs.lock); 304 } 305 spin_unlock_irq(&udl->urbs.lock); 306 } 307 308 int udl_init(struct udl_device *udl) 309 { 310 struct drm_device *dev = &udl->drm; 311 int ret = -ENOMEM; 312 313 DRM_DEBUG("\n"); 314 315 udl->dmadev = usb_intf_get_dma_device(to_usb_interface(dev->dev)); 316 if (!udl->dmadev) 317 drm_warn(dev, "buffer sharing not supported"); /* not an error */ 318 319 mutex_init(&udl->gem_lock); 320 321 if (!udl_parse_vendor_descriptor(udl)) { 322 ret = -ENODEV; 323 DRM_ERROR("firmware not recognized. Assume incompatible device\n"); 324 goto err; 325 } 326 327 if (udl_select_std_channel(udl)) 328 DRM_ERROR("Selecting channel failed\n"); 329 330 if (!udl_alloc_urb_list(dev, WRITES_IN_FLIGHT, MAX_TRANSFER)) { 331 DRM_ERROR("udl_alloc_urb_list failed\n"); 332 goto err; 333 } 334 335 DRM_DEBUG("\n"); 336 ret = udl_modeset_init(dev); 337 if (ret) 338 goto err; 339 340 drm_kms_helper_poll_init(dev); 341 342 return 0; 343 344 err: 345 if (udl->urbs.count) 346 udl_free_urb_list(dev); 347 put_device(udl->dmadev); 348 DRM_ERROR("%d\n", ret); 349 return ret; 350 } 351 352 int udl_drop_usb(struct drm_device *dev) 353 { 354 struct udl_device *udl = to_udl(dev); 355 356 udl_kill_pending_urbs(dev); 357 udl_free_urb_list(dev); 358 put_device(udl->dmadev); 359 udl->dmadev = NULL; 360 361 return 0; 362 } 363