Release 4.9 drivers/usb/serial/symbolserial.c

/*
 * Symbol USB barcode to serial driver
 *
 * Copyright (C) 2013 Johan Hovold <jhovold@gmail.com>
 * Copyright (C) 2009 Greg Kroah-Hartman <gregkh@suse.de>
 * Copyright (C) 2009 Novell Inc.
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License version
 *      2 as published by the Free Software Foundation.
 */

#include <linux/kernel.h>
#include <linux/tty.h>
#include <linux/slab.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/usb/serial.h>
#include <linux/uaccess.h>


static const struct usb_device_id id_table[] = {
	{ USB_DEVICE(0x05e0, 0x0600) },
	{ },
};
MODULE_DEVICE_TABLE(usb, id_table);


struct symbol_private {
	
spinlock_t lock;	/* protects the following flags */
	
bool throttled;
	
bool actually_throttled;
};



static void symbol_int_callback(struct urb *urb)
{
	struct usb_serial_port *port = urb->context;
	struct symbol_private *priv = usb_get_serial_port_data(port);
	unsigned char *data = urb->transfer_buffer;
	int status = urb->status;
	int result;
	int data_length;

	switch (status) {
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
		dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
			__func__, status);
		return;
	default:
		dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
			__func__, status);
		goto exit;
	}

	usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);

	/*
         * Data from the device comes with a 1 byte header:
         *
         * <size of data> <data>...
         */
	if (urb->actual_length > 1) {
		data_length = data[0];
		if (data_length > (urb->actual_length - 1))
			data_length = urb->actual_length - 1;
		tty_insert_flip_string(&port->port, &data[1], data_length);
		tty_flip_buffer_push(&port->port);
	} else {
		dev_dbg(&port->dev, "%s - short packet\n", __func__);
	}

exit:
	spin_lock(&priv->lock);

	/* Continue trying to always read if we should */
	if (!priv->throttled) {
		result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
		if (result)
			dev_err(&port->dev,
			    "%s - failed resubmitting read urb, error %d\n",
							__func__, result);
	} else
		priv->actually_throttled = true;
	spin_unlock(&priv->lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
greg kroah-hartman
greg kroah-hartman
220
82.71%
2
20.00%
philipp hachtmann
philipp hachtmann
20
7.52%
1
10.00%
johan hovold
johan hovold
17
6.39%
4
40.00%
jiri slaby
jiri slaby
8
3.01%
2
20.00%
alan cox
alan cox
1
0.38%
1
10.00%
Total
266
100.00%
10
100.00%



static int symbol_open(struct tty_struct *tty, struct usb_serial_port *port)
{
	struct symbol_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	int result = 0;

	spin_lock_irqsave(&priv->lock, flags);
	priv->throttled = false;
	priv->actually_throttled = false;
	spin_unlock_irqrestore(&priv->lock, flags);

	/* Start reading from the device */
	result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
	if (result)
		dev_err(&port->dev,
			"%s - failed resubmitting read urb, error %d\n",
			__func__, result);
	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
greg kroah-hartman
greg kroah-hartman
97
97.00%
1
33.33%
johan hovold
johan hovold
2
2.00%
1
33.33%
philipp hachtmann
philipp hachtmann
1
1.00%
1
33.33%
Total
100
100.00%
3
100.00%



static void symbol_close(struct usb_serial_port *port)
{
	usb_kill_urb(port->interrupt_in_urb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
greg kroah-hartman
greg kroah-hartman
16
88.89%
1
50.00%
johan hovold
johan hovold
2
11.11%
1
50.00%
Total
18
100.00%
2
100.00%



static void symbol_throttle(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
	struct symbol_private *priv = usb_get_serial_port_data(port);

	spin_lock_irq(&priv->lock);
	priv->throttled = true;
	spin_unlock_irq(&priv->lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
greg kroah-hartman
greg kroah-hartman
49
94.23%
1
33.33%
oliver neukum
oliver neukum
2
3.85%
1
33.33%
philipp hachtmann
philipp hachtmann
1
1.92%
1
33.33%
Total
52
100.00%
3
100.00%



static void symbol_unthrottle(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
	struct symbol_private *priv = usb_get_serial_port_data(port);
	int result;
	bool was_throttled;

	spin_lock_irq(&priv->lock);
	priv->throttled = false;
	was_throttled = priv->actually_throttled;
	priv->actually_throttled = false;
	spin_unlock_irq(&priv->lock);

	if (was_throttled) {
		result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
		if (result)
			dev_err(&port->dev,
				"%s - failed submitting read urb, error %d\n",
							__func__, result);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
greg kroah-hartman
greg kroah-hartman
84
80.00%
1
20.00%
oliver neukum
oliver neukum
18
17.14%
2
40.00%
johan hovold
johan hovold
2
1.90%
1
20.00%
philipp hachtmann
philipp hachtmann
1
0.95%
1
20.00%
Total
105
100.00%
5
100.00%



static int symbol_startup(struct usb_serial *serial)
{
	if (!serial->num_interrupt_in) {
		dev_err(&serial->dev->dev, "no interrupt-in endpoint\n");
		return -ENODEV;
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
johan hovold
johan hovold
28
71.79%
2
66.67%
greg kroah-hartman
greg kroah-hartman
11
28.21%
1
33.33%
Total
39
100.00%
3
100.00%



static int symbol_port_probe(struct usb_serial_port *port)
{
	struct symbol_private *priv;

	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	spin_lock_init(&priv->lock);

	usb_set_serial_port_data(port, priv);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
greg kroah-hartman
greg kroah-hartman
37
66.07%
1
33.33%
johan hovold
johan hovold
18
32.14%
1
33.33%
alan stern
alan stern
1
1.79%
1
33.33%
Total
56
100.00%
3
100.00%



static int symbol_port_remove(struct usb_serial_port *port)
{
	struct symbol_private *priv = usb_get_serial_port_data(port);

	kfree(priv);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
alan stern
alan stern
14
48.28%
1
33.33%
johan hovold
johan hovold
9
31.03%
1
33.33%
greg kroah-hartman
greg kroah-hartman
6
20.69%
1
33.33%
Total
29
100.00%
3
100.00%


static struct usb_serial_driver symbol_device = {
	.driver = {
		.owner =	THIS_MODULE,
		.name =		"symbol",
        },
	.id_table =		id_table,
	.num_ports =		1,
	.attach =		symbol_startup,
	.port_probe =		symbol_port_probe,
	.port_remove =		symbol_port_remove,
	.open =			symbol_open,
	.close =		symbol_close,
	.throttle = 		symbol_throttle,
	.unthrottle =		symbol_unthrottle,
	.read_int_callback =	symbol_int_callback,
};


static struct usb_serial_driver * const serial_drivers[] = {
	&symbol_device, NULL
};

module_usb_serial_driver(serial_drivers, id_table);

MODULE_LICENSE("GPL");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
greg kroah-hartman
greg kroah-hartman
653
78.30%
4
21.05%
johan hovold
johan hovold
94
11.27%
4
21.05%
alan stern
alan stern
31
3.72%
2
10.53%
philipp hachtmann
philipp hachtmann
23
2.76%
2
10.53%
oliver neukum
oliver neukum
20
2.40%
2
10.53%
jiri slaby
jiri slaby
8
0.96%
2
10.53%
tejun heo
tejun heo
3
0.36%
1
5.26%
marton nemeth
marton nemeth
1
0.12%
1
5.26%
alan cox
alan cox
1
0.12%
1
5.26%
Total
834
100.00%
19
100.00%
  
Directory: drivers/usb/serial