1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 Keyspan USB to Serial Converter driver 4 5 (C) Copyright (C) 2000-2001 Hugh Blemings <hugh@blemings.org> 6 (C) Copyright (C) 2002 Greg Kroah-Hartman <greg@kroah.com> 7 8 See http://blemings.org/hugh/keyspan.html for more information. 9 10 Code in this driver inspired by and in a number of places taken 11 from Brian Warner's original Keyspan-PDA driver. 12 13 This driver has been put together with the support of Innosys, Inc. 14 and Keyspan, Inc the manufacturers of the Keyspan USB-serial products. 15 Thanks Guys :) 16 17 Thanks to Paulus for miscellaneous tidy ups, some largish chunks 18 of much nicer and/or completely new code and (perhaps most uniquely) 19 having the patience to sit down and explain why and where he'd changed 20 stuff. 21 22 Tip 'o the hat to IBM (and previously Linuxcare :) for supporting 23 staff in their work on open source projects. 24 */ 25 26 27 #include <linux/kernel.h> 28 #include <linux/jiffies.h> 29 #include <linux/errno.h> 30 #include <linux/slab.h> 31 #include <linux/tty.h> 32 #include <linux/tty_driver.h> 33 #include <linux/tty_flip.h> 34 #include <linux/module.h> 35 #include <linux/spinlock.h> 36 #include <linux/uaccess.h> 37 #include <linux/usb.h> 38 #include <linux/usb/serial.h> 39 #include <linux/usb/ezusb.h> 40 41 #define DRIVER_AUTHOR "Hugh Blemings <hugh@misc.nu" 42 #define DRIVER_DESC "Keyspan USB to Serial Converter Driver" 43 44 /* Function prototypes for Keyspan serial converter */ 45 static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port); 46 static void keyspan_close(struct usb_serial_port *port); 47 static void keyspan_dtr_rts(struct usb_serial_port *port, int on); 48 static int keyspan_startup(struct usb_serial *serial); 49 static void keyspan_disconnect(struct usb_serial *serial); 50 static void keyspan_release(struct usb_serial *serial); 51 static int keyspan_port_probe(struct usb_serial_port *port); 52 static int keyspan_port_remove(struct usb_serial_port *port); 53 static int keyspan_write_room(struct tty_struct *tty); 54 static int keyspan_write(struct tty_struct *tty, struct usb_serial_port *port, 55 const unsigned char *buf, int count); 56 static void keyspan_send_setup(struct usb_serial_port *port, int reset_port); 57 static void keyspan_set_termios(struct tty_struct *tty, 58 struct usb_serial_port *port, 59 struct ktermios *old); 60 static void keyspan_break_ctl(struct tty_struct *tty, int break_state); 61 static int keyspan_tiocmget(struct tty_struct *tty); 62 static int keyspan_tiocmset(struct tty_struct *tty, unsigned int set, 63 unsigned int clear); 64 static int keyspan_fake_startup(struct usb_serial *serial); 65 66 static int keyspan_usa19_calc_baud(struct usb_serial_port *port, 67 u32 baud_rate, u32 baudclk, 68 u8 *rate_hi, u8 *rate_low, 69 u8 *prescaler, int portnum); 70 static int keyspan_usa19w_calc_baud(struct usb_serial_port *port, 71 u32 baud_rate, u32 baudclk, 72 u8 *rate_hi, u8 *rate_low, 73 u8 *prescaler, int portnum); 74 static int keyspan_usa28_calc_baud(struct usb_serial_port *port, 75 u32 baud_rate, u32 baudclk, 76 u8 *rate_hi, u8 *rate_low, 77 u8 *prescaler, int portnum); 78 static int keyspan_usa19hs_calc_baud(struct usb_serial_port *port, 79 u32 baud_rate, u32 baudclk, 80 u8 *rate_hi, u8 *rate_low, 81 u8 *prescaler, int portnum); 82 83 static int keyspan_usa28_send_setup(struct usb_serial *serial, 84 struct usb_serial_port *port, 85 int reset_port); 86 static int keyspan_usa26_send_setup(struct usb_serial *serial, 87 struct usb_serial_port *port, 88 int reset_port); 89 static int keyspan_usa49_send_setup(struct usb_serial *serial, 90 struct usb_serial_port *port, 91 int reset_port); 92 static int keyspan_usa90_send_setup(struct usb_serial *serial, 93 struct usb_serial_port *port, 94 int reset_port); 95 static int keyspan_usa67_send_setup(struct usb_serial *serial, 96 struct usb_serial_port *port, 97 int reset_port); 98 99 /* Values used for baud rate calculation - device specific */ 100 #define KEYSPAN_INVALID_BAUD_RATE (-1) 101 #define KEYSPAN_BAUD_RATE_OK (0) 102 #define KEYSPAN_USA18X_BAUDCLK (12000000L) /* a guess */ 103 #define KEYSPAN_USA19_BAUDCLK (12000000L) 104 #define KEYSPAN_USA19W_BAUDCLK (24000000L) 105 #define KEYSPAN_USA19HS_BAUDCLK (14769231L) 106 #define KEYSPAN_USA28_BAUDCLK (1843200L) 107 #define KEYSPAN_USA28X_BAUDCLK (12000000L) 108 #define KEYSPAN_USA49W_BAUDCLK (48000000L) 109 110 /* Some constants used to characterise each device. */ 111 #define KEYSPAN_MAX_NUM_PORTS (4) 112 #define KEYSPAN_MAX_FLIPS (2) 113 114 /* 115 * Device info for the Keyspan serial converter, used by the overall 116 * usb-serial probe function. 117 */ 118 #define KEYSPAN_VENDOR_ID (0x06cd) 119 120 /* Product IDs for the products supported, pre-renumeration */ 121 #define keyspan_usa18x_pre_product_id 0x0105 122 #define keyspan_usa19_pre_product_id 0x0103 123 #define keyspan_usa19qi_pre_product_id 0x010b 124 #define keyspan_mpr_pre_product_id 0x011b 125 #define keyspan_usa19qw_pre_product_id 0x0118 126 #define keyspan_usa19w_pre_product_id 0x0106 127 #define keyspan_usa28_pre_product_id 0x0101 128 #define keyspan_usa28x_pre_product_id 0x0102 129 #define keyspan_usa28xa_pre_product_id 0x0114 130 #define keyspan_usa28xb_pre_product_id 0x0113 131 #define keyspan_usa49w_pre_product_id 0x0109 132 #define keyspan_usa49wlc_pre_product_id 0x011a 133 134 /* 135 * Product IDs post-renumeration. Note that the 28x and 28xb have the same 136 * id's post-renumeration but behave identically so it's not an issue. As 137 * such, the 28xb is not listed in any of the device tables. 138 */ 139 #define keyspan_usa18x_product_id 0x0112 140 #define keyspan_usa19_product_id 0x0107 141 #define keyspan_usa19qi_product_id 0x010c 142 #define keyspan_usa19hs_product_id 0x0121 143 #define keyspan_mpr_product_id 0x011c 144 #define keyspan_usa19qw_product_id 0x0119 145 #define keyspan_usa19w_product_id 0x0108 146 #define keyspan_usa28_product_id 0x010f 147 #define keyspan_usa28x_product_id 0x0110 148 #define keyspan_usa28xa_product_id 0x0115 149 #define keyspan_usa28xb_product_id 0x0110 150 #define keyspan_usa28xg_product_id 0x0135 151 #define keyspan_usa49w_product_id 0x010a 152 #define keyspan_usa49wlc_product_id 0x012a 153 #define keyspan_usa49wg_product_id 0x0131 154 155 struct keyspan_device_details { 156 /* product ID value */ 157 int product_id; 158 159 enum {msg_usa26, msg_usa28, msg_usa49, msg_usa90, msg_usa67} msg_format; 160 161 /* Number of physical ports */ 162 int num_ports; 163 164 /* 1 if endpoint flipping used on input, 0 if not */ 165 int indat_endp_flip; 166 167 /* 1 if endpoint flipping used on output, 0 if not */ 168 int outdat_endp_flip; 169 170 /* 171 * Table mapping input data endpoint IDs to physical port 172 * number and flip if used 173 */ 174 int indat_endpoints[KEYSPAN_MAX_NUM_PORTS]; 175 176 /* Same for output endpoints */ 177 int outdat_endpoints[KEYSPAN_MAX_NUM_PORTS]; 178 179 /* Input acknowledge endpoints */ 180 int inack_endpoints[KEYSPAN_MAX_NUM_PORTS]; 181 182 /* Output control endpoints */ 183 int outcont_endpoints[KEYSPAN_MAX_NUM_PORTS]; 184 185 /* Endpoint used for input status */ 186 int instat_endpoint; 187 188 /* Endpoint used for input data 49WG only */ 189 int indat_endpoint; 190 191 /* Endpoint used for global control functions */ 192 int glocont_endpoint; 193 194 int (*calculate_baud_rate)(struct usb_serial_port *port, 195 u32 baud_rate, u32 baudclk, 196 u8 *rate_hi, u8 *rate_low, u8 *prescaler, 197 int portnum); 198 u32 baudclk; 199 }; 200 201 /* 202 * Now for each device type we setup the device detail structure with the 203 * appropriate information (provided in Keyspan's documentation) 204 */ 205 206 static const struct keyspan_device_details usa18x_device_details = { 207 .product_id = keyspan_usa18x_product_id, 208 .msg_format = msg_usa26, 209 .num_ports = 1, 210 .indat_endp_flip = 0, 211 .outdat_endp_flip = 1, 212 .indat_endpoints = {0x81}, 213 .outdat_endpoints = {0x01}, 214 .inack_endpoints = {0x85}, 215 .outcont_endpoints = {0x05}, 216 .instat_endpoint = 0x87, 217 .indat_endpoint = -1, 218 .glocont_endpoint = 0x07, 219 .calculate_baud_rate = keyspan_usa19w_calc_baud, 220 .baudclk = KEYSPAN_USA18X_BAUDCLK, 221 }; 222 223 static const struct keyspan_device_details usa19_device_details = { 224 .product_id = keyspan_usa19_product_id, 225 .msg_format = msg_usa28, 226 .num_ports = 1, 227 .indat_endp_flip = 1, 228 .outdat_endp_flip = 1, 229 .indat_endpoints = {0x81}, 230 .outdat_endpoints = {0x01}, 231 .inack_endpoints = {0x83}, 232 .outcont_endpoints = {0x03}, 233 .instat_endpoint = 0x84, 234 .indat_endpoint = -1, 235 .glocont_endpoint = -1, 236 .calculate_baud_rate = keyspan_usa19_calc_baud, 237 .baudclk = KEYSPAN_USA19_BAUDCLK, 238 }; 239 240 static const struct keyspan_device_details usa19qi_device_details = { 241 .product_id = keyspan_usa19qi_product_id, 242 .msg_format = msg_usa28, 243 .num_ports = 1, 244 .indat_endp_flip = 1, 245 .outdat_endp_flip = 1, 246 .indat_endpoints = {0x81}, 247 .outdat_endpoints = {0x01}, 248 .inack_endpoints = {0x83}, 249 .outcont_endpoints = {0x03}, 250 .instat_endpoint = 0x84, 251 .indat_endpoint = -1, 252 .glocont_endpoint = -1, 253 .calculate_baud_rate = keyspan_usa28_calc_baud, 254 .baudclk = KEYSPAN_USA19_BAUDCLK, 255 }; 256 257 static const struct keyspan_device_details mpr_device_details = { 258 .product_id = keyspan_mpr_product_id, 259 .msg_format = msg_usa28, 260 .num_ports = 1, 261 .indat_endp_flip = 1, 262 .outdat_endp_flip = 1, 263 .indat_endpoints = {0x81}, 264 .outdat_endpoints = {0x01}, 265 .inack_endpoints = {0x83}, 266 .outcont_endpoints = {0x03}, 267 .instat_endpoint = 0x84, 268 .indat_endpoint = -1, 269 .glocont_endpoint = -1, 270 .calculate_baud_rate = keyspan_usa28_calc_baud, 271 .baudclk = KEYSPAN_USA19_BAUDCLK, 272 }; 273 274 static const struct keyspan_device_details usa19qw_device_details = { 275 .product_id = keyspan_usa19qw_product_id, 276 .msg_format = msg_usa26, 277 .num_ports = 1, 278 .indat_endp_flip = 0, 279 .outdat_endp_flip = 1, 280 .indat_endpoints = {0x81}, 281 .outdat_endpoints = {0x01}, 282 .inack_endpoints = {0x85}, 283 .outcont_endpoints = {0x05}, 284 .instat_endpoint = 0x87, 285 .indat_endpoint = -1, 286 .glocont_endpoint = 0x07, 287 .calculate_baud_rate = keyspan_usa19w_calc_baud, 288 .baudclk = KEYSPAN_USA19W_BAUDCLK, 289 }; 290 291 static const struct keyspan_device_details usa19w_device_details = { 292 .product_id = keyspan_usa19w_product_id, 293 .msg_format = msg_usa26, 294 .num_ports = 1, 295 .indat_endp_flip = 0, 296 .outdat_endp_flip = 1, 297 .indat_endpoints = {0x81}, 298 .outdat_endpoints = {0x01}, 299 .inack_endpoints = {0x85}, 300 .outcont_endpoints = {0x05}, 301 .instat_endpoint = 0x87, 302 .indat_endpoint = -1, 303 .glocont_endpoint = 0x07, 304 .calculate_baud_rate = keyspan_usa19w_calc_baud, 305 .baudclk = KEYSPAN_USA19W_BAUDCLK, 306 }; 307 308 static const struct keyspan_device_details usa19hs_device_details = { 309 .product_id = keyspan_usa19hs_product_id, 310 .msg_format = msg_usa90, 311 .num_ports = 1, 312 .indat_endp_flip = 0, 313 .outdat_endp_flip = 0, 314 .indat_endpoints = {0x81}, 315 .outdat_endpoints = {0x01}, 316 .inack_endpoints = {-1}, 317 .outcont_endpoints = {0x02}, 318 .instat_endpoint = 0x82, 319 .indat_endpoint = -1, 320 .glocont_endpoint = -1, 321 .calculate_baud_rate = keyspan_usa19hs_calc_baud, 322 .baudclk = KEYSPAN_USA19HS_BAUDCLK, 323 }; 324 325 static const struct keyspan_device_details usa28_device_details = { 326 .product_id = keyspan_usa28_product_id, 327 .msg_format = msg_usa28, 328 .num_ports = 2, 329 .indat_endp_flip = 1, 330 .outdat_endp_flip = 1, 331 .indat_endpoints = {0x81, 0x83}, 332 .outdat_endpoints = {0x01, 0x03}, 333 .inack_endpoints = {0x85, 0x86}, 334 .outcont_endpoints = {0x05, 0x06}, 335 .instat_endpoint = 0x87, 336 .indat_endpoint = -1, 337 .glocont_endpoint = 0x07, 338 .calculate_baud_rate = keyspan_usa28_calc_baud, 339 .baudclk = KEYSPAN_USA28_BAUDCLK, 340 }; 341 342 static const struct keyspan_device_details usa28x_device_details = { 343 .product_id = keyspan_usa28x_product_id, 344 .msg_format = msg_usa26, 345 .num_ports = 2, 346 .indat_endp_flip = 0, 347 .outdat_endp_flip = 1, 348 .indat_endpoints = {0x81, 0x83}, 349 .outdat_endpoints = {0x01, 0x03}, 350 .inack_endpoints = {0x85, 0x86}, 351 .outcont_endpoints = {0x05, 0x06}, 352 .instat_endpoint = 0x87, 353 .indat_endpoint = -1, 354 .glocont_endpoint = 0x07, 355 .calculate_baud_rate = keyspan_usa19w_calc_baud, 356 .baudclk = KEYSPAN_USA28X_BAUDCLK, 357 }; 358 359 static const struct keyspan_device_details usa28xa_device_details = { 360 .product_id = keyspan_usa28xa_product_id, 361 .msg_format = msg_usa26, 362 .num_ports = 2, 363 .indat_endp_flip = 0, 364 .outdat_endp_flip = 1, 365 .indat_endpoints = {0x81, 0x83}, 366 .outdat_endpoints = {0x01, 0x03}, 367 .inack_endpoints = {0x85, 0x86}, 368 .outcont_endpoints = {0x05, 0x06}, 369 .instat_endpoint = 0x87, 370 .indat_endpoint = -1, 371 .glocont_endpoint = 0x07, 372 .calculate_baud_rate = keyspan_usa19w_calc_baud, 373 .baudclk = KEYSPAN_USA28X_BAUDCLK, 374 }; 375 376 static const struct keyspan_device_details usa28xg_device_details = { 377 .product_id = keyspan_usa28xg_product_id, 378 .msg_format = msg_usa67, 379 .num_ports = 2, 380 .indat_endp_flip = 0, 381 .outdat_endp_flip = 0, 382 .indat_endpoints = {0x84, 0x88}, 383 .outdat_endpoints = {0x02, 0x06}, 384 .inack_endpoints = {-1, -1}, 385 .outcont_endpoints = {-1, -1}, 386 .instat_endpoint = 0x81, 387 .indat_endpoint = -1, 388 .glocont_endpoint = 0x01, 389 .calculate_baud_rate = keyspan_usa19w_calc_baud, 390 .baudclk = KEYSPAN_USA28X_BAUDCLK, 391 }; 392 /* 393 * We don't need a separate entry for the usa28xb as it appears as a 28x 394 * anyway. 395 */ 396 397 static const struct keyspan_device_details usa49w_device_details = { 398 .product_id = keyspan_usa49w_product_id, 399 .msg_format = msg_usa49, 400 .num_ports = 4, 401 .indat_endp_flip = 0, 402 .outdat_endp_flip = 0, 403 .indat_endpoints = {0x81, 0x82, 0x83, 0x84}, 404 .outdat_endpoints = {0x01, 0x02, 0x03, 0x04}, 405 .inack_endpoints = {-1, -1, -1, -1}, 406 .outcont_endpoints = {-1, -1, -1, -1}, 407 .instat_endpoint = 0x87, 408 .indat_endpoint = -1, 409 .glocont_endpoint = 0x07, 410 .calculate_baud_rate = keyspan_usa19w_calc_baud, 411 .baudclk = KEYSPAN_USA49W_BAUDCLK, 412 }; 413 414 static const struct keyspan_device_details usa49wlc_device_details = { 415 .product_id = keyspan_usa49wlc_product_id, 416 .msg_format = msg_usa49, 417 .num_ports = 4, 418 .indat_endp_flip = 0, 419 .outdat_endp_flip = 0, 420 .indat_endpoints = {0x81, 0x82, 0x83, 0x84}, 421 .outdat_endpoints = {0x01, 0x02, 0x03, 0x04}, 422 .inack_endpoints = {-1, -1, -1, -1}, 423 .outcont_endpoints = {-1, -1, -1, -1}, 424 .instat_endpoint = 0x87, 425 .indat_endpoint = -1, 426 .glocont_endpoint = 0x07, 427 .calculate_baud_rate = keyspan_usa19w_calc_baud, 428 .baudclk = KEYSPAN_USA19W_BAUDCLK, 429 }; 430 431 static const struct keyspan_device_details usa49wg_device_details = { 432 .product_id = keyspan_usa49wg_product_id, 433 .msg_format = msg_usa49, 434 .num_ports = 4, 435 .indat_endp_flip = 0, 436 .outdat_endp_flip = 0, 437 .indat_endpoints = {-1, -1, -1, -1}, /* single 'global' data in EP */ 438 .outdat_endpoints = {0x01, 0x02, 0x04, 0x06}, 439 .inack_endpoints = {-1, -1, -1, -1}, 440 .outcont_endpoints = {-1, -1, -1, -1}, 441 .instat_endpoint = 0x81, 442 .indat_endpoint = 0x88, 443 .glocont_endpoint = 0x00, /* uses control EP */ 444 .calculate_baud_rate = keyspan_usa19w_calc_baud, 445 .baudclk = KEYSPAN_USA19W_BAUDCLK, 446 }; 447 448 static const struct keyspan_device_details *keyspan_devices[] = { 449 &usa18x_device_details, 450 &usa19_device_details, 451 &usa19qi_device_details, 452 &mpr_device_details, 453 &usa19qw_device_details, 454 &usa19w_device_details, 455 &usa19hs_device_details, 456 &usa28_device_details, 457 &usa28x_device_details, 458 &usa28xa_device_details, 459 &usa28xg_device_details, 460 /* 28xb not required as it renumerates as a 28x */ 461 &usa49w_device_details, 462 &usa49wlc_device_details, 463 &usa49wg_device_details, 464 NULL, 465 }; 466 467 static const struct usb_device_id keyspan_ids_combined[] = { 468 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_pre_product_id) }, 469 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_pre_product_id) }, 470 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_pre_product_id) }, 471 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_pre_product_id) }, 472 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_pre_product_id) }, 473 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_pre_product_id) }, 474 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_pre_product_id) }, 475 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_pre_product_id) }, 476 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_pre_product_id) }, 477 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xb_pre_product_id) }, 478 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_pre_product_id) }, 479 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_pre_product_id) }, 480 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_product_id) }, 481 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_product_id) }, 482 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_product_id) }, 483 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_product_id) }, 484 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_product_id) }, 485 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19hs_product_id) }, 486 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_product_id) }, 487 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_product_id) }, 488 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_product_id) }, 489 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_product_id) }, 490 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xg_product_id) }, 491 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_product_id)}, 492 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_product_id)}, 493 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wg_product_id)}, 494 { } /* Terminating entry */ 495 }; 496 497 MODULE_DEVICE_TABLE(usb, keyspan_ids_combined); 498 499 /* usb_device_id table for the pre-firmware download keyspan devices */ 500 static const struct usb_device_id keyspan_pre_ids[] = { 501 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_pre_product_id) }, 502 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_pre_product_id) }, 503 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_pre_product_id) }, 504 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_pre_product_id) }, 505 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_pre_product_id) }, 506 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_pre_product_id) }, 507 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_pre_product_id) }, 508 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_pre_product_id) }, 509 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_pre_product_id) }, 510 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xb_pre_product_id) }, 511 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_pre_product_id) }, 512 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_pre_product_id) }, 513 { } /* Terminating entry */ 514 }; 515 516 static const struct usb_device_id keyspan_1port_ids[] = { 517 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa18x_product_id) }, 518 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19_product_id) }, 519 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qi_product_id) }, 520 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19qw_product_id) }, 521 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19w_product_id) }, 522 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa19hs_product_id) }, 523 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_mpr_product_id) }, 524 { } /* Terminating entry */ 525 }; 526 527 static const struct usb_device_id keyspan_2port_ids[] = { 528 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_product_id) }, 529 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_product_id) }, 530 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_product_id) }, 531 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xg_product_id) }, 532 { } /* Terminating entry */ 533 }; 534 535 static const struct usb_device_id keyspan_4port_ids[] = { 536 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_product_id) }, 537 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_product_id)}, 538 { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wg_product_id)}, 539 { } /* Terminating entry */ 540 }; 541 542 #define INSTAT_BUFLEN 32 543 #define GLOCONT_BUFLEN 64 544 #define INDAT49W_BUFLEN 512 545 #define IN_BUFLEN 64 546 #define OUT_BUFLEN 64 547 #define INACK_BUFLEN 1 548 #define OUTCONT_BUFLEN 64 549 550 /* Per device and per port private data */ 551 struct keyspan_serial_private { 552 const struct keyspan_device_details *device_details; 553 554 struct urb *instat_urb; 555 char *instat_buf; 556 557 /* added to support 49wg, where data from all 4 ports comes in 558 on 1 EP and high-speed supported */ 559 struct urb *indat_urb; 560 char *indat_buf; 561 562 /* XXX this one probably will need a lock */ 563 struct urb *glocont_urb; 564 char *glocont_buf; 565 char *ctrl_buf; /* for EP0 control message */ 566 }; 567 568 struct keyspan_port_private { 569 /* Keep track of which input & output endpoints to use */ 570 int in_flip; 571 int out_flip; 572 573 /* Keep duplicate of device details in each port 574 structure as well - simplifies some of the 575 callback functions etc. */ 576 const struct keyspan_device_details *device_details; 577 578 /* Input endpoints and buffer for this port */ 579 struct urb *in_urbs[2]; 580 char *in_buffer[2]; 581 /* Output endpoints and buffer for this port */ 582 struct urb *out_urbs[2]; 583 char *out_buffer[2]; 584 585 /* Input ack endpoint */ 586 struct urb *inack_urb; 587 char *inack_buffer; 588 589 /* Output control endpoint */ 590 struct urb *outcont_urb; 591 char *outcont_buffer; 592 593 /* Settings for the port */ 594 int baud; 595 int old_baud; 596 unsigned int cflag; 597 unsigned int old_cflag; 598 enum {flow_none, flow_cts, flow_xon} flow_control; 599 int rts_state; /* Handshaking pins (outputs) */ 600 int dtr_state; 601 int cts_state; /* Handshaking pins (inputs) */ 602 int dsr_state; 603 int dcd_state; 604 int ri_state; 605 int break_on; 606 607 unsigned long tx_start_time[2]; 608 int resend_cont; /* need to resend control packet */ 609 }; 610 611 /* Include Keyspan message headers. All current Keyspan Adapters 612 make use of one of five message formats which are referred 613 to as USA-26, USA-28, USA-49, USA-90, USA-67 by Keyspan and 614 within this driver. */ 615 #include "keyspan_usa26msg.h" 616 #include "keyspan_usa28msg.h" 617 #include "keyspan_usa49msg.h" 618 #include "keyspan_usa90msg.h" 619 #include "keyspan_usa67msg.h" 620 621 622 static void keyspan_break_ctl(struct tty_struct *tty, int break_state) 623 { 624 struct usb_serial_port *port = tty->driver_data; 625 struct keyspan_port_private *p_priv; 626 627 p_priv = usb_get_serial_port_data(port); 628 629 if (break_state == -1) 630 p_priv->break_on = 1; 631 else 632 p_priv->break_on = 0; 633 634 keyspan_send_setup(port, 0); 635 } 636 637 638 static void keyspan_set_termios(struct tty_struct *tty, 639 struct usb_serial_port *port, struct ktermios *old_termios) 640 { 641 int baud_rate, device_port; 642 struct keyspan_port_private *p_priv; 643 const struct keyspan_device_details *d_details; 644 unsigned int cflag; 645 646 p_priv = usb_get_serial_port_data(port); 647 d_details = p_priv->device_details; 648 cflag = tty->termios.c_cflag; 649 device_port = port->port_number; 650 651 /* Baud rate calculation takes baud rate as an integer 652 so other rates can be generated if desired. */ 653 baud_rate = tty_get_baud_rate(tty); 654 /* If no match or invalid, don't change */ 655 if (d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk, 656 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) { 657 /* FIXME - more to do here to ensure rate changes cleanly */ 658 /* FIXME - calculate exact rate from divisor ? */ 659 p_priv->baud = baud_rate; 660 } else 661 baud_rate = tty_termios_baud_rate(old_termios); 662 663 tty_encode_baud_rate(tty, baud_rate, baud_rate); 664 /* set CTS/RTS handshake etc. */ 665 p_priv->cflag = cflag; 666 p_priv->flow_control = (cflag & CRTSCTS) ? flow_cts : flow_none; 667 668 /* Mark/Space not supported */ 669 tty->termios.c_cflag &= ~CMSPAR; 670 671 keyspan_send_setup(port, 0); 672 } 673 674 static int keyspan_tiocmget(struct tty_struct *tty) 675 { 676 struct usb_serial_port *port = tty->driver_data; 677 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port); 678 unsigned int value; 679 680 value = ((p_priv->rts_state) ? TIOCM_RTS : 0) | 681 ((p_priv->dtr_state) ? TIOCM_DTR : 0) | 682 ((p_priv->cts_state) ? TIOCM_CTS : 0) | 683 ((p_priv->dsr_state) ? TIOCM_DSR : 0) | 684 ((p_priv->dcd_state) ? TIOCM_CAR : 0) | 685 ((p_priv->ri_state) ? TIOCM_RNG : 0); 686 687 return value; 688 } 689 690 static int keyspan_tiocmset(struct tty_struct *tty, 691 unsigned int set, unsigned int clear) 692 { 693 struct usb_serial_port *port = tty->driver_data; 694 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port); 695 696 if (set & TIOCM_RTS) 697 p_priv->rts_state = 1; 698 if (set & TIOCM_DTR) 699 p_priv->dtr_state = 1; 700 if (clear & TIOCM_RTS) 701 p_priv->rts_state = 0; 702 if (clear & TIOCM_DTR) 703 p_priv->dtr_state = 0; 704 keyspan_send_setup(port, 0); 705 return 0; 706 } 707 708 /* Write function is similar for the four protocols used 709 with only a minor change for usa90 (usa19hs) required */ 710 static int keyspan_write(struct tty_struct *tty, 711 struct usb_serial_port *port, const unsigned char *buf, int count) 712 { 713 struct keyspan_port_private *p_priv; 714 const struct keyspan_device_details *d_details; 715 int flip; 716 int left, todo; 717 struct urb *this_urb; 718 int err, maxDataLen, dataOffset; 719 720 p_priv = usb_get_serial_port_data(port); 721 d_details = p_priv->device_details; 722 723 if (d_details->msg_format == msg_usa90) { 724 maxDataLen = 64; 725 dataOffset = 0; 726 } else { 727 maxDataLen = 63; 728 dataOffset = 1; 729 } 730 731 dev_dbg(&port->dev, "%s - %d chars, flip=%d\n", __func__, count, 732 p_priv->out_flip); 733 734 for (left = count; left > 0; left -= todo) { 735 todo = left; 736 if (todo > maxDataLen) 737 todo = maxDataLen; 738 739 flip = p_priv->out_flip; 740 741 /* Check we have a valid urb/endpoint before we use it... */ 742 this_urb = p_priv->out_urbs[flip]; 743 if (this_urb == NULL) { 744 /* no bulk out, so return 0 bytes written */ 745 dev_dbg(&port->dev, "%s - no output urb :(\n", __func__); 746 return count; 747 } 748 749 dev_dbg(&port->dev, "%s - endpoint %x flip %d\n", 750 __func__, usb_pipeendpoint(this_urb->pipe), flip); 751 752 if (this_urb->status == -EINPROGRESS) { 753 if (time_before(jiffies, 754 p_priv->tx_start_time[flip] + 10 * HZ)) 755 break; 756 usb_unlink_urb(this_urb); 757 break; 758 } 759 760 /* First byte in buffer is "last flag" (except for usa19hx) 761 - unused so for now so set to zero */ 762 ((char *)this_urb->transfer_buffer)[0] = 0; 763 764 memcpy(this_urb->transfer_buffer + dataOffset, buf, todo); 765 buf += todo; 766 767 /* send the data out the bulk port */ 768 this_urb->transfer_buffer_length = todo + dataOffset; 769 770 err = usb_submit_urb(this_urb, GFP_ATOMIC); 771 if (err != 0) 772 dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed (%d)\n", err); 773 p_priv->tx_start_time[flip] = jiffies; 774 775 /* Flip for next time if usa26 or usa28 interface 776 (not used on usa49) */ 777 p_priv->out_flip = (flip + 1) & d_details->outdat_endp_flip; 778 } 779 780 return count - left; 781 } 782 783 static void usa26_indat_callback(struct urb *urb) 784 { 785 int i, err; 786 int endpoint; 787 struct usb_serial_port *port; 788 unsigned char *data = urb->transfer_buffer; 789 int status = urb->status; 790 791 endpoint = usb_pipeendpoint(urb->pipe); 792 793 if (status) { 794 dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n", 795 __func__, status, endpoint); 796 return; 797 } 798 799 port = urb->context; 800 if (urb->actual_length) { 801 /* 0x80 bit is error flag */ 802 if ((data[0] & 0x80) == 0) { 803 /* no errors on individual bytes, only 804 possible overrun err */ 805 if (data[0] & RXERROR_OVERRUN) { 806 tty_insert_flip_char(&port->port, 0, 807 TTY_OVERRUN); 808 } 809 for (i = 1; i < urb->actual_length ; ++i) 810 tty_insert_flip_char(&port->port, data[i], 811 TTY_NORMAL); 812 } else { 813 /* some bytes had errors, every byte has status */ 814 dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__); 815 for (i = 0; i + 1 < urb->actual_length; i += 2) { 816 int stat = data[i]; 817 int flag = TTY_NORMAL; 818 819 if (stat & RXERROR_OVERRUN) { 820 tty_insert_flip_char(&port->port, 0, 821 TTY_OVERRUN); 822 } 823 /* XXX should handle break (0x10) */ 824 if (stat & RXERROR_PARITY) 825 flag = TTY_PARITY; 826 else if (stat & RXERROR_FRAMING) 827 flag = TTY_FRAME; 828 829 tty_insert_flip_char(&port->port, data[i+1], 830 flag); 831 } 832 } 833 tty_flip_buffer_push(&port->port); 834 } 835 836 /* Resubmit urb so we continue receiving */ 837 err = usb_submit_urb(urb, GFP_ATOMIC); 838 if (err != 0) 839 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err); 840 } 841 842 /* Outdat handling is common for all devices */ 843 static void usa2x_outdat_callback(struct urb *urb) 844 { 845 struct usb_serial_port *port; 846 struct keyspan_port_private *p_priv; 847 848 port = urb->context; 849 p_priv = usb_get_serial_port_data(port); 850 dev_dbg(&port->dev, "%s - urb %d\n", __func__, urb == p_priv->out_urbs[1]); 851 852 usb_serial_port_softint(port); 853 } 854 855 static void usa26_inack_callback(struct urb *urb) 856 { 857 } 858 859 static void usa26_outcont_callback(struct urb *urb) 860 { 861 struct usb_serial_port *port; 862 struct keyspan_port_private *p_priv; 863 864 port = urb->context; 865 p_priv = usb_get_serial_port_data(port); 866 867 if (p_priv->resend_cont) { 868 dev_dbg(&port->dev, "%s - sending setup\n", __func__); 869 keyspan_usa26_send_setup(port->serial, port, 870 p_priv->resend_cont - 1); 871 } 872 } 873 874 static void usa26_instat_callback(struct urb *urb) 875 { 876 unsigned char *data = urb->transfer_buffer; 877 struct keyspan_usa26_portStatusMessage *msg; 878 struct usb_serial *serial; 879 struct usb_serial_port *port; 880 struct keyspan_port_private *p_priv; 881 int old_dcd_state, err; 882 int status = urb->status; 883 884 serial = urb->context; 885 886 if (status) { 887 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n", 888 __func__, status); 889 return; 890 } 891 if (urb->actual_length != 9) { 892 dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length); 893 goto exit; 894 } 895 896 msg = (struct keyspan_usa26_portStatusMessage *)data; 897 898 /* Check port number from message and retrieve private data */ 899 if (msg->port >= serial->num_ports) { 900 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port); 901 goto exit; 902 } 903 port = serial->port[msg->port]; 904 p_priv = usb_get_serial_port_data(port); 905 if (!p_priv) 906 goto resubmit; 907 908 /* Update handshaking pin state information */ 909 old_dcd_state = p_priv->dcd_state; 910 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0); 911 p_priv->dsr_state = ((msg->dsr) ? 1 : 0); 912 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0); 913 p_priv->ri_state = ((msg->ri) ? 1 : 0); 914 915 if (old_dcd_state != p_priv->dcd_state) 916 tty_port_tty_hangup(&port->port, true); 917 resubmit: 918 /* Resubmit urb so we continue receiving */ 919 err = usb_submit_urb(urb, GFP_ATOMIC); 920 if (err != 0) 921 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err); 922 exit: ; 923 } 924 925 static void usa26_glocont_callback(struct urb *urb) 926 { 927 } 928 929 930 static void usa28_indat_callback(struct urb *urb) 931 { 932 int err; 933 struct usb_serial_port *port; 934 unsigned char *data; 935 struct keyspan_port_private *p_priv; 936 int status = urb->status; 937 938 port = urb->context; 939 p_priv = usb_get_serial_port_data(port); 940 data = urb->transfer_buffer; 941 942 if (urb != p_priv->in_urbs[p_priv->in_flip]) 943 return; 944 945 do { 946 if (status) { 947 dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n", 948 __func__, status, usb_pipeendpoint(urb->pipe)); 949 return; 950 } 951 952 port = urb->context; 953 p_priv = usb_get_serial_port_data(port); 954 data = urb->transfer_buffer; 955 956 if (urb->actual_length) { 957 tty_insert_flip_string(&port->port, data, 958 urb->actual_length); 959 tty_flip_buffer_push(&port->port); 960 } 961 962 /* Resubmit urb so we continue receiving */ 963 err = usb_submit_urb(urb, GFP_ATOMIC); 964 if (err != 0) 965 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", 966 __func__, err); 967 p_priv->in_flip ^= 1; 968 969 urb = p_priv->in_urbs[p_priv->in_flip]; 970 } while (urb->status != -EINPROGRESS); 971 } 972 973 static void usa28_inack_callback(struct urb *urb) 974 { 975 } 976 977 static void usa28_outcont_callback(struct urb *urb) 978 { 979 struct usb_serial_port *port; 980 struct keyspan_port_private *p_priv; 981 982 port = urb->context; 983 p_priv = usb_get_serial_port_data(port); 984 985 if (p_priv->resend_cont) { 986 dev_dbg(&port->dev, "%s - sending setup\n", __func__); 987 keyspan_usa28_send_setup(port->serial, port, 988 p_priv->resend_cont - 1); 989 } 990 } 991 992 static void usa28_instat_callback(struct urb *urb) 993 { 994 int err; 995 unsigned char *data = urb->transfer_buffer; 996 struct keyspan_usa28_portStatusMessage *msg; 997 struct usb_serial *serial; 998 struct usb_serial_port *port; 999 struct keyspan_port_private *p_priv; 1000 int old_dcd_state; 1001 int status = urb->status; 1002 1003 serial = urb->context; 1004 1005 if (status) { 1006 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n", 1007 __func__, status); 1008 return; 1009 } 1010 1011 if (urb->actual_length != sizeof(struct keyspan_usa28_portStatusMessage)) { 1012 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length); 1013 goto exit; 1014 } 1015 1016 msg = (struct keyspan_usa28_portStatusMessage *)data; 1017 1018 /* Check port number from message and retrieve private data */ 1019 if (msg->port >= serial->num_ports) { 1020 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port); 1021 goto exit; 1022 } 1023 port = serial->port[msg->port]; 1024 p_priv = usb_get_serial_port_data(port); 1025 if (!p_priv) 1026 goto resubmit; 1027 1028 /* Update handshaking pin state information */ 1029 old_dcd_state = p_priv->dcd_state; 1030 p_priv->cts_state = ((msg->cts) ? 1 : 0); 1031 p_priv->dsr_state = ((msg->dsr) ? 1 : 0); 1032 p_priv->dcd_state = ((msg->dcd) ? 1 : 0); 1033 p_priv->ri_state = ((msg->ri) ? 1 : 0); 1034 1035 if (old_dcd_state != p_priv->dcd_state && old_dcd_state) 1036 tty_port_tty_hangup(&port->port, true); 1037 resubmit: 1038 /* Resubmit urb so we continue receiving */ 1039 err = usb_submit_urb(urb, GFP_ATOMIC); 1040 if (err != 0) 1041 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err); 1042 exit: ; 1043 } 1044 1045 static void usa28_glocont_callback(struct urb *urb) 1046 { 1047 } 1048 1049 1050 static void usa49_glocont_callback(struct urb *urb) 1051 { 1052 struct usb_serial *serial; 1053 struct usb_serial_port *port; 1054 struct keyspan_port_private *p_priv; 1055 int i; 1056 1057 serial = urb->context; 1058 for (i = 0; i < serial->num_ports; ++i) { 1059 port = serial->port[i]; 1060 p_priv = usb_get_serial_port_data(port); 1061 1062 if (p_priv->resend_cont) { 1063 dev_dbg(&port->dev, "%s - sending setup\n", __func__); 1064 keyspan_usa49_send_setup(serial, port, 1065 p_priv->resend_cont - 1); 1066 break; 1067 } 1068 } 1069 } 1070 1071 /* This is actually called glostat in the Keyspan 1072 doco */ 1073 static void usa49_instat_callback(struct urb *urb) 1074 { 1075 int err; 1076 unsigned char *data = urb->transfer_buffer; 1077 struct keyspan_usa49_portStatusMessage *msg; 1078 struct usb_serial *serial; 1079 struct usb_serial_port *port; 1080 struct keyspan_port_private *p_priv; 1081 int old_dcd_state; 1082 int status = urb->status; 1083 1084 serial = urb->context; 1085 1086 if (status) { 1087 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n", 1088 __func__, status); 1089 return; 1090 } 1091 1092 if (urb->actual_length != 1093 sizeof(struct keyspan_usa49_portStatusMessage)) { 1094 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length); 1095 goto exit; 1096 } 1097 1098 msg = (struct keyspan_usa49_portStatusMessage *)data; 1099 1100 /* Check port number from message and retrieve private data */ 1101 if (msg->portNumber >= serial->num_ports) { 1102 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", 1103 __func__, msg->portNumber); 1104 goto exit; 1105 } 1106 port = serial->port[msg->portNumber]; 1107 p_priv = usb_get_serial_port_data(port); 1108 if (!p_priv) 1109 goto resubmit; 1110 1111 /* Update handshaking pin state information */ 1112 old_dcd_state = p_priv->dcd_state; 1113 p_priv->cts_state = ((msg->cts) ? 1 : 0); 1114 p_priv->dsr_state = ((msg->dsr) ? 1 : 0); 1115 p_priv->dcd_state = ((msg->dcd) ? 1 : 0); 1116 p_priv->ri_state = ((msg->ri) ? 1 : 0); 1117 1118 if (old_dcd_state != p_priv->dcd_state && old_dcd_state) 1119 tty_port_tty_hangup(&port->port, true); 1120 resubmit: 1121 /* Resubmit urb so we continue receiving */ 1122 err = usb_submit_urb(urb, GFP_ATOMIC); 1123 if (err != 0) 1124 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err); 1125 exit: ; 1126 } 1127 1128 static void usa49_inack_callback(struct urb *urb) 1129 { 1130 } 1131 1132 static void usa49_indat_callback(struct urb *urb) 1133 { 1134 int i, err; 1135 int endpoint; 1136 struct usb_serial_port *port; 1137 unsigned char *data = urb->transfer_buffer; 1138 int status = urb->status; 1139 1140 endpoint = usb_pipeendpoint(urb->pipe); 1141 1142 if (status) { 1143 dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n", 1144 __func__, status, endpoint); 1145 return; 1146 } 1147 1148 port = urb->context; 1149 if (urb->actual_length) { 1150 /* 0x80 bit is error flag */ 1151 if ((data[0] & 0x80) == 0) { 1152 /* no error on any byte */ 1153 tty_insert_flip_string(&port->port, data + 1, 1154 urb->actual_length - 1); 1155 } else { 1156 /* some bytes had errors, every byte has status */ 1157 for (i = 0; i + 1 < urb->actual_length; i += 2) { 1158 int stat = data[i]; 1159 int flag = TTY_NORMAL; 1160 1161 if (stat & RXERROR_OVERRUN) { 1162 tty_insert_flip_char(&port->port, 0, 1163 TTY_OVERRUN); 1164 } 1165 /* XXX should handle break (0x10) */ 1166 if (stat & RXERROR_PARITY) 1167 flag = TTY_PARITY; 1168 else if (stat & RXERROR_FRAMING) 1169 flag = TTY_FRAME; 1170 1171 tty_insert_flip_char(&port->port, data[i+1], 1172 flag); 1173 } 1174 } 1175 tty_flip_buffer_push(&port->port); 1176 } 1177 1178 /* Resubmit urb so we continue receiving */ 1179 err = usb_submit_urb(urb, GFP_ATOMIC); 1180 if (err != 0) 1181 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err); 1182 } 1183 1184 static void usa49wg_indat_callback(struct urb *urb) 1185 { 1186 int i, len, x, err; 1187 struct usb_serial *serial; 1188 struct usb_serial_port *port; 1189 unsigned char *data = urb->transfer_buffer; 1190 int status = urb->status; 1191 1192 serial = urb->context; 1193 1194 if (status) { 1195 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n", 1196 __func__, status); 1197 return; 1198 } 1199 1200 /* inbound data is in the form P#, len, status, data */ 1201 i = 0; 1202 len = 0; 1203 1204 while (i < urb->actual_length) { 1205 1206 /* Check port number from message */ 1207 if (data[i] >= serial->num_ports) { 1208 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", 1209 __func__, data[i]); 1210 return; 1211 } 1212 port = serial->port[data[i++]]; 1213 len = data[i++]; 1214 1215 /* 0x80 bit is error flag */ 1216 if ((data[i] & 0x80) == 0) { 1217 /* no error on any byte */ 1218 i++; 1219 for (x = 1; x < len && i < urb->actual_length; ++x) 1220 tty_insert_flip_char(&port->port, 1221 data[i++], 0); 1222 } else { 1223 /* 1224 * some bytes had errors, every byte has status 1225 */ 1226 for (x = 0; x + 1 < len && 1227 i + 1 < urb->actual_length; x += 2) { 1228 int stat = data[i]; 1229 int flag = TTY_NORMAL; 1230 1231 if (stat & RXERROR_OVERRUN) { 1232 tty_insert_flip_char(&port->port, 0, 1233 TTY_OVERRUN); 1234 } 1235 /* XXX should handle break (0x10) */ 1236 if (stat & RXERROR_PARITY) 1237 flag = TTY_PARITY; 1238 else if (stat & RXERROR_FRAMING) 1239 flag = TTY_FRAME; 1240 1241 tty_insert_flip_char(&port->port, data[i+1], 1242 flag); 1243 i += 2; 1244 } 1245 } 1246 tty_flip_buffer_push(&port->port); 1247 } 1248 1249 /* Resubmit urb so we continue receiving */ 1250 err = usb_submit_urb(urb, GFP_ATOMIC); 1251 if (err != 0) 1252 dev_dbg(&urb->dev->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err); 1253 } 1254 1255 /* not used, usa-49 doesn't have per-port control endpoints */ 1256 static void usa49_outcont_callback(struct urb *urb) 1257 { 1258 } 1259 1260 static void usa90_indat_callback(struct urb *urb) 1261 { 1262 int i, err; 1263 int endpoint; 1264 struct usb_serial_port *port; 1265 struct keyspan_port_private *p_priv; 1266 unsigned char *data = urb->transfer_buffer; 1267 int status = urb->status; 1268 1269 endpoint = usb_pipeendpoint(urb->pipe); 1270 1271 if (status) { 1272 dev_dbg(&urb->dev->dev, "%s - nonzero status %d on endpoint %x\n", 1273 __func__, status, endpoint); 1274 return; 1275 } 1276 1277 port = urb->context; 1278 p_priv = usb_get_serial_port_data(port); 1279 1280 if (urb->actual_length) { 1281 /* if current mode is DMA, looks like usa28 format 1282 otherwise looks like usa26 data format */ 1283 1284 if (p_priv->baud > 57600) 1285 tty_insert_flip_string(&port->port, data, 1286 urb->actual_length); 1287 else { 1288 /* 0x80 bit is error flag */ 1289 if ((data[0] & 0x80) == 0) { 1290 /* no errors on individual bytes, only 1291 possible overrun err*/ 1292 if (data[0] & RXERROR_OVERRUN) { 1293 tty_insert_flip_char(&port->port, 0, 1294 TTY_OVERRUN); 1295 } 1296 for (i = 1; i < urb->actual_length ; ++i) 1297 tty_insert_flip_char(&port->port, 1298 data[i], TTY_NORMAL); 1299 } else { 1300 /* some bytes had errors, every byte has status */ 1301 dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__); 1302 for (i = 0; i + 1 < urb->actual_length; i += 2) { 1303 int stat = data[i]; 1304 int flag = TTY_NORMAL; 1305 1306 if (stat & RXERROR_OVERRUN) { 1307 tty_insert_flip_char( 1308 &port->port, 0, 1309 TTY_OVERRUN); 1310 } 1311 /* XXX should handle break (0x10) */ 1312 if (stat & RXERROR_PARITY) 1313 flag = TTY_PARITY; 1314 else if (stat & RXERROR_FRAMING) 1315 flag = TTY_FRAME; 1316 1317 tty_insert_flip_char(&port->port, 1318 data[i+1], flag); 1319 } 1320 } 1321 } 1322 tty_flip_buffer_push(&port->port); 1323 } 1324 1325 /* Resubmit urb so we continue receiving */ 1326 err = usb_submit_urb(urb, GFP_ATOMIC); 1327 if (err != 0) 1328 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err); 1329 } 1330 1331 1332 static void usa90_instat_callback(struct urb *urb) 1333 { 1334 unsigned char *data = urb->transfer_buffer; 1335 struct keyspan_usa90_portStatusMessage *msg; 1336 struct usb_serial *serial; 1337 struct usb_serial_port *port; 1338 struct keyspan_port_private *p_priv; 1339 int old_dcd_state, err; 1340 int status = urb->status; 1341 1342 serial = urb->context; 1343 1344 if (status) { 1345 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n", 1346 __func__, status); 1347 return; 1348 } 1349 if (urb->actual_length < 14) { 1350 dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length); 1351 goto exit; 1352 } 1353 1354 msg = (struct keyspan_usa90_portStatusMessage *)data; 1355 1356 /* Now do something useful with the data */ 1357 1358 port = serial->port[0]; 1359 p_priv = usb_get_serial_port_data(port); 1360 if (!p_priv) 1361 goto resubmit; 1362 1363 /* Update handshaking pin state information */ 1364 old_dcd_state = p_priv->dcd_state; 1365 p_priv->cts_state = ((msg->cts) ? 1 : 0); 1366 p_priv->dsr_state = ((msg->dsr) ? 1 : 0); 1367 p_priv->dcd_state = ((msg->dcd) ? 1 : 0); 1368 p_priv->ri_state = ((msg->ri) ? 1 : 0); 1369 1370 if (old_dcd_state != p_priv->dcd_state && old_dcd_state) 1371 tty_port_tty_hangup(&port->port, true); 1372 resubmit: 1373 /* Resubmit urb so we continue receiving */ 1374 err = usb_submit_urb(urb, GFP_ATOMIC); 1375 if (err != 0) 1376 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err); 1377 exit: 1378 ; 1379 } 1380 1381 static void usa90_outcont_callback(struct urb *urb) 1382 { 1383 struct usb_serial_port *port; 1384 struct keyspan_port_private *p_priv; 1385 1386 port = urb->context; 1387 p_priv = usb_get_serial_port_data(port); 1388 1389 if (p_priv->resend_cont) { 1390 dev_dbg(&urb->dev->dev, "%s - sending setup\n", __func__); 1391 keyspan_usa90_send_setup(port->serial, port, 1392 p_priv->resend_cont - 1); 1393 } 1394 } 1395 1396 /* Status messages from the 28xg */ 1397 static void usa67_instat_callback(struct urb *urb) 1398 { 1399 int err; 1400 unsigned char *data = urb->transfer_buffer; 1401 struct keyspan_usa67_portStatusMessage *msg; 1402 struct usb_serial *serial; 1403 struct usb_serial_port *port; 1404 struct keyspan_port_private *p_priv; 1405 int old_dcd_state; 1406 int status = urb->status; 1407 1408 serial = urb->context; 1409 1410 if (status) { 1411 dev_dbg(&urb->dev->dev, "%s - nonzero status: %d\n", 1412 __func__, status); 1413 return; 1414 } 1415 1416 if (urb->actual_length != 1417 sizeof(struct keyspan_usa67_portStatusMessage)) { 1418 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length); 1419 return; 1420 } 1421 1422 1423 /* Now do something useful with the data */ 1424 msg = (struct keyspan_usa67_portStatusMessage *)data; 1425 1426 /* Check port number from message and retrieve private data */ 1427 if (msg->port >= serial->num_ports) { 1428 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port); 1429 return; 1430 } 1431 1432 port = serial->port[msg->port]; 1433 p_priv = usb_get_serial_port_data(port); 1434 if (!p_priv) 1435 goto resubmit; 1436 1437 /* Update handshaking pin state information */ 1438 old_dcd_state = p_priv->dcd_state; 1439 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0); 1440 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0); 1441 1442 if (old_dcd_state != p_priv->dcd_state && old_dcd_state) 1443 tty_port_tty_hangup(&port->port, true); 1444 resubmit: 1445 /* Resubmit urb so we continue receiving */ 1446 err = usb_submit_urb(urb, GFP_ATOMIC); 1447 if (err != 0) 1448 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err); 1449 } 1450 1451 static void usa67_glocont_callback(struct urb *urb) 1452 { 1453 struct usb_serial *serial; 1454 struct usb_serial_port *port; 1455 struct keyspan_port_private *p_priv; 1456 int i; 1457 1458 serial = urb->context; 1459 for (i = 0; i < serial->num_ports; ++i) { 1460 port = serial->port[i]; 1461 p_priv = usb_get_serial_port_data(port); 1462 1463 if (p_priv->resend_cont) { 1464 dev_dbg(&port->dev, "%s - sending setup\n", __func__); 1465 keyspan_usa67_send_setup(serial, port, 1466 p_priv->resend_cont - 1); 1467 break; 1468 } 1469 } 1470 } 1471 1472 static int keyspan_write_room(struct tty_struct *tty) 1473 { 1474 struct usb_serial_port *port = tty->driver_data; 1475 struct keyspan_port_private *p_priv; 1476 const struct keyspan_device_details *d_details; 1477 int flip; 1478 int data_len; 1479 struct urb *this_urb; 1480 1481 p_priv = usb_get_serial_port_data(port); 1482 d_details = p_priv->device_details; 1483 1484 /* FIXME: locking */ 1485 if (d_details->msg_format == msg_usa90) 1486 data_len = 64; 1487 else 1488 data_len = 63; 1489 1490 flip = p_priv->out_flip; 1491 1492 /* Check both endpoints to see if any are available. */ 1493 this_urb = p_priv->out_urbs[flip]; 1494 if (this_urb != NULL) { 1495 if (this_urb->status != -EINPROGRESS) 1496 return data_len; 1497 flip = (flip + 1) & d_details->outdat_endp_flip; 1498 this_urb = p_priv->out_urbs[flip]; 1499 if (this_urb != NULL) { 1500 if (this_urb->status != -EINPROGRESS) 1501 return data_len; 1502 } 1503 } 1504 return 0; 1505 } 1506 1507 1508 static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port) 1509 { 1510 struct keyspan_port_private *p_priv; 1511 const struct keyspan_device_details *d_details; 1512 int i, err; 1513 int baud_rate, device_port; 1514 struct urb *urb; 1515 unsigned int cflag = 0; 1516 1517 p_priv = usb_get_serial_port_data(port); 1518 d_details = p_priv->device_details; 1519 1520 /* Set some sane defaults */ 1521 p_priv->rts_state = 1; 1522 p_priv->dtr_state = 1; 1523 p_priv->baud = 9600; 1524 1525 /* force baud and lcr to be set on open */ 1526 p_priv->old_baud = 0; 1527 p_priv->old_cflag = 0; 1528 1529 p_priv->out_flip = 0; 1530 p_priv->in_flip = 0; 1531 1532 /* Reset low level data toggle and start reading from endpoints */ 1533 for (i = 0; i < 2; i++) { 1534 urb = p_priv->in_urbs[i]; 1535 if (urb == NULL) 1536 continue; 1537 1538 /* make sure endpoint data toggle is synchronized 1539 with the device */ 1540 usb_clear_halt(urb->dev, urb->pipe); 1541 err = usb_submit_urb(urb, GFP_KERNEL); 1542 if (err != 0) 1543 dev_dbg(&port->dev, "%s - submit urb %d failed (%d)\n", __func__, i, err); 1544 } 1545 1546 /* Reset low level data toggle on out endpoints */ 1547 for (i = 0; i < 2; i++) { 1548 urb = p_priv->out_urbs[i]; 1549 if (urb == NULL) 1550 continue; 1551 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), 1552 usb_pipeout(urb->pipe), 0); */ 1553 } 1554 1555 /* get the terminal config for the setup message now so we don't 1556 * need to send 2 of them */ 1557 1558 device_port = port->port_number; 1559 if (tty) { 1560 cflag = tty->termios.c_cflag; 1561 /* Baud rate calculation takes baud rate as an integer 1562 so other rates can be generated if desired. */ 1563 baud_rate = tty_get_baud_rate(tty); 1564 /* If no match or invalid, leave as default */ 1565 if (baud_rate >= 0 1566 && d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk, 1567 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) { 1568 p_priv->baud = baud_rate; 1569 } 1570 } 1571 /* set CTS/RTS handshake etc. */ 1572 p_priv->cflag = cflag; 1573 p_priv->flow_control = (cflag & CRTSCTS) ? flow_cts : flow_none; 1574 1575 keyspan_send_setup(port, 1); 1576 /* mdelay(100); */ 1577 /* keyspan_set_termios(port, NULL); */ 1578 1579 return 0; 1580 } 1581 1582 static void keyspan_dtr_rts(struct usb_serial_port *port, int on) 1583 { 1584 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port); 1585 1586 p_priv->rts_state = on; 1587 p_priv->dtr_state = on; 1588 keyspan_send_setup(port, 0); 1589 } 1590 1591 static void keyspan_close(struct usb_serial_port *port) 1592 { 1593 int i; 1594 struct keyspan_port_private *p_priv; 1595 1596 p_priv = usb_get_serial_port_data(port); 1597 1598 p_priv->rts_state = 0; 1599 p_priv->dtr_state = 0; 1600 1601 keyspan_send_setup(port, 2); 1602 /* pilot-xfer seems to work best with this delay */ 1603 mdelay(100); 1604 1605 p_priv->out_flip = 0; 1606 p_priv->in_flip = 0; 1607 1608 usb_kill_urb(p_priv->inack_urb); 1609 for (i = 0; i < 2; i++) { 1610 usb_kill_urb(p_priv->in_urbs[i]); 1611 usb_kill_urb(p_priv->out_urbs[i]); 1612 } 1613 } 1614 1615 /* download the firmware to a pre-renumeration device */ 1616 static int keyspan_fake_startup(struct usb_serial *serial) 1617 { 1618 char *fw_name; 1619 1620 dev_dbg(&serial->dev->dev, "Keyspan startup version %04x product %04x\n", 1621 le16_to_cpu(serial->dev->descriptor.bcdDevice), 1622 le16_to_cpu(serial->dev->descriptor.idProduct)); 1623 1624 if ((le16_to_cpu(serial->dev->descriptor.bcdDevice) & 0x8000) 1625 != 0x8000) { 1626 dev_dbg(&serial->dev->dev, "Firmware already loaded. Quitting.\n"); 1627 return 1; 1628 } 1629 1630 /* Select firmware image on the basis of idProduct */ 1631 switch (le16_to_cpu(serial->dev->descriptor.idProduct)) { 1632 case keyspan_usa28_pre_product_id: 1633 fw_name = "keyspan/usa28.fw"; 1634 break; 1635 1636 case keyspan_usa28x_pre_product_id: 1637 fw_name = "keyspan/usa28x.fw"; 1638 break; 1639 1640 case keyspan_usa28xa_pre_product_id: 1641 fw_name = "keyspan/usa28xa.fw"; 1642 break; 1643 1644 case keyspan_usa28xb_pre_product_id: 1645 fw_name = "keyspan/usa28xb.fw"; 1646 break; 1647 1648 case keyspan_usa19_pre_product_id: 1649 fw_name = "keyspan/usa19.fw"; 1650 break; 1651 1652 case keyspan_usa19qi_pre_product_id: 1653 fw_name = "keyspan/usa19qi.fw"; 1654 break; 1655 1656 case keyspan_mpr_pre_product_id: 1657 fw_name = "keyspan/mpr.fw"; 1658 break; 1659 1660 case keyspan_usa19qw_pre_product_id: 1661 fw_name = "keyspan/usa19qw.fw"; 1662 break; 1663 1664 case keyspan_usa18x_pre_product_id: 1665 fw_name = "keyspan/usa18x.fw"; 1666 break; 1667 1668 case keyspan_usa19w_pre_product_id: 1669 fw_name = "keyspan/usa19w.fw"; 1670 break; 1671 1672 case keyspan_usa49w_pre_product_id: 1673 fw_name = "keyspan/usa49w.fw"; 1674 break; 1675 1676 case keyspan_usa49wlc_pre_product_id: 1677 fw_name = "keyspan/usa49wlc.fw"; 1678 break; 1679 1680 default: 1681 dev_err(&serial->dev->dev, "Unknown product ID (%04x)\n", 1682 le16_to_cpu(serial->dev->descriptor.idProduct)); 1683 return 1; 1684 } 1685 1686 dev_dbg(&serial->dev->dev, "Uploading Keyspan %s firmware.\n", fw_name); 1687 1688 if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) { 1689 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n", 1690 fw_name); 1691 return -ENOENT; 1692 } 1693 1694 /* after downloading firmware Renumeration will occur in a 1695 moment and the new device will bind to the real driver */ 1696 1697 /* we don't want this device to have a driver assigned to it. */ 1698 return 1; 1699 } 1700 1701 /* Helper functions used by keyspan_setup_urbs */ 1702 static struct usb_endpoint_descriptor const *find_ep(struct usb_serial const *serial, 1703 int endpoint) 1704 { 1705 struct usb_host_interface *iface_desc; 1706 struct usb_endpoint_descriptor *ep; 1707 int i; 1708 1709 iface_desc = serial->interface->cur_altsetting; 1710 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 1711 ep = &iface_desc->endpoint[i].desc; 1712 if (ep->bEndpointAddress == endpoint) 1713 return ep; 1714 } 1715 dev_warn(&serial->interface->dev, "found no endpoint descriptor for endpoint %x\n", 1716 endpoint); 1717 return NULL; 1718 } 1719 1720 static struct urb *keyspan_setup_urb(struct usb_serial *serial, int endpoint, 1721 int dir, void *ctx, char *buf, int len, 1722 void (*callback)(struct urb *)) 1723 { 1724 struct urb *urb; 1725 struct usb_endpoint_descriptor const *ep_desc; 1726 char const *ep_type_name; 1727 1728 if (endpoint == -1) 1729 return NULL; /* endpoint not needed */ 1730 1731 dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %x\n", 1732 __func__, endpoint); 1733 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */ 1734 if (!urb) 1735 return NULL; 1736 1737 if (endpoint == 0) { 1738 /* control EP filled in when used */ 1739 return urb; 1740 } 1741 1742 ep_desc = find_ep(serial, endpoint); 1743 if (!ep_desc) { 1744 usb_free_urb(urb); 1745 return NULL; 1746 } 1747 if (usb_endpoint_xfer_int(ep_desc)) { 1748 ep_type_name = "INT"; 1749 usb_fill_int_urb(urb, serial->dev, 1750 usb_sndintpipe(serial->dev, endpoint) | dir, 1751 buf, len, callback, ctx, 1752 ep_desc->bInterval); 1753 } else if (usb_endpoint_xfer_bulk(ep_desc)) { 1754 ep_type_name = "BULK"; 1755 usb_fill_bulk_urb(urb, serial->dev, 1756 usb_sndbulkpipe(serial->dev, endpoint) | dir, 1757 buf, len, callback, ctx); 1758 } else { 1759 dev_warn(&serial->interface->dev, 1760 "unsupported endpoint type %x\n", 1761 usb_endpoint_type(ep_desc)); 1762 usb_free_urb(urb); 1763 return NULL; 1764 } 1765 1766 dev_dbg(&serial->interface->dev, "%s - using urb %p for %s endpoint %x\n", 1767 __func__, urb, ep_type_name, endpoint); 1768 return urb; 1769 } 1770 1771 static struct callbacks { 1772 void (*instat_callback)(struct urb *); 1773 void (*glocont_callback)(struct urb *); 1774 void (*indat_callback)(struct urb *); 1775 void (*outdat_callback)(struct urb *); 1776 void (*inack_callback)(struct urb *); 1777 void (*outcont_callback)(struct urb *); 1778 } keyspan_callbacks[] = { 1779 { 1780 /* msg_usa26 callbacks */ 1781 .instat_callback = usa26_instat_callback, 1782 .glocont_callback = usa26_glocont_callback, 1783 .indat_callback = usa26_indat_callback, 1784 .outdat_callback = usa2x_outdat_callback, 1785 .inack_callback = usa26_inack_callback, 1786 .outcont_callback = usa26_outcont_callback, 1787 }, { 1788 /* msg_usa28 callbacks */ 1789 .instat_callback = usa28_instat_callback, 1790 .glocont_callback = usa28_glocont_callback, 1791 .indat_callback = usa28_indat_callback, 1792 .outdat_callback = usa2x_outdat_callback, 1793 .inack_callback = usa28_inack_callback, 1794 .outcont_callback = usa28_outcont_callback, 1795 }, { 1796 /* msg_usa49 callbacks */ 1797 .instat_callback = usa49_instat_callback, 1798 .glocont_callback = usa49_glocont_callback, 1799 .indat_callback = usa49_indat_callback, 1800 .outdat_callback = usa2x_outdat_callback, 1801 .inack_callback = usa49_inack_callback, 1802 .outcont_callback = usa49_outcont_callback, 1803 }, { 1804 /* msg_usa90 callbacks */ 1805 .instat_callback = usa90_instat_callback, 1806 .glocont_callback = usa28_glocont_callback, 1807 .indat_callback = usa90_indat_callback, 1808 .outdat_callback = usa2x_outdat_callback, 1809 .inack_callback = usa28_inack_callback, 1810 .outcont_callback = usa90_outcont_callback, 1811 }, { 1812 /* msg_usa67 callbacks */ 1813 .instat_callback = usa67_instat_callback, 1814 .glocont_callback = usa67_glocont_callback, 1815 .indat_callback = usa26_indat_callback, 1816 .outdat_callback = usa2x_outdat_callback, 1817 .inack_callback = usa26_inack_callback, 1818 .outcont_callback = usa26_outcont_callback, 1819 } 1820 }; 1821 1822 /* Generic setup urbs function that uses 1823 data in device_details */ 1824 static void keyspan_setup_urbs(struct usb_serial *serial) 1825 { 1826 struct keyspan_serial_private *s_priv; 1827 const struct keyspan_device_details *d_details; 1828 struct callbacks *cback; 1829 1830 s_priv = usb_get_serial_data(serial); 1831 d_details = s_priv->device_details; 1832 1833 /* Setup values for the various callback routines */ 1834 cback = &keyspan_callbacks[d_details->msg_format]; 1835 1836 /* Allocate and set up urbs for each one that is in use, 1837 starting with instat endpoints */ 1838 s_priv->instat_urb = keyspan_setup_urb 1839 (serial, d_details->instat_endpoint, USB_DIR_IN, 1840 serial, s_priv->instat_buf, INSTAT_BUFLEN, 1841 cback->instat_callback); 1842 1843 s_priv->indat_urb = keyspan_setup_urb 1844 (serial, d_details->indat_endpoint, USB_DIR_IN, 1845 serial, s_priv->indat_buf, INDAT49W_BUFLEN, 1846 usa49wg_indat_callback); 1847 1848 s_priv->glocont_urb = keyspan_setup_urb 1849 (serial, d_details->glocont_endpoint, USB_DIR_OUT, 1850 serial, s_priv->glocont_buf, GLOCONT_BUFLEN, 1851 cback->glocont_callback); 1852 } 1853 1854 /* usa19 function doesn't require prescaler */ 1855 static int keyspan_usa19_calc_baud(struct usb_serial_port *port, 1856 u32 baud_rate, u32 baudclk, u8 *rate_hi, 1857 u8 *rate_low, u8 *prescaler, int portnum) 1858 { 1859 u32 b16, /* baud rate times 16 (actual rate used internally) */ 1860 div, /* divisor */ 1861 cnt; /* inverse of divisor (programmed into 8051) */ 1862 1863 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate); 1864 1865 /* prevent divide by zero... */ 1866 b16 = baud_rate * 16L; 1867 if (b16 == 0) 1868 return KEYSPAN_INVALID_BAUD_RATE; 1869 /* Any "standard" rate over 57k6 is marginal on the USA-19 1870 as we run out of divisor resolution. */ 1871 if (baud_rate > 57600) 1872 return KEYSPAN_INVALID_BAUD_RATE; 1873 1874 /* calculate the divisor and the counter (its inverse) */ 1875 div = baudclk / b16; 1876 if (div == 0) 1877 return KEYSPAN_INVALID_BAUD_RATE; 1878 else 1879 cnt = 0 - div; 1880 1881 if (div > 0xffff) 1882 return KEYSPAN_INVALID_BAUD_RATE; 1883 1884 /* return the counter values if non-null */ 1885 if (rate_low) 1886 *rate_low = (u8) (cnt & 0xff); 1887 if (rate_hi) 1888 *rate_hi = (u8) ((cnt >> 8) & 0xff); 1889 if (rate_low && rate_hi) 1890 dev_dbg(&port->dev, "%s - %d %02x %02x.\n", 1891 __func__, baud_rate, *rate_hi, *rate_low); 1892 return KEYSPAN_BAUD_RATE_OK; 1893 } 1894 1895 /* usa19hs function doesn't require prescaler */ 1896 static int keyspan_usa19hs_calc_baud(struct usb_serial_port *port, 1897 u32 baud_rate, u32 baudclk, u8 *rate_hi, 1898 u8 *rate_low, u8 *prescaler, int portnum) 1899 { 1900 u32 b16, /* baud rate times 16 (actual rate used internally) */ 1901 div; /* divisor */ 1902 1903 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate); 1904 1905 /* prevent divide by zero... */ 1906 b16 = baud_rate * 16L; 1907 if (b16 == 0) 1908 return KEYSPAN_INVALID_BAUD_RATE; 1909 1910 /* calculate the divisor */ 1911 div = baudclk / b16; 1912 if (div == 0) 1913 return KEYSPAN_INVALID_BAUD_RATE; 1914 1915 if (div > 0xffff) 1916 return KEYSPAN_INVALID_BAUD_RATE; 1917 1918 /* return the counter values if non-null */ 1919 if (rate_low) 1920 *rate_low = (u8) (div & 0xff); 1921 1922 if (rate_hi) 1923 *rate_hi = (u8) ((div >> 8) & 0xff); 1924 1925 if (rate_low && rate_hi) 1926 dev_dbg(&port->dev, "%s - %d %02x %02x.\n", 1927 __func__, baud_rate, *rate_hi, *rate_low); 1928 1929 return KEYSPAN_BAUD_RATE_OK; 1930 } 1931 1932 static int keyspan_usa19w_calc_baud(struct usb_serial_port *port, 1933 u32 baud_rate, u32 baudclk, u8 *rate_hi, 1934 u8 *rate_low, u8 *prescaler, int portnum) 1935 { 1936 u32 b16, /* baud rate times 16 (actual rate used internally) */ 1937 clk, /* clock with 13/8 prescaler */ 1938 div, /* divisor using 13/8 prescaler */ 1939 res, /* resulting baud rate using 13/8 prescaler */ 1940 diff, /* error using 13/8 prescaler */ 1941 smallest_diff; 1942 u8 best_prescaler; 1943 int i; 1944 1945 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate); 1946 1947 /* prevent divide by zero */ 1948 b16 = baud_rate * 16L; 1949 if (b16 == 0) 1950 return KEYSPAN_INVALID_BAUD_RATE; 1951 1952 /* Calculate prescaler by trying them all and looking 1953 for best fit */ 1954 1955 /* start with largest possible difference */ 1956 smallest_diff = 0xffffffff; 1957 1958 /* 0 is an invalid prescaler, used as a flag */ 1959 best_prescaler = 0; 1960 1961 for (i = 8; i <= 0xff; ++i) { 1962 clk = (baudclk * 8) / (u32) i; 1963 1964 div = clk / b16; 1965 if (div == 0) 1966 continue; 1967 1968 res = clk / div; 1969 diff = (res > b16) ? (res-b16) : (b16-res); 1970 1971 if (diff < smallest_diff) { 1972 best_prescaler = i; 1973 smallest_diff = diff; 1974 } 1975 } 1976 1977 if (best_prescaler == 0) 1978 return KEYSPAN_INVALID_BAUD_RATE; 1979 1980 clk = (baudclk * 8) / (u32) best_prescaler; 1981 div = clk / b16; 1982 1983 /* return the divisor and prescaler if non-null */ 1984 if (rate_low) 1985 *rate_low = (u8) (div & 0xff); 1986 if (rate_hi) 1987 *rate_hi = (u8) ((div >> 8) & 0xff); 1988 if (prescaler) { 1989 *prescaler = best_prescaler; 1990 /* dev_dbg(&port->dev, "%s - %d %d\n", __func__, *prescaler, div); */ 1991 } 1992 return KEYSPAN_BAUD_RATE_OK; 1993 } 1994 1995 /* USA-28 supports different maximum baud rates on each port */ 1996 static int keyspan_usa28_calc_baud(struct usb_serial_port *port, 1997 u32 baud_rate, u32 baudclk, u8 *rate_hi, 1998 u8 *rate_low, u8 *prescaler, int portnum) 1999 { 2000 u32 b16, /* baud rate times 16 (actual rate used internally) */ 2001 div, /* divisor */ 2002 cnt; /* inverse of divisor (programmed into 8051) */ 2003 2004 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate); 2005 2006 /* prevent divide by zero */ 2007 b16 = baud_rate * 16L; 2008 if (b16 == 0) 2009 return KEYSPAN_INVALID_BAUD_RATE; 2010 2011 /* calculate the divisor and the counter (its inverse) */ 2012 div = KEYSPAN_USA28_BAUDCLK / b16; 2013 if (div == 0) 2014 return KEYSPAN_INVALID_BAUD_RATE; 2015 else 2016 cnt = 0 - div; 2017 2018 /* check for out of range, based on portnum, 2019 and return result */ 2020 if (portnum == 0) { 2021 if (div > 0xffff) 2022 return KEYSPAN_INVALID_BAUD_RATE; 2023 } else { 2024 if (portnum == 1) { 2025 if (div > 0xff) 2026 return KEYSPAN_INVALID_BAUD_RATE; 2027 } else 2028 return KEYSPAN_INVALID_BAUD_RATE; 2029 } 2030 2031 /* return the counter values if not NULL 2032 (port 1 will ignore retHi) */ 2033 if (rate_low) 2034 *rate_low = (u8) (cnt & 0xff); 2035 if (rate_hi) 2036 *rate_hi = (u8) ((cnt >> 8) & 0xff); 2037 dev_dbg(&port->dev, "%s - %d OK.\n", __func__, baud_rate); 2038 return KEYSPAN_BAUD_RATE_OK; 2039 } 2040 2041 static int keyspan_usa26_send_setup(struct usb_serial *serial, 2042 struct usb_serial_port *port, 2043 int reset_port) 2044 { 2045 struct keyspan_usa26_portControlMessage msg; 2046 struct keyspan_serial_private *s_priv; 2047 struct keyspan_port_private *p_priv; 2048 const struct keyspan_device_details *d_details; 2049 struct urb *this_urb; 2050 int device_port, err; 2051 2052 dev_dbg(&port->dev, "%s reset=%d\n", __func__, reset_port); 2053 2054 s_priv = usb_get_serial_data(serial); 2055 p_priv = usb_get_serial_port_data(port); 2056 d_details = s_priv->device_details; 2057 device_port = port->port_number; 2058 2059 this_urb = p_priv->outcont_urb; 2060 2061 /* Make sure we have an urb then send the message */ 2062 if (this_urb == NULL) { 2063 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__); 2064 return -1; 2065 } 2066 2067 dev_dbg(&port->dev, "%s - endpoint %x\n", 2068 __func__, usb_pipeendpoint(this_urb->pipe)); 2069 2070 /* Save reset port val for resend. 2071 Don't overwrite resend for open/close condition. */ 2072 if ((reset_port + 1) > p_priv->resend_cont) 2073 p_priv->resend_cont = reset_port + 1; 2074 if (this_urb->status == -EINPROGRESS) { 2075 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */ 2076 mdelay(5); 2077 return -1; 2078 } 2079 2080 memset(&msg, 0, sizeof(struct keyspan_usa26_portControlMessage)); 2081 2082 /* Only set baud rate if it's changed */ 2083 if (p_priv->old_baud != p_priv->baud) { 2084 p_priv->old_baud = p_priv->baud; 2085 msg.setClocking = 0xff; 2086 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk, 2087 &msg.baudHi, &msg.baudLo, &msg.prescaler, 2088 device_port) == KEYSPAN_INVALID_BAUD_RATE) { 2089 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n", 2090 __func__, p_priv->baud); 2091 msg.baudLo = 0; 2092 msg.baudHi = 125; /* Values for 9600 baud */ 2093 msg.prescaler = 10; 2094 } 2095 msg.setPrescaler = 0xff; 2096 } 2097 2098 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1; 2099 switch (p_priv->cflag & CSIZE) { 2100 case CS5: 2101 msg.lcr |= USA_DATABITS_5; 2102 break; 2103 case CS6: 2104 msg.lcr |= USA_DATABITS_6; 2105 break; 2106 case CS7: 2107 msg.lcr |= USA_DATABITS_7; 2108 break; 2109 case CS8: 2110 msg.lcr |= USA_DATABITS_8; 2111 break; 2112 } 2113 if (p_priv->cflag & PARENB) { 2114 /* note USA_PARITY_NONE == 0 */ 2115 msg.lcr |= (p_priv->cflag & PARODD) ? 2116 USA_PARITY_ODD : USA_PARITY_EVEN; 2117 } 2118 msg.setLcr = 0xff; 2119 2120 msg.ctsFlowControl = (p_priv->flow_control == flow_cts); 2121 msg.xonFlowControl = 0; 2122 msg.setFlowControl = 0xff; 2123 msg.forwardingLength = 16; 2124 msg.xonChar = 17; 2125 msg.xoffChar = 19; 2126 2127 /* Opening port */ 2128 if (reset_port == 1) { 2129 msg._txOn = 1; 2130 msg._txOff = 0; 2131 msg.txFlush = 0; 2132 msg.txBreak = 0; 2133 msg.rxOn = 1; 2134 msg.rxOff = 0; 2135 msg.rxFlush = 1; 2136 msg.rxForward = 0; 2137 msg.returnStatus = 0; 2138 msg.resetDataToggle = 0xff; 2139 } 2140 2141 /* Closing port */ 2142 else if (reset_port == 2) { 2143 msg._txOn = 0; 2144 msg._txOff = 1; 2145 msg.txFlush = 0; 2146 msg.txBreak = 0; 2147 msg.rxOn = 0; 2148 msg.rxOff = 1; 2149 msg.rxFlush = 1; 2150 msg.rxForward = 0; 2151 msg.returnStatus = 0; 2152 msg.resetDataToggle = 0; 2153 } 2154 2155 /* Sending intermediate configs */ 2156 else { 2157 msg._txOn = (!p_priv->break_on); 2158 msg._txOff = 0; 2159 msg.txFlush = 0; 2160 msg.txBreak = (p_priv->break_on); 2161 msg.rxOn = 0; 2162 msg.rxOff = 0; 2163 msg.rxFlush = 0; 2164 msg.rxForward = 0; 2165 msg.returnStatus = 0; 2166 msg.resetDataToggle = 0x0; 2167 } 2168 2169 /* Do handshaking outputs */ 2170 msg.setTxTriState_setRts = 0xff; 2171 msg.txTriState_rts = p_priv->rts_state; 2172 2173 msg.setHskoa_setDtr = 0xff; 2174 msg.hskoa_dtr = p_priv->dtr_state; 2175 2176 p_priv->resend_cont = 0; 2177 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg)); 2178 2179 /* send the data out the device on control endpoint */ 2180 this_urb->transfer_buffer_length = sizeof(msg); 2181 2182 err = usb_submit_urb(this_urb, GFP_ATOMIC); 2183 if (err != 0) 2184 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err); 2185 return 0; 2186 } 2187 2188 static int keyspan_usa28_send_setup(struct usb_serial *serial, 2189 struct usb_serial_port *port, 2190 int reset_port) 2191 { 2192 struct keyspan_usa28_portControlMessage msg; 2193 struct keyspan_serial_private *s_priv; 2194 struct keyspan_port_private *p_priv; 2195 const struct keyspan_device_details *d_details; 2196 struct urb *this_urb; 2197 int device_port, err; 2198 2199 s_priv = usb_get_serial_data(serial); 2200 p_priv = usb_get_serial_port_data(port); 2201 d_details = s_priv->device_details; 2202 device_port = port->port_number; 2203 2204 /* only do something if we have a bulk out endpoint */ 2205 this_urb = p_priv->outcont_urb; 2206 if (this_urb == NULL) { 2207 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__); 2208 return -1; 2209 } 2210 2211 /* Save reset port val for resend. 2212 Don't overwrite resend for open/close condition. */ 2213 if ((reset_port + 1) > p_priv->resend_cont) 2214 p_priv->resend_cont = reset_port + 1; 2215 if (this_urb->status == -EINPROGRESS) { 2216 dev_dbg(&port->dev, "%s already writing\n", __func__); 2217 mdelay(5); 2218 return -1; 2219 } 2220 2221 memset(&msg, 0, sizeof(struct keyspan_usa28_portControlMessage)); 2222 2223 msg.setBaudRate = 1; 2224 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk, 2225 &msg.baudHi, &msg.baudLo, NULL, 2226 device_port) == KEYSPAN_INVALID_BAUD_RATE) { 2227 dev_dbg(&port->dev, "%s - Invalid baud rate requested %d.\n", 2228 __func__, p_priv->baud); 2229 msg.baudLo = 0xff; 2230 msg.baudHi = 0xb2; /* Values for 9600 baud */ 2231 } 2232 2233 /* If parity is enabled, we must calculate it ourselves. */ 2234 msg.parity = 0; /* XXX for now */ 2235 2236 msg.ctsFlowControl = (p_priv->flow_control == flow_cts); 2237 msg.xonFlowControl = 0; 2238 2239 /* Do handshaking outputs, DTR is inverted relative to RTS */ 2240 msg.rts = p_priv->rts_state; 2241 msg.dtr = p_priv->dtr_state; 2242 2243 msg.forwardingLength = 16; 2244 msg.forwardMs = 10; 2245 msg.breakThreshold = 45; 2246 msg.xonChar = 17; 2247 msg.xoffChar = 19; 2248 2249 /*msg.returnStatus = 1; 2250 msg.resetDataToggle = 0xff;*/ 2251 /* Opening port */ 2252 if (reset_port == 1) { 2253 msg._txOn = 1; 2254 msg._txOff = 0; 2255 msg.txFlush = 0; 2256 msg.txForceXoff = 0; 2257 msg.txBreak = 0; 2258 msg.rxOn = 1; 2259 msg.rxOff = 0; 2260 msg.rxFlush = 1; 2261 msg.rxForward = 0; 2262 msg.returnStatus = 0; 2263 msg.resetDataToggle = 0xff; 2264 } 2265 /* Closing port */ 2266 else if (reset_port == 2) { 2267 msg._txOn = 0; 2268 msg._txOff = 1; 2269 msg.txFlush = 0; 2270 msg.txForceXoff = 0; 2271 msg.txBreak = 0; 2272 msg.rxOn = 0; 2273 msg.rxOff = 1; 2274 msg.rxFlush = 1; 2275 msg.rxForward = 0; 2276 msg.returnStatus = 0; 2277 msg.resetDataToggle = 0; 2278 } 2279 /* Sending intermediate configs */ 2280 else { 2281 msg._txOn = (!p_priv->break_on); 2282 msg._txOff = 0; 2283 msg.txFlush = 0; 2284 msg.txForceXoff = 0; 2285 msg.txBreak = (p_priv->break_on); 2286 msg.rxOn = 0; 2287 msg.rxOff = 0; 2288 msg.rxFlush = 0; 2289 msg.rxForward = 0; 2290 msg.returnStatus = 0; 2291 msg.resetDataToggle = 0x0; 2292 } 2293 2294 p_priv->resend_cont = 0; 2295 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg)); 2296 2297 /* send the data out the device on control endpoint */ 2298 this_urb->transfer_buffer_length = sizeof(msg); 2299 2300 err = usb_submit_urb(this_urb, GFP_ATOMIC); 2301 if (err != 0) 2302 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed\n", __func__); 2303 2304 return 0; 2305 } 2306 2307 static int keyspan_usa49_send_setup(struct usb_serial *serial, 2308 struct usb_serial_port *port, 2309 int reset_port) 2310 { 2311 struct keyspan_usa49_portControlMessage msg; 2312 struct usb_ctrlrequest *dr = NULL; 2313 struct keyspan_serial_private *s_priv; 2314 struct keyspan_port_private *p_priv; 2315 const struct keyspan_device_details *d_details; 2316 struct urb *this_urb; 2317 int err, device_port; 2318 2319 s_priv = usb_get_serial_data(serial); 2320 p_priv = usb_get_serial_port_data(port); 2321 d_details = s_priv->device_details; 2322 2323 this_urb = s_priv->glocont_urb; 2324 2325 /* Work out which port within the device is being setup */ 2326 device_port = port->port_number; 2327 2328 /* Make sure we have an urb then send the message */ 2329 if (this_urb == NULL) { 2330 dev_dbg(&port->dev, "%s - oops no urb for port.\n", __func__); 2331 return -1; 2332 } 2333 2334 dev_dbg(&port->dev, "%s - endpoint %x (%d)\n", 2335 __func__, usb_pipeendpoint(this_urb->pipe), device_port); 2336 2337 /* Save reset port val for resend. 2338 Don't overwrite resend for open/close condition. */ 2339 if ((reset_port + 1) > p_priv->resend_cont) 2340 p_priv->resend_cont = reset_port + 1; 2341 2342 if (this_urb->status == -EINPROGRESS) { 2343 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */ 2344 mdelay(5); 2345 return -1; 2346 } 2347 2348 memset(&msg, 0, sizeof(struct keyspan_usa49_portControlMessage)); 2349 2350 msg.portNumber = device_port; 2351 2352 /* Only set baud rate if it's changed */ 2353 if (p_priv->old_baud != p_priv->baud) { 2354 p_priv->old_baud = p_priv->baud; 2355 msg.setClocking = 0xff; 2356 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk, 2357 &msg.baudHi, &msg.baudLo, &msg.prescaler, 2358 device_port) == KEYSPAN_INVALID_BAUD_RATE) { 2359 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n", 2360 __func__, p_priv->baud); 2361 msg.baudLo = 0; 2362 msg.baudHi = 125; /* Values for 9600 baud */ 2363 msg.prescaler = 10; 2364 } 2365 /* msg.setPrescaler = 0xff; */ 2366 } 2367 2368 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1; 2369 switch (p_priv->cflag & CSIZE) { 2370 case CS5: 2371 msg.lcr |= USA_DATABITS_5; 2372 break; 2373 case CS6: 2374 msg.lcr |= USA_DATABITS_6; 2375 break; 2376 case CS7: 2377 msg.lcr |= USA_DATABITS_7; 2378 break; 2379 case CS8: 2380 msg.lcr |= USA_DATABITS_8; 2381 break; 2382 } 2383 if (p_priv->cflag & PARENB) { 2384 /* note USA_PARITY_NONE == 0 */ 2385 msg.lcr |= (p_priv->cflag & PARODD) ? 2386 USA_PARITY_ODD : USA_PARITY_EVEN; 2387 } 2388 msg.setLcr = 0xff; 2389 2390 msg.ctsFlowControl = (p_priv->flow_control == flow_cts); 2391 msg.xonFlowControl = 0; 2392 msg.setFlowControl = 0xff; 2393 2394 msg.forwardingLength = 16; 2395 msg.xonChar = 17; 2396 msg.xoffChar = 19; 2397 2398 /* Opening port */ 2399 if (reset_port == 1) { 2400 msg._txOn = 1; 2401 msg._txOff = 0; 2402 msg.txFlush = 0; 2403 msg.txBreak = 0; 2404 msg.rxOn = 1; 2405 msg.rxOff = 0; 2406 msg.rxFlush = 1; 2407 msg.rxForward = 0; 2408 msg.returnStatus = 0; 2409 msg.resetDataToggle = 0xff; 2410 msg.enablePort = 1; 2411 msg.disablePort = 0; 2412 } 2413 /* Closing port */ 2414 else if (reset_port == 2) { 2415 msg._txOn = 0; 2416 msg._txOff = 1; 2417 msg.txFlush = 0; 2418 msg.txBreak = 0; 2419 msg.rxOn = 0; 2420 msg.rxOff = 1; 2421 msg.rxFlush = 1; 2422 msg.rxForward = 0; 2423 msg.returnStatus = 0; 2424 msg.resetDataToggle = 0; 2425 msg.enablePort = 0; 2426 msg.disablePort = 1; 2427 } 2428 /* Sending intermediate configs */ 2429 else { 2430 msg._txOn = (!p_priv->break_on); 2431 msg._txOff = 0; 2432 msg.txFlush = 0; 2433 msg.txBreak = (p_priv->break_on); 2434 msg.rxOn = 0; 2435 msg.rxOff = 0; 2436 msg.rxFlush = 0; 2437 msg.rxForward = 0; 2438 msg.returnStatus = 0; 2439 msg.resetDataToggle = 0x0; 2440 msg.enablePort = 0; 2441 msg.disablePort = 0; 2442 } 2443 2444 /* Do handshaking outputs */ 2445 msg.setRts = 0xff; 2446 msg.rts = p_priv->rts_state; 2447 2448 msg.setDtr = 0xff; 2449 msg.dtr = p_priv->dtr_state; 2450 2451 p_priv->resend_cont = 0; 2452 2453 /* if the device is a 49wg, we send control message on usb 2454 control EP 0 */ 2455 2456 if (d_details->product_id == keyspan_usa49wg_product_id) { 2457 dr = (void *)(s_priv->ctrl_buf); 2458 dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT; 2459 dr->bRequest = 0xB0; /* 49wg control message */ 2460 dr->wValue = 0; 2461 dr->wIndex = 0; 2462 dr->wLength = cpu_to_le16(sizeof(msg)); 2463 2464 memcpy(s_priv->glocont_buf, &msg, sizeof(msg)); 2465 2466 usb_fill_control_urb(this_urb, serial->dev, 2467 usb_sndctrlpipe(serial->dev, 0), 2468 (unsigned char *)dr, s_priv->glocont_buf, 2469 sizeof(msg), usa49_glocont_callback, serial); 2470 2471 } else { 2472 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg)); 2473 2474 /* send the data out the device on control endpoint */ 2475 this_urb->transfer_buffer_length = sizeof(msg); 2476 } 2477 err = usb_submit_urb(this_urb, GFP_ATOMIC); 2478 if (err != 0) 2479 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err); 2480 2481 return 0; 2482 } 2483 2484 static int keyspan_usa90_send_setup(struct usb_serial *serial, 2485 struct usb_serial_port *port, 2486 int reset_port) 2487 { 2488 struct keyspan_usa90_portControlMessage msg; 2489 struct keyspan_serial_private *s_priv; 2490 struct keyspan_port_private *p_priv; 2491 const struct keyspan_device_details *d_details; 2492 struct urb *this_urb; 2493 int err; 2494 u8 prescaler; 2495 2496 s_priv = usb_get_serial_data(serial); 2497 p_priv = usb_get_serial_port_data(port); 2498 d_details = s_priv->device_details; 2499 2500 /* only do something if we have a bulk out endpoint */ 2501 this_urb = p_priv->outcont_urb; 2502 if (this_urb == NULL) { 2503 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__); 2504 return -1; 2505 } 2506 2507 /* Save reset port val for resend. 2508 Don't overwrite resend for open/close condition. */ 2509 if ((reset_port + 1) > p_priv->resend_cont) 2510 p_priv->resend_cont = reset_port + 1; 2511 if (this_urb->status == -EINPROGRESS) { 2512 dev_dbg(&port->dev, "%s already writing\n", __func__); 2513 mdelay(5); 2514 return -1; 2515 } 2516 2517 memset(&msg, 0, sizeof(struct keyspan_usa90_portControlMessage)); 2518 2519 /* Only set baud rate if it's changed */ 2520 if (p_priv->old_baud != p_priv->baud) { 2521 p_priv->old_baud = p_priv->baud; 2522 msg.setClocking = 0x01; 2523 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk, 2524 &msg.baudHi, &msg.baudLo, &prescaler, 0) == KEYSPAN_INVALID_BAUD_RATE) { 2525 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n", 2526 __func__, p_priv->baud); 2527 p_priv->baud = 9600; 2528 d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk, 2529 &msg.baudHi, &msg.baudLo, &prescaler, 0); 2530 } 2531 msg.setRxMode = 1; 2532 msg.setTxMode = 1; 2533 } 2534 2535 /* modes must always be correctly specified */ 2536 if (p_priv->baud > 57600) { 2537 msg.rxMode = RXMODE_DMA; 2538 msg.txMode = TXMODE_DMA; 2539 } else { 2540 msg.rxMode = RXMODE_BYHAND; 2541 msg.txMode = TXMODE_BYHAND; 2542 } 2543 2544 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1; 2545 switch (p_priv->cflag & CSIZE) { 2546 case CS5: 2547 msg.lcr |= USA_DATABITS_5; 2548 break; 2549 case CS6: 2550 msg.lcr |= USA_DATABITS_6; 2551 break; 2552 case CS7: 2553 msg.lcr |= USA_DATABITS_7; 2554 break; 2555 case CS8: 2556 msg.lcr |= USA_DATABITS_8; 2557 break; 2558 } 2559 if (p_priv->cflag & PARENB) { 2560 /* note USA_PARITY_NONE == 0 */ 2561 msg.lcr |= (p_priv->cflag & PARODD) ? 2562 USA_PARITY_ODD : USA_PARITY_EVEN; 2563 } 2564 if (p_priv->old_cflag != p_priv->cflag) { 2565 p_priv->old_cflag = p_priv->cflag; 2566 msg.setLcr = 0x01; 2567 } 2568 2569 if (p_priv->flow_control == flow_cts) 2570 msg.txFlowControl = TXFLOW_CTS; 2571 msg.setTxFlowControl = 0x01; 2572 msg.setRxFlowControl = 0x01; 2573 2574 msg.rxForwardingLength = 16; 2575 msg.rxForwardingTimeout = 16; 2576 msg.txAckSetting = 0; 2577 msg.xonChar = 17; 2578 msg.xoffChar = 19; 2579 2580 /* Opening port */ 2581 if (reset_port == 1) { 2582 msg.portEnabled = 1; 2583 msg.rxFlush = 1; 2584 msg.txBreak = (p_priv->break_on); 2585 } 2586 /* Closing port */ 2587 else if (reset_port == 2) 2588 msg.portEnabled = 0; 2589 /* Sending intermediate configs */ 2590 else { 2591 msg.portEnabled = 1; 2592 msg.txBreak = (p_priv->break_on); 2593 } 2594 2595 /* Do handshaking outputs */ 2596 msg.setRts = 0x01; 2597 msg.rts = p_priv->rts_state; 2598 2599 msg.setDtr = 0x01; 2600 msg.dtr = p_priv->dtr_state; 2601 2602 p_priv->resend_cont = 0; 2603 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg)); 2604 2605 /* send the data out the device on control endpoint */ 2606 this_urb->transfer_buffer_length = sizeof(msg); 2607 2608 err = usb_submit_urb(this_urb, GFP_ATOMIC); 2609 if (err != 0) 2610 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err); 2611 return 0; 2612 } 2613 2614 static int keyspan_usa67_send_setup(struct usb_serial *serial, 2615 struct usb_serial_port *port, 2616 int reset_port) 2617 { 2618 struct keyspan_usa67_portControlMessage msg; 2619 struct keyspan_serial_private *s_priv; 2620 struct keyspan_port_private *p_priv; 2621 const struct keyspan_device_details *d_details; 2622 struct urb *this_urb; 2623 int err, device_port; 2624 2625 s_priv = usb_get_serial_data(serial); 2626 p_priv = usb_get_serial_port_data(port); 2627 d_details = s_priv->device_details; 2628 2629 this_urb = s_priv->glocont_urb; 2630 2631 /* Work out which port within the device is being setup */ 2632 device_port = port->port_number; 2633 2634 /* Make sure we have an urb then send the message */ 2635 if (this_urb == NULL) { 2636 dev_dbg(&port->dev, "%s - oops no urb for port.\n", __func__); 2637 return -1; 2638 } 2639 2640 /* Save reset port val for resend. 2641 Don't overwrite resend for open/close condition. */ 2642 if ((reset_port + 1) > p_priv->resend_cont) 2643 p_priv->resend_cont = reset_port + 1; 2644 if (this_urb->status == -EINPROGRESS) { 2645 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */ 2646 mdelay(5); 2647 return -1; 2648 } 2649 2650 memset(&msg, 0, sizeof(struct keyspan_usa67_portControlMessage)); 2651 2652 msg.port = device_port; 2653 2654 /* Only set baud rate if it's changed */ 2655 if (p_priv->old_baud != p_priv->baud) { 2656 p_priv->old_baud = p_priv->baud; 2657 msg.setClocking = 0xff; 2658 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk, 2659 &msg.baudHi, &msg.baudLo, &msg.prescaler, 2660 device_port) == KEYSPAN_INVALID_BAUD_RATE) { 2661 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n", 2662 __func__, p_priv->baud); 2663 msg.baudLo = 0; 2664 msg.baudHi = 125; /* Values for 9600 baud */ 2665 msg.prescaler = 10; 2666 } 2667 msg.setPrescaler = 0xff; 2668 } 2669 2670 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1; 2671 switch (p_priv->cflag & CSIZE) { 2672 case CS5: 2673 msg.lcr |= USA_DATABITS_5; 2674 break; 2675 case CS6: 2676 msg.lcr |= USA_DATABITS_6; 2677 break; 2678 case CS7: 2679 msg.lcr |= USA_DATABITS_7; 2680 break; 2681 case CS8: 2682 msg.lcr |= USA_DATABITS_8; 2683 break; 2684 } 2685 if (p_priv->cflag & PARENB) { 2686 /* note USA_PARITY_NONE == 0 */ 2687 msg.lcr |= (p_priv->cflag & PARODD) ? 2688 USA_PARITY_ODD : USA_PARITY_EVEN; 2689 } 2690 msg.setLcr = 0xff; 2691 2692 msg.ctsFlowControl = (p_priv->flow_control == flow_cts); 2693 msg.xonFlowControl = 0; 2694 msg.setFlowControl = 0xff; 2695 msg.forwardingLength = 16; 2696 msg.xonChar = 17; 2697 msg.xoffChar = 19; 2698 2699 if (reset_port == 1) { 2700 /* Opening port */ 2701 msg._txOn = 1; 2702 msg._txOff = 0; 2703 msg.txFlush = 0; 2704 msg.txBreak = 0; 2705 msg.rxOn = 1; 2706 msg.rxOff = 0; 2707 msg.rxFlush = 1; 2708 msg.rxForward = 0; 2709 msg.returnStatus = 0; 2710 msg.resetDataToggle = 0xff; 2711 } else if (reset_port == 2) { 2712 /* Closing port */ 2713 msg._txOn = 0; 2714 msg._txOff = 1; 2715 msg.txFlush = 0; 2716 msg.txBreak = 0; 2717 msg.rxOn = 0; 2718 msg.rxOff = 1; 2719 msg.rxFlush = 1; 2720 msg.rxForward = 0; 2721 msg.returnStatus = 0; 2722 msg.resetDataToggle = 0; 2723 } else { 2724 /* Sending intermediate configs */ 2725 msg._txOn = (!p_priv->break_on); 2726 msg._txOff = 0; 2727 msg.txFlush = 0; 2728 msg.txBreak = (p_priv->break_on); 2729 msg.rxOn = 0; 2730 msg.rxOff = 0; 2731 msg.rxFlush = 0; 2732 msg.rxForward = 0; 2733 msg.returnStatus = 0; 2734 msg.resetDataToggle = 0x0; 2735 } 2736 2737 /* Do handshaking outputs */ 2738 msg.setTxTriState_setRts = 0xff; 2739 msg.txTriState_rts = p_priv->rts_state; 2740 2741 msg.setHskoa_setDtr = 0xff; 2742 msg.hskoa_dtr = p_priv->dtr_state; 2743 2744 p_priv->resend_cont = 0; 2745 2746 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg)); 2747 2748 /* send the data out the device on control endpoint */ 2749 this_urb->transfer_buffer_length = sizeof(msg); 2750 2751 err = usb_submit_urb(this_urb, GFP_ATOMIC); 2752 if (err != 0) 2753 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err); 2754 return 0; 2755 } 2756 2757 static void keyspan_send_setup(struct usb_serial_port *port, int reset_port) 2758 { 2759 struct usb_serial *serial = port->serial; 2760 struct keyspan_serial_private *s_priv; 2761 const struct keyspan_device_details *d_details; 2762 2763 s_priv = usb_get_serial_data(serial); 2764 d_details = s_priv->device_details; 2765 2766 switch (d_details->msg_format) { 2767 case msg_usa26: 2768 keyspan_usa26_send_setup(serial, port, reset_port); 2769 break; 2770 case msg_usa28: 2771 keyspan_usa28_send_setup(serial, port, reset_port); 2772 break; 2773 case msg_usa49: 2774 keyspan_usa49_send_setup(serial, port, reset_port); 2775 break; 2776 case msg_usa90: 2777 keyspan_usa90_send_setup(serial, port, reset_port); 2778 break; 2779 case msg_usa67: 2780 keyspan_usa67_send_setup(serial, port, reset_port); 2781 break; 2782 } 2783 } 2784 2785 2786 /* Gets called by the "real" driver (ie once firmware is loaded 2787 and renumeration has taken place. */ 2788 static int keyspan_startup(struct usb_serial *serial) 2789 { 2790 int i, err; 2791 struct keyspan_serial_private *s_priv; 2792 const struct keyspan_device_details *d_details; 2793 2794 for (i = 0; (d_details = keyspan_devices[i]) != NULL; ++i) 2795 if (d_details->product_id == 2796 le16_to_cpu(serial->dev->descriptor.idProduct)) 2797 break; 2798 if (d_details == NULL) { 2799 dev_err(&serial->dev->dev, "%s - unknown product id %x\n", 2800 __func__, le16_to_cpu(serial->dev->descriptor.idProduct)); 2801 return -ENODEV; 2802 } 2803 2804 /* Setup private data for serial driver */ 2805 s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL); 2806 if (!s_priv) 2807 return -ENOMEM; 2808 2809 s_priv->instat_buf = kzalloc(INSTAT_BUFLEN, GFP_KERNEL); 2810 if (!s_priv->instat_buf) 2811 goto err_instat_buf; 2812 2813 s_priv->indat_buf = kzalloc(INDAT49W_BUFLEN, GFP_KERNEL); 2814 if (!s_priv->indat_buf) 2815 goto err_indat_buf; 2816 2817 s_priv->glocont_buf = kzalloc(GLOCONT_BUFLEN, GFP_KERNEL); 2818 if (!s_priv->glocont_buf) 2819 goto err_glocont_buf; 2820 2821 s_priv->ctrl_buf = kzalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL); 2822 if (!s_priv->ctrl_buf) 2823 goto err_ctrl_buf; 2824 2825 s_priv->device_details = d_details; 2826 usb_set_serial_data(serial, s_priv); 2827 2828 keyspan_setup_urbs(serial); 2829 2830 if (s_priv->instat_urb != NULL) { 2831 err = usb_submit_urb(s_priv->instat_urb, GFP_KERNEL); 2832 if (err != 0) 2833 dev_dbg(&serial->dev->dev, "%s - submit instat urb failed %d\n", __func__, err); 2834 } 2835 if (s_priv->indat_urb != NULL) { 2836 err = usb_submit_urb(s_priv->indat_urb, GFP_KERNEL); 2837 if (err != 0) 2838 dev_dbg(&serial->dev->dev, "%s - submit indat urb failed %d\n", __func__, err); 2839 } 2840 2841 return 0; 2842 2843 err_ctrl_buf: 2844 kfree(s_priv->glocont_buf); 2845 err_glocont_buf: 2846 kfree(s_priv->indat_buf); 2847 err_indat_buf: 2848 kfree(s_priv->instat_buf); 2849 err_instat_buf: 2850 kfree(s_priv); 2851 2852 return -ENOMEM; 2853 } 2854 2855 static void keyspan_disconnect(struct usb_serial *serial) 2856 { 2857 struct keyspan_serial_private *s_priv; 2858 2859 s_priv = usb_get_serial_data(serial); 2860 2861 usb_kill_urb(s_priv->instat_urb); 2862 usb_kill_urb(s_priv->glocont_urb); 2863 usb_kill_urb(s_priv->indat_urb); 2864 } 2865 2866 static void keyspan_release(struct usb_serial *serial) 2867 { 2868 struct keyspan_serial_private *s_priv; 2869 2870 s_priv = usb_get_serial_data(serial); 2871 2872 /* Make sure to unlink the URBs submitted in attach. */ 2873 usb_kill_urb(s_priv->instat_urb); 2874 usb_kill_urb(s_priv->indat_urb); 2875 2876 usb_free_urb(s_priv->instat_urb); 2877 usb_free_urb(s_priv->indat_urb); 2878 usb_free_urb(s_priv->glocont_urb); 2879 2880 kfree(s_priv->ctrl_buf); 2881 kfree(s_priv->glocont_buf); 2882 kfree(s_priv->indat_buf); 2883 kfree(s_priv->instat_buf); 2884 2885 kfree(s_priv); 2886 } 2887 2888 static int keyspan_port_probe(struct usb_serial_port *port) 2889 { 2890 struct usb_serial *serial = port->serial; 2891 struct keyspan_serial_private *s_priv; 2892 struct keyspan_port_private *p_priv; 2893 const struct keyspan_device_details *d_details; 2894 struct callbacks *cback; 2895 int endp; 2896 int port_num; 2897 int i; 2898 2899 s_priv = usb_get_serial_data(serial); 2900 d_details = s_priv->device_details; 2901 2902 p_priv = kzalloc(sizeof(*p_priv), GFP_KERNEL); 2903 if (!p_priv) 2904 return -ENOMEM; 2905 2906 for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i) { 2907 p_priv->in_buffer[i] = kzalloc(IN_BUFLEN, GFP_KERNEL); 2908 if (!p_priv->in_buffer[i]) 2909 goto err_in_buffer; 2910 } 2911 2912 for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i) { 2913 p_priv->out_buffer[i] = kzalloc(OUT_BUFLEN, GFP_KERNEL); 2914 if (!p_priv->out_buffer[i]) 2915 goto err_out_buffer; 2916 } 2917 2918 p_priv->inack_buffer = kzalloc(INACK_BUFLEN, GFP_KERNEL); 2919 if (!p_priv->inack_buffer) 2920 goto err_inack_buffer; 2921 2922 p_priv->outcont_buffer = kzalloc(OUTCONT_BUFLEN, GFP_KERNEL); 2923 if (!p_priv->outcont_buffer) 2924 goto err_outcont_buffer; 2925 2926 p_priv->device_details = d_details; 2927 2928 /* Setup values for the various callback routines */ 2929 cback = &keyspan_callbacks[d_details->msg_format]; 2930 2931 port_num = port->port_number; 2932 2933 /* Do indat endpoints first, once for each flip */ 2934 endp = d_details->indat_endpoints[port_num]; 2935 for (i = 0; i <= d_details->indat_endp_flip; ++i, ++endp) { 2936 p_priv->in_urbs[i] = keyspan_setup_urb(serial, endp, 2937 USB_DIR_IN, port, 2938 p_priv->in_buffer[i], 2939 IN_BUFLEN, 2940 cback->indat_callback); 2941 } 2942 /* outdat endpoints also have flip */ 2943 endp = d_details->outdat_endpoints[port_num]; 2944 for (i = 0; i <= d_details->outdat_endp_flip; ++i, ++endp) { 2945 p_priv->out_urbs[i] = keyspan_setup_urb(serial, endp, 2946 USB_DIR_OUT, port, 2947 p_priv->out_buffer[i], 2948 OUT_BUFLEN, 2949 cback->outdat_callback); 2950 } 2951 /* inack endpoint */ 2952 p_priv->inack_urb = keyspan_setup_urb(serial, 2953 d_details->inack_endpoints[port_num], 2954 USB_DIR_IN, port, 2955 p_priv->inack_buffer, 2956 INACK_BUFLEN, 2957 cback->inack_callback); 2958 /* outcont endpoint */ 2959 p_priv->outcont_urb = keyspan_setup_urb(serial, 2960 d_details->outcont_endpoints[port_num], 2961 USB_DIR_OUT, port, 2962 p_priv->outcont_buffer, 2963 OUTCONT_BUFLEN, 2964 cback->outcont_callback); 2965 2966 usb_set_serial_port_data(port, p_priv); 2967 2968 return 0; 2969 2970 err_outcont_buffer: 2971 kfree(p_priv->inack_buffer); 2972 err_inack_buffer: 2973 for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i) 2974 kfree(p_priv->out_buffer[i]); 2975 err_out_buffer: 2976 for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i) 2977 kfree(p_priv->in_buffer[i]); 2978 err_in_buffer: 2979 kfree(p_priv); 2980 2981 return -ENOMEM; 2982 } 2983 2984 static int keyspan_port_remove(struct usb_serial_port *port) 2985 { 2986 struct keyspan_port_private *p_priv; 2987 int i; 2988 2989 p_priv = usb_get_serial_port_data(port); 2990 2991 usb_kill_urb(p_priv->inack_urb); 2992 usb_kill_urb(p_priv->outcont_urb); 2993 for (i = 0; i < 2; i++) { 2994 usb_kill_urb(p_priv->in_urbs[i]); 2995 usb_kill_urb(p_priv->out_urbs[i]); 2996 } 2997 2998 usb_free_urb(p_priv->inack_urb); 2999 usb_free_urb(p_priv->outcont_urb); 3000 for (i = 0; i < 2; i++) { 3001 usb_free_urb(p_priv->in_urbs[i]); 3002 usb_free_urb(p_priv->out_urbs[i]); 3003 } 3004 3005 kfree(p_priv->outcont_buffer); 3006 kfree(p_priv->inack_buffer); 3007 for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i) 3008 kfree(p_priv->out_buffer[i]); 3009 for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i) 3010 kfree(p_priv->in_buffer[i]); 3011 3012 kfree(p_priv); 3013 3014 return 0; 3015 } 3016 3017 /* Structs for the devices, pre and post renumeration. */ 3018 static struct usb_serial_driver keyspan_pre_device = { 3019 .driver = { 3020 .owner = THIS_MODULE, 3021 .name = "keyspan_no_firm", 3022 }, 3023 .description = "Keyspan - (without firmware)", 3024 .id_table = keyspan_pre_ids, 3025 .num_ports = 1, 3026 .attach = keyspan_fake_startup, 3027 }; 3028 3029 static struct usb_serial_driver keyspan_1port_device = { 3030 .driver = { 3031 .owner = THIS_MODULE, 3032 .name = "keyspan_1", 3033 }, 3034 .description = "Keyspan 1 port adapter", 3035 .id_table = keyspan_1port_ids, 3036 .num_ports = 1, 3037 .open = keyspan_open, 3038 .close = keyspan_close, 3039 .dtr_rts = keyspan_dtr_rts, 3040 .write = keyspan_write, 3041 .write_room = keyspan_write_room, 3042 .set_termios = keyspan_set_termios, 3043 .break_ctl = keyspan_break_ctl, 3044 .tiocmget = keyspan_tiocmget, 3045 .tiocmset = keyspan_tiocmset, 3046 .attach = keyspan_startup, 3047 .disconnect = keyspan_disconnect, 3048 .release = keyspan_release, 3049 .port_probe = keyspan_port_probe, 3050 .port_remove = keyspan_port_remove, 3051 }; 3052 3053 static struct usb_serial_driver keyspan_2port_device = { 3054 .driver = { 3055 .owner = THIS_MODULE, 3056 .name = "keyspan_2", 3057 }, 3058 .description = "Keyspan 2 port adapter", 3059 .id_table = keyspan_2port_ids, 3060 .num_ports = 2, 3061 .open = keyspan_open, 3062 .close = keyspan_close, 3063 .dtr_rts = keyspan_dtr_rts, 3064 .write = keyspan_write, 3065 .write_room = keyspan_write_room, 3066 .set_termios = keyspan_set_termios, 3067 .break_ctl = keyspan_break_ctl, 3068 .tiocmget = keyspan_tiocmget, 3069 .tiocmset = keyspan_tiocmset, 3070 .attach = keyspan_startup, 3071 .disconnect = keyspan_disconnect, 3072 .release = keyspan_release, 3073 .port_probe = keyspan_port_probe, 3074 .port_remove = keyspan_port_remove, 3075 }; 3076 3077 static struct usb_serial_driver keyspan_4port_device = { 3078 .driver = { 3079 .owner = THIS_MODULE, 3080 .name = "keyspan_4", 3081 }, 3082 .description = "Keyspan 4 port adapter", 3083 .id_table = keyspan_4port_ids, 3084 .num_ports = 4, 3085 .open = keyspan_open, 3086 .close = keyspan_close, 3087 .dtr_rts = keyspan_dtr_rts, 3088 .write = keyspan_write, 3089 .write_room = keyspan_write_room, 3090 .set_termios = keyspan_set_termios, 3091 .break_ctl = keyspan_break_ctl, 3092 .tiocmget = keyspan_tiocmget, 3093 .tiocmset = keyspan_tiocmset, 3094 .attach = keyspan_startup, 3095 .disconnect = keyspan_disconnect, 3096 .release = keyspan_release, 3097 .port_probe = keyspan_port_probe, 3098 .port_remove = keyspan_port_remove, 3099 }; 3100 3101 static struct usb_serial_driver * const serial_drivers[] = { 3102 &keyspan_pre_device, &keyspan_1port_device, 3103 &keyspan_2port_device, &keyspan_4port_device, NULL 3104 }; 3105 3106 module_usb_serial_driver(serial_drivers, keyspan_ids_combined); 3107 3108 MODULE_AUTHOR(DRIVER_AUTHOR); 3109 MODULE_DESCRIPTION(DRIVER_DESC); 3110 MODULE_LICENSE("GPL"); 3111 3112 MODULE_FIRMWARE("keyspan/usa28.fw"); 3113 MODULE_FIRMWARE("keyspan/usa28x.fw"); 3114 MODULE_FIRMWARE("keyspan/usa28xa.fw"); 3115 MODULE_FIRMWARE("keyspan/usa28xb.fw"); 3116 MODULE_FIRMWARE("keyspan/usa19.fw"); 3117 MODULE_FIRMWARE("keyspan/usa19qi.fw"); 3118 MODULE_FIRMWARE("keyspan/mpr.fw"); 3119 MODULE_FIRMWARE("keyspan/usa19qw.fw"); 3120 MODULE_FIRMWARE("keyspan/usa18x.fw"); 3121 MODULE_FIRMWARE("keyspan/usa19w.fw"); 3122 MODULE_FIRMWARE("keyspan/usa49w.fw"); 3123 MODULE_FIRMWARE("keyspan/usa49wlc.fw"); 3124