Revert "tty: hvc: pass DMA capable memory to put_chars()"

This reverts commit 0986d7bc5598f5df30e3db777d00e73890c97627.

It still has some issues and needs to be dropped at this point in time.

Link: https://lore.kernel.org/r/[e-mail]
Reported-by: Jiri Slaby <[e-mail]>
Cc: Xianting Tian <[e-mail]>
Cc: Shile Zhang <[e-mail]>
Signed-off-by: Greg Kroah-Hartman <[e-mail]>

drivers/tty/hvc/hvc_console.c

···
  */
 #define HVC_CLOSE_WAIT (HZ/100) /* 1/10 of a second */
 
+/*
+ * These sizes are most efficient for vio, because they are the
+ * native transfer size. We could make them selectable in the
+ * future to better deal with backends that want other buffer sizes.
+ */
+#define N_OUTBUF	16
+#define N_INBUF		16
+
+#define __ALIGNED__ __attribute__((__aligned__(L1_CACHE_BYTES)))
+
 static struct tty_driver *hvc_driver;
 static struct task_struct *hvc_task;
 
···
 static const struct hv_ops *cons_ops[MAX_NR_HVC_CONSOLES];
 static uint32_t vtermnos[MAX_NR_HVC_CONSOLES] =
 	{[0 ... MAX_NR_HVC_CONSOLES - 1] = -1};
-static struct hvc_struct *cons_hvcs[MAX_NR_HVC_CONSOLES];
 
 /*
  * Console APIs, NOT TTY.  These APIs are available immediately when
···
 static void hvc_console_print(struct console *co, const char *b,
 			      unsigned count)
 {
-	char *c;
+	char c[N_OUTBUF] __ALIGNED__;
 	unsigned i = 0, n = 0;
 	int r, donecr = 0, index = co->index;
-	unsigned long flags;
-	struct hvc_struct *hp;
 
 	/* Console access attempt outside of acceptable console range. */
 	if (index >= MAX_NR_HVC_CONSOLES)
···
 	if (vtermnos[index] == -1)
 		return;
 
-	hp = cons_hvcs[index];
-	if (!hp)
-		return;
-
-	c = hp->cons_outbuf;
-
-	spin_lock_irqsave(&hp->cons_outbuf_lock, flags);
 	while (count > 0 || i > 0) {
 		if (count > 0 && i < sizeof(c)) {
 			if (b[n] == '\n' && !donecr) {
···
 			}
 		}
 	}
-	spin_unlock_irqrestore(&hp->cons_outbuf_lock, flags);
 	hvc_console_flush(cons_ops[index], vtermnos[index]);
 }
 
···
 	struct tty_struct *tty = driver->ttys[0];
 	struct hvc_struct *hp = tty->driver_data;
 	int n;
-	unsigned long flags;
 
 	do {
-		spin_lock_irqsave(&hp->cons_outbuf_lock, flags);
-		hp->cons_outbuf[0] = ch;
-		n = hp->ops->put_chars(hp->vtermno, &hp->cons_outbuf[0], 1);
-		spin_unlock_irqrestore(&hp->cons_outbuf_lock, flags);
+		n = hp->ops->put_chars(hp->vtermno, &ch, 1);
 	} while (n <= 0);
 }
 #endif
···
 			return ERR_PTR(err);
 	}
 
-	hp = kzalloc(struct_size(hp, outbuf, outbuf_size), GFP_KERNEL);
+	hp = kzalloc(ALIGN(sizeof(*hp), sizeof(long)) + outbuf_size,
+			GFP_KERNEL);
 	if (!hp)
 		return ERR_PTR(-ENOMEM);
 
···
 	hp->data = data;
 	hp->ops = ops;
 	hp->outbuf_size = outbuf_size;
+	hp->outbuf = &((char *)hp)[ALIGN(sizeof(*hp), sizeof(long))];
 
 	tty_port_init(&hp->port);
 	hp->port.ops = &hvc_port_ops;
 
 	INIT_WORK(&hp->tty_resize, hvc_set_winsz);
 	spin_lock_init(&hp->lock);
-	spin_lock_init(&hp->cons_outbuf_lock);
 	mutex_lock(&hvc_structs_mutex);
 
 	/*
···
 	if (i < MAX_NR_HVC_CONSOLES) {
 		cons_ops[i] = ops;
 		vtermnos[i] = vtermno;
-		cons_hvcs[i] = hp;
 	}
 
 	list_add_tail(&(hp->next), &hvc_structs);
···
 	if (hp->index < MAX_NR_HVC_CONSOLES) {
 		vtermnos[hp->index] = -1;
 		cons_ops[hp->index] = NULL;
-		cons_hvcs[hp->index] = NULL;
 	}
 
 	/* Don't whack hp->irq because tty_hangup() will need to free the irq. */

drivers/tty/hvc/hvc_console.h

···
  */
 #define HVC_ALLOC_TTY_ADAPTERS	8
 
-/*
- * These sizes are most efficient for vio, because they are the
- * native transfer size. We could make them selectable in the
- * future to better deal with backends that want other buffer sizes.
- */
-#define N_OUTBUF	16
-#define N_INBUF		16
-
-#define __ALIGNED__ __attribute__((__aligned__(L1_CACHE_BYTES)))
-
 struct hvc_struct {
 	struct tty_port port;
 	spinlock_t lock;
 	int index;
 	int do_wakeup;
+	char *outbuf;
 	int outbuf_size;
 	int n_outbuf;
 	uint32_t vtermno;
···
 	struct work_struct tty_resize;
 	struct list_head next;
 	unsigned long flags;
-
-	/*
-	 * the buf and its lock are used in hvc console api for putting chars,
-	 * and also used in hvc_poll_put_char() for putting single char.
-	 */
-	spinlock_t cons_outbuf_lock;
-	char cons_outbuf[N_OUTBUF] __ALIGNED__;
-
-	/* the buf is used for putting chars to tty */
-	char outbuf[] __ALIGNED__;
 };
 
 /* implemented by a low level driver */