Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/drivers/input/touchscreen/sur40.c

  1 /*
  2  * Surface2.0/SUR40/PixelSense input driver
  3  *
  4  * Copyright (c) 2014 by Florian 'floe' Echtler <floe@butterbrot.org>
  5  *
  6  * Derived from the USB Skeleton driver 1.1,
  7  * Copyright (c) 2003 Greg Kroah-Hartman (greg@kroah.com)
  8  *
  9  * and from the Apple USB BCM5974 multitouch driver,
 10  * Copyright (c) 2008 Henrik Rydberg (rydberg@euromail.se)
 11  *
 12  * and from the generic hid-multitouch driver,
 13  * Copyright (c) 2010-2012 Stephane Chatty <chatty@enac.fr>
 14  *
 15  * and from the v4l2-pci-skeleton driver,
 16  * Copyright (c) Copyright 2014 Cisco Systems, Inc.
 17  *
 18  * This program is free software; you can redistribute it and/or
 19  * modify it under the terms of the GNU General Public License as
 20  * published by the Free Software Foundation; either version 2 of
 21  * the License, or (at your option) any later version.
 22  */
 23 
 24 #include <linux/kernel.h>
 25 #include <linux/errno.h>
 26 #include <linux/delay.h>
 27 #include <linux/init.h>
 28 #include <linux/slab.h>
 29 #include <linux/module.h>
 30 #include <linux/completion.h>
 31 #include <linux/uaccess.h>
 32 #include <linux/usb.h>
 33 #include <linux/printk.h>
 34 #include <linux/input-polldev.h>
 35 #include <linux/input/mt.h>
 36 #include <linux/usb/input.h>
 37 #include <linux/videodev2.h>
 38 #include <media/v4l2-device.h>
 39 #include <media/v4l2-dev.h>
 40 #include <media/v4l2-ioctl.h>
 41 #include <media/videobuf2-dma-sg.h>
 42 
 43 /* read 512 bytes from endpoint 0x86 -> get header + blobs */
 44 struct sur40_header {
 45 
 46         __le16 type;       /* always 0x0001 */
 47         __le16 count;      /* count of blobs (if 0: continue prev. packet) */
 48 
 49         __le32 packet_id;  /* unique ID for all packets in one frame */
 50 
 51         __le32 timestamp;  /* milliseconds (inc. by 16 or 17 each frame) */
 52         __le32 unknown;    /* "epoch?" always 02/03 00 00 00 */
 53 
 54 } __packed;
 55 
 56 struct sur40_blob {
 57 
 58         __le16 blob_id;
 59 
 60         u8 action;         /* 0x02 = enter/exit, 0x03 = update (?) */
 61         u8 unknown;        /* always 0x01 or 0x02 (no idea what this is?) */
 62 
 63         __le16 bb_pos_x;   /* upper left corner of bounding box */
 64         __le16 bb_pos_y;
 65 
 66         __le16 bb_size_x;  /* size of bounding box */
 67         __le16 bb_size_y;
 68 
 69         __le16 pos_x;      /* finger tip position */
 70         __le16 pos_y;
 71 
 72         __le16 ctr_x;      /* centroid position */
 73         __le16 ctr_y;
 74 
 75         __le16 axis_x;     /* somehow related to major/minor axis, mostly: */
 76         __le16 axis_y;     /* axis_x == bb_size_y && axis_y == bb_size_x */
 77 
 78         __le32 angle;      /* orientation in radians relative to x axis -
 79                               actually an IEEE754 float, don't use in kernel */
 80 
 81         __le32 area;       /* size in pixels/pressure (?) */
 82 
 83         u8 padding[32];
 84 
 85 } __packed;
 86 
 87 /* combined header/blob data */
 88 struct sur40_data {
 89         struct sur40_header header;
 90         struct sur40_blob   blobs[];
 91 } __packed;
 92 
 93 /* read 512 bytes from endpoint 0x82 -> get header below
 94  * continue reading 16k blocks until header.size bytes read */
 95 struct sur40_image_header {
 96         __le32 magic;     /* "SUBF" */
 97         __le32 packet_id;
 98         __le32 size;      /* always 0x0007e900 = 960x540 */
 99         __le32 timestamp; /* milliseconds (increases by 16 or 17 each frame) */
100         __le32 unknown;   /* "epoch?" always 02/03 00 00 00 */
101 } __packed;
102 
103 /* version information */
104 #define DRIVER_SHORT   "sur40"
105 #define DRIVER_LONG    "Samsung SUR40"
106 #define DRIVER_AUTHOR  "Florian 'floe' Echtler <floe@butterbrot.org>"
107 #define DRIVER_DESC    "Surface2.0/SUR40/PixelSense input driver"
108 
109 /* vendor and device IDs */
110 #define ID_MICROSOFT 0x045e
111 #define ID_SUR40     0x0775
112 
113 /* sensor resolution */
114 #define SENSOR_RES_X 1920
115 #define SENSOR_RES_Y 1080
116 
117 /* touch data endpoint */
118 #define TOUCH_ENDPOINT 0x86
119 
120 /* video data endpoint */
121 #define VIDEO_ENDPOINT 0x82
122 
123 /* video header fields */
124 #define VIDEO_HEADER_MAGIC 0x46425553
125 #define VIDEO_PACKET_SIZE  16384
126 
127 /* polling interval (ms) */
128 #define POLL_INTERVAL 10
129 
130 /* maximum number of contacts FIXME: this is a guess? */
131 #define MAX_CONTACTS 64
132 
133 /* control commands */
134 #define SUR40_GET_VERSION 0xb0 /* 12 bytes string    */
135 #define SUR40_UNKNOWN1    0xb3 /*  5 bytes           */
136 #define SUR40_UNKNOWN2    0xc1 /* 24 bytes           */
137 
138 #define SUR40_GET_STATE   0xc5 /*  4 bytes state (?) */
139 #define SUR40_GET_SENSORS 0xb1 /*  8 bytes sensors   */
140 
141 /* master device state */
142 struct sur40_state {
143 
144         struct usb_device *usbdev;
145         struct device *dev;
146         struct input_polled_dev *input;
147 
148         struct v4l2_device v4l2;
149         struct video_device vdev;
150         struct mutex lock;
151 
152         struct vb2_queue queue;
153         struct vb2_alloc_ctx *alloc_ctx;
154         struct list_head buf_list;
155         spinlock_t qlock;
156         int sequence;
157 
158         struct sur40_data *bulk_in_buffer;
159         size_t bulk_in_size;
160         u8 bulk_in_epaddr;
161 
162         char phys[64];
163 };
164 
165 struct sur40_buffer {
166         struct vb2_buffer vb;
167         struct list_head list;
168 };
169 
170 /* forward declarations */
171 static const struct video_device sur40_video_device;
172 static const struct v4l2_pix_format sur40_video_format;
173 static const struct vb2_queue sur40_queue;
174 static void sur40_process_video(struct sur40_state *sur40);
175 
176 /*
177  * Note: an earlier, non-public version of this driver used USB_RECIP_ENDPOINT
178  * here by mistake which is very likely to have corrupted the firmware EEPROM
179  * on two separate SUR40 devices. Thanks to Alan Stern who spotted this bug.
180  * Should you ever run into a similar problem, the background story to this
181  * incident and instructions on how to fix the corrupted EEPROM are available
182  * at https://floe.butterbrot.org/matrix/hacking/surface/brick.html
183 */
184 
185 /* command wrapper */
186 static int sur40_command(struct sur40_state *dev,
187                          u8 command, u16 index, void *buffer, u16 size)
188 {
189         return usb_control_msg(dev->usbdev, usb_rcvctrlpipe(dev->usbdev, 0),
190                                command,
191                                USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
192                                0x00, index, buffer, size, 1000);
193 }
194 
195 /* Initialization routine, called from sur40_open */
196 static int sur40_init(struct sur40_state *dev)
197 {
198         int result;
199         u8 buffer[24];
200 
201         /* stupidly replay the original MS driver init sequence */
202         result = sur40_command(dev, SUR40_GET_VERSION, 0x00, buffer, 12);
203         if (result < 0)
204                 return result;
205 
206         result = sur40_command(dev, SUR40_GET_VERSION, 0x01, buffer, 12);
207         if (result < 0)
208                 return result;
209 
210         result = sur40_command(dev, SUR40_GET_VERSION, 0x02, buffer, 12);
211         if (result < 0)
212                 return result;
213 
214         result = sur40_command(dev, SUR40_UNKNOWN2,    0x00, buffer, 24);
215         if (result < 0)
216                 return result;
217 
218         result = sur40_command(dev, SUR40_UNKNOWN1,    0x00, buffer,  5);
219         if (result < 0)
220                 return result;
221 
222         result = sur40_command(dev, SUR40_GET_VERSION, 0x03, buffer, 12);
223 
224         /*
225          * Discard the result buffer - no known data inside except
226          * some version strings, maybe extract these sometime...
227          */
228 
229         return result;
230 }
231 
232 /*
233  * Callback routines from input_polled_dev
234  */
235 
236 /* Enable the device, polling will now start. */
237 static void sur40_open(struct input_polled_dev *polldev)
238 {
239         struct sur40_state *sur40 = polldev->private;
240 
241         dev_dbg(sur40->dev, "open\n");
242         sur40_init(sur40);
243 }
244 
245 /* Disable device, polling has stopped. */
246 static void sur40_close(struct input_polled_dev *polldev)
247 {
248         struct sur40_state *sur40 = polldev->private;
249 
250         dev_dbg(sur40->dev, "close\n");
251         /*
252          * There is no known way to stop the device, so we simply
253          * stop polling.
254          */
255 }
256 
257 /*
258  * This function is called when a whole contact has been processed,
259  * so that it can assign it to a slot and store the data there.
260  */
261 static void sur40_report_blob(struct sur40_blob *blob, struct input_dev *input)
262 {
263         int wide, major, minor;
264 
265         int bb_size_x = le16_to_cpu(blob->bb_size_x);
266         int bb_size_y = le16_to_cpu(blob->bb_size_y);
267 
268         int pos_x = le16_to_cpu(blob->pos_x);
269         int pos_y = le16_to_cpu(blob->pos_y);
270 
271         int ctr_x = le16_to_cpu(blob->ctr_x);
272         int ctr_y = le16_to_cpu(blob->ctr_y);
273 
274         int slotnum = input_mt_get_slot_by_key(input, blob->blob_id);
275         if (slotnum < 0 || slotnum >= MAX_CONTACTS)
276                 return;
277 
278         input_mt_slot(input, slotnum);
279         input_mt_report_slot_state(input, MT_TOOL_FINGER, 1);
280         wide = (bb_size_x > bb_size_y);
281         major = max(bb_size_x, bb_size_y);
282         minor = min(bb_size_x, bb_size_y);
283 
284         input_report_abs(input, ABS_MT_POSITION_X, pos_x);
285         input_report_abs(input, ABS_MT_POSITION_Y, pos_y);
286         input_report_abs(input, ABS_MT_TOOL_X, ctr_x);
287         input_report_abs(input, ABS_MT_TOOL_Y, ctr_y);
288 
289         /* TODO: use a better orientation measure */
290         input_report_abs(input, ABS_MT_ORIENTATION, wide);
291         input_report_abs(input, ABS_MT_TOUCH_MAJOR, major);
292         input_report_abs(input, ABS_MT_TOUCH_MINOR, minor);
293 }
294 
295 /* core function: poll for new input data */
296 static void sur40_poll(struct input_polled_dev *polldev)
297 {
298         struct sur40_state *sur40 = polldev->private;
299         struct input_dev *input = polldev->input;
300         int result, bulk_read, need_blobs, packet_blobs, i;
301         u32 uninitialized_var(packet_id);
302 
303         struct sur40_header *header = &sur40->bulk_in_buffer->header;
304         struct sur40_blob *inblob = &sur40->bulk_in_buffer->blobs[0];
305 
306         dev_dbg(sur40->dev, "poll\n");
307 
308         need_blobs = -1;
309 
310         do {
311 
312                 /* perform a blocking bulk read to get data from the device */
313                 result = usb_bulk_msg(sur40->usbdev,
314                         usb_rcvbulkpipe(sur40->usbdev, sur40->bulk_in_epaddr),
315                         sur40->bulk_in_buffer, sur40->bulk_in_size,
316                         &bulk_read, 1000);
317 
318                 dev_dbg(sur40->dev, "received %d bytes\n", bulk_read);
319 
320                 if (result < 0) {
321                         dev_err(sur40->dev, "error in usb_bulk_read\n");
322                         return;
323                 }
324 
325                 result = bulk_read - sizeof(struct sur40_header);
326 
327                 if (result % sizeof(struct sur40_blob) != 0) {
328                         dev_err(sur40->dev, "transfer size mismatch\n");
329                         return;
330                 }
331 
332                 /* first packet? */
333                 if (need_blobs == -1) {
334                         need_blobs = le16_to_cpu(header->count);
335                         dev_dbg(sur40->dev, "need %d blobs\n", need_blobs);
336                         packet_id = le32_to_cpu(header->packet_id);
337                 }
338 
339                 /*
340                  * Sanity check. when video data is also being retrieved, the
341                  * packet ID will usually increase in the middle of a series
342                  * instead of at the end.
343                  */
344                 if (packet_id != header->packet_id)
345                         dev_warn(sur40->dev, "packet ID mismatch\n");
346 
347                 packet_blobs = result / sizeof(struct sur40_blob);
348                 dev_dbg(sur40->dev, "received %d blobs\n", packet_blobs);
349 
350                 /* packets always contain at least 4 blobs, even if empty */
351                 if (packet_blobs > need_blobs)
352                         packet_blobs = need_blobs;
353 
354                 for (i = 0; i < packet_blobs; i++) {
355                         need_blobs--;
356                         dev_dbg(sur40->dev, "processing blob\n");
357                         sur40_report_blob(&(inblob[i]), input);
358                 }
359 
360         } while (need_blobs > 0);
361 
362         input_mt_sync_frame(input);
363         input_sync(input);
364 
365         sur40_process_video(sur40);
366 }
367 
368 /* deal with video data */
369 static void sur40_process_video(struct sur40_state *sur40)
370 {
371 
372         struct sur40_image_header *img = (void *)(sur40->bulk_in_buffer);
373         struct sur40_buffer *new_buf;
374         struct usb_sg_request sgr;
375         struct sg_table *sgt;
376         int result, bulk_read;
377 
378         if (!vb2_start_streaming_called(&sur40->queue))
379                 return;
380 
381         /* get a new buffer from the list */
382         spin_lock(&sur40->qlock);
383         if (list_empty(&sur40->buf_list)) {
384                 dev_dbg(sur40->dev, "buffer queue empty\n");
385                 spin_unlock(&sur40->qlock);
386                 return;
387         }
388         new_buf = list_entry(sur40->buf_list.next, struct sur40_buffer, list);
389         list_del(&new_buf->list);
390         spin_unlock(&sur40->qlock);
391 
392         /* retrieve data via bulk read */
393         result = usb_bulk_msg(sur40->usbdev,
394                         usb_rcvbulkpipe(sur40->usbdev, VIDEO_ENDPOINT),
395                         sur40->bulk_in_buffer, sur40->bulk_in_size,
396                         &bulk_read, 1000);
397 
398         if (result < 0) {
399                 dev_err(sur40->dev, "error in usb_bulk_read\n");
400                 goto err_poll;
401         }
402 
403         if (bulk_read != sizeof(struct sur40_image_header)) {
404                 dev_err(sur40->dev, "received %d bytes (%zd expected)\n",
405                         bulk_read, sizeof(struct sur40_image_header));
406                 goto err_poll;
407         }
408 
409         if (le32_to_cpu(img->magic) != VIDEO_HEADER_MAGIC) {
410                 dev_err(sur40->dev, "image magic mismatch\n");
411                 goto err_poll;
412         }
413 
414         if (le32_to_cpu(img->size) != sur40_video_format.sizeimage) {
415                 dev_err(sur40->dev, "image size mismatch\n");
416                 goto err_poll;
417         }
418 
419         sgt = vb2_dma_sg_plane_desc(&new_buf->vb, 0);
420 
421         result = usb_sg_init(&sgr, sur40->usbdev,
422                 usb_rcvbulkpipe(sur40->usbdev, VIDEO_ENDPOINT), 0,
423                 sgt->sgl, sgt->nents, sur40_video_format.sizeimage, 0);
424         if (result < 0) {
425                 dev_err(sur40->dev, "error %d in usb_sg_init\n", result);
426                 goto err_poll;
427         }
428 
429         usb_sg_wait(&sgr);
430         if (sgr.status < 0) {
431                 dev_err(sur40->dev, "error %d in usb_sg_wait\n", sgr.status);
432                 goto err_poll;
433         }
434 
435         /* mark as finished */
436         v4l2_get_timestamp(&new_buf->vb.v4l2_buf.timestamp);
437         new_buf->vb.v4l2_buf.sequence = sur40->sequence++;
438         new_buf->vb.v4l2_buf.field = V4L2_FIELD_NONE;
439         vb2_buffer_done(&new_buf->vb, VB2_BUF_STATE_DONE);
440         return;
441 
442 err_poll:
443         vb2_buffer_done(&new_buf->vb, VB2_BUF_STATE_ERROR);
444 }
445 
446 /* Initialize input device parameters. */
447 static void sur40_input_setup(struct input_dev *input_dev)
448 {
449         __set_bit(EV_KEY, input_dev->evbit);
450         __set_bit(EV_ABS, input_dev->evbit);
451 
452         input_set_abs_params(input_dev, ABS_MT_POSITION_X,
453                              0, SENSOR_RES_X, 0, 0);
454         input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
455                              0, SENSOR_RES_Y, 0, 0);
456 
457         input_set_abs_params(input_dev, ABS_MT_TOOL_X,
458                              0, SENSOR_RES_X, 0, 0);
459         input_set_abs_params(input_dev, ABS_MT_TOOL_Y,
460                              0, SENSOR_RES_Y, 0, 0);
461 
462         /* max value unknown, but major/minor axis
463          * can never be larger than screen */
464         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
465                              0, SENSOR_RES_X, 0, 0);
466         input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR,
467                              0, SENSOR_RES_Y, 0, 0);
468 
469         input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
470 
471         input_mt_init_slots(input_dev, MAX_CONTACTS,
472                             INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
473 }
474 
475 /* Check candidate USB interface. */
476 static int sur40_probe(struct usb_interface *interface,
477                        const struct usb_device_id *id)
478 {
479         struct usb_device *usbdev = interface_to_usbdev(interface);
480         struct sur40_state *sur40;
481         struct usb_host_interface *iface_desc;
482         struct usb_endpoint_descriptor *endpoint;
483         struct input_polled_dev *poll_dev;
484         int error;
485 
486         /* Check if we really have the right interface. */
487         iface_desc = &interface->altsetting[0];
488         if (iface_desc->desc.bInterfaceClass != 0xFF)
489                 return -ENODEV;
490 
491         /* Use endpoint #4 (0x86). */
492         endpoint = &iface_desc->endpoint[4].desc;
493         if (endpoint->bEndpointAddress != TOUCH_ENDPOINT)
494                 return -ENODEV;
495 
496         /* Allocate memory for our device state and initialize it. */
497         sur40 = kzalloc(sizeof(struct sur40_state), GFP_KERNEL);
498         if (!sur40)
499                 return -ENOMEM;
500 
501         poll_dev = input_allocate_polled_device();
502         if (!poll_dev) {
503                 error = -ENOMEM;
504                 goto err_free_dev;
505         }
506 
507         /* initialize locks/lists */
508         INIT_LIST_HEAD(&sur40->buf_list);
509         spin_lock_init(&sur40->qlock);
510         mutex_init(&sur40->lock);
511 
512         /* Set up polled input device control structure */
513         poll_dev->private = sur40;
514         poll_dev->poll_interval = POLL_INTERVAL;
515         poll_dev->open = sur40_open;
516         poll_dev->poll = sur40_poll;
517         poll_dev->close = sur40_close;
518 
519         /* Set up regular input device structure */
520         sur40_input_setup(poll_dev->input);
521 
522         poll_dev->input->name = DRIVER_LONG;
523         usb_to_input_id(usbdev, &poll_dev->input->id);
524         usb_make_path(usbdev, sur40->phys, sizeof(sur40->phys));
525         strlcat(sur40->phys, "/input0", sizeof(sur40->phys));
526         poll_dev->input->phys = sur40->phys;
527         poll_dev->input->dev.parent = &interface->dev;
528 
529         sur40->usbdev = usbdev;
530         sur40->dev = &interface->dev;
531         sur40->input = poll_dev;
532 
533         /* use the bulk-in endpoint tested above */
534         sur40->bulk_in_size = usb_endpoint_maxp(endpoint);
535         sur40->bulk_in_epaddr = endpoint->bEndpointAddress;
536         sur40->bulk_in_buffer = kmalloc(sur40->bulk_in_size, GFP_KERNEL);
537         if (!sur40->bulk_in_buffer) {
538                 dev_err(&interface->dev, "Unable to allocate input buffer.");
539                 error = -ENOMEM;
540                 goto err_free_polldev;
541         }
542 
543         /* register the polled input device */
544         error = input_register_polled_device(poll_dev);
545         if (error) {
546                 dev_err(&interface->dev,
547                         "Unable to register polled input device.");
548                 goto err_free_buffer;
549         }
550 
551         /* register the video master device */
552         snprintf(sur40->v4l2.name, sizeof(sur40->v4l2.name), "%s", DRIVER_LONG);
553         error = v4l2_device_register(sur40->dev, &sur40->v4l2);
554         if (error) {
555                 dev_err(&interface->dev,
556                         "Unable to register video master device.");
557                 goto err_unreg_v4l2;
558         }
559 
560         /* initialize the lock and subdevice */
561         sur40->queue = sur40_queue;
562         sur40->queue.drv_priv = sur40;
563         sur40->queue.lock = &sur40->lock;
564 
565         /* initialize the queue */
566         error = vb2_queue_init(&sur40->queue);
567         if (error)
568                 goto err_unreg_v4l2;
569 
570         sur40->alloc_ctx = vb2_dma_sg_init_ctx(sur40->dev);
571         if (IS_ERR(sur40->alloc_ctx)) {
572                 dev_err(sur40->dev, "Can't allocate buffer context");
573                 goto err_unreg_v4l2;
574         }
575 
576         sur40->vdev = sur40_video_device;
577         sur40->vdev.v4l2_dev = &sur40->v4l2;
578         sur40->vdev.lock = &sur40->lock;
579         sur40->vdev.queue = &sur40->queue;
580         video_set_drvdata(&sur40->vdev, sur40);
581 
582         error = video_register_device(&sur40->vdev, VFL_TYPE_GRABBER, -1);
583         if (error) {
584                 dev_err(&interface->dev,
585                         "Unable to register video subdevice.");
586                 goto err_unreg_video;
587         }
588 
589         /* we can register the device now, as it is ready */
590         usb_set_intfdata(interface, sur40);
591         dev_dbg(&interface->dev, "%s is now attached\n", DRIVER_DESC);
592 
593         return 0;
594 
595 err_unreg_video:
596         video_unregister_device(&sur40->vdev);
597 err_unreg_v4l2:
598         v4l2_device_unregister(&sur40->v4l2);
599 err_free_buffer:
600         kfree(sur40->bulk_in_buffer);
601 err_free_polldev:
602         input_free_polled_device(sur40->input);
603 err_free_dev:
604         kfree(sur40);
605 
606         return error;
607 }
608 
609 /* Unregister device & clean up. */
610 static void sur40_disconnect(struct usb_interface *interface)
611 {
612         struct sur40_state *sur40 = usb_get_intfdata(interface);
613 
614         video_unregister_device(&sur40->vdev);
615         v4l2_device_unregister(&sur40->v4l2);
616         vb2_dma_sg_cleanup_ctx(sur40->alloc_ctx);
617 
618         input_unregister_polled_device(sur40->input);
619         input_free_polled_device(sur40->input);
620         kfree(sur40->bulk_in_buffer);
621         kfree(sur40);
622 
623         usb_set_intfdata(interface, NULL);
624         dev_dbg(&interface->dev, "%s is now disconnected\n", DRIVER_DESC);
625 }
626 
627 /*
628  * Setup the constraints of the queue: besides setting the number of planes
629  * per buffer and the size and allocation context of each plane, it also
630  * checks if sufficient buffers have been allocated. Usually 3 is a good
631  * minimum number: many DMA engines need a minimum of 2 buffers in the
632  * queue and you need to have another available for userspace processing.
633  */
634 static int sur40_queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
635                        unsigned int *nbuffers, unsigned int *nplanes,
636                        unsigned int sizes[], void *alloc_ctxs[])
637 {
638         struct sur40_state *sur40 = vb2_get_drv_priv(q);
639 
640         if (q->num_buffers + *nbuffers < 3)
641                 *nbuffers = 3 - q->num_buffers;
642 
643         if (fmt && fmt->fmt.pix.sizeimage < sur40_video_format.sizeimage)
644                 return -EINVAL;
645 
646         *nplanes = 1;
647         sizes[0] = fmt ? fmt->fmt.pix.sizeimage : sur40_video_format.sizeimage;
648         alloc_ctxs[0] = sur40->alloc_ctx;
649 
650         return 0;
651 }
652 
653 /*
654  * Prepare the buffer for queueing to the DMA engine: check and set the
655  * payload size.
656  */
657 static int sur40_buffer_prepare(struct vb2_buffer *vb)
658 {
659         struct sur40_state *sur40 = vb2_get_drv_priv(vb->vb2_queue);
660         unsigned long size = sur40_video_format.sizeimage;
661 
662         if (vb2_plane_size(vb, 0) < size) {
663                 dev_err(&sur40->usbdev->dev, "buffer too small (%lu < %lu)\n",
664                          vb2_plane_size(vb, 0), size);
665                 return -EINVAL;
666         }
667 
668         vb2_set_plane_payload(vb, 0, size);
669         return 0;
670 }
671 
672 /*
673  * Queue this buffer to the DMA engine.
674  */
675 static void sur40_buffer_queue(struct vb2_buffer *vb)
676 {
677         struct sur40_state *sur40 = vb2_get_drv_priv(vb->vb2_queue);
678         struct sur40_buffer *buf = (struct sur40_buffer *)vb;
679 
680         spin_lock(&sur40->qlock);
681         list_add_tail(&buf->list, &sur40->buf_list);
682         spin_unlock(&sur40->qlock);
683 }
684 
685 static void return_all_buffers(struct sur40_state *sur40,
686                                enum vb2_buffer_state state)
687 {
688         struct sur40_buffer *buf, *node;
689 
690         spin_lock(&sur40->qlock);
691         list_for_each_entry_safe(buf, node, &sur40->buf_list, list) {
692                 vb2_buffer_done(&buf->vb, state);
693                 list_del(&buf->list);
694         }
695         spin_unlock(&sur40->qlock);
696 }
697 
698 /*
699  * Start streaming. First check if the minimum number of buffers have been
700  * queued. If not, then return -ENOBUFS and the vb2 framework will call
701  * this function again the next time a buffer has been queued until enough
702  * buffers are available to actually start the DMA engine.
703  */
704 static int sur40_start_streaming(struct vb2_queue *vq, unsigned int count)
705 {
706         struct sur40_state *sur40 = vb2_get_drv_priv(vq);
707 
708         sur40->sequence = 0;
709         return 0;
710 }
711 
712 /*
713  * Stop the DMA engine. Any remaining buffers in the DMA queue are dequeued
714  * and passed on to the vb2 framework marked as STATE_ERROR.
715  */
716 static void sur40_stop_streaming(struct vb2_queue *vq)
717 {
718         struct sur40_state *sur40 = vb2_get_drv_priv(vq);
719 
720         /* Release all active buffers */
721         return_all_buffers(sur40, VB2_BUF_STATE_ERROR);
722 }
723 
724 /* V4L ioctl */
725 static int sur40_vidioc_querycap(struct file *file, void *priv,
726                                  struct v4l2_capability *cap)
727 {
728         struct sur40_state *sur40 = video_drvdata(file);
729 
730         strlcpy(cap->driver, DRIVER_SHORT, sizeof(cap->driver));
731         strlcpy(cap->card, DRIVER_LONG, sizeof(cap->card));
732         usb_make_path(sur40->usbdev, cap->bus_info, sizeof(cap->bus_info));
733         cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
734                 V4L2_CAP_READWRITE |
735                 V4L2_CAP_STREAMING;
736         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
737         return 0;
738 }
739 
740 static int sur40_vidioc_enum_input(struct file *file, void *priv,
741                                    struct v4l2_input *i)
742 {
743         if (i->index != 0)
744                 return -EINVAL;
745         i->type = V4L2_INPUT_TYPE_CAMERA;
746         i->std = V4L2_STD_UNKNOWN;
747         strlcpy(i->name, "In-Cell Sensor", sizeof(i->name));
748         i->capabilities = 0;
749         return 0;
750 }
751 
752 static int sur40_vidioc_s_input(struct file *file, void *priv, unsigned int i)
753 {
754         return (i == 0) ? 0 : -EINVAL;
755 }
756 
757 static int sur40_vidioc_g_input(struct file *file, void *priv, unsigned int *i)
758 {
759         *i = 0;
760         return 0;
761 }
762 
763 static int sur40_vidioc_fmt(struct file *file, void *priv,
764                             struct v4l2_format *f)
765 {
766         f->fmt.pix = sur40_video_format;
767         return 0;
768 }
769 
770 static int sur40_vidioc_enum_fmt(struct file *file, void *priv,
771                                  struct v4l2_fmtdesc *f)
772 {
773         if (f->index != 0)
774                 return -EINVAL;
775         strlcpy(f->description, "8-bit greyscale", sizeof(f->description));
776         f->pixelformat = V4L2_PIX_FMT_GREY;
777         f->flags = 0;
778         return 0;
779 }
780 
781 static const struct usb_device_id sur40_table[] = {
782         { USB_DEVICE(ID_MICROSOFT, ID_SUR40) },  /* Samsung SUR40 */
783         { }                                      /* terminating null entry */
784 };
785 MODULE_DEVICE_TABLE(usb, sur40_table);
786 
787 /* V4L2 structures */
788 static const struct vb2_ops sur40_queue_ops = {
789         .queue_setup            = sur40_queue_setup,
790         .buf_prepare            = sur40_buffer_prepare,
791         .buf_queue              = sur40_buffer_queue,
792         .start_streaming        = sur40_start_streaming,
793         .stop_streaming         = sur40_stop_streaming,
794         .wait_prepare           = vb2_ops_wait_prepare,
795         .wait_finish            = vb2_ops_wait_finish,
796 };
797 
798 static const struct vb2_queue sur40_queue = {
799         .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
800         /*
801          * VB2_USERPTR in currently not enabled: passing a user pointer to
802          * dma-sg will result in segment sizes that are not a multiple of
803          * 512 bytes, which is required by the host controller.
804         */
805         .io_modes = VB2_MMAP | VB2_READ | VB2_DMABUF,
806         .buf_struct_size = sizeof(struct sur40_buffer),
807         .ops = &sur40_queue_ops,
808         .mem_ops = &vb2_dma_sg_memops,
809         .timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC,
810         .min_buffers_needed = 3,
811 };
812 
813 static const struct v4l2_file_operations sur40_video_fops = {
814         .owner = THIS_MODULE,
815         .open = v4l2_fh_open,
816         .release = vb2_fop_release,
817         .unlocked_ioctl = video_ioctl2,
818         .read = vb2_fop_read,
819         .mmap = vb2_fop_mmap,
820         .poll = vb2_fop_poll,
821 };
822 
823 static const struct v4l2_ioctl_ops sur40_video_ioctl_ops = {
824 
825         .vidioc_querycap        = sur40_vidioc_querycap,
826 
827         .vidioc_enum_fmt_vid_cap = sur40_vidioc_enum_fmt,
828         .vidioc_try_fmt_vid_cap = sur40_vidioc_fmt,
829         .vidioc_s_fmt_vid_cap   = sur40_vidioc_fmt,
830         .vidioc_g_fmt_vid_cap   = sur40_vidioc_fmt,
831 
832         .vidioc_enum_input      = sur40_vidioc_enum_input,
833         .vidioc_g_input         = sur40_vidioc_g_input,
834         .vidioc_s_input         = sur40_vidioc_s_input,
835 
836         .vidioc_reqbufs         = vb2_ioctl_reqbufs,
837         .vidioc_create_bufs     = vb2_ioctl_create_bufs,
838         .vidioc_querybuf        = vb2_ioctl_querybuf,
839         .vidioc_qbuf            = vb2_ioctl_qbuf,
840         .vidioc_dqbuf           = vb2_ioctl_dqbuf,
841         .vidioc_expbuf          = vb2_ioctl_expbuf,
842 
843         .vidioc_streamon        = vb2_ioctl_streamon,
844         .vidioc_streamoff       = vb2_ioctl_streamoff,
845 };
846 
847 static const struct video_device sur40_video_device = {
848         .name = DRIVER_LONG,
849         .fops = &sur40_video_fops,
850         .ioctl_ops = &sur40_video_ioctl_ops,
851         .release = video_device_release_empty,
852 };
853 
854 static const struct v4l2_pix_format sur40_video_format = {
855         .pixelformat = V4L2_PIX_FMT_GREY,
856         .width  = SENSOR_RES_X / 2,
857         .height = SENSOR_RES_Y / 2,
858         .field = V4L2_FIELD_NONE,
859         .colorspace = V4L2_COLORSPACE_SRGB,
860         .bytesperline = SENSOR_RES_X / 2,
861         .sizeimage = (SENSOR_RES_X/2) * (SENSOR_RES_Y/2),
862 };
863 
864 /* USB-specific object needed to register this driver with the USB subsystem. */
865 static struct usb_driver sur40_driver = {
866         .name = DRIVER_SHORT,
867         .probe = sur40_probe,
868         .disconnect = sur40_disconnect,
869         .id_table = sur40_table,
870 };
871 
872 module_usb_driver(sur40_driver);
873 
874 MODULE_AUTHOR(DRIVER_AUTHOR);
875 MODULE_DESCRIPTION(DRIVER_DESC);
876 MODULE_LICENSE("GPL");
877 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us