gnss: add USB support

Add a generic driver for GNSS receivers with a USB interface with two
bulk endpoints.

The driver currently assumes that the device protocol is NMEA (only) but
this can be generalised later as needed.

Link: https://lore.kernel.org/r/20211220111901.23206-2-johan@kernel.org
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Tested-by: Marc Ferland <ferlandm@amotus.ca>
Signed-off-by: Johan Hovold <johan@kernel.org>

diff --git a/drivers/gnss/Kconfig b/drivers/gnss/Kconfig
index bd12e3d..d7fe265 100644 (file)
--- a/drivers/gnss/Kconfig
+++ b/drivers/gnss/Kconfig
@@ -54,4 +54,15 @@ config GNSS_UBX_SERIAL
 
          If unsure, say N.
 
+config GNSS_USB
+       tristate "USB GNSS receiver support"
+       depends on USB
+       help
+         Say Y here if you have a GNSS receiver which uses a USB interface.
+
+         To compile this driver as a module, choose M here: the module will
+         be called gnss-usb.
+
+         If unsure, say N.
+
 endif # GNSS

diff --git a/drivers/gnss/Makefile b/drivers/gnss/Makefile
index 451f114..bb2cbad 100644 (file)
--- a/drivers/gnss/Makefile
+++ b/drivers/gnss/Makefile
@@ -17,3 +17,6 @@ gnss-sirf-y := sirf.o
 
 obj-$(CONFIG_GNSS_UBX_SERIAL)          += gnss-ubx.o
 gnss-ubx-y := ubx.o
+
+obj-$(CONFIG_GNSS_USB)                 += gnss-usb.o
+gnss-usb-y := usb.o

