tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

tty: stop using alloc_tty_driver

alloc_tty_driver was deprecated by tty_alloc_driver in commit
7f0bc6a68ed9 (TTY: pass flags to alloc_tty_driver) in 2012.

I never got into eliminating alloc_tty_driver until now. So we still
have two functions for allocating drivers which might be confusing. So
get rid of alloc_tty_driver uses to eliminate it for good in the next
patch.

Note we need to switch return value checking as tty_alloc_driver uses
ERR_PTR. And flags are now a parameter of tty_alloc_driver.

Cc: Richard Henderson <rth@twiddle.net>(odd fixer:ALPHA PORT)
Cc: Ivan Kokshaysky <ink@jurassic.park.msu.ru>
Cc: Matt Turner <mattst88@gmail.com>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: "James E.J. Bottomley" <James.Bottomley@HansenPartnership.com>
Cc: Helge Deller <deller@gmx.de>
Cc: Jeff Dike <jdike@addtoit.com>
Cc: Richard Weinberger <richard@nod.at>
Cc: Anton Ivanov <anton.ivanov@cambridgegreys.com>
Cc: Chris Zankel <chris@zankel.net>
Cc: Max Filippov <jcmvbkbc@gmail.com>
Cc: Samuel Iglesias Gonsalvez <siglesias@igalia.com>
Cc: Jens Taprogge <jens.taprogge@taprogge.org>
Cc: Karsten Keil <isdn@linux-pingi.de>
Cc: Ulf Hansson <ulf.hansson@linaro.org>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Jakub Kicinski <kuba@kernel.org>
Cc: Heiko Carstens <hca@linux.ibm.com>
Cc: Vasily Gorbik <gor@linux.ibm.com>
Cc: Christian Borntraeger <borntraeger@de.ibm.com>
Cc: Laurentiu Tudor <laurentiu.tudor@nxp.com>
Cc: Jiri Kosina <jikos@kernel.org>
Cc: David Sterba <dsterba@suse.com>
Cc: Shawn Guo <shawnguo@kernel.org>
Cc: Sascha Hauer <s.hauer@pengutronix.de>
Cc: Oliver Neukum <oneukum@suse.com>
Cc: Felipe Balbi <balbi@kernel.org>
Cc: Johan Hovold <johan@kernel.org>
Cc: Marcel Holtmann <marcel@holtmann.org>
Cc: Johan Hedberg <johan.hedberg@gmail.com>
Cc: Luiz Augusto von Dentz <luiz.dentz@gmail.com>
Acked-by: Samuel Iglesias Gonsálvez <siglesias@igalia.com>
Acked-by: Max Filippov <jcmvbkbc@gmail.com>
Acked-by: David Sterba <dsterba@suse.com>
Acked-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Jiri Slaby <jslaby@suse.cz>
Link: https://lore.kernel.org/r/20210723074317.32690-5-jslaby@suse.cz
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

authored by

Jiri Slaby and committed by
Greg Kroah-Hartman 39b7b42b 0524513a

