Lines Matching refs:uhid
23 #include <linux/uhid.h>
26 #define UHID_NAME "uhid"
70 struct uhid_device *uhid = container_of(work, struct uhid_device, worker);
73 ret = hid_add_device(uhid->hid);
75 hid_err(uhid->hid, "Cannot register HID device: error %d\n", ret);
80 * of using uhid->hid.
81 * Just leave uhid->hid as-is for now, and clean it up when
82 * userspace tries to close or reinitialize the uhid instance.
87 uhid->running = false;
88 wake_up_interruptible(&uhid->report_wait);
92 static void uhid_queue(struct uhid_device *uhid, struct uhid_event *ev)
96 newhead = (uhid->head + 1) % UHID_BUFSIZE;
98 if (newhead != uhid->tail) {
99 uhid->outq[uhid->head] = ev;
100 uhid->head = newhead;
101 wake_up_interruptible(&uhid->waitq);
103 hid_warn(uhid->hid, "Output queue is full\n");
108 static int uhid_queue_event(struct uhid_device *uhid, __u32 event)
119 spin_lock_irqsave(&uhid->qlock, flags);
120 uhid_queue(uhid, ev);
121 spin_unlock_irqrestore(&uhid->qlock, flags);
128 struct uhid_device *uhid = hid->driver_data;
145 spin_lock_irqsave(&uhid->qlock, flags);
146 uhid_queue(uhid, ev);
147 spin_unlock_irqrestore(&uhid->qlock, flags);
154 struct uhid_device *uhid = hid->driver_data;
157 uhid_queue_event(uhid, UHID_STOP);
162 struct uhid_device *uhid = hid->driver_data;
164 return uhid_queue_event(uhid, UHID_OPEN);
169 struct uhid_device *uhid = hid->driver_data;
171 uhid_queue_event(uhid, UHID_CLOSE);
176 struct uhid_device *uhid = hid->driver_data;
178 return hid_parse_report(hid, uhid->rd_data, uhid->rd_size);
182 static int __uhid_report_queue_and_wait(struct uhid_device *uhid,
189 spin_lock_irqsave(&uhid->qlock, flags);
190 *report_id = ++uhid->report_id;
191 uhid->report_type = ev->type + 1;
192 uhid->report_running = true;
193 uhid_queue(uhid, ev);
194 spin_unlock_irqrestore(&uhid->qlock, flags);
196 ret = wait_event_interruptible_timeout(uhid->report_wait,
197 !uhid->report_running || !uhid->running,
199 if (!ret || !uhid->running || uhid->report_running)
206 uhid->report_running = false;
211 static void uhid_report_wake_up(struct uhid_device *uhid, u32 id,
216 spin_lock_irqsave(&uhid->qlock, flags);
219 if (uhid->report_type != ev->type || uhid->report_id != id)
221 if (!uhid->report_running)
224 memcpy(&uhid->report_buf, ev, sizeof(*ev));
225 uhid->report_running = false;
226 wake_up_interruptible(&uhid->report_wait);
229 spin_unlock_irqrestore(&uhid->qlock, flags);
235 struct uhid_device *uhid = hid->driver_data;
240 if (!uhid->running)
251 ret = mutex_lock_interruptible(&uhid->report_lock);
258 ret = __uhid_report_queue_and_wait(uhid, ev, &ev->u.get_report.id);
262 req = &uhid->report_buf.u.get_report_reply;
271 mutex_unlock(&uhid->report_lock);
278 struct uhid_device *uhid = hid->driver_data;
282 if (!uhid->running || count > UHID_DATA_MAX)
295 ret = mutex_lock_interruptible(&uhid->report_lock);
302 ret = __uhid_report_queue_and_wait(uhid, ev, &ev->u.set_report.id);
306 if (uhid->report_buf.u.set_report_reply.err)
312 mutex_unlock(&uhid->report_lock);
349 struct uhid_device *uhid = hid->driver_data;
377 spin_lock_irqsave(&uhid->qlock, flags);
378 uhid_queue(uhid, ev);
379 spin_unlock_irqrestore(&uhid->qlock, flags);
490 static int uhid_dev_create2(struct uhid_device *uhid,
498 if (uhid->hid)
509 uhid->rd_size = rd_size;
510 uhid->rd_data = rd_data;
532 hid->driver_data = uhid;
535 uhid->hid = hid;
536 uhid->running = true;
542 schedule_work(&uhid->worker);
547 kfree(uhid->rd_data);
548 uhid->rd_data = NULL;
549 uhid->rd_size = 0;
553 static int uhid_dev_create(struct uhid_device *uhid,
575 return uhid_dev_create2(uhid, ev);
578 static int uhid_dev_destroy(struct uhid_device *uhid)
580 if (!uhid->hid)
583 uhid->running = false;
584 wake_up_interruptible(&uhid->report_wait);
586 cancel_work_sync(&uhid->worker);
588 hid_destroy_device(uhid->hid);
589 uhid->hid = NULL;
590 kfree(uhid->rd_data);
595 static int uhid_dev_input(struct uhid_device *uhid, struct uhid_event *ev)
597 if (!uhid->running)
600 hid_input_report(uhid->hid, HID_INPUT_REPORT, ev->u.input.data,
606 static int uhid_dev_input2(struct uhid_device *uhid, struct uhid_event *ev)
608 if (!uhid->running)
611 hid_input_report(uhid->hid, HID_INPUT_REPORT, ev->u.input2.data,
617 static int uhid_dev_get_report_reply(struct uhid_device *uhid,
620 if (!uhid->running)
623 uhid_report_wake_up(uhid, ev->u.get_report_reply.id, ev);
627 static int uhid_dev_set_report_reply(struct uhid_device *uhid,
630 if (!uhid->running)
633 uhid_report_wake_up(uhid, ev->u.set_report_reply.id, ev);
639 struct uhid_device *uhid;
641 uhid = kzalloc(sizeof(*uhid), GFP_KERNEL);
642 if (!uhid)
645 mutex_init(&uhid->devlock);
646 mutex_init(&uhid->report_lock);
647 spin_lock_init(&uhid->qlock);
648 init_waitqueue_head(&uhid->waitq);
649 init_waitqueue_head(&uhid->report_wait);
650 uhid->running = false;
651 INIT_WORK(&uhid->worker, uhid_device_add_worker);
653 file->private_data = uhid;
661 struct uhid_device *uhid = file->private_data;
664 uhid_dev_destroy(uhid);
667 kfree(uhid->outq[i]);
669 kfree(uhid);
677 struct uhid_device *uhid = file->private_data;
688 if (uhid->head == uhid->tail)
691 ret = wait_event_interruptible(uhid->waitq,
692 uhid->head != uhid->tail);
697 ret = mutex_lock_interruptible(&uhid->devlock);
701 if (uhid->head == uhid->tail) {
702 mutex_unlock(&uhid->devlock);
705 len = min(count, sizeof(**uhid->outq));
706 if (copy_to_user(buffer, uhid->outq[uhid->tail], len)) {
709 kfree(uhid->outq[uhid->tail]);
710 uhid->outq[uhid->tail] = NULL;
712 spin_lock_irqsave(&uhid->qlock, flags);
713 uhid->tail = (uhid->tail + 1) % UHID_BUFSIZE;
714 spin_unlock_irqrestore(&uhid->qlock, flags);
718 mutex_unlock(&uhid->devlock);
725 struct uhid_device *uhid = file->private_data;
733 ret = mutex_lock_interruptible(&uhid->devlock);
737 memset(&uhid->input_buf, 0, sizeof(uhid->input_buf));
738 len = min(count, sizeof(uhid->input_buf));
740 ret = uhid_event_from_user(buffer, len, &uhid->input_buf);
744 switch (uhid->input_buf.type) {
757 ret = uhid_dev_create(uhid, &uhid->input_buf);
760 ret = uhid_dev_create2(uhid, &uhid->input_buf);
763 ret = uhid_dev_destroy(uhid);
766 ret = uhid_dev_input(uhid, &uhid->input_buf);
769 ret = uhid_dev_input2(uhid, &uhid->input_buf);
772 ret = uhid_dev_get_report_reply(uhid, &uhid->input_buf);
775 ret = uhid_dev_set_report_reply(uhid, &uhid->input_buf);
782 mutex_unlock(&uhid->devlock);
790 struct uhid_device *uhid = file->private_data;
791 __poll_t mask = EPOLLOUT | EPOLLWRNORM; /* uhid is always writable */
793 poll_wait(file, &uhid->waitq, wait);
795 if (uhid->head != uhid->tail)