diff --git a/drivers/gnss/usb.c b/drivers/gnss/usb.c
new file mode 100644 (file)
index 0000000..fb1dd04
--- /dev/null
+++ b/drivers/gnss/usb.c
@@ -0,0 +1,213 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Generic USB GNSS receiver driver
+ *
+ * Copyright (C) 2021 Johan Hovold <johan@kernel.org>
+ */
+
+#include <linux/errno.h>
+#include <linux/gnss.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+
+#define GNSS_USB_READ_BUF_LEN  512
+#define GNSS_USB_WRITE_TIMEOUT 1000
+
+static const struct usb_device_id gnss_usb_id_table[] = {
+       { }
+};
+MODULE_DEVICE_TABLE(usb, gnss_usb_id_table);
+
+struct gnss_usb {
+       struct usb_device *udev;
+       struct usb_interface *intf;
+       struct gnss_device *gdev;
+       struct urb *read_urb;
+       unsigned int write_pipe;
+};
+
+static void gnss_usb_rx_complete(struct urb *urb)
+{
+       struct gnss_usb *gusb = urb->context;
+       struct gnss_device *gdev = gusb->gdev;
+       int status = urb->status;
+       int len;
+       int ret;
+
+       switch (status) {
+       case 0:
+               break;
+       case -ENOENT:
+       case -ECONNRESET:
+       case -ESHUTDOWN:
+               dev_dbg(&gdev->dev, "urb stopped: %d\n", status);
+               return;
+       case -EPIPE:
+               dev_err(&gdev->dev, "urb stopped: %d\n", status);
+               return;
+       default:
+               dev_dbg(&gdev->dev, "nonzero urb status: %d\n", status);
+               goto resubmit;
+       }
+
+       len = urb->actual_length;
+       if (len == 0)
+               goto resubmit;
+
+       ret = gnss_insert_raw(gdev, urb->transfer_buffer, len);
+       if (ret < len)
+               dev_dbg(&gdev->dev, "dropped %d bytes\n", len - ret);
+resubmit:
+       ret = usb_submit_urb(urb, GFP_ATOMIC);
+       if (ret && ret != -EPERM && ret != -ENODEV)
+               dev_err(&gdev->dev, "failed to resubmit urb: %d\n", ret);
+}
+
+static int gnss_usb_open(struct gnss_device *gdev)
+{
+       struct gnss_usb *gusb = gnss_get_drvdata(gdev);
+       int ret;
+
+       ret = usb_submit_urb(gusb->read_urb, GFP_KERNEL);
+       if (ret) {
+               if (ret != -EPERM && ret != -ENODEV)
+                       dev_err(&gdev->dev, "failed to submit urb: %d\n", ret);
+               return ret;
+       }
+
+       return 0;
+}
+
+static void gnss_usb_close(struct gnss_device *gdev)
+{
+       struct gnss_usb *gusb = gnss_get_drvdata(gdev);
+
+       usb_kill_urb(gusb->read_urb);
+}
+
+static int gnss_usb_write_raw(struct gnss_device *gdev,
+               const unsigned char *buf, size_t count)
+{
+       struct gnss_usb *gusb = gnss_get_drvdata(gdev);
+       void *tbuf;
+       int ret;
+
+       tbuf = kmemdup(buf, count, GFP_KERNEL);
+       if (!tbuf)
+               return -ENOMEM;
+
+       ret = usb_bulk_msg(gusb->udev, gusb->write_pipe, tbuf, count, NULL,
+                       GNSS_USB_WRITE_TIMEOUT);
+       kfree(tbuf);
+       if (ret)
+               return ret;
+
+       return count;
+}
+
+static const struct gnss_operations gnss_usb_gnss_ops = {
+       .open           = gnss_usb_open,
+       .close          = gnss_usb_close,
+       .write_raw      = gnss_usb_write_raw,
+};
+
+static int gnss_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
+{
+       struct usb_device *udev = interface_to_usbdev(intf);
+       struct usb_endpoint_descriptor *in, *out;
+       struct gnss_device *gdev;
+       struct gnss_usb *gusb;
+       struct urb *urb;
+       size_t buf_len;
+       void *buf;
+       int ret;
+
+       ret = usb_find_common_endpoints(intf->cur_altsetting, &in, &out, NULL,
+                       NULL);
+       if (ret)
+               return ret;
+
+       gusb = kzalloc(sizeof(*gusb), GFP_KERNEL);
+       if (!gusb)
+               return -ENOMEM;
+
+       gdev = gnss_allocate_device(&intf->dev);
+       if (!gdev) {
+               ret = -ENOMEM;
+               goto err_free_gusb;
+       }
+
+       gdev->ops = &gnss_usb_gnss_ops;
+       gdev->type = GNSS_TYPE_NMEA;
+       gnss_set_drvdata(gdev, gusb);
+
+       urb = usb_alloc_urb(0, GFP_KERNEL);
+       if (!urb) {
+               ret = -ENOMEM;
+               goto err_put_gdev;
+       }
+
+       buf_len = max(usb_endpoint_maxp(in), GNSS_USB_READ_BUF_LEN);
+
+       buf = kzalloc(buf_len, GFP_KERNEL);
+       if (!buf) {
+               ret = -ENOMEM;
+               goto err_free_urb;
+       }
+
+       usb_fill_bulk_urb(urb, udev,
+                       usb_rcvbulkpipe(udev, usb_endpoint_num(in)),
+                       buf, buf_len, gnss_usb_rx_complete, gusb);
+
+       gusb->intf = intf;
+       gusb->udev = udev;
+       gusb->gdev = gdev;
+       gusb->read_urb = urb;
+       gusb->write_pipe = usb_sndbulkpipe(udev, usb_endpoint_num(out));
+
+       ret = gnss_register_device(gdev);
+       if (ret)
+               goto err_free_buf;
+
+       usb_set_intfdata(intf, gusb);
+
+       return 0;
+
+err_free_buf:
+       kfree(buf);
+err_free_urb:
+       usb_free_urb(urb);
+err_put_gdev:
+       gnss_put_device(gdev);
+err_free_gusb:
+       kfree(gusb);
+
+       return ret;
+}
+
+static void gnss_usb_disconnect(struct usb_interface *intf)
+{
+       struct gnss_usb *gusb = usb_get_intfdata(intf);
+
+       gnss_deregister_device(gusb->gdev);
+
+       kfree(gusb->read_urb->transfer_buffer);
+       usb_free_urb(gusb->read_urb);
+       gnss_put_device(gusb->gdev);
+       kfree(gusb);
+}
+
+static struct usb_driver gnss_usb_driver = {
+       .name           = "gnss-usb",
+       .probe          = gnss_usb_probe,
+       .disconnect     = gnss_usb_disconnect,
+       .id_table       = gnss_usb_id_table,
+};
+module_usb_driver(gnss_usb_driver);
+
+MODULE_AUTHOR("Johan Hovold <johan@kernel.org>");
+MODULE_DESCRIPTION("Generic USB GNSS receiver driver");
+MODULE_LICENSE("GPL v2");