2014-08-15 08:01:23 +00:00
|
|
|
/*
|
2014-08-15 11:44:32 +00:00
|
|
|
* UART driver for the Greybus "generic" UART module.
|
2014-08-15 08:01:23 +00:00
|
|
|
*
|
|
|
|
* Copyright 2014 Google Inc.
|
|
|
|
*
|
|
|
|
* Released under the GPLv2 only.
|
2014-08-15 11:44:32 +00:00
|
|
|
*
|
|
|
|
* Heavily based on drivers/usb/class/cdc-acm.c and
|
|
|
|
* drivers/usb/serial/usb-serial.c.
|
2014-08-15 08:01:23 +00:00
|
|
|
*/
|
2014-09-13 23:15:52 +00:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
2014-08-15 08:01:23 +00:00
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
2014-08-15 11:44:32 +00:00
|
|
|
#include <linux/errno.h>
|
2014-08-15 08:01:23 +00:00
|
|
|
#include <linux/module.h>
|
2014-08-15 11:44:32 +00:00
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/wait.h>
|
2014-08-15 08:01:23 +00:00
|
|
|
#include <linux/slab.h>
|
2014-08-15 11:44:32 +00:00
|
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <linux/mutex.h>
|
2014-08-15 08:01:23 +00:00
|
|
|
#include <linux/tty.h>
|
|
|
|
#include <linux/serial.h>
|
|
|
|
#include <linux/tty_driver.h>
|
|
|
|
#include <linux/tty_flip.h>
|
2014-08-15 11:44:32 +00:00
|
|
|
#include <linux/serial.h>
|
2014-08-15 10:33:33 +00:00
|
|
|
#include <linux/idr.h>
|
2014-09-06 03:56:10 +00:00
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/kdev_t.h>
|
2014-10-02 02:54:11 +00:00
|
|
|
|
2014-08-15 08:01:23 +00:00
|
|
|
#include "greybus.h"
|
2014-10-02 02:54:11 +00:00
|
|
|
#include "module.h"
|
2014-08-15 08:01:23 +00:00
|
|
|
|
2014-08-15 10:54:11 +00:00
|
|
|
#define GB_NUM_MINORS 255 /* 255 is enough for anyone... */
|
2014-09-06 03:56:10 +00:00
|
|
|
#define GB_NAME "ttyGB"
|
2014-08-15 08:01:23 +00:00
|
|
|
|
2014-11-16 02:30:00 +00:00
|
|
|
/* Version of the Greybus PWM protocol we support */
|
|
|
|
#define GB_UART_VERSION_MAJOR 0x00
|
|
|
|
#define GB_UART_VERSION_MINOR 0x01
|
|
|
|
|
|
|
|
/* Greybus UART request types */
|
|
|
|
#define GB_UART_REQ_INVALID 0x00
|
|
|
|
#define GB_UART_REQ_PROTOCOL_VERSION 0x01
|
|
|
|
#define GB_UART_REQ_SEND_DATA 0x02
|
|
|
|
#define GB_UART_REQ_RECEIVE_DATA 0x03 /* Unsolicited data */
|
|
|
|
#define GB_UART_REQ_SET_LINE_CODING 0x04
|
|
|
|
#define GB_UART_REQ_SET_CONTROL_LINE_STATE 0x05
|
|
|
|
#define GB_UART_REQ_SET_BREAK 0x06
|
|
|
|
#define GB_UART_REQ_SERIAL_STATE 0x07 /* Unsolicited data */
|
|
|
|
#define GB_UART_TYPE_RESPONSE 0x80 /* OR'd with rest */
|
|
|
|
|
|
|
|
struct gb_uart_proto_version_response {
|
|
|
|
__u8 status;
|
|
|
|
__u8 major;
|
|
|
|
__u8 minor;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gb_uart_send_data_request {
|
|
|
|
__le16 size;
|
|
|
|
__u8 data[0];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gb_serial_line_coding {
|
|
|
|
__le32 rate;
|
|
|
|
__u8 format;
|
|
|
|
#define GB_SERIAL_1_STOP_BITS 0
|
|
|
|
#define GB_SERIAL_1_5_STOP_BITS 1
|
|
|
|
#define GB_SERIAL_2_STOP_BITS 2
|
|
|
|
|
|
|
|
__u8 parity;
|
|
|
|
#define GB_SERIAL_NO_PARITY 0
|
|
|
|
#define GB_SERIAL_ODD_PARITY 1
|
|
|
|
#define GB_SERIAL_EVEN_PARITY 2
|
|
|
|
#define GB_SERIAL_MARK_PARITY 3
|
|
|
|
#define GB_SERIAL_SPACE_PARITY 4
|
|
|
|
|
|
|
|
__u8 data;
|
|
|
|
} __attribute__ ((packed));
|
|
|
|
|
|
|
|
struct gb_uart_set_line_coding_request {
|
|
|
|
struct gb_serial_line_coding line_coding;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* output control lines */
|
|
|
|
#define GB_UART_CTRL_DTR 0x01
|
|
|
|
#define GB_UART_CTRL_RTS 0x02
|
|
|
|
|
|
|
|
struct gb_uart_set_control_line_state_request {
|
|
|
|
__le16 control;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gb_uart_set_break_request {
|
|
|
|
__u8 state;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* input control lines and line errors */
|
|
|
|
#define GB_UART_CTRL_DCD 0x01
|
|
|
|
#define GB_UART_CTRL_DSR 0x02
|
|
|
|
#define GB_UART_CTRL_BRK 0x04
|
|
|
|
#define GB_UART_CTRL_RI 0x08
|
|
|
|
|
|
|
|
#define GB_UART_CTRL_FRAMING 0x10
|
|
|
|
#define GB_UART_CTRL_PARITY 0x20
|
|
|
|
#define GB_UART_CTRL_OVERRUN 0x40
|
|
|
|
|
|
|
|
struct gb_uart_serial_state_request {
|
|
|
|
__u16 control;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gb_uart_simple_response {
|
|
|
|
__u8 status;
|
|
|
|
};
|
|
|
|
|
2014-08-15 08:01:23 +00:00
|
|
|
struct gb_tty {
|
|
|
|
struct tty_port port;
|
2014-10-27 09:32:34 +00:00
|
|
|
struct gb_connection *connection;
|
2014-10-01 00:25:21 +00:00
|
|
|
u16 cport_id;
|
2014-08-15 08:01:23 +00:00
|
|
|
unsigned int minor;
|
|
|
|
unsigned char clocal;
|
2014-08-15 10:54:11 +00:00
|
|
|
unsigned int throttled:1;
|
|
|
|
unsigned int throttle_req:1;
|
2014-08-15 11:44:32 +00:00
|
|
|
bool disconnected;
|
|
|
|
int writesize; // FIXME - set this somehow.
|
2014-08-15 10:54:11 +00:00
|
|
|
spinlock_t read_lock;
|
|
|
|
spinlock_t write_lock;
|
2014-08-15 11:44:32 +00:00
|
|
|
struct async_icount iocount;
|
|
|
|
struct async_icount oldcount;
|
|
|
|
wait_queue_head_t wioctl;
|
|
|
|
struct mutex mutex;
|
2014-11-16 02:30:00 +00:00
|
|
|
u8 version_major;
|
|
|
|
u8 version_minor;
|
|
|
|
unsigned int ctrlin; /* input control lines */
|
|
|
|
unsigned int ctrlout; /* output control lines */
|
|
|
|
struct gb_serial_line_coding line_coding;
|
2014-08-15 08:01:23 +00:00
|
|
|
};
|
|
|
|
|
2014-11-16 02:30:00 +00:00
|
|
|
|
2014-08-15 10:33:33 +00:00
|
|
|
static struct tty_driver *gb_tty_driver;
|
|
|
|
static DEFINE_IDR(tty_minors);
|
|
|
|
static DEFINE_MUTEX(table_lock);
|
2014-10-27 09:42:45 +00:00
|
|
|
static atomic_t reference_count = ATOMIC_INIT(0);
|
|
|
|
|
2014-11-16 02:30:00 +00:00
|
|
|
|
|
|
|
static int request_operation(struct gb_connection *connection, int type,
|
|
|
|
void *response, int response_size)
|
|
|
|
{
|
|
|
|
struct gb_operation *operation;
|
2014-11-19 22:29:15 +00:00
|
|
|
struct gb_uart_simple_response *fake_response;
|
2014-11-16 02:30:00 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
operation = gb_operation_create(connection, type, 0, response_size);
|
2014-11-19 22:29:15 +00:00
|
|
|
if (!operation)
|
2014-11-16 02:30:00 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* Synchronous operation--no callback */
|
|
|
|
ret = gb_operation_request_send(operation, NULL);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("version operation failed (%d)\n", ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We only want to look at the status, and all requests have the same
|
|
|
|
* layout for where the status is, so cast this to a random request so
|
|
|
|
* we can see the status easier.
|
|
|
|
*/
|
2014-11-19 22:29:15 +00:00
|
|
|
fake_response = operation->response.payload;
|
|
|
|
if (fake_response->status) {
|
2014-11-16 02:30:00 +00:00
|
|
|
gb_connection_err(connection, "response %hhu",
|
2014-11-19 22:29:15 +00:00
|
|
|
fake_response->status);
|
2014-11-16 02:30:00 +00:00
|
|
|
ret = -EIO;
|
|
|
|
} else {
|
|
|
|
/* Good request, so copy to the caller's buffer */
|
2014-11-17 23:15:34 +00:00
|
|
|
if (response_size && response)
|
2014-11-19 22:29:15 +00:00
|
|
|
memcpy(response, fake_response, response_size);
|
2014-11-16 02:30:00 +00:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
gb_operation_destroy(operation);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This request only uses the connection field, and if successful,
|
|
|
|
* fills in the major and minor protocol version of the target.
|
|
|
|
*/
|
|
|
|
static int get_version(struct gb_tty *tty)
|
|
|
|
{
|
2014-11-19 22:29:15 +00:00
|
|
|
struct gb_uart_proto_version_response version_response;
|
2014-11-16 02:30:00 +00:00
|
|
|
int retval;
|
|
|
|
|
|
|
|
retval = request_operation(tty->connection,
|
|
|
|
GB_UART_REQ_PROTOCOL_VERSION,
|
2014-11-19 22:29:15 +00:00
|
|
|
&version_response, sizeof(version_response));
|
2014-11-16 02:30:00 +00:00
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
2014-11-19 22:29:15 +00:00
|
|
|
if (version_response.major > GB_UART_VERSION_MAJOR) {
|
2014-11-16 02:30:00 +00:00
|
|
|
pr_err("unsupported major version (%hhu > %hhu)\n",
|
2014-11-19 22:29:15 +00:00
|
|
|
version_response.major, GB_UART_VERSION_MAJOR);
|
2014-11-16 02:30:00 +00:00
|
|
|
return -ENOTSUPP;
|
|
|
|
}
|
|
|
|
|
2014-11-19 22:29:15 +00:00
|
|
|
tty->version_major = version_response.major;
|
|
|
|
tty->version_minor = version_response.minor;
|
2014-11-16 02:30:00 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int send_data(struct gb_tty *tty, u16 size, const u8 *data)
|
|
|
|
{
|
|
|
|
struct gb_connection *connection = tty->connection;
|
|
|
|
struct gb_operation *operation;
|
|
|
|
struct gb_uart_send_data_request *request;
|
|
|
|
struct gb_uart_simple_response *response;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
if (!data || !size)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
operation = gb_operation_create(connection, GB_UART_REQ_SEND_DATA,
|
|
|
|
sizeof(*request) + size,
|
|
|
|
sizeof(*response));
|
|
|
|
if (!operation)
|
|
|
|
return -ENOMEM;
|
2014-11-18 00:08:31 +00:00
|
|
|
request = operation->request.payload;
|
2014-11-16 02:30:00 +00:00
|
|
|
request->size = cpu_to_le16(size);
|
|
|
|
memcpy(&request->data[0], data, size);
|
|
|
|
|
|
|
|
/* Synchronous operation--no callback */
|
|
|
|
retval = gb_operation_request_send(operation, NULL);
|
|
|
|
if (retval) {
|
|
|
|
dev_err(&connection->dev,
|
|
|
|
"send data operation failed (%d)\n", retval);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-11-18 00:08:31 +00:00
|
|
|
response = operation->response.payload;
|
2014-11-16 02:30:00 +00:00
|
|
|
if (response->status) {
|
|
|
|
gb_connection_err(connection, "send data response %hhu",
|
|
|
|
response->status);
|
|
|
|
retval = -EIO;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
gb_operation_destroy(operation);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int send_line_coding(struct gb_tty *tty,
|
|
|
|
struct gb_serial_line_coding *line_coding)
|
|
|
|
{
|
|
|
|
struct gb_connection *connection = tty->connection;
|
|
|
|
struct gb_operation *operation;
|
|
|
|
struct gb_uart_set_line_coding_request *request;
|
|
|
|
struct gb_uart_simple_response *response;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
operation = gb_operation_create(connection, GB_UART_REQ_SET_LINE_CODING,
|
|
|
|
sizeof(*request),
|
|
|
|
sizeof(*response));
|
|
|
|
if (!operation)
|
|
|
|
return -ENOMEM;
|
2014-11-18 00:08:31 +00:00
|
|
|
request = operation->request.payload;
|
2014-11-16 02:30:00 +00:00
|
|
|
memcpy(&request->line_coding, line_coding, sizeof(*line_coding));
|
|
|
|
|
|
|
|
/* Synchronous operation--no callback */
|
|
|
|
retval = gb_operation_request_send(operation, NULL);
|
|
|
|
if (retval) {
|
|
|
|
dev_err(&connection->dev,
|
|
|
|
"send line coding operation failed (%d)\n", retval);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-11-18 00:08:31 +00:00
|
|
|
response = operation->response.payload;
|
2014-11-16 02:30:00 +00:00
|
|
|
if (response->status) {
|
|
|
|
gb_connection_err(connection, "send line coding response %hhu",
|
|
|
|
response->status);
|
|
|
|
retval = -EIO;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
gb_operation_destroy(operation);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int send_control(struct gb_tty *tty, u16 control)
|
|
|
|
{
|
|
|
|
struct gb_connection *connection = tty->connection;
|
|
|
|
struct gb_operation *operation;
|
|
|
|
struct gb_uart_set_control_line_state_request *request;
|
|
|
|
struct gb_uart_simple_response *response;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
operation = gb_operation_create(connection,
|
|
|
|
GB_UART_REQ_SET_CONTROL_LINE_STATE,
|
|
|
|
sizeof(*request),
|
|
|
|
sizeof(*response));
|
|
|
|
if (!operation)
|
|
|
|
return -ENOMEM;
|
2014-11-18 00:08:31 +00:00
|
|
|
request = operation->request.payload;
|
2014-11-16 02:30:00 +00:00
|
|
|
request->control = cpu_to_le16(control);
|
|
|
|
|
|
|
|
/* Synchronous operation--no callback */
|
|
|
|
retval = gb_operation_request_send(operation, NULL);
|
|
|
|
if (retval) {
|
|
|
|
dev_err(&connection->dev,
|
|
|
|
"send control operation failed (%d)\n", retval);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-11-18 00:08:31 +00:00
|
|
|
response = operation->response.payload;
|
2014-11-16 02:30:00 +00:00
|
|
|
if (response->status) {
|
|
|
|
gb_connection_err(connection, "send control response %hhu",
|
|
|
|
response->status);
|
|
|
|
retval = -EIO;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
gb_operation_destroy(operation);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int send_break(struct gb_tty *tty, u8 state)
|
|
|
|
{
|
|
|
|
struct gb_connection *connection = tty->connection;
|
|
|
|
struct gb_operation *operation;
|
|
|
|
struct gb_uart_set_break_request *request;
|
|
|
|
struct gb_uart_simple_response *response;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
if ((state != 0) && (state != 1)) {
|
|
|
|
dev_err(&connection->dev, "invalid break state of %d\n", state);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
operation = gb_operation_create(connection, GB_UART_REQ_SET_BREAK,
|
|
|
|
sizeof(*request),
|
|
|
|
sizeof(*response));
|
|
|
|
if (!operation)
|
|
|
|
return -ENOMEM;
|
2014-11-18 00:08:31 +00:00
|
|
|
request = operation->request.payload;
|
2014-11-16 02:30:00 +00:00
|
|
|
request->state = state;
|
|
|
|
|
|
|
|
/* Synchronous operation--no callback */
|
|
|
|
retval = gb_operation_request_send(operation, NULL);
|
|
|
|
if (retval) {
|
|
|
|
dev_err(&connection->dev,
|
|
|
|
"send break operation failed (%d)\n", retval);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-11-18 00:08:31 +00:00
|
|
|
response = operation->response.payload;
|
2014-11-16 02:30:00 +00:00
|
|
|
if (response->status) {
|
|
|
|
gb_connection_err(connection, "send break response %hhu",
|
|
|
|
response->status);
|
|
|
|
retval = -EIO;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
gb_operation_destroy(operation);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2014-08-15 10:33:33 +00:00
|
|
|
|
|
|
|
static struct gb_tty *get_gb_by_minor(unsigned minor)
|
|
|
|
{
|
|
|
|
struct gb_tty *gb_tty;
|
|
|
|
|
|
|
|
mutex_lock(&table_lock);
|
|
|
|
gb_tty = idr_find(&tty_minors, minor);
|
2014-08-15 11:44:32 +00:00
|
|
|
if (gb_tty) {
|
|
|
|
mutex_lock(&gb_tty->mutex);
|
|
|
|
if (gb_tty->disconnected) {
|
|
|
|
mutex_unlock(&gb_tty->mutex);
|
|
|
|
gb_tty = NULL;
|
|
|
|
} else {
|
|
|
|
tty_port_get(&gb_tty->port);
|
|
|
|
mutex_unlock(&gb_tty->mutex);
|
|
|
|
}
|
|
|
|
}
|
2014-08-15 10:33:33 +00:00
|
|
|
mutex_unlock(&table_lock);
|
|
|
|
return gb_tty;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int alloc_minor(struct gb_tty *gb_tty)
|
|
|
|
{
|
|
|
|
int minor;
|
|
|
|
|
|
|
|
mutex_lock(&table_lock);
|
greybus: uart-gb: improve minor device number error checking
When alloc_minor() finds an available minor device number it
does not constrain the highest number desired. Instead, it
relies on its caller, tty_gb_probe() to see if the returned
number indicates all minor numbers have been exhausted.
There are a couple problems with this--or rather with this
code.
First, if an allocation is attempted *after* GB_NUM_MINORS
is returned, a new number greater than (but not equal to)
GB_NUM_MINORS will be allocated, and that won't produce
any error condition.
Second, alloc_minor() can return an error code (like -ENOMEM). And
its caller is only checking for GB_NUM_MINORS. If an error code
is returned, tty_gb_probe() simply uses it.
Change alloc_minor() so it requests minor device numbers in the
range 0..(GB_NUM_MINORS-1), and use an error return to detect
when the minor device numbers have been exhausted.
If alloc_minor() returns -ENOSPC (from idr_alloc()), translate that
to -ENODEV. The only other error we might see is -ENOMEM, and if
we get that, return it.
Finally, zero gb_tty->minor when it's released. (If this is
actually important a reserved value like GB_NUM_MINORS should
be used instead to signify a gb_tty with no minor assigned.)
Signed-off-by: Alex Elder <elder@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-08-18 23:25:11 +00:00
|
|
|
minor = idr_alloc(&tty_minors, gb_tty, 0, GB_NUM_MINORS, GFP_KERNEL);
|
2014-08-15 10:33:33 +00:00
|
|
|
mutex_unlock(&table_lock);
|
greybus: uart-gb: improve minor device number error checking
When alloc_minor() finds an available minor device number it
does not constrain the highest number desired. Instead, it
relies on its caller, tty_gb_probe() to see if the returned
number indicates all minor numbers have been exhausted.
There are a couple problems with this--or rather with this
code.
First, if an allocation is attempted *after* GB_NUM_MINORS
is returned, a new number greater than (but not equal to)
GB_NUM_MINORS will be allocated, and that won't produce
any error condition.
Second, alloc_minor() can return an error code (like -ENOMEM). And
its caller is only checking for GB_NUM_MINORS. If an error code
is returned, tty_gb_probe() simply uses it.
Change alloc_minor() so it requests minor device numbers in the
range 0..(GB_NUM_MINORS-1), and use an error return to detect
when the minor device numbers have been exhausted.
If alloc_minor() returns -ENOSPC (from idr_alloc()), translate that
to -ENODEV. The only other error we might see is -ENOMEM, and if
we get that, return it.
Finally, zero gb_tty->minor when it's released. (If this is
actually important a reserved value like GB_NUM_MINORS should
be used instead to signify a gb_tty with no minor assigned.)
Signed-off-by: Alex Elder <elder@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-08-18 23:25:11 +00:00
|
|
|
if (minor >= 0)
|
|
|
|
gb_tty->minor = minor;
|
2014-08-15 10:33:33 +00:00
|
|
|
return minor;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void release_minor(struct gb_tty *gb_tty)
|
|
|
|
{
|
greybus: uart-gb: improve minor device number error checking
When alloc_minor() finds an available minor device number it
does not constrain the highest number desired. Instead, it
relies on its caller, tty_gb_probe() to see if the returned
number indicates all minor numbers have been exhausted.
There are a couple problems with this--or rather with this
code.
First, if an allocation is attempted *after* GB_NUM_MINORS
is returned, a new number greater than (but not equal to)
GB_NUM_MINORS will be allocated, and that won't produce
any error condition.
Second, alloc_minor() can return an error code (like -ENOMEM). And
its caller is only checking for GB_NUM_MINORS. If an error code
is returned, tty_gb_probe() simply uses it.
Change alloc_minor() so it requests minor device numbers in the
range 0..(GB_NUM_MINORS-1), and use an error return to detect
when the minor device numbers have been exhausted.
If alloc_minor() returns -ENOSPC (from idr_alloc()), translate that
to -ENODEV. The only other error we might see is -ENOMEM, and if
we get that, return it.
Finally, zero gb_tty->minor when it's released. (If this is
actually important a reserved value like GB_NUM_MINORS should
be used instead to signify a gb_tty with no minor assigned.)
Signed-off-by: Alex Elder <elder@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-08-18 23:25:11 +00:00
|
|
|
int minor = gb_tty->minor;
|
|
|
|
|
|
|
|
gb_tty->minor = 0; /* Maybe should use an invalid value instead */
|
2014-08-15 10:33:33 +00:00
|
|
|
mutex_lock(&table_lock);
|
greybus: uart-gb: improve minor device number error checking
When alloc_minor() finds an available minor device number it
does not constrain the highest number desired. Instead, it
relies on its caller, tty_gb_probe() to see if the returned
number indicates all minor numbers have been exhausted.
There are a couple problems with this--or rather with this
code.
First, if an allocation is attempted *after* GB_NUM_MINORS
is returned, a new number greater than (but not equal to)
GB_NUM_MINORS will be allocated, and that won't produce
any error condition.
Second, alloc_minor() can return an error code (like -ENOMEM). And
its caller is only checking for GB_NUM_MINORS. If an error code
is returned, tty_gb_probe() simply uses it.
Change alloc_minor() so it requests minor device numbers in the
range 0..(GB_NUM_MINORS-1), and use an error return to detect
when the minor device numbers have been exhausted.
If alloc_minor() returns -ENOSPC (from idr_alloc()), translate that
to -ENODEV. The only other error we might see is -ENOMEM, and if
we get that, return it.
Finally, zero gb_tty->minor when it's released. (If this is
actually important a reserved value like GB_NUM_MINORS should
be used instead to signify a gb_tty with no minor assigned.)
Signed-off-by: Alex Elder <elder@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-08-18 23:25:11 +00:00
|
|
|
idr_remove(&tty_minors, minor);
|
2014-08-15 10:33:33 +00:00
|
|
|
mutex_unlock(&table_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gb_tty_install(struct tty_driver *driver, struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct gb_tty *gb_tty;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
gb_tty = get_gb_by_minor(tty->index);
|
|
|
|
if (!gb_tty)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
retval = tty_standard_install(driver, tty);
|
|
|
|
if (retval)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
tty->driver_data = gb_tty;
|
|
|
|
return 0;
|
|
|
|
error:
|
|
|
|
tty_port_put(&gb_tty->port);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gb_tty_open(struct tty_struct *tty, struct file *file)
|
|
|
|
{
|
|
|
|
struct gb_tty *gb_tty = tty->driver_data;
|
|
|
|
|
|
|
|
return tty_port_open(&gb_tty->port, tty, file);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gb_tty_close(struct tty_struct *tty, struct file *file)
|
|
|
|
{
|
|
|
|
struct gb_tty *gb_tty = tty->driver_data;
|
|
|
|
|
|
|
|
tty_port_close(&gb_tty->port, tty, file);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gb_tty_cleanup(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct gb_tty *gb_tty = tty->driver_data;
|
|
|
|
|
|
|
|
tty_port_put(&gb_tty->port);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gb_tty_hangup(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct gb_tty *gb_tty = tty->driver_data;
|
|
|
|
|
|
|
|
tty_port_hangup(&gb_tty->port);
|
|
|
|
}
|
|
|
|
|
2014-08-15 10:54:11 +00:00
|
|
|
static int gb_tty_write(struct tty_struct *tty, const unsigned char *buf,
|
|
|
|
int count)
|
|
|
|
{
|
2014-11-16 02:30:00 +00:00
|
|
|
struct gb_tty *gb_tty = tty->driver_data;
|
2014-08-15 10:54:11 +00:00
|
|
|
|
2014-11-16 02:30:00 +00:00
|
|
|
return send_data(gb_tty, count, buf);
|
2014-08-15 10:54:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int gb_tty_write_room(struct tty_struct *tty)
|
|
|
|
{
|
2014-08-15 11:44:32 +00:00
|
|
|
// struct gb_tty *gb_tty = tty->driver_data;
|
2014-08-15 10:54:11 +00:00
|
|
|
|
|
|
|
// FIXME - how much do we want to say we have room for?
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gb_tty_chars_in_buffer(struct tty_struct *tty)
|
|
|
|
{
|
2014-08-15 11:44:32 +00:00
|
|
|
// struct gb_tty *gb_tty = tty->driver_data;
|
2014-08-15 10:54:11 +00:00
|
|
|
|
|
|
|
// FIXME - how many left to send?
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-15 11:44:32 +00:00
|
|
|
static int gb_tty_break_ctl(struct tty_struct *tty, int state)
|
|
|
|
{
|
2014-11-16 02:30:00 +00:00
|
|
|
struct gb_tty *gb_tty = tty->driver_data;
|
2014-08-15 11:44:32 +00:00
|
|
|
|
2014-11-16 02:30:00 +00:00
|
|
|
return send_break(gb_tty, state ? 1 : 0);
|
2014-08-15 11:44:32 +00:00
|
|
|
}
|
|
|
|
|
2014-11-16 02:30:00 +00:00
|
|
|
static void gb_tty_set_termios(struct tty_struct *tty,
|
|
|
|
struct ktermios *termios_old)
|
2014-08-15 11:44:32 +00:00
|
|
|
{
|
2014-11-16 02:30:00 +00:00
|
|
|
struct gb_tty *gb_tty = tty->driver_data;
|
|
|
|
struct ktermios *termios = &tty->termios;
|
|
|
|
struct gb_serial_line_coding newline;
|
|
|
|
int newctrl = gb_tty->ctrlout;
|
|
|
|
|
|
|
|
newline.rate = cpu_to_le32(tty_get_baud_rate(tty));
|
|
|
|
newline.format = termios->c_cflag & CSTOPB ? 2 : 0;
|
|
|
|
newline.parity = termios->c_cflag & PARENB ?
|
|
|
|
(termios->c_cflag & PARODD ? 1 : 2) +
|
|
|
|
(termios->c_cflag & CMSPAR ? 2 : 0) : 0;
|
|
|
|
|
|
|
|
switch (termios->c_cflag & CSIZE) {
|
|
|
|
case CS5:
|
|
|
|
newline.data = 5;
|
|
|
|
break;
|
|
|
|
case CS6:
|
|
|
|
newline.data = 6;
|
|
|
|
break;
|
|
|
|
case CS7:
|
|
|
|
newline.data = 7;
|
|
|
|
break;
|
|
|
|
case CS8:
|
|
|
|
default:
|
|
|
|
newline.data = 8;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* FIXME: needs to clear unsupported bits in the termios */
|
|
|
|
gb_tty->clocal = ((termios->c_cflag & CLOCAL) != 0);
|
|
|
|
|
|
|
|
if (C_BAUD(tty) == B0) {
|
|
|
|
newline.rate = gb_tty->line_coding.rate;
|
|
|
|
newctrl &= GB_UART_CTRL_DTR;
|
|
|
|
} else if (termios_old && (termios_old->c_cflag & CBAUD) == B0) {
|
|
|
|
newctrl |= GB_UART_CTRL_DTR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (newctrl != gb_tty->ctrlout) {
|
|
|
|
gb_tty->ctrlout = newctrl;
|
|
|
|
send_control(gb_tty, newctrl);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (memcpy(&gb_tty->line_coding, &newline, sizeof(newline))) {
|
|
|
|
memcpy(&gb_tty->line_coding, &newline, sizeof(newline));
|
|
|
|
send_line_coding(gb_tty, &gb_tty->line_coding);
|
|
|
|
}
|
2014-08-15 11:44:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int gb_tty_tiocmget(struct tty_struct *tty)
|
|
|
|
{
|
2014-11-16 02:30:00 +00:00
|
|
|
struct gb_tty *gb_tty = tty->driver_data;
|
2014-08-15 11:44:32 +00:00
|
|
|
|
2014-11-16 02:30:00 +00:00
|
|
|
return (gb_tty->ctrlout & GB_UART_CTRL_DTR ? TIOCM_DTR : 0) |
|
|
|
|
(gb_tty->ctrlout & GB_UART_CTRL_RTS ? TIOCM_RTS : 0) |
|
|
|
|
(gb_tty->ctrlin & GB_UART_CTRL_DSR ? TIOCM_DSR : 0) |
|
|
|
|
(gb_tty->ctrlin & GB_UART_CTRL_RI ? TIOCM_RI : 0) |
|
|
|
|
(gb_tty->ctrlin & GB_UART_CTRL_DCD ? TIOCM_CD : 0) |
|
|
|
|
TIOCM_CTS;
|
2014-08-15 11:44:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int gb_tty_tiocmset(struct tty_struct *tty, unsigned int set,
|
|
|
|
unsigned int clear)
|
|
|
|
{
|
2014-11-16 02:30:00 +00:00
|
|
|
struct gb_tty *gb_tty = tty->driver_data;
|
|
|
|
unsigned int newctrl = gb_tty->ctrlout;
|
2014-08-15 11:44:32 +00:00
|
|
|
|
2014-11-16 02:30:00 +00:00
|
|
|
set = (set & TIOCM_DTR ? GB_UART_CTRL_DTR : 0) |
|
|
|
|
(set & TIOCM_RTS ? GB_UART_CTRL_RTS : 0);
|
|
|
|
clear = (clear & TIOCM_DTR ? GB_UART_CTRL_DTR : 0) |
|
|
|
|
(clear & TIOCM_RTS ? GB_UART_CTRL_RTS : 0);
|
|
|
|
|
|
|
|
newctrl = (newctrl & ~clear) | set;
|
|
|
|
if (gb_tty->ctrlout == newctrl)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
gb_tty->ctrlout = newctrl;
|
|
|
|
return send_control(gb_tty, newctrl);
|
2014-08-15 11:44:32 +00:00
|
|
|
}
|
|
|
|
|
2014-08-15 10:54:11 +00:00
|
|
|
static void gb_tty_throttle(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct gb_tty *gb_tty = tty->driver_data;
|
|
|
|
|
|
|
|
spin_lock_irq(&gb_tty->read_lock);
|
|
|
|
gb_tty->throttle_req = 1;
|
|
|
|
spin_unlock_irq(&gb_tty->read_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gb_tty_unthrottle(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct gb_tty *gb_tty = tty->driver_data;
|
|
|
|
unsigned int was_throttled;
|
|
|
|
|
|
|
|
spin_lock_irq(&gb_tty->read_lock);
|
|
|
|
was_throttled = gb_tty->throttled;
|
|
|
|
gb_tty->throttle_req = 0;
|
|
|
|
gb_tty->throttled = 0;
|
|
|
|
spin_unlock_irq(&gb_tty->read_lock);
|
|
|
|
|
|
|
|
if (was_throttled) {
|
|
|
|
// FIXME - send more data
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-15 11:44:32 +00:00
|
|
|
static int get_serial_info(struct gb_tty *gb_tty,
|
|
|
|
struct serial_struct __user *info)
|
|
|
|
{
|
|
|
|
struct serial_struct tmp;
|
|
|
|
|
|
|
|
if (!info)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
memset(&tmp, 0, sizeof(tmp));
|
|
|
|
tmp.flags = ASYNC_LOW_LATENCY;
|
|
|
|
tmp.xmit_fifo_size = gb_tty->writesize;
|
|
|
|
tmp.baud_base = 0; // FIXME
|
|
|
|
tmp.close_delay = gb_tty->port.close_delay / 10;
|
|
|
|
tmp.closing_wait = gb_tty->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
|
|
|
|
ASYNC_CLOSING_WAIT_NONE : gb_tty->port.closing_wait / 10;
|
|
|
|
|
|
|
|
if (copy_to_user(info, &tmp, sizeof(tmp)))
|
|
|
|
return -EFAULT;
|
2014-09-02 02:10:06 +00:00
|
|
|
return 0;
|
2014-08-15 11:44:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int set_serial_info(struct gb_tty *gb_tty,
|
|
|
|
struct serial_struct __user *newinfo)
|
|
|
|
{
|
|
|
|
struct serial_struct new_serial;
|
|
|
|
unsigned int closing_wait;
|
|
|
|
unsigned int close_delay;
|
2014-09-22 23:53:02 +00:00
|
|
|
int retval = 0;
|
2014-08-15 11:44:32 +00:00
|
|
|
|
|
|
|
if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
close_delay = new_serial.close_delay * 10;
|
|
|
|
closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
|
|
|
|
ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
|
|
|
|
|
|
|
|
mutex_lock(&gb_tty->port.mutex);
|
|
|
|
if (!capable(CAP_SYS_ADMIN)) {
|
|
|
|
if ((close_delay != gb_tty->port.close_delay) ||
|
|
|
|
(closing_wait != gb_tty->port.closing_wait))
|
|
|
|
retval = -EPERM;
|
|
|
|
else
|
|
|
|
retval = -EOPNOTSUPP;
|
|
|
|
} else {
|
|
|
|
gb_tty->port.close_delay = close_delay;
|
|
|
|
gb_tty->port.closing_wait = closing_wait;
|
|
|
|
}
|
|
|
|
mutex_unlock(&gb_tty->port.mutex);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wait_serial_change(struct gb_tty *gb_tty, unsigned long arg)
|
|
|
|
{
|
|
|
|
int retval = 0;
|
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
|
|
struct async_icount old;
|
|
|
|
struct async_icount new;
|
|
|
|
|
2014-08-18 23:25:12 +00:00
|
|
|
if (!(arg & (TIOCM_DSR | TIOCM_RI | TIOCM_CD)))
|
2014-08-15 11:44:32 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
do {
|
|
|
|
spin_lock_irq(&gb_tty->read_lock);
|
|
|
|
old = gb_tty->oldcount;
|
|
|
|
new = gb_tty->iocount;
|
|
|
|
gb_tty->oldcount = new;
|
2014-08-18 23:25:12 +00:00
|
|
|
spin_unlock_irq(&gb_tty->read_lock);
|
2014-08-15 11:44:32 +00:00
|
|
|
|
|
|
|
if ((arg & TIOCM_DSR) && (old.dsr != new.dsr))
|
|
|
|
break;
|
|
|
|
if ((arg & TIOCM_CD) && (old.dcd != new.dcd))
|
|
|
|
break;
|
|
|
|
if ((arg & TIOCM_RI) && (old.rng != new.rng))
|
|
|
|
break;
|
|
|
|
|
|
|
|
add_wait_queue(&gb_tty->wioctl, &wait);
|
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
|
|
schedule();
|
|
|
|
remove_wait_queue(&gb_tty->wioctl, &wait);
|
|
|
|
if (gb_tty->disconnected) {
|
|
|
|
if (arg & TIOCM_CD)
|
|
|
|
break;
|
2014-08-18 23:25:12 +00:00
|
|
|
retval = -ENODEV;
|
|
|
|
} else if (signal_pending(current)) {
|
|
|
|
retval = -ERESTARTSYS;
|
2014-08-15 11:44:32 +00:00
|
|
|
}
|
|
|
|
} while (!retval);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_serial_usage(struct gb_tty *gb_tty,
|
|
|
|
struct serial_icounter_struct __user *count)
|
|
|
|
{
|
|
|
|
struct serial_icounter_struct icount;
|
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
memset(&icount, 0, sizeof(icount));
|
|
|
|
icount.dsr = gb_tty->iocount.dsr;
|
|
|
|
icount.rng = gb_tty->iocount.rng;
|
|
|
|
icount.dcd = gb_tty->iocount.dcd;
|
|
|
|
icount.frame = gb_tty->iocount.frame;
|
|
|
|
icount.overrun = gb_tty->iocount.overrun;
|
|
|
|
icount.parity = gb_tty->iocount.parity;
|
|
|
|
icount.brk = gb_tty->iocount.brk;
|
|
|
|
|
|
|
|
if (copy_to_user(count, &icount, sizeof(icount)) > 0)
|
|
|
|
retval = -EFAULT;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gb_tty_ioctl(struct tty_struct *tty, unsigned int cmd,
|
|
|
|
unsigned long arg)
|
|
|
|
{
|
|
|
|
struct gb_tty *gb_tty = tty->driver_data;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case TIOCGSERIAL:
|
2014-08-30 23:20:22 +00:00
|
|
|
return get_serial_info(gb_tty,
|
|
|
|
(struct serial_struct __user *)arg);
|
2014-08-15 11:44:32 +00:00
|
|
|
case TIOCSSERIAL:
|
2014-08-30 23:20:22 +00:00
|
|
|
return set_serial_info(gb_tty,
|
|
|
|
(struct serial_struct __user *)arg);
|
2014-08-15 11:44:32 +00:00
|
|
|
case TIOCMIWAIT:
|
2014-08-30 23:20:22 +00:00
|
|
|
return wait_serial_change(gb_tty, arg);
|
2014-08-15 11:44:32 +00:00
|
|
|
case TIOCGICOUNT:
|
2014-08-30 23:20:22 +00:00
|
|
|
return get_serial_usage(gb_tty,
|
|
|
|
(struct serial_icounter_struct __user *)arg);
|
2014-08-15 11:44:32 +00:00
|
|
|
}
|
|
|
|
|
2014-08-30 23:20:22 +00:00
|
|
|
return -ENOIOCTLCMD;
|
2014-08-15 11:44:32 +00:00
|
|
|
}
|
|
|
|
|
2014-08-15 08:01:23 +00:00
|
|
|
|
|
|
|
static const struct tty_operations gb_ops = {
|
|
|
|
.install = gb_tty_install,
|
|
|
|
.open = gb_tty_open,
|
|
|
|
.close = gb_tty_close,
|
|
|
|
.cleanup = gb_tty_cleanup,
|
|
|
|
.hangup = gb_tty_hangup,
|
|
|
|
.write = gb_tty_write,
|
|
|
|
.write_room = gb_tty_write_room,
|
|
|
|
.ioctl = gb_tty_ioctl,
|
|
|
|
.throttle = gb_tty_throttle,
|
|
|
|
.unthrottle = gb_tty_unthrottle,
|
|
|
|
.chars_in_buffer = gb_tty_chars_in_buffer,
|
|
|
|
.break_ctl = gb_tty_break_ctl,
|
|
|
|
.set_termios = gb_tty_set_termios,
|
|
|
|
.tiocmget = gb_tty_tiocmget,
|
|
|
|
.tiocmset = gb_tty_tiocmset,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2014-11-16 02:30:00 +00:00
|
|
|
static int gb_tty_init(void);
|
|
|
|
static void gb_tty_exit(void);
|
|
|
|
|
2014-10-28 01:49:33 +00:00
|
|
|
static int gb_uart_connection_init(struct gb_connection *connection)
|
2014-08-15 08:01:23 +00:00
|
|
|
{
|
2014-08-15 10:54:11 +00:00
|
|
|
struct gb_tty *gb_tty;
|
|
|
|
struct device *tty_dev;
|
2014-08-15 08:01:23 +00:00
|
|
|
int retval;
|
2014-08-15 10:54:11 +00:00
|
|
|
int minor;
|
|
|
|
|
2014-10-27 09:42:45 +00:00
|
|
|
/* First time here, initialize the tty structures */
|
|
|
|
if (atomic_inc_return(&reference_count) == 1) {
|
|
|
|
retval = gb_tty_init();
|
|
|
|
if (retval) {
|
|
|
|
atomic_dec(&reference_count);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-31 00:18:04 +00:00
|
|
|
gb_tty = kzalloc(sizeof(*gb_tty), GFP_KERNEL);
|
2014-08-15 10:54:11 +00:00
|
|
|
if (!gb_tty)
|
|
|
|
return -ENOMEM;
|
2014-11-16 02:30:00 +00:00
|
|
|
gb_tty->connection = connection;
|
|
|
|
|
|
|
|
/* Check for compatible protocol version */
|
|
|
|
retval = get_version(gb_tty);
|
|
|
|
if (retval)
|
|
|
|
goto error_version;
|
2014-08-15 10:54:11 +00:00
|
|
|
|
|
|
|
minor = alloc_minor(gb_tty);
|
greybus: uart-gb: improve minor device number error checking
When alloc_minor() finds an available minor device number it
does not constrain the highest number desired. Instead, it
relies on its caller, tty_gb_probe() to see if the returned
number indicates all minor numbers have been exhausted.
There are a couple problems with this--or rather with this
code.
First, if an allocation is attempted *after* GB_NUM_MINORS
is returned, a new number greater than (but not equal to)
GB_NUM_MINORS will be allocated, and that won't produce
any error condition.
Second, alloc_minor() can return an error code (like -ENOMEM). And
its caller is only checking for GB_NUM_MINORS. If an error code
is returned, tty_gb_probe() simply uses it.
Change alloc_minor() so it requests minor device numbers in the
range 0..(GB_NUM_MINORS-1), and use an error return to detect
when the minor device numbers have been exhausted.
If alloc_minor() returns -ENOSPC (from idr_alloc()), translate that
to -ENODEV. The only other error we might see is -ENOMEM, and if
we get that, return it.
Finally, zero gb_tty->minor when it's released. (If this is
actually important a reserved value like GB_NUM_MINORS should
be used instead to signify a gb_tty with no minor assigned.)
Signed-off-by: Alex Elder <elder@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-08-18 23:25:11 +00:00
|
|
|
if (minor < 0) {
|
|
|
|
if (minor == -ENOSPC) {
|
2014-11-16 02:30:00 +00:00
|
|
|
dev_err(&connection->dev,
|
|
|
|
"no more free minor numbers\n");
|
greybus: uart-gb: improve minor device number error checking
When alloc_minor() finds an available minor device number it
does not constrain the highest number desired. Instead, it
relies on its caller, tty_gb_probe() to see if the returned
number indicates all minor numbers have been exhausted.
There are a couple problems with this--or rather with this
code.
First, if an allocation is attempted *after* GB_NUM_MINORS
is returned, a new number greater than (but not equal to)
GB_NUM_MINORS will be allocated, and that won't produce
any error condition.
Second, alloc_minor() can return an error code (like -ENOMEM). And
its caller is only checking for GB_NUM_MINORS. If an error code
is returned, tty_gb_probe() simply uses it.
Change alloc_minor() so it requests minor device numbers in the
range 0..(GB_NUM_MINORS-1), and use an error return to detect
when the minor device numbers have been exhausted.
If alloc_minor() returns -ENOSPC (from idr_alloc()), translate that
to -ENODEV. The only other error we might see is -ENOMEM, and if
we get that, return it.
Finally, zero gb_tty->minor when it's released. (If this is
actually important a reserved value like GB_NUM_MINORS should
be used instead to signify a gb_tty with no minor assigned.)
Signed-off-by: Alex Elder <elder@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-08-18 23:25:11 +00:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
return minor;
|
2014-08-15 10:54:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
gb_tty->minor = minor;
|
|
|
|
spin_lock_init(&gb_tty->write_lock);
|
|
|
|
spin_lock_init(&gb_tty->read_lock);
|
2014-08-15 11:44:32 +00:00
|
|
|
init_waitqueue_head(&gb_tty->wioctl);
|
|
|
|
mutex_init(&gb_tty->mutex);
|
2014-08-15 10:54:11 +00:00
|
|
|
|
2014-10-27 09:32:34 +00:00
|
|
|
connection->private = gb_tty;
|
2014-08-15 10:54:11 +00:00
|
|
|
|
2014-11-16 02:30:00 +00:00
|
|
|
send_control(gb_tty, gb_tty->ctrlout);
|
|
|
|
|
|
|
|
/* initialize the uart to be 9600n81 */
|
|
|
|
gb_tty->line_coding.rate = cpu_to_le32(9600);
|
|
|
|
gb_tty->line_coding.format = GB_SERIAL_1_STOP_BITS;
|
|
|
|
gb_tty->line_coding.parity = GB_SERIAL_NO_PARITY;
|
|
|
|
gb_tty->line_coding.data = 8;
|
|
|
|
send_line_coding(gb_tty, &gb_tty->line_coding);
|
|
|
|
|
2014-08-15 10:54:11 +00:00
|
|
|
tty_dev = tty_port_register_device(&gb_tty->port, gb_tty_driver, minor,
|
2014-10-27 09:32:34 +00:00
|
|
|
&connection->dev);
|
2014-08-15 10:54:11 +00:00
|
|
|
if (IS_ERR(tty_dev)) {
|
|
|
|
retval = PTR_ERR(tty_dev);
|
|
|
|
goto error;
|
|
|
|
}
|
2014-08-15 08:01:23 +00:00
|
|
|
|
|
|
|
return 0;
|
2014-08-15 10:54:11 +00:00
|
|
|
error:
|
|
|
|
release_minor(gb_tty);
|
2014-11-16 02:30:00 +00:00
|
|
|
error_version:
|
|
|
|
connection->private = NULL;
|
|
|
|
kfree(gb_tty);
|
2014-08-15 10:54:11 +00:00
|
|
|
return retval;
|
2014-08-15 08:01:23 +00:00
|
|
|
}
|
|
|
|
|
2014-10-28 01:49:33 +00:00
|
|
|
static void gb_uart_connection_exit(struct gb_connection *connection)
|
2014-08-15 08:01:23 +00:00
|
|
|
{
|
2014-10-27 09:32:34 +00:00
|
|
|
struct gb_tty *gb_tty = connection->private;
|
2014-08-15 10:54:11 +00:00
|
|
|
struct tty_struct *tty;
|
|
|
|
|
2014-08-15 11:44:32 +00:00
|
|
|
if (!gb_tty)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&gb_tty->mutex);
|
|
|
|
gb_tty->disconnected = true;
|
|
|
|
|
|
|
|
wake_up_all(&gb_tty->wioctl);
|
2014-10-27 09:32:34 +00:00
|
|
|
connection->private = NULL;
|
2014-08-15 11:44:32 +00:00
|
|
|
mutex_unlock(&gb_tty->mutex);
|
|
|
|
|
2014-08-15 10:54:11 +00:00
|
|
|
tty = tty_port_tty_get(&gb_tty->port);
|
|
|
|
if (tty) {
|
|
|
|
tty_vhangup(tty);
|
|
|
|
tty_kref_put(tty);
|
|
|
|
}
|
|
|
|
/* FIXME - stop all traffic */
|
|
|
|
|
|
|
|
tty_unregister_device(gb_tty_driver, gb_tty->minor);
|
|
|
|
|
2014-08-15 11:44:32 +00:00
|
|
|
/* FIXME - free transmit / recieve buffers */
|
|
|
|
|
2014-08-15 10:54:11 +00:00
|
|
|
tty_port_put(&gb_tty->port);
|
2014-08-31 00:11:41 +00:00
|
|
|
|
|
|
|
kfree(gb_tty);
|
2014-10-27 09:42:45 +00:00
|
|
|
|
|
|
|
/* If last device is gone, tear down the tty structures */
|
|
|
|
if (atomic_dec_return(&reference_count) == 0)
|
|
|
|
gb_tty_exit();
|
2014-08-15 08:01:23 +00:00
|
|
|
}
|
|
|
|
|
2014-10-27 09:42:45 +00:00
|
|
|
static int gb_tty_init(void)
|
2014-08-15 08:01:23 +00:00
|
|
|
{
|
2014-09-06 03:56:10 +00:00
|
|
|
int retval = 0;
|
2014-08-15 08:01:23 +00:00
|
|
|
|
2014-09-06 03:56:09 +00:00
|
|
|
gb_tty_driver = tty_alloc_driver(GB_NUM_MINORS, 0);
|
2014-09-06 03:56:10 +00:00
|
|
|
if (IS_ERR(gb_tty_driver)) {
|
2014-09-13 23:15:52 +00:00
|
|
|
pr_err("Can not allocate tty driver\n");
|
2014-09-06 03:56:10 +00:00
|
|
|
retval = -ENOMEM;
|
|
|
|
goto fail_unregister_dev;
|
|
|
|
}
|
2014-08-15 08:01:23 +00:00
|
|
|
|
|
|
|
gb_tty_driver->driver_name = "gb";
|
2014-09-06 03:56:10 +00:00
|
|
|
gb_tty_driver->name = GB_NAME;
|
2014-09-13 23:15:52 +00:00
|
|
|
gb_tty_driver->major = 0;
|
|
|
|
gb_tty_driver->minor_start = 0;
|
2014-08-15 08:01:23 +00:00
|
|
|
gb_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
|
|
|
|
gb_tty_driver->subtype = SERIAL_TYPE_NORMAL;
|
|
|
|
gb_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
|
|
|
|
gb_tty_driver->init_termios = tty_std_termios;
|
|
|
|
gb_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
|
|
|
|
tty_set_operations(gb_tty_driver, &gb_ops);
|
|
|
|
|
|
|
|
retval = tty_register_driver(gb_tty_driver);
|
2014-09-13 23:15:52 +00:00
|
|
|
if (retval) {
|
|
|
|
pr_err("Can not register tty driver: %d\n", retval);
|
2014-09-06 03:56:10 +00:00
|
|
|
goto fail_put_gb_tty;
|
2014-09-13 23:15:52 +00:00
|
|
|
}
|
2014-08-15 08:01:23 +00:00
|
|
|
|
2014-09-06 03:56:10 +00:00
|
|
|
return 0;
|
|
|
|
|
2014-09-14 00:02:47 +00:00
|
|
|
fail_put_gb_tty:
|
2014-09-06 03:56:10 +00:00
|
|
|
put_tty_driver(gb_tty_driver);
|
2014-09-14 00:02:47 +00:00
|
|
|
fail_unregister_dev:
|
2014-08-15 08:01:23 +00:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2014-10-27 09:42:45 +00:00
|
|
|
static void gb_tty_exit(void)
|
2014-08-15 08:01:23 +00:00
|
|
|
{
|
2014-09-06 03:56:10 +00:00
|
|
|
int major = MAJOR(gb_tty_driver->major);
|
|
|
|
int minor = gb_tty_driver->minor_start;
|
2014-09-14 00:02:47 +00:00
|
|
|
|
2014-08-15 08:01:23 +00:00
|
|
|
tty_unregister_driver(gb_tty_driver);
|
|
|
|
put_tty_driver(gb_tty_driver);
|
2014-09-06 03:56:10 +00:00
|
|
|
unregister_chrdev_region(MKDEV(major, minor), GB_NUM_MINORS);
|
2014-08-15 08:01:23 +00:00
|
|
|
}
|
2014-10-27 11:04:30 +00:00
|
|
|
|
2014-11-05 22:12:53 +00:00
|
|
|
static struct gb_protocol uart_protocol = {
|
|
|
|
.id = GREYBUS_PROTOCOL_UART,
|
|
|
|
.major = 0,
|
|
|
|
.minor = 1,
|
2014-11-05 22:12:54 +00:00
|
|
|
.connection_init = gb_uart_connection_init,
|
|
|
|
.connection_exit = gb_uart_connection_exit,
|
2014-11-16 02:30:00 +00:00
|
|
|
.request_recv = NULL, /* FIXME we have 2 types of requests!!! */
|
2014-11-05 22:12:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
bool gb_uart_protocol_init(void)
|
|
|
|
{
|
|
|
|
return gb_protocol_register(&uart_protocol);
|
|
|
|
}
|
|
|
|
|
|
|
|
void gb_uart_protocol_exit(void)
|
|
|
|
{
|
|
|
|
gb_protocol_deregister(&uart_protocol);
|
|
|
|
}
|