+120 -132
+3 -3
arch/alpha/kernel/srmcons.c
··· 204 204 struct tty_driver *driver; 205 205 int err; 206 206 207 - driver = alloc_tty_driver(MAX_SRM_CONSOLE_DEVICES); 208 - if (!driver) 209 - return -ENOMEM; 207 + driver = tty_alloc_driver(MAX_SRM_CONSOLE_DEVICES, 0); 208 + if (IS_ERR(driver)) 209 + return PTR_ERR(driver); 210 210 211 211 tty_port_init(&srmcons_singleton.port); 212 212
+3 -4
arch/m68k/emu/nfcon.c
··· 127 127 if (!stderr_id) 128 128 return -ENODEV; 129 129 130 - driver = alloc_tty_driver(1); 131 - if (!driver) 132 - return -ENOMEM; 130 + driver = tty_alloc_driver(1, TTY_DRIVER_REAL_RAW); 131 + if (IS_ERR(driver)) 132 + return PTR_ERR(driver); 133 133 134 134 tty_port_init(&nfcon_tty_port); 135 135 ··· 138 138 driver->type = TTY_DRIVER_TYPE_SYSTEM; 139 139 driver->subtype = SYSTEM_TYPE_TTY; 140 140 driver->init_termios = tty_std_termios; 141 - driver->flags = TTY_DRIVER_REAL_RAW; 142 141 143 142 tty_set_operations(driver, &nfcon_tty_ops); 144 143 tty_port_link_device(&nfcon_tty_port, driver, 0);
+4 -5
arch/parisc/kernel/pdc_cons.c
··· 161 161 printk(KERN_INFO "The PDC console driver is still registered, removing CON_BOOT flag\n"); 162 162 pdc_cons.flags &= ~CON_BOOT; 163 163 164 - driver = alloc_tty_driver(1); 165 - if (!driver) 166 - return -ENOMEM; 164 + driver = tty_alloc_driver(1, TTY_DRIVER_REAL_RAW | 165 + TTY_DRIVER_RESET_TERMIOS); 166 + if (IS_ERR(driver)) 167 + return PTR_ERR(driver); 167 168 168 169 tty_port_init(&tty_port); 169 170 ··· 174 173 driver->minor_start = 0; 175 174 driver->type = TTY_DRIVER_TYPE_SYSTEM; 176 175 driver->init_termios = tty_std_termios; 177 - driver->flags = TTY_DRIVER_REAL_RAW | 178 - TTY_DRIVER_RESET_TERMIOS; 179 176 tty_set_operations(driver, &pdc_console_tty_ops); 180 177 tty_port_link_device(&tty_port, driver, 0); 181 178
+6 -5
arch/um/drivers/line.c
··· 538 538 const struct tty_operations *ops, 539 539 struct line *lines, int nlines) 540 540 { 541 - struct tty_driver *driver = alloc_tty_driver(nlines); 541 + struct tty_driver *driver; 542 542 int err; 543 543 int i; 544 544 545 - if (!driver) 546 - return -ENOMEM; 545 + driver = tty_alloc_driver(nlines, TTY_DRIVER_REAL_RAW | 546 + TTY_DRIVER_DYNAMIC_DEV); 547 + if (IS_ERR(driver)) 548 + return PTR_ERR(driver); 547 549 548 550 driver->driver_name = line_driver->name; 549 551 driver->name = line_driver->device_name; ··· 553 551 driver->minor_start = line_driver->minor_start; 554 552 driver->type = line_driver->type; 555 553 driver->subtype = line_driver->subtype; 556 - driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 557 554 driver->init_termios = tty_std_termios; 558 - 555 + 559 556 for (i = 0; i < nlines; i++) { 560 557 tty_port_init(&lines[i].port); 561 558 lines[i].port.ops = &line_port_ops;
+3 -4
arch/xtensa/platforms/iss/console.c
··· 139 139 struct tty_driver *driver; 140 140 int ret; 141 141 142 - driver = alloc_tty_driver(SERIAL_MAX_NUM_LINES); 143 - if (!driver) 144 - return -ENOMEM; 142 + driver = tty_alloc_driver(SERIAL_MAX_NUM_LINES, TTY_DRIVER_REAL_RAW); 143 + if (IS_ERR(driver)) 144 + return PTR_ERR(driver); 145 145 146 146 tty_port_init(&serial_port); 147 147 ··· 156 156 driver->init_termios = tty_std_termios; 157 157 driver->init_termios.c_cflag = 158 158 B9600 | CS8 | CREAD | HUPCL | CLOCAL; 159 - driver->flags = TTY_DRIVER_REAL_RAW; 160 159 161 160 tty_set_operations(driver, &serial_ops); 162 161 tty_port_link_device(&serial_port, driver, 0);
+4 -5
drivers/ipack/devices/ipoctal.c
··· 347 347 /* Register the TTY device */ 348 348 349 349 /* Each IP-OCTAL channel is a TTY port */ 350 - tty = alloc_tty_driver(NR_CHANNELS); 351 - 352 - if (!tty) 353 - return -ENOMEM; 350 + tty = tty_alloc_driver(NR_CHANNELS, TTY_DRIVER_REAL_RAW | 351 + TTY_DRIVER_DYNAMIC_DEV); 352 + if (IS_ERR(tty)) 353 + return PTR_ERR(tty); 354 354 355 355 /* Fill struct tty_driver with ipoctal data */ 356 356 tty->owner = THIS_MODULE; ··· 362 362 tty->minor_start = 0; 363 363 tty->type = TTY_DRIVER_TYPE_SERIAL; 364 364 tty->subtype = SERIAL_TYPE_NORMAL; 365 - tty->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 366 365 tty->init_termios = tty_std_termios; 367 366 tty->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; 368 367 tty->init_termios.c_ispeed = 9600;
+4 -6
drivers/isdn/capi/capi.c
··· 1269 1269 if (!capiminors) 1270 1270 return -ENOMEM; 1271 1271 1272 - drv = alloc_tty_driver(capi_ttyminors); 1273 - if (!drv) { 1272 + drv = tty_alloc_driver(capi_ttyminors, TTY_DRIVER_REAL_RAW | 1273 + TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_DYNAMIC_DEV); 1274 + if (IS_ERR(drv)) { 1274 1275 kfree(capiminors); 1275 - return -ENOMEM; 1276 + return PTR_ERR(drv); 1276 1277 } 1277 1278 drv->driver_name = "capi_nc"; 1278 1279 drv->name = "capi!"; ··· 1286 1285 drv->init_termios.c_oflag = OPOST | ONLCR; 1287 1286 drv->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; 1288 1287 drv->init_termios.c_lflag = 0; 1289 - drv->flags = 1290 - TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS | 1291 - TTY_DRIVER_DYNAMIC_DEV; 1292 1288 tty_set_operations(drv, &capinc_ops); 1293 1289 1294 1290 err = tty_register_driver(drv);
+4 -4
drivers/mmc/core/sdio_uart.c
··· 1135 1135 int ret; 1136 1136 struct tty_driver *tty_drv; 1137 1137 1138 - sdio_uart_tty_driver = tty_drv = alloc_tty_driver(UART_NR); 1139 - if (!tty_drv) 1140 - return -ENOMEM; 1138 + sdio_uart_tty_driver = tty_drv = tty_alloc_driver(UART_NR, 1139 + TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV); 1140 + if (IS_ERR(tty_drv)) 1141 + return PTR_ERR(tty_drv); 1141 1142 1142 1143 tty_drv->driver_name = "sdio_uart"; 1143 1144 tty_drv->name = "ttySDIO"; ··· 1146 1145 tty_drv->minor_start = 0; 1147 1146 tty_drv->type = TTY_DRIVER_TYPE_SERIAL; 1148 1147 tty_drv->subtype = SERIAL_TYPE_NORMAL; 1149 - tty_drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 1150 1148 tty_drv->init_termios = tty_std_termios; 1151 1149 tty_drv->init_termios.c_cflag = B4800 | CS8 | CREAD | HUPCL | CLOCAL; 1152 1150 tty_drv->init_termios.c_ispeed = 4800;
+4 -4
drivers/net/usb/hso.c
··· 3229 3229 serial_table[i] = NULL; 3230 3230 3231 3231 /* allocate our driver using the proper amount of supported minors */ 3232 - tty_drv = alloc_tty_driver(HSO_SERIAL_TTY_MINORS); 3233 - if (!tty_drv) 3234 - return -ENOMEM; 3232 + tty_drv = tty_alloc_driver(HSO_SERIAL_TTY_MINORS, TTY_DRIVER_REAL_RAW | 3233 + TTY_DRIVER_DYNAMIC_DEV); 3234 + if (IS_ERR(tty_drv)) 3235 + return PTR_ERR(tty_drv); 3235 3236 3236 3237 /* fill in all needed values */ 3237 3238 tty_drv->driver_name = driver_name; ··· 3245 3244 tty_drv->minor_start = 0; 3246 3245 tty_drv->type = TTY_DRIVER_TYPE_SERIAL; 3247 3246 tty_drv->subtype = SERIAL_TYPE_NORMAL; 3248 - tty_drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 3249 3247 tty_drv->init_termios = tty_std_termios; 3250 3248 hso_init_termios(&tty_drv->init_termios); 3251 3249 tty_set_operations(tty_drv, &hso_serial_ops);
+3 -4
drivers/s390/char/con3215.c
··· 1076 1076 if (!CONSOLE_IS_3215) 1077 1077 return 0; 1078 1078 1079 - driver = alloc_tty_driver(NR_3215); 1080 - if (!driver) 1081 - return -ENOMEM; 1079 + driver = tty_alloc_driver(NR_3215, TTY_DRIVER_REAL_RAW); 1080 + if (IS_ERR(driver)) 1081 + return PTR_ERR(driver); 1082 1082 1083 1083 ret = ccw_driver_register(&raw3215_ccw_driver); 1084 1084 if (ret) { ··· 1101 1101 driver->init_termios.c_iflag = IGNBRK | IGNPAR; 1102 1102 driver->init_termios.c_oflag = ONLCR; 1103 1103 driver->init_termios.c_lflag = ISIG; 1104 - driver->flags = TTY_DRIVER_REAL_RAW; 1105 1104 tty_set_operations(driver, &tty3215_ops); 1106 1105 ret = tty_register_driver(driver); 1107 1106 if (ret) {
+3 -4
drivers/s390/char/sclp_tty.c
··· 503 503 return 0; 504 504 if (!sclp.has_linemode) 505 505 return 0; 506 - driver = alloc_tty_driver(1); 507 - if (!driver) 508 - return -ENOMEM; 506 + driver = tty_alloc_driver(1, TTY_DRIVER_REAL_RAW); 507 + if (IS_ERR(driver)) 508 + return PTR_ERR(driver); 509 509 510 510 rc = sclp_rw_init(); 511 511 if (rc) { ··· 548 548 driver->init_termios.c_iflag = IGNBRK | IGNPAR; 549 549 driver->init_termios.c_oflag = ONLCR; 550 550 driver->init_termios.c_lflag = ISIG | ECHO; 551 - driver->flags = TTY_DRIVER_REAL_RAW; 552 551 tty_set_operations(driver, &sclp_ops); 553 552 tty_port_link_device(&sclp_port, driver, 0); 554 553 rc = tty_register_driver(driver);
+3 -4
drivers/s390/char/sclp_vt220.c
··· 732 732 733 733 /* Note: we're not testing for CONSOLE_IS_SCLP here to preserve 734 734 * symmetry between VM and LPAR systems regarding ttyS1. */ 735 - driver = alloc_tty_driver(1); 736 - if (!driver) 737 - return -ENOMEM; 735 + driver = tty_alloc_driver(1, TTY_DRIVER_REAL_RAW); 736 + if (IS_ERR(driver)) 737 + return PTR_ERR(driver); 738 738 rc = __sclp_vt220_init(MAX_KMEM_PAGES); 739 739 if (rc) 740 740 goto out_driver; ··· 746 746 driver->type = TTY_DRIVER_TYPE_SYSTEM; 747 747 driver->subtype = SYSTEM_TYPE_TTY; 748 748 driver->init_termios = tty_std_termios; 749 - driver->flags = TTY_DRIVER_REAL_RAW; 750 749 tty_set_operations(driver, &sclp_vt220_ops); 751 750 tty_port_link_device(&sclp_vt220_port, driver, 0); 752 751
+4 -5
drivers/staging/gdm724x/gdm_tty.c
··· 281 281 int ret; 282 282 283 283 for (i = 0; i < TTY_MAX_COUNT; i++) { 284 - tty_driver = alloc_tty_driver(GDM_TTY_MINOR); 285 - if (!tty_driver) 286 - return -ENOMEM; 284 + tty_driver = tty_alloc_driver(GDM_TTY_MINOR, 285 + TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV); 286 + if (IS_ERR(tty_driver)) 287 + return PTR_ERR(tty_driver); 287 288 288 289 tty_driver->owner = THIS_MODULE; 289 290 tty_driver->driver_name = DRIVER_STRING[i]; ··· 292 291 tty_driver->major = GDM_TTY_MAJOR; 293 292 tty_driver->type = TTY_DRIVER_TYPE_SERIAL; 294 293 tty_driver->subtype = SERIAL_TYPE_NORMAL; 295 - tty_driver->flags = TTY_DRIVER_REAL_RAW | 296 - TTY_DRIVER_DYNAMIC_DEV; 297 294 tty_driver->init_termios = tty_std_termios; 298 295 tty_driver->init_termios.c_cflag = B9600 | CS8 | HUPCL | CLOCAL; 299 296 tty_driver->init_termios.c_lflag = ISIG | ICANON | IEXTEN;
+3 -4
drivers/tty/amiserial.c
··· 1494 1494 unsigned long flags; 1495 1495 int error; 1496 1496 1497 - driver = alloc_tty_driver(1); 1498 - if (!driver) 1499 - return -ENOMEM; 1497 + driver = tty_alloc_driver(1, TTY_DRIVER_REAL_RAW); 1498 + if (IS_ERR(driver)) 1499 + return PTR_ERR(driver); 1500 1500 1501 1501 /* Initialize the tty_driver structure */ 1502 1502 ··· 1509 1509 driver->init_termios = tty_std_termios; 1510 1510 driver->init_termios.c_cflag = 1511 1511 B9600 | CS8 | CREAD | HUPCL | CLOCAL; 1512 - driver->flags = TTY_DRIVER_REAL_RAW; 1513 1512 tty_set_operations(driver, &serial_ops); 1514 1513 1515 1514 memset(state, 0, sizeof(*state));
+4 -4
drivers/tty/ehv_bytechan.c
··· 774 774 if (!bcs) 775 775 return -ENOMEM; 776 776 777 - driver = alloc_tty_driver(count); 778 - if (!driver) { 779 - ret = -ENOMEM; 777 + driver = tty_alloc_driver(count, TTY_DRIVER_REAL_RAW | 778 + TTY_DRIVER_DYNAMIC_DEV); 779 + if (IS_ERR(driver)) { 780 + ret = PTR_ERR(driver); 780 781 goto err_free_bcs; 781 782 } 782 783 ··· 786 785 driver->type = TTY_DRIVER_TYPE_CONSOLE; 787 786 driver->subtype = SYSTEM_TYPE_CONSOLE; 788 787 driver->init_termios = tty_std_termios; 789 - driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 790 788 tty_set_operations(driver, &ehv_bc_ops); 791 789 792 790 ret = tty_register_driver(driver);
+7 -7
drivers/tty/goldfish.c
··· 253 253 ret = -ENOMEM; 254 254 goto err_alloc_goldfish_ttys_failed; 255 255 } 256 - tty = alloc_tty_driver(goldfish_tty_line_count); 257 - if (tty == NULL) { 258 - ret = -ENOMEM; 259 - goto err_alloc_tty_driver_failed; 256 + tty = tty_alloc_driver(goldfish_tty_line_count, 257 + TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | 258 + TTY_DRIVER_DYNAMIC_DEV); 259 + if (IS_ERR(tty)) { 260 + ret = PTR_ERR(tty); 261 + goto err_tty_alloc_driver_failed; 260 262 } 261 263 tty->driver_name = "goldfish"; 262 264 tty->name = "ttyGF"; 263 265 tty->type = TTY_DRIVER_TYPE_SERIAL; 264 266 tty->subtype = SERIAL_TYPE_NORMAL; 265 267 tty->init_termios = tty_std_termios; 266 - tty->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | 267 - TTY_DRIVER_DYNAMIC_DEV; 268 268 tty_set_operations(tty, &goldfish_tty_ops); 269 269 ret = tty_register_driver(tty); 270 270 if (ret) ··· 275 275 276 276 err_tty_register_driver_failed: 277 277 put_tty_driver(tty); 278 - err_alloc_tty_driver_failed: 278 + err_tty_alloc_driver_failed: 279 279 kfree(goldfish_ttys); 280 280 goldfish_ttys = NULL; 281 281 err_alloc_goldfish_ttys_failed:
+4 -4
drivers/tty/hvc/hvc_console.c
··· 1021 1021 int err; 1022 1022 1023 1023 /* We need more than hvc_count adapters due to hotplug additions. */ 1024 - drv = alloc_tty_driver(HVC_ALLOC_TTY_ADAPTERS); 1025 - if (!drv) { 1026 - err = -ENOMEM; 1024 + drv = tty_alloc_driver(HVC_ALLOC_TTY_ADAPTERS, TTY_DRIVER_REAL_RAW | 1025 + TTY_DRIVER_RESET_TERMIOS); 1026 + if (IS_ERR(drv)) { 1027 + err = PTR_ERR(drv); 1027 1028 goto out; 1028 1029 } 1029 1030 ··· 1034 1033 drv->minor_start = HVC_MINOR; 1035 1034 drv->type = TTY_DRIVER_TYPE_SYSTEM; 1036 1035 drv->init_termios = tty_std_termios; 1037 - drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS; 1038 1036 tty_set_operations(drv, &hvc_ops); 1039 1037 1040 1038 /* Always start the kthread because there can be hotplug vty adapters
+4 -4
drivers/tty/hvc/hvcs.c
··· 1445 1445 } else 1446 1446 num_ttys_to_alloc = hvcs_parm_num_devs; 1447 1447 1448 - hvcs_tty_driver = alloc_tty_driver(num_ttys_to_alloc); 1449 - if (!hvcs_tty_driver) { 1448 + hvcs_tty_driver = tty_alloc_driver(num_ttys_to_alloc, 1449 + TTY_DRIVER_REAL_RAW); 1450 + if (IS_ERR(hvcs_tty_driver)) { 1450 1451 mutex_unlock(&hvcs_init_mutex); 1451 - return -ENOMEM; 1452 + return PTR_ERR(hvcs_tty_driver); 1452 1453 } 1453 1454 1454 1455 if (hvcs_alloc_index_list(num_ttys_to_alloc)) { ··· 1474 1473 * throw us into a horrible recursive echo-echo-echo loop. 1475 1474 */ 1476 1475 hvcs_tty_driver->init_termios = hvcs_tty_termios; 1477 - hvcs_tty_driver->flags = TTY_DRIVER_REAL_RAW; 1478 1476 1479 1477 tty_set_operations(hvcs_tty_driver, &hvcs_ops); 1480 1478
+3 -4
drivers/tty/hvc/hvsi.c
··· 1041 1041 struct tty_driver *driver; 1042 1042 int i, ret; 1043 1043 1044 - driver = alloc_tty_driver(hvsi_count); 1045 - if (!driver) 1046 - return -ENOMEM; 1044 + driver = tty_alloc_driver(hvsi_count, TTY_DRIVER_REAL_RAW); 1045 + if (IS_ERR(driver)) 1046 + return PTR_ERR(driver); 1047 1047 1048 1048 driver->driver_name = "hvsi"; 1049 1049 driver->name = "hvsi"; ··· 1054 1054 driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL; 1055 1055 driver->init_termios.c_ispeed = 9600; 1056 1056 driver->init_termios.c_ospeed = 9600; 1057 - driver->flags = TTY_DRIVER_REAL_RAW; 1058 1057 tty_set_operations(driver, &hvsi_ops); 1059 1058 1060 1059 for (i=0; i < hvsi_count; i++) {
+4 -4
drivers/tty/ipwireless/tty.c
··· 564 564 { 565 565 int result; 566 566 567 - ipw_tty_driver = alloc_tty_driver(IPWIRELESS_PCMCIA_MINORS); 568 - if (!ipw_tty_driver) 569 - return -ENOMEM; 567 + ipw_tty_driver = tty_alloc_driver(IPWIRELESS_PCMCIA_MINORS, 568 + TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV); 569 + if (IS_ERR(ipw_tty_driver)) 570 + return PTR_ERR(ipw_tty_driver); 570 571 571 572 ipw_tty_driver->driver_name = IPWIRELESS_PCCARD_NAME; 572 573 ipw_tty_driver->name = "ttyIPWp"; ··· 575 574 ipw_tty_driver->minor_start = IPWIRELESS_PCMCIA_START; 576 575 ipw_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; 577 576 ipw_tty_driver->subtype = SERIAL_TYPE_NORMAL; 578 - ipw_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 579 577 ipw_tty_driver->init_termios = tty_std_termios; 580 578 ipw_tty_driver->init_termios.c_cflag = 581 579 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+4 -4
drivers/tty/mxser.c
··· 1976 1976 { 1977 1977 int retval; 1978 1978 1979 - mxvar_sdriver = alloc_tty_driver(MXSER_PORTS); 1980 - if (!mxvar_sdriver) 1981 - return -ENOMEM; 1979 + mxvar_sdriver = tty_alloc_driver(MXSER_PORTS, TTY_DRIVER_REAL_RAW | 1980 + TTY_DRIVER_DYNAMIC_DEV); 1981 + if (IS_ERR(mxvar_sdriver)) 1982 + return PTR_ERR(mxvar_sdriver); 1982 1983 1983 1984 /* Initialize the tty_driver structure */ 1984 1985 mxvar_sdriver->name = "ttyMI"; ··· 1989 1988 mxvar_sdriver->subtype = SERIAL_TYPE_NORMAL; 1990 1989 mxvar_sdriver->init_termios = tty_std_termios; 1991 1990 mxvar_sdriver->init_termios.c_cflag = B9600|CS8|CREAD|HUPCL|CLOCAL; 1992 - mxvar_sdriver->flags = TTY_DRIVER_REAL_RAW|TTY_DRIVER_DYNAMIC_DEV; 1993 1991 tty_set_operations(mxvar_sdriver, &mxser_ops); 1994 1992 1995 1993 retval = tty_register_driver(mxvar_sdriver);
+4 -5
drivers/tty/n_gsm.c
··· 3252 3252 return status; 3253 3253 } 3254 3254 3255 - gsm_tty_driver = alloc_tty_driver(256); 3256 - if (!gsm_tty_driver) { 3255 + gsm_tty_driver = tty_alloc_driver(256, TTY_DRIVER_REAL_RAW | 3256 + TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_HARDWARE_BREAK); 3257 + if (IS_ERR(gsm_tty_driver)) { 3257 3258 pr_err("gsm_init: tty allocation failed.\n"); 3258 - status = -ENOMEM; 3259 + status = PTR_ERR(gsm_tty_driver); 3259 3260 goto err_unreg_ldisc; 3260 3261 } 3261 3262 gsm_tty_driver->driver_name = "gsmtty"; ··· 3265 3264 gsm_tty_driver->minor_start = 0; 3266 3265 gsm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; 3267 3266 gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL; 3268 - gsm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV 3269 - | TTY_DRIVER_HARDWARE_BREAK; 3270 3267 gsm_tty_driver->init_termios = tty_std_termios; 3271 3268 /* Fixme */ 3272 3269 gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
+4 -4
drivers/tty/nozomi.c
··· 1824 1824 { 1825 1825 int ret; 1826 1826 1827 - ntty_driver = alloc_tty_driver(NTTY_TTY_MAXMINORS); 1828 - if (!ntty_driver) 1829 - return -ENOMEM; 1827 + ntty_driver = tty_alloc_driver(NTTY_TTY_MAXMINORS, TTY_DRIVER_REAL_RAW | 1828 + TTY_DRIVER_DYNAMIC_DEV); 1829 + if (IS_ERR(ntty_driver)) 1830 + return PTR_ERR(ntty_driver); 1830 1831 1831 1832 ntty_driver->driver_name = NOZOMI_NAME_TTY; 1832 1833 ntty_driver->name = "noz"; 1833 1834 ntty_driver->major = 0; 1834 1835 ntty_driver->type = TTY_DRIVER_TYPE_SERIAL; 1835 1836 ntty_driver->subtype = SERIAL_TYPE_NORMAL; 1836 - ntty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 1837 1837 ntty_driver->init_termios = tty_std_termios; 1838 1838 ntty_driver->init_termios.c_cflag = B115200 | CS8 | CREAD | \ 1839 1839 HUPCL | CLOCAL;
+3 -4
drivers/tty/serial/kgdb_nmi.c
··· 330 330 if (!arch_kgdb_ops.enable_nmi) 331 331 return 0; 332 332 333 - kgdb_nmi_tty_driver = alloc_tty_driver(1); 334 - if (!kgdb_nmi_tty_driver) { 333 + kgdb_nmi_tty_driver = tty_alloc_driver(1, TTY_DRIVER_REAL_RAW); 334 + if (IS_ERR(kgdb_nmi_tty_driver)) { 335 335 pr_err("%s: cannot allocate tty\n", __func__); 336 - return -ENOMEM; 336 + return PTR_ERR(kgdb_nmi_tty_driver); 337 337 } 338 338 kgdb_nmi_tty_driver->driver_name = "ttyNMI"; 339 339 kgdb_nmi_tty_driver->name = "ttyNMI"; 340 340 kgdb_nmi_tty_driver->num = 1; 341 341 kgdb_nmi_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; 342 342 kgdb_nmi_tty_driver->subtype = SERIAL_TYPE_NORMAL; 343 - kgdb_nmi_tty_driver->flags = TTY_DRIVER_REAL_RAW; 344 343 kgdb_nmi_tty_driver->init_termios = tty_std_termios; 345 344 tty_termios_encode_baud_rate(&kgdb_nmi_tty_driver->init_termios, 346 345 KGDB_NMI_BAUD, KGDB_NMI_BAUD);
+5 -3
drivers/tty/serial/serial_core.c
··· 2530 2530 if (!drv->state) 2531 2531 goto out; 2532 2532 2533 - normal = alloc_tty_driver(drv->nr); 2534 - if (!normal) 2533 + normal = tty_alloc_driver(drv->nr, TTY_DRIVER_REAL_RAW | 2534 + TTY_DRIVER_DYNAMIC_DEV); 2535 + if (IS_ERR(normal)) { 2536 + retval = PTR_ERR(normal); 2535 2537 goto out_kfree; 2538 + } 2536 2539 2537 2540 drv->tty_driver = normal; 2538 2541 ··· 2548 2545 normal->init_termios = tty_std_termios; 2549 2546 normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; 2550 2547 normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600; 2551 - normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 2552 2548 normal->driver_state = drv; 2553 2549 tty_set_operations(normal, &uart_ops); 2554 2550
+3 -3
drivers/tty/vt/vt.c
··· 3576 3576 3577 3577 vcs_init(); 3578 3578 3579 - console_driver = alloc_tty_driver(MAX_NR_CONSOLES); 3580 - if (!console_driver) 3579 + console_driver = tty_alloc_driver(MAX_NR_CONSOLES, TTY_DRIVER_REAL_RAW | 3580 + TTY_DRIVER_RESET_TERMIOS); 3581 + if (IS_ERR(console_driver)) 3581 3582 panic("Couldn't allocate console driver\n"); 3582 3583 3583 3584 console_driver->name = "tty"; ··· 3589 3588 console_driver->init_termios = tty_std_termios; 3590 3589 if (default_utf8) 3591 3590 console_driver->init_termios.c_iflag |= IUTF8; 3592 - console_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS; 3593 3591 tty_set_operations(console_driver, &con_ops); 3594 3592 if (tty_register_driver(console_driver)) 3595 3593 panic("Couldn't register console driver\n");
+4 -4
drivers/usb/class/cdc-acm.c
··· 2027 2027 static int __init acm_init(void) 2028 2028 { 2029 2029 int retval; 2030 - acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS); 2031 - if (!acm_tty_driver) 2032 - return -ENOMEM; 2030 + acm_tty_driver = tty_alloc_driver(ACM_TTY_MINORS, TTY_DRIVER_REAL_RAW | 2031 + TTY_DRIVER_DYNAMIC_DEV); 2032 + if (IS_ERR(acm_tty_driver)) 2033 + return PTR_ERR(acm_tty_driver); 2033 2034 acm_tty_driver->driver_name = "acm", 2034 2035 acm_tty_driver->name = "ttyACM", 2035 2036 acm_tty_driver->major = ACM_TTY_MAJOR, 2036 2037 acm_tty_driver->minor_start = 0, 2037 2038 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL, 2038 2039 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL, 2039 - acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 2040 2040 acm_tty_driver->init_termios = tty_std_termios; 2041 2041 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | 2042 2042 HUPCL | CLOCAL;
+4 -4
drivers/usb/gadget/function/u_serial.c
··· 1449 1449 unsigned i; 1450 1450 int status; 1451 1451 1452 - driver = alloc_tty_driver(MAX_U_SERIAL_PORTS); 1453 - if (!driver) 1454 - return -ENOMEM; 1452 + driver = tty_alloc_driver(MAX_U_SERIAL_PORTS, TTY_DRIVER_REAL_RAW | 1453 + TTY_DRIVER_DYNAMIC_DEV); 1454 + if (IS_ERR(driver)) 1455 + return PTR_ERR(driver); 1455 1456 1456 1457 driver->driver_name = "g_serial"; 1457 1458 driver->name = "ttyGS"; ··· 1460 1459 1461 1460 driver->type = TTY_DRIVER_TYPE_SERIAL; 1462 1461 driver->subtype = SERIAL_TYPE_NORMAL; 1463 - driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 1464 1462 driver->init_termios = tty_std_termios; 1465 1463 1466 1464 /* 9600-8-N-1 ... matches defaults expected by "usbser.sys" on
+4 -5
drivers/usb/serial/usb-serial.c
··· 1319 1319 { 1320 1320 int result; 1321 1321 1322 - usb_serial_tty_driver = alloc_tty_driver(USB_SERIAL_TTY_MINORS); 1323 - if (!usb_serial_tty_driver) 1324 - return -ENOMEM; 1322 + usb_serial_tty_driver = tty_alloc_driver(USB_SERIAL_TTY_MINORS, 1323 + TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV); 1324 + if (IS_ERR(usb_serial_tty_driver)) 1325 + return PTR_ERR(usb_serial_tty_driver); 1325 1326 1326 1327 /* Initialize our global data */ 1327 1328 result = bus_register(&usb_serial_bus_type); ··· 1337 1336 usb_serial_tty_driver->minor_start = 0; 1338 1337 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; 1339 1338 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL; 1340 - usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW | 1341 - TTY_DRIVER_DYNAMIC_DEV; 1342 1339 usb_serial_tty_driver->init_termios = tty_std_termios; 1343 1340 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD 1344 1341 | HUPCL | CLOCAL;
+4 -4
net/bluetooth/rfcomm/tty.c
··· 1127 1127 { 1128 1128 int error; 1129 1129 1130 - rfcomm_tty_driver = alloc_tty_driver(RFCOMM_TTY_PORTS); 1131 - if (!rfcomm_tty_driver) 1132 - return -ENOMEM; 1130 + rfcomm_tty_driver = tty_alloc_driver(RFCOMM_TTY_PORTS, 1131 + TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV); 1132 + if (IS_ERR(rfcomm_tty_driver)) 1133 + return PTR_ERR(rfcomm_tty_driver); 1133 1134 1134 1135 rfcomm_tty_driver->driver_name = "rfcomm"; 1135 1136 rfcomm_tty_driver->name = "rfcomm"; ··· 1138 1137 rfcomm_tty_driver->minor_start = RFCOMM_TTY_MINOR; 1139 1138 rfcomm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; 1140 1139 rfcomm_tty_driver->subtype = SERIAL_TYPE_NORMAL; 1141 - rfcomm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 1142 1140 rfcomm_tty_driver->init_termios = tty_std_termios; 1143 1141 rfcomm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL; 1144 1142 rfcomm_tty_driver->init_termios.c_lflag &= ~ICANON;