Merge tag 'spi-fix-v4.9-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/spi

[cascardo/linux.git] / drivers / staging / greybus / uart.c

diff --git a/drivers/staging/greybus/uart.c b/drivers/staging/greybus/uart.c
index 8089638..2633d2b 100644 (file)
--- a/drivers/staging/greybus/uart.c
+++ b/drivers/staging/greybus/uart.c
@@ -93,8 +93,8 @@ static int gb_uart_receive_data_handler(struct gb_operation *op)
 
        if (request->payload_size < sizeof(*receive_data)) {
                dev_err(&gb_tty->gbphy_dev->dev,
-                               "short receive-data request received (%zu < %zu)\n",
-                               request->payload_size, sizeof(*receive_data));
+                       "short receive-data request received (%zu < %zu)\n",
+                       request->payload_size, sizeof(*receive_data));
                return -EINVAL;
        }
 
@@ -103,9 +103,9 @@ static int gb_uart_receive_data_handler(struct gb_operation *op)
 
        if (recv_data_size != request->payload_size - sizeof(*receive_data)) {
                dev_err(&gb_tty->gbphy_dev->dev,
-                               "malformed receive-data request received (%u != %zu)\n",
-                               recv_data_size,
-                               request->payload_size - sizeof(*receive_data));
+                       "malformed receive-data request received (%u != %zu)\n",
+                       recv_data_size,
+                       request->payload_size - sizeof(*receive_data));
                return -EINVAL;
        }
 
@@ -145,8 +145,8 @@ static int gb_uart_serial_state_handler(struct gb_operation *op)
 
        if (request->payload_size < sizeof(*serial_state)) {
                dev_err(&gb_tty->gbphy_dev->dev,
-                               "short serial-state event received (%zu < %zu)\n",
-                               request->payload_size, sizeof(*serial_state));
+                       "short serial-state event received (%zu < %zu)\n",
+                       request->payload_size, sizeof(*serial_state));
                return -EINVAL;
        }
 
@@ -168,9 +168,9 @@ static int gb_uart_receive_credits_handler(struct gb_operation *op)
 
        if (request->payload_size < sizeof(*credit_request)) {
                dev_err(&gb_tty->gbphy_dev->dev,
-                               "short receive_credits event received (%zu < %zu)\n",
-                               request->payload_size,
-                               sizeof(*credit_request));
+                       "short receive_credits event received (%zu < %zu)\n",
+                       request->payload_size,
+                       sizeof(*credit_request));
                return -EINVAL;
        }
 
@@ -253,8 +253,8 @@ static void  gb_uart_tx_write_work(struct work_struct *work)
                        send_size = gb_tty->credits;
 
                send_size = kfifo_out_peek(&gb_tty->write_fifo,
-                                       &request->data[0],
-                                       send_size);
+                                          &request->data[0],
+                                          send_size);
                if (!send_size) {
                        spin_unlock_irqrestore(&gb_tty->write_lock, flags);
                        break;
@@ -350,7 +350,7 @@ static int gb_uart_flush(struct gb_tty *gb_tty, u8 flags)
                                 &request, sizeof(request), NULL, 0);
 }
 
-static struct gb_tty *get_gb_by_minor(unsigned minor)
+static struct gb_tty *get_gb_by_minor(unsigned int minor)
 {
        struct gb_tty *gb_tty;
 
@@ -446,7 +446,7 @@ static int gb_tty_write(struct tty_struct *tty, const unsigned char *buf,
        struct gb_tty *gb_tty = tty->driver_data;
 
        count =  kfifo_in_spinlocked(&gb_tty->write_fifo, buf, count,
-                                       &gb_tty->write_lock);
+                                    &gb_tty->write_lock);
        if (count && !gb_tty->close_pending)
                schedule_work(&gb_tty->tx_work);
 
@@ -674,7 +674,6 @@ static int set_serial_info(struct gb_tty *gb_tty,
 static int wait_serial_change(struct gb_tty *gb_tty, unsigned long arg)
 {
        int retval = 0;
-       unsigned long flags;
        DECLARE_WAITQUEUE(wait, current);
        struct async_icount old;
        struct async_icount new;
@@ -683,11 +682,11 @@ static int wait_serial_change(struct gb_tty *gb_tty, unsigned long arg)
                return -EINVAL;
 
        do {
-               spin_lock_irqsave(&gb_tty->read_lock, flags);
+               spin_lock_irq(&gb_tty->read_lock);
                old = gb_tty->oldcount;
                new = gb_tty->iocount;
                gb_tty->oldcount = new;
-               spin_unlock_irqrestore(&gb_tty->read_lock, flags);
+               spin_unlock_irq(&gb_tty->read_lock);
 
                if ((arg & TIOCM_DSR) && (old.dsr != new.dsr))
                        break;
@@ -772,6 +771,16 @@ static void gb_tty_dtr_rts(struct tty_port *port, int on)
        send_control(gb_tty, newctrl);
 }
 
+static int gb_tty_port_activate(struct tty_port *port,
+                               struct tty_struct *tty)
+{
+       struct gb_tty *gb_tty;
+
+       gb_tty = container_of(port, struct gb_tty, port);
+
+       return gbphy_runtime_get_sync(gb_tty->gbphy_dev);
+}
+
 static void gb_tty_port_shutdown(struct tty_port *port)
 {
        struct gb_tty *gb_tty;
@@ -801,6 +810,8 @@ static void gb_tty_port_shutdown(struct tty_port *port)
 
 out:
        gb_tty->close_pending = false;
+
+       gbphy_runtime_put_autosuspend(gb_tty->gbphy_dev);
 }
 
 static const struct tty_operations gb_ops = {
@@ -823,6 +834,7 @@ static const struct tty_operations gb_ops = {
 
 static struct tty_port_operations gb_port_ops = {
        .dtr_rts =              gb_tty_dtr_rts,
+       .activate =             gb_tty_port_activate,
        .shutdown =             gb_tty_port_shutdown,
 };
 
@@ -866,7 +878,7 @@ static int gb_uart_probe(struct gbphy_device *gbphy_dev,
        INIT_WORK(&gb_tty->tx_work, gb_uart_tx_write_work);
 
        retval = kfifo_alloc(&gb_tty->write_fifo, GB_UART_WRITE_FIFO_SIZE,
-                               GFP_KERNEL);
+                            GFP_KERNEL);
        if (retval)
                goto exit_buf_free;
 
@@ -876,7 +888,7 @@ static int gb_uart_probe(struct gbphy_device *gbphy_dev,
        minor = alloc_minor(gb_tty);
        if (minor < 0) {
                if (minor == -ENOSPC) {
-                       dev_err(&connection->bundle->dev,
+                       dev_err(&gbphy_dev->dev,
                                "no more free minor numbers\n");
                        retval = -ENODEV;
                } else {
@@ -923,6 +935,7 @@ static int gb_uart_probe(struct gbphy_device *gbphy_dev,
                goto exit_connection_disable;
        }
 
+       gbphy_runtime_put_autosuspend(gbphy_dev);
        return 0;
 
 exit_connection_disable:
@@ -946,6 +959,11 @@ static void gb_uart_remove(struct gbphy_device *gbphy_dev)
        struct gb_tty *gb_tty = gb_gbphy_get_data(gbphy_dev);
        struct gb_connection *connection = gb_tty->connection;
        struct tty_struct *tty;
+       int ret;
+
+       ret = gbphy_runtime_get_sync(gbphy_dev);
+       if (ret)
+               gbphy_runtime_get_noresume(gbphy_dev);
 
        mutex_lock(&gb_tty->mutex);
        gb_tty->disconnected = true;