drivers/staging/gdm724x/gdm_tty.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved. */
   3
   4 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   5
   6 #include <linux/kernel.h>
   7 #include <linux/errno.h>
   8 #include <linux/tty.h>
   9 #include <linux/tty_driver.h>
  10 #include <linux/tty_flip.h>
  11 #include <linux/module.h>
  12 #include <linux/slab.h>
  13 #include <linux/usb/cdc.h>
  14 #include <linux/serial.h>
  15 #include "gdm_tty.h"
  16
  17 #define GDM_TTY_MAJOR 0
  18 #define GDM_TTY_MINOR 32
  19
  20 #define WRITE_SIZE 2048
  21
  22 #define MUX_TX_MAX_SIZE 2048
  23
  24 static inline bool gdm_tty_ready(struct gdm *gdm)
  25 {
  26         return gdm && gdm->tty_dev && gdm->port.count;
  27 }
  28
  29 static struct tty_driver *gdm_driver[TTY_MAX_COUNT];
  30 static struct gdm *gdm_table[TTY_MAX_COUNT][GDM_TTY_MINOR];
  31 static DEFINE_MUTEX(gdm_table_lock);
  32
  33 static const char *DRIVER_STRING[TTY_MAX_COUNT] = {"GCTATC", "GCTDM"};
  34 static char *DEVICE_STRING[TTY_MAX_COUNT] = {"GCT-ATC", "GCT-DM"};
  35
  36 static void gdm_port_destruct(struct tty_port *port)
  37 {
  38         struct gdm *gdm = container_of(port, struct gdm, port);
  39
  40         mutex_lock(&gdm_table_lock);
  41         gdm_table[gdm->index][gdm->minor] = NULL;
  42         mutex_unlock(&gdm_table_lock);
  43
  44         kfree(gdm);
  45 }
  46
  47 static const struct tty_port_operations gdm_port_ops = {
  48         .destruct = gdm_port_destruct,
  49 };
  50
  51 static int gdm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
  52 {
  53         struct gdm *gdm = NULL;
  54         int ret;
  55
  56         ret = match_string(DRIVER_STRING, TTY_MAX_COUNT,
  57                            tty->driver->driver_name);
  58         if (ret < 0)
  59                 return -ENODEV;
  60
  61         mutex_lock(&gdm_table_lock);
  62         gdm = gdm_table[ret][tty->index];
  63         if (!gdm) {
  64                 mutex_unlock(&gdm_table_lock);
  65                 return -ENODEV;
  66         }
  67
  68         tty_port_get(&gdm->port);
  69
  70         ret = tty_standard_install(driver, tty);
  71         if (ret) {
  72                 tty_port_put(&gdm->port);
  73                 mutex_unlock(&gdm_table_lock);
  74                 return ret;
  75         }
  76
  77         tty->driver_data = gdm;
  78         mutex_unlock(&gdm_table_lock);
  79
  80         return 0;
  81 }
  82
  83 static int gdm_tty_open(struct tty_struct *tty, struct file *filp)
  84 {
  85         struct gdm *gdm = tty->driver_data;
  86
  87         return tty_port_open(&gdm->port, tty, filp);
  88 }
  89
  90 static void gdm_tty_cleanup(struct tty_struct *tty)
  91 {
  92         struct gdm *gdm = tty->driver_data;
  93
  94         tty_port_put(&gdm->port);
  95 }
  96
  97 static void gdm_tty_hangup(struct tty_struct *tty)
  98 {
  99         struct gdm *gdm = tty->driver_data;
 100
 101         tty_port_hangup(&gdm->port);
 102 }
 103
 104 static void gdm_tty_close(struct tty_struct *tty, struct file *filp)
 105 {
 106         struct gdm *gdm = tty->driver_data;
 107
 108         tty_port_close(&gdm->port, tty, filp);
 109 }
 110
 111 static int gdm_tty_recv_complete(void *data,
 112                                  int len,
 113                                  int index,
 114                                  struct tty_dev *tty_dev,
 115                                  int complete)
 116 {
 117         struct gdm *gdm = tty_dev->gdm[index];
 118
 119         if (!gdm_tty_ready(gdm)) {
 120                 if (complete == RECV_PACKET_PROCESS_COMPLETE)
 121                         gdm->tty_dev->recv_func(gdm->tty_dev->priv_dev,
 122                                                 gdm_tty_recv_complete);
 123                 return TO_HOST_PORT_CLOSE;
 124         }
 125
 126         if (data && len) {
 127                 if (tty_buffer_request_room(&gdm->port, len) == len) {
 128                         tty_insert_flip_string(&gdm->port, data, len);
 129                         tty_flip_buffer_push(&gdm->port);
 130                 } else {
 131                         return TO_HOST_BUFFER_REQUEST_FAIL;
 132                 }
 133         }
 134
 135         if (complete == RECV_PACKET_PROCESS_COMPLETE)
 136                 gdm->tty_dev->recv_func(gdm->tty_dev->priv_dev,
 137                                         gdm_tty_recv_complete);
 138
 139         return 0;
 140 }
 141
 142 static void gdm_tty_send_complete(void *arg)
 143 {
 144         struct gdm *gdm = arg;
 145
 146         if (!gdm_tty_ready(gdm))
 147                 return;
 148
 149         tty_port_tty_wakeup(&gdm->port);
 150 }
 151
 152 static ssize_t gdm_tty_write(struct tty_struct *tty, const u8 *buf, size_t len)
 153 {
 154         struct gdm *gdm = tty->driver_data;
 155         size_t remain = len;
 156         size_t sent_len = 0;
 157
 158         if (!gdm_tty_ready(gdm))
 159                 return -ENODEV;
 160
 161         while (remain) {
 162                 size_t sending_len = min_t(size_t, MUX_TX_MAX_SIZE, remain);
 163                 gdm->tty_dev->send_func(gdm->tty_dev->priv_dev,
 164                                         (void *)(buf + sent_len),
 165                                         sending_len,
 166                                         gdm->index,
 167                                         gdm_tty_send_complete,
 168                                         gdm);
 169                 sent_len += sending_len;
 170                 remain -= sending_len;
 171         }
 172
 173         return len;
 174 }
 175
 176 static unsigned int gdm_tty_write_room(struct tty_struct *tty)
 177 {
 178         struct gdm *gdm = tty->driver_data;
 179
 180         if (!gdm_tty_ready(gdm))
 181                 return 0;
 182
 183         return WRITE_SIZE;
 184 }
 185
 186 int register_lte_tty_device(struct tty_dev *tty_dev, struct device *device)
 187 {
 188         struct gdm *gdm;
 189         int i;
 190         int j;
 191
 192         for (i = 0; i < TTY_MAX_COUNT; i++) {
 193                 gdm = kmalloc(sizeof(*gdm), GFP_KERNEL);
 194                 if (!gdm)
 195                         return -ENOMEM;
 196
 197                 mutex_lock(&gdm_table_lock);
 198                 for (j = 0; j < GDM_TTY_MINOR; j++) {
 199                         if (!gdm_table[i][j])
 200                                 break;
 201                 }
 202
 203                 if (j == GDM_TTY_MINOR) {
 204                         kfree(gdm);
 205                         mutex_unlock(&gdm_table_lock);
 206                         return -EINVAL;
 207                 }
 208
 209                 gdm_table[i][j] = gdm;
 210                 mutex_unlock(&gdm_table_lock);
 211
 212                 tty_dev->gdm[i] = gdm;
 213                 tty_port_init(&gdm->port);
 214
 215                 gdm->port.ops = &gdm_port_ops;
 216                 gdm->index = i;
 217                 gdm->minor = j;
 218                 gdm->tty_dev = tty_dev;
 219
 220                 tty_port_register_device(&gdm->port, gdm_driver[i],
 221                                          gdm->minor, device);
 222         }
 223
 224         for (i = 0; i < MAX_ISSUE_NUM; i++)
 225                 gdm->tty_dev->recv_func(gdm->tty_dev->priv_dev,
 226                                         gdm_tty_recv_complete);
 227
 228         return 0;
 229 }
 230
 231 void unregister_lte_tty_device(struct tty_dev *tty_dev)
 232 {
 233         struct gdm *gdm;
 234         struct tty_struct *tty;
 235         int i;
 236
 237         for (i = 0; i < TTY_MAX_COUNT; i++) {
 238                 gdm = tty_dev->gdm[i];
 239                 if (!gdm)
 240                         continue;
 241
 242                 mutex_lock(&gdm_table_lock);
 243                 gdm_table[gdm->index][gdm->minor] = NULL;
 244                 mutex_unlock(&gdm_table_lock);
 245
 246                 tty = tty_port_tty_get(&gdm->port);
 247                 if (tty) {
 248                         tty_vhangup(tty);
 249                         tty_kref_put(tty);
 250                 }
 251
 252                 tty_unregister_device(gdm_driver[i], gdm->minor);
 253                 tty_port_put(&gdm->port);
 254         }
 255 }
 256
 257 static const struct tty_operations gdm_tty_ops = {
 258         .install =      gdm_tty_install,
 259         .open =         gdm_tty_open,
 260         .close =        gdm_tty_close,
 261         .cleanup =      gdm_tty_cleanup,
 262         .hangup =       gdm_tty_hangup,
 263         .write =        gdm_tty_write,
 264         .write_room =   gdm_tty_write_room,
 265 };
 266
 267 int register_lte_tty_driver(void)
 268 {
 269         struct tty_driver *tty_driver;
 270         int i;
 271         int ret;
 272
 273         for (i = 0; i < TTY_MAX_COUNT; i++) {
 274                 tty_driver = tty_alloc_driver(GDM_TTY_MINOR,
 275                                 TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV);
 276                 if (IS_ERR(tty_driver))
 277                         return PTR_ERR(tty_driver);
 278
 279                 tty_driver->owner = THIS_MODULE;
 280                 tty_driver->driver_name = DRIVER_STRING[i];
 281                 tty_driver->name = DEVICE_STRING[i];
 282                 tty_driver->major = GDM_TTY_MAJOR;
 283                 tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
 284                 tty_driver->subtype = SERIAL_TYPE_NORMAL;
 285                 tty_driver->init_termios = tty_std_termios;
 286                 tty_driver->init_termios.c_cflag = B9600 | CS8 | HUPCL | CLOCAL;
 287                 tty_driver->init_termios.c_lflag = ISIG | ICANON | IEXTEN;
 288                 tty_set_operations(tty_driver, &gdm_tty_ops);
 289
 290                 ret = tty_register_driver(tty_driver);
 291                 if (ret) {
 292                         tty_driver_kref_put(tty_driver);
 293                         return ret;
 294                 }
 295
 296                 gdm_driver[i] = tty_driver;
 297         }
 298
 299         return ret;
 300 }
 301
 302 void unregister_lte_tty_driver(void)
 303 {
 304         struct tty_driver *tty_driver;
 305         int i;
 306
 307         for (i = 0; i < TTY_MAX_COUNT; i++) {
 308                 tty_driver = gdm_driver[i];
 309                 if (tty_driver) {
 310                         tty_unregister_driver(tty_driver);
 311                         tty_driver_kref_put(tty_driver);
 312                 }
 313         }
 314 }
 315