From patchwork Fri Jun 17 14:49:17 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Herrmann X-Patchwork-Id: 891732 X-Patchwork-Delegate: jikos@jikos.cz Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by demeter2.kernel.org (8.14.4/8.14.4) with ESMTP id p5HEpxR7017161 for ; Fri, 17 Jun 2011 14:51:59 GMT Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1759449Ab1FQOv1 (ORCPT ); Fri, 17 Jun 2011 10:51:27 -0400 Received: from mail-fx0-f46.google.com ([209.85.161.46]:61394 "EHLO mail-fx0-f46.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1759242Ab1FQOuY (ORCPT ); Fri, 17 Jun 2011 10:50:24 -0400 Received: by fxm17 with SMTP id 17so1796173fxm.19 for ; Fri, 17 Jun 2011 07:50:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=googlemail.com; s=gamma; h=domainkey-signature:from:to:cc:subject:date:message-id:x-mailer :in-reply-to:references; bh=TWZKPHxS9lX2vmz+k1VBgR67xLgMz0wSCwU/YAmSQYY=; b=N1+AipeODa2bL8Q79pe3Pb2DLjh0/FEWaFN4qwC3BbfbnFNiO0is1Ws1WMBIKHm8yJ kZXw95A1QG8o7ZX+xemkz5filNLfqas5cF5cbAn2buGRrB1gzxPFHkMTBoReYVA0zjxN 9I/ru0/NYS8/MmE6LjP2iW+esF4xBQdXFz5eQ= DomainKey-Signature: a=rsa-sha1; c=nofws; d=googlemail.com; s=gamma; h=from:to:cc:subject:date:message-id:x-mailer:in-reply-to:references; b=Wd/GZy+VKy5S1aReOvjEpMJjiTEMTr0WRmEBnjz33iSbVdXbH4P0MfjwgIUko1ip33 bCBsu/xpnxf5QQNH8g9uPchEXLGab+8Xuq7a1hiQOiFwdsRBUGoFC5thsdcmEZdOFnf0 gO841okaLHPgKXxchqMh8nF/OhOR904+JRtqI= Received: by 10.223.22.130 with SMTP id n2mr81448fab.50.1308322222255; Fri, 17 Jun 2011 07:50:22 -0700 (PDT) Received: from localhost.localdomain (stgt-4d039afc.pool.mediaWays.net [77.3.154.252]) by mx.google.com with ESMTPS id o10sm1378710fah.31.2011.06.17.07.50.20 (version=TLSv1/SSLv3 cipher=OTHER); Fri, 17 Jun 2011 07:50:21 -0700 (PDT) From: David Herrmann To: linux-input@vger.kernel.org Cc: padovan@profusion.mobi, jkosina@suse.cz, oliver@neukum.org, dh.herrmann@googlemail.com Subject: [PATCH 07/12 v2] HID: wiimote: Add output queue for wiimote driver Date: Fri, 17 Jun 2011 16:49:17 +0200 Message-Id: <1308322162-13953-7-git-send-email-dh.herrmann@googlemail.com> X-Mailer: git-send-email 1.7.5.2 In-Reply-To: <1308322162-13953-1-git-send-email-dh.herrmann@googlemail.com> References: <1308322162-13953-1-git-send-email-dh.herrmann@googlemail.com> Sender: linux-input-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-input@vger.kernel.org X-Greylist: IP, sender and recipient auto-whitelisted, not delayed by milter-greylist-4.2.6 (demeter2.kernel.org [140.211.167.43]); Fri, 17 Jun 2011 14:51:59 +0000 (UTC) The raw hid output function that is supported by bluetooth low-level hid driver does not provide an output queue and also may sleep. The wiimote driver, though, may need to send data in atomic context so this patch adds a buffered output queue for the wiimote driver. We use the shared workqueue to send our buffer to the hid device. There is always only one active worker which reschedules itself until the wiimote queue is empty. This prevents the worker from occupying the shared workqueue for too long. If our queue is full, every further output is discarded. Signed-off-by: David Herrmann --- V2: Add write memory barrier after atomic_set operation. drivers/hid/hid-wiimote.c | 106 +++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 106 insertions(+), 0 deletions(-) diff --git a/drivers/hid/hid-wiimote.c b/drivers/hid/hid-wiimote.c index b6ae2a1..c06fdc8 100644 --- a/drivers/hid/hid-wiimote.c +++ b/drivers/hid/hid-wiimote.c @@ -15,15 +15,28 @@ #include #include #include +#include #include "hid-ids.h" #define WIIMOTE_VERSION "0.1" #define WIIMOTE_NAME "Nintendo Wii Remote" +#define WIIMOTE_BUFSIZE 32 + +struct wiimote_buf { + __u8 data[HID_MAX_BUFFER_SIZE]; + size_t size; +}; struct wiimote_data { atomic_t ready; struct hid_device *hdev; struct input_dev *input; + + spinlock_t qlock; + __u8 head; + __u8 tail; + struct wiimote_buf outq[WIIMOTE_BUFSIZE]; + struct work_struct worker; }; static ssize_t wiimote_hid_send(struct hid_device *hdev, __u8 *buffer, @@ -45,6 +58,79 @@ static ssize_t wiimote_hid_send(struct hid_device *hdev, __u8 *buffer, return ret; } +static void wiimote_worker(struct work_struct *work) +{ + struct wiimote_data *wdata = container_of(work, struct wiimote_data, + worker); + unsigned long flags; + + if (!atomic_read(&wdata->ready)) + return; + + spin_lock_irqsave(&wdata->qlock, flags); + + if (wdata->head != wdata->tail) { + spin_unlock_irqrestore(&wdata->qlock, flags); + wiimote_hid_send(wdata->hdev, wdata->outq[wdata->tail].data, + wdata->outq[wdata->tail].size); + spin_lock_irqsave(&wdata->qlock, flags); + + wdata->tail = (wdata->tail + 1) % WIIMOTE_BUFSIZE; + + /* + * We are using the shared workqueue so send at most one whole + * buffer and then reschedule ourself so we do not occupy the + * shared workqueue for too long. + */ + if (wdata->head != wdata->tail) + schedule_work(&wdata->worker); + } + + spin_unlock_irqrestore(&wdata->qlock, flags); +} + +static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer, + size_t count) +{ + unsigned long flags; + __u8 newhead; + + if (!atomic_read(&wdata->ready)) + return; + + if (count > HID_MAX_BUFFER_SIZE) { + hid_warn(wdata->hdev, "Sending too large output report\n"); + return; + } + + /* + * Copy new request into our output queue and check whether the + * queue is full. If it is full, discard this request. + * If it is empty we need to start a new worker that will + * send out the buffer to the hid device. + * If the queue is not empty, then there must be a worker + * that is currently sending out our buffer and this worker + * will reschedule itself until the queue is empty. + */ + + spin_lock_irqsave(&wdata->qlock, flags); + + memcpy(wdata->outq[wdata->head].data, buffer, count); + wdata->outq[wdata->head].size = count; + newhead = (wdata->head + 1) % WIIMOTE_BUFSIZE; + + if (wdata->head == wdata->tail) { + wdata->head = newhead; + schedule_work(&wdata->worker); + } else if (newhead != wdata->tail) { + wdata->head = newhead; + } else { + hid_warn(wdata->hdev, "Output queue is full"); + } + + spin_unlock_irqrestore(&wdata->qlock, flags); +} + static int wiimote_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) { @@ -98,6 +184,9 @@ static struct wiimote_data *wiimote_create(struct hid_device *hdev) wdata->input->id.version = wdata->hdev->version; wdata->input->name = WIIMOTE_NAME; + spin_lock_init(&wdata->qlock); + INIT_WORK(&wdata->worker, wiimote_worker); + return wdata; } @@ -154,8 +243,25 @@ static void wiimote_hid_remove(struct hid_device *hdev) struct wiimote_data *wdata = hid_get_drvdata(hdev); hid_info(hdev, "Device removed\n"); + + /* + * We handle events from HID, input and sysfs and + * send requests to HID and input. So stop sysfs + * first, then lock HID output and stop HID. + * Now only input is left so stop it and free the + * the device data. + */ + + atomic_set(&wdata->ready, 0); + smp_wmb(); + cancel_work_sync(&wdata->worker); + hid_hw_stop(hdev); input_unregister_device(wdata->input); + + /* the worker may have been rescheduled so wait again for it */ + cancel_work_sync(&wdata->worker); + wiimote_destroy(wdata); }