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 WRITE_ONCE(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 || !READ_ONCE(uhid->running),
199 if (!ret || !READ_ONCE(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 (!READ_ONCE(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 (!READ_ONCE(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);
489 static int uhid_dev_create2(struct uhid_device *uhid,
497 if (uhid->hid)
508 uhid->rd_size = rd_size;
509 uhid->rd_data = rd_data;
531 hid->driver_data = uhid;
534 uhid->hid = hid;
535 uhid->running = true;
541 schedule_work(&uhid->worker);
546 kfree(uhid->rd_data);
547 uhid->rd_data = NULL;
548 uhid->rd_size = 0;
552 static int uhid_dev_create(struct uhid_device *uhid,
574 return uhid_dev_create2(uhid, ev);
577 static int uhid_dev_destroy(struct uhid_device *uhid)
579 if (!uhid->hid)
582 WRITE_ONCE(uhid->running, false);
583 wake_up_interruptible(&uhid->report_wait);
585 cancel_work_sync(&uhid->worker);
587 hid_destroy_device(uhid->hid);
588 uhid->hid = NULL;
589 kfree(uhid->rd_data);
594 static int uhid_dev_input(struct uhid_device *uhid, struct uhid_event *ev)
596 if (!READ_ONCE(uhid->running))
599 hid_input_report(uhid->hid, HID_INPUT_REPORT, ev->u.input.data,
605 static int uhid_dev_input2(struct uhid_device *uhid, struct uhid_event *ev)
607 if (!READ_ONCE(uhid->running))
610 hid_input_report(uhid->hid, HID_INPUT_REPORT, ev->u.input2.data,
616 static int uhid_dev_get_report_reply(struct uhid_device *uhid,
619 if (!READ_ONCE(uhid->running))
622 uhid_report_wake_up(uhid, ev->u.get_report_reply.id, ev);
626 static int uhid_dev_set_report_reply(struct uhid_device *uhid,
629 if (!READ_ONCE(uhid->running))
632 uhid_report_wake_up(uhid, ev->u.set_report_reply.id, ev);
638 struct uhid_device *uhid;
640 uhid = kzalloc(sizeof(*uhid), GFP_KERNEL);
641 if (!uhid)
644 mutex_init(&uhid->devlock);
645 mutex_init(&uhid->report_lock);
646 spin_lock_init(&uhid->qlock);
647 init_waitqueue_head(&uhid->waitq);
648 init_waitqueue_head(&uhid->report_wait);
649 uhid->running = false;
650 INIT_WORK(&uhid->worker, uhid_device_add_worker);
652 file->private_data = uhid;
660 struct uhid_device *uhid = file->private_data;
663 uhid_dev_destroy(uhid);
666 kfree(uhid->outq[i]);
668 kfree(uhid);
676 struct uhid_device *uhid = file->private_data;
687 if (uhid->head == uhid->tail)
690 ret = wait_event_interruptible(uhid->waitq,
691 uhid->head != uhid->tail);
696 ret = mutex_lock_interruptible(&uhid->devlock);
700 if (uhid->head == uhid->tail) {
701 mutex_unlock(&uhid->devlock);
704 len = min(count, sizeof(**uhid->outq));
705 if (copy_to_user(buffer, uhid->outq[uhid->tail], len)) {
708 kfree(uhid->outq[uhid->tail]);
709 uhid->outq[uhid->tail] = NULL;
711 spin_lock_irqsave(&uhid->qlock, flags);
712 uhid->tail = (uhid->tail + 1) % UHID_BUFSIZE;
713 spin_unlock_irqrestore(&uhid->qlock, flags);
717 mutex_unlock(&uhid->devlock);
724 struct uhid_device *uhid = file->private_data;
732 ret = mutex_lock_interruptible(&uhid->devlock);
736 memset(&uhid->input_buf, 0, sizeof(uhid->input_buf));
737 len = min(count, sizeof(uhid->input_buf));
739 ret = uhid_event_from_user(buffer, len, &uhid->input_buf);
743 switch (uhid->input_buf.type) {
756 ret = uhid_dev_create(uhid, &uhid->input_buf);
759 ret = uhid_dev_create2(uhid, &uhid->input_buf);
762 ret = uhid_dev_destroy(uhid);
765 ret = uhid_dev_input(uhid, &uhid->input_buf);
768 ret = uhid_dev_input2(uhid, &uhid->input_buf);
771 ret = uhid_dev_get_report_reply(uhid, &uhid->input_buf);
774 ret = uhid_dev_set_report_reply(uhid, &uhid->input_buf);
781 mutex_unlock(&uhid->devlock);
789 struct uhid_device *uhid = file->private_data;
790 __poll_t mask = EPOLLOUT | EPOLLWRNORM; /* uhid is always writable */
792 poll_wait(file, &uhid->waitq, wait);
794 if (uhid->head != uhid->tail)