1 /* 2 * USB HandSpring Visor, Palm m50x, and Sony Clie driver 3 * (supports all of the Palm OS USB devices) 4 * 5 * Copyright (C) 1999 - 2004 6 * Greg Kroah-Hartman (greg@kroah.com) 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License. 11 * 12 * See Documentation/usb/usb-serial.txt for more information on using this driver 13 * 14 */ 15 16 #include <linux/config.h> 17 #include <linux/kernel.h> 18 #include <linux/errno.h> 19 #include <linux/init.h> 20 #include <linux/slab.h> 21 #include <linux/tty.h> 22 #include <linux/tty_driver.h> 23 #include <linux/tty_flip.h> 24 #include <linux/module.h> 25 #include <linux/moduleparam.h> 26 #include <linux/spinlock.h> 27 #include <asm/uaccess.h> 28 #include <linux/usb.h> 29 #include "usb-serial.h" 30 #include "visor.h" 31 32 /* 33 * Version Information 34 */ 35 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>" 36 #define DRIVER_DESC "USB HandSpring Visor / Palm OS driver" 37 38 /* function prototypes for a handspring visor */ 39 static int visor_open (struct usb_serial_port *port, struct file *filp); 40 static void visor_close (struct usb_serial_port *port, struct file *filp); 41 static int visor_write (struct usb_serial_port *port, const unsigned char *buf, int count); 42 static int visor_write_room (struct usb_serial_port *port); 43 static int visor_chars_in_buffer (struct usb_serial_port *port); 44 static void visor_throttle (struct usb_serial_port *port); 45 static void visor_unthrottle (struct usb_serial_port *port); 46 static int visor_probe (struct usb_serial *serial, const struct usb_device_id *id); 47 static int visor_calc_num_ports(struct usb_serial *serial); 48 static void visor_shutdown (struct usb_serial *serial); 49 static int visor_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg); 50 static void visor_set_termios (struct usb_serial_port *port, struct termios *old_termios); 51 static void visor_write_bulk_callback (struct urb *urb, struct pt_regs *regs); 52 static void visor_read_bulk_callback (struct urb *urb, struct pt_regs *regs); 53 static void visor_read_int_callback (struct urb *urb, struct pt_regs *regs); 54 static int clie_3_5_startup (struct usb_serial *serial); 55 static int treo_attach (struct usb_serial *serial); 56 static int clie_5_attach (struct usb_serial *serial); 57 static int palm_os_3_probe (struct usb_serial *serial, const struct usb_device_id *id); 58 static int palm_os_4_probe (struct usb_serial *serial, const struct usb_device_id *id); 59 60 /* Parameters that may be passed into the module. */ 61 static int debug; 62 static __u16 vendor; 63 static __u16 product; 64 65 static struct usb_device_id id_table [] = { 66 { USB_DEVICE(HANDSPRING_VENDOR_ID, HANDSPRING_VISOR_ID), 67 .driver_info = (kernel_ulong_t)&palm_os_3_probe }, 68 { USB_DEVICE(HANDSPRING_VENDOR_ID, HANDSPRING_TREO_ID), 69 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 70 { USB_DEVICE(HANDSPRING_VENDOR_ID, HANDSPRING_TREO600_ID), 71 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 72 { USB_DEVICE(PALM_VENDOR_ID, PALM_M500_ID), 73 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 74 { USB_DEVICE(PALM_VENDOR_ID, PALM_M505_ID), 75 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 76 { USB_DEVICE(PALM_VENDOR_ID, PALM_M515_ID), 77 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 78 { USB_DEVICE(PALM_VENDOR_ID, PALM_I705_ID), 79 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 80 { USB_DEVICE(PALM_VENDOR_ID, PALM_M100_ID), 81 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 82 { USB_DEVICE(PALM_VENDOR_ID, PALM_M125_ID), 83 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 84 { USB_DEVICE(PALM_VENDOR_ID, PALM_M130_ID), 85 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 86 { USB_DEVICE(PALM_VENDOR_ID, PALM_TUNGSTEN_T_ID), 87 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 88 { USB_DEVICE(PALM_VENDOR_ID, PALM_TREO_650), 89 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 90 { USB_DEVICE(PALM_VENDOR_ID, PALM_TUNGSTEN_Z_ID), 91 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 92 { USB_DEVICE(PALM_VENDOR_ID, PALM_ZIRE31_ID), 93 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 94 { USB_DEVICE(PALM_VENDOR_ID, PALM_ZIRE_ID), 95 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 96 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_4_0_ID), 97 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 98 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_S360_ID), 99 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 100 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_4_1_ID), 101 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 102 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_NX60_ID), 103 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 104 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_NZ90V_ID), 105 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 106 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_TJ25_ID), 107 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 108 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_SCH_I330_ID), 109 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 110 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_SPH_I500_ID), 111 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 112 { USB_DEVICE(TAPWAVE_VENDOR_ID, TAPWAVE_ZODIAC_ID), 113 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 114 { USB_DEVICE(GARMIN_VENDOR_ID, GARMIN_IQUE_3600_ID), 115 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 116 { USB_DEVICE(ACEECA_VENDOR_ID, ACEECA_MEZ1000_ID), 117 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 118 { USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_7135_ID), 119 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 120 { USB_DEVICE(FOSSIL_VENDOR_ID, FOSSIL_ABACUS_ID), 121 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 122 { }, /* optional parameter entry */ 123 { } /* Terminating entry */ 124 }; 125 126 static struct usb_device_id clie_id_5_table [] = { 127 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_UX50_ID), 128 .driver_info = (kernel_ulong_t)&palm_os_4_probe }, 129 { }, /* optional parameter entry */ 130 { } /* Terminating entry */ 131 }; 132 133 static struct usb_device_id clie_id_3_5_table [] = { 134 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_3_5_ID) }, 135 { } /* Terminating entry */ 136 }; 137 138 static struct usb_device_id id_table_combined [] = { 139 { USB_DEVICE(HANDSPRING_VENDOR_ID, HANDSPRING_VISOR_ID) }, 140 { USB_DEVICE(HANDSPRING_VENDOR_ID, HANDSPRING_TREO_ID) }, 141 { USB_DEVICE(HANDSPRING_VENDOR_ID, HANDSPRING_TREO600_ID) }, 142 { USB_DEVICE(PALM_VENDOR_ID, PALM_M500_ID) }, 143 { USB_DEVICE(PALM_VENDOR_ID, PALM_M505_ID) }, 144 { USB_DEVICE(PALM_VENDOR_ID, PALM_M515_ID) }, 145 { USB_DEVICE(PALM_VENDOR_ID, PALM_I705_ID) }, 146 { USB_DEVICE(PALM_VENDOR_ID, PALM_M100_ID) }, 147 { USB_DEVICE(PALM_VENDOR_ID, PALM_M125_ID) }, 148 { USB_DEVICE(PALM_VENDOR_ID, PALM_M130_ID) }, 149 { USB_DEVICE(PALM_VENDOR_ID, PALM_TUNGSTEN_T_ID) }, 150 { USB_DEVICE(PALM_VENDOR_ID, PALM_TREO_650) }, 151 { USB_DEVICE(PALM_VENDOR_ID, PALM_TUNGSTEN_Z_ID) }, 152 { USB_DEVICE(PALM_VENDOR_ID, PALM_ZIRE31_ID) }, 153 { USB_DEVICE(PALM_VENDOR_ID, PALM_ZIRE_ID) }, 154 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_3_5_ID) }, 155 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_4_0_ID) }, 156 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_S360_ID) }, 157 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_4_1_ID) }, 158 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_NX60_ID) }, 159 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_NZ90V_ID) }, 160 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_UX50_ID) }, 161 { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_TJ25_ID) }, 162 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_SCH_I330_ID) }, 163 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_SPH_I500_ID) }, 164 { USB_DEVICE(TAPWAVE_VENDOR_ID, TAPWAVE_ZODIAC_ID) }, 165 { USB_DEVICE(GARMIN_VENDOR_ID, GARMIN_IQUE_3600_ID) }, 166 { USB_DEVICE(ACEECA_VENDOR_ID, ACEECA_MEZ1000_ID) }, 167 { USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_7135_ID) }, 168 { USB_DEVICE(FOSSIL_VENDOR_ID, FOSSIL_ABACUS_ID) }, 169 { }, /* optional parameter entry */ 170 { } /* Terminating entry */ 171 }; 172 173 MODULE_DEVICE_TABLE (usb, id_table_combined); 174 175 static struct usb_driver visor_driver = { 176 .name = "visor", 177 .probe = usb_serial_probe, 178 .disconnect = usb_serial_disconnect, 179 .id_table = id_table_combined, 180 .no_dynamic_id = 1, 181 }; 182 183 /* All of the device info needed for the Handspring Visor, and Palm 4.0 devices */ 184 static struct usb_serial_driver handspring_device = { 185 .driver = { 186 .owner = THIS_MODULE, 187 .name = "visor", 188 }, 189 .description = "Handspring Visor / Palm OS", 190 .id_table = id_table, 191 .num_interrupt_in = NUM_DONT_CARE, 192 .num_bulk_in = 2, 193 .num_bulk_out = 2, 194 .num_ports = 2, 195 .open = visor_open, 196 .close = visor_close, 197 .throttle = visor_throttle, 198 .unthrottle = visor_unthrottle, 199 .attach = treo_attach, 200 .probe = visor_probe, 201 .calc_num_ports = visor_calc_num_ports, 202 .shutdown = visor_shutdown, 203 .ioctl = visor_ioctl, 204 .set_termios = visor_set_termios, 205 .write = visor_write, 206 .write_room = visor_write_room, 207 .chars_in_buffer = visor_chars_in_buffer, 208 .write_bulk_callback = visor_write_bulk_callback, 209 .read_bulk_callback = visor_read_bulk_callback, 210 .read_int_callback = visor_read_int_callback, 211 }; 212 213 /* All of the device info needed for the Clie UX50, TH55 Palm 5.0 devices */ 214 static struct usb_serial_driver clie_5_device = { 215 .driver = { 216 .owner = THIS_MODULE, 217 .name = "clie_5", 218 }, 219 .description = "Sony Clie 5.0", 220 .id_table = clie_id_5_table, 221 .num_interrupt_in = NUM_DONT_CARE, 222 .num_bulk_in = 2, 223 .num_bulk_out = 2, 224 .num_ports = 2, 225 .open = visor_open, 226 .close = visor_close, 227 .throttle = visor_throttle, 228 .unthrottle = visor_unthrottle, 229 .attach = clie_5_attach, 230 .probe = visor_probe, 231 .calc_num_ports = visor_calc_num_ports, 232 .shutdown = visor_shutdown, 233 .ioctl = visor_ioctl, 234 .set_termios = visor_set_termios, 235 .write = visor_write, 236 .write_room = visor_write_room, 237 .chars_in_buffer = visor_chars_in_buffer, 238 .write_bulk_callback = visor_write_bulk_callback, 239 .read_bulk_callback = visor_read_bulk_callback, 240 .read_int_callback = visor_read_int_callback, 241 }; 242 243 /* device info for the Sony Clie OS version 3.5 */ 244 static struct usb_serial_driver clie_3_5_device = { 245 .driver = { 246 .owner = THIS_MODULE, 247 .name = "clie_3.5", 248 }, 249 .description = "Sony Clie 3.5", 250 .id_table = clie_id_3_5_table, 251 .num_interrupt_in = 0, 252 .num_bulk_in = 1, 253 .num_bulk_out = 1, 254 .num_ports = 1, 255 .open = visor_open, 256 .close = visor_close, 257 .throttle = visor_throttle, 258 .unthrottle = visor_unthrottle, 259 .attach = clie_3_5_startup, 260 .ioctl = visor_ioctl, 261 .set_termios = visor_set_termios, 262 .write = visor_write, 263 .write_room = visor_write_room, 264 .chars_in_buffer = visor_chars_in_buffer, 265 .write_bulk_callback = visor_write_bulk_callback, 266 .read_bulk_callback = visor_read_bulk_callback, 267 }; 268 269 struct visor_private { 270 spinlock_t lock; 271 int bytes_in; 272 int bytes_out; 273 int outstanding_urbs; 274 int throttled; 275 }; 276 277 /* number of outstanding urbs to prevent userspace DoS from happening */ 278 #define URB_UPPER_LIMIT 42 279 280 static int stats; 281 282 /****************************************************************************** 283 * Handspring Visor specific driver functions 284 ******************************************************************************/ 285 static int visor_open (struct usb_serial_port *port, struct file *filp) 286 { 287 struct usb_serial *serial = port->serial; 288 struct visor_private *priv = usb_get_serial_port_data(port); 289 unsigned long flags; 290 int result = 0; 291 292 dbg("%s - port %d", __FUNCTION__, port->number); 293 294 if (!port->read_urb) { 295 /* this is needed for some brain dead Sony devices */ 296 dev_err(&port->dev, "Device lied about number of ports, please use a lower one.\n"); 297 return -ENODEV; 298 } 299 300 spin_lock_irqsave(&priv->lock, flags); 301 priv->bytes_in = 0; 302 priv->bytes_out = 0; 303 priv->outstanding_urbs = 0; 304 priv->throttled = 0; 305 spin_unlock_irqrestore(&priv->lock, flags); 306 307 /* 308 * Force low_latency on so that our tty_push actually forces the data 309 * through, otherwise it is scheduled, and with high data rates (like 310 * with OHCI) data can get lost. 311 */ 312 if (port->tty) 313 port->tty->low_latency = 1; 314 315 /* Start reading from the device */ 316 usb_fill_bulk_urb (port->read_urb, serial->dev, 317 usb_rcvbulkpipe (serial->dev, 318 port->bulk_in_endpointAddress), 319 port->read_urb->transfer_buffer, 320 port->read_urb->transfer_buffer_length, 321 visor_read_bulk_callback, port); 322 result = usb_submit_urb(port->read_urb, GFP_KERNEL); 323 if (result) { 324 dev_err(&port->dev, "%s - failed submitting read urb, error %d\n", 325 __FUNCTION__, result); 326 goto exit; 327 } 328 329 if (port->interrupt_in_urb) { 330 dbg("%s - adding interrupt input for treo", __FUNCTION__); 331 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 332 if (result) 333 dev_err(&port->dev, "%s - failed submitting interrupt urb, error %d\n", 334 __FUNCTION__, result); 335 } 336 exit: 337 return result; 338 } 339 340 341 static void visor_close (struct usb_serial_port *port, struct file * filp) 342 { 343 struct visor_private *priv = usb_get_serial_port_data(port); 344 unsigned char *transfer_buffer; 345 346 dbg("%s - port %d", __FUNCTION__, port->number); 347 348 /* shutdown our urbs */ 349 usb_kill_urb(port->read_urb); 350 if (port->interrupt_in_urb) 351 usb_kill_urb(port->interrupt_in_urb); 352 353 /* Try to send shutdown message, if the device is gone, this will just fail. */ 354 transfer_buffer = kmalloc (0x12, GFP_KERNEL); 355 if (transfer_buffer) { 356 usb_control_msg (port->serial->dev, 357 usb_rcvctrlpipe(port->serial->dev, 0), 358 VISOR_CLOSE_NOTIFICATION, 0xc2, 359 0x0000, 0x0000, 360 transfer_buffer, 0x12, 300); 361 kfree (transfer_buffer); 362 } 363 364 if (stats) 365 dev_info(&port->dev, "Bytes In = %d Bytes Out = %d\n", 366 priv->bytes_in, priv->bytes_out); 367 } 368 369 370 static int visor_write (struct usb_serial_port *port, const unsigned char *buf, int count) 371 { 372 struct visor_private *priv = usb_get_serial_port_data(port); 373 struct usb_serial *serial = port->serial; 374 struct urb *urb; 375 unsigned char *buffer; 376 unsigned long flags; 377 int status; 378 379 dbg("%s - port %d", __FUNCTION__, port->number); 380 381 spin_lock_irqsave(&priv->lock, flags); 382 if (priv->outstanding_urbs > URB_UPPER_LIMIT) { 383 spin_unlock_irqrestore(&priv->lock, flags); 384 dbg("%s - write limit hit\n", __FUNCTION__); 385 return 0; 386 } 387 spin_unlock_irqrestore(&priv->lock, flags); 388 389 buffer = kmalloc (count, GFP_ATOMIC); 390 if (!buffer) { 391 dev_err(&port->dev, "out of memory\n"); 392 return -ENOMEM; 393 } 394 395 urb = usb_alloc_urb(0, GFP_ATOMIC); 396 if (!urb) { 397 dev_err(&port->dev, "no more free urbs\n"); 398 kfree (buffer); 399 return -ENOMEM; 400 } 401 402 memcpy (buffer, buf, count); 403 404 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count, buffer); 405 406 usb_fill_bulk_urb (urb, serial->dev, 407 usb_sndbulkpipe (serial->dev, 408 port->bulk_out_endpointAddress), 409 buffer, count, 410 visor_write_bulk_callback, port); 411 412 /* send it down the pipe */ 413 status = usb_submit_urb(urb, GFP_ATOMIC); 414 if (status) { 415 dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed with status = %d\n", 416 __FUNCTION__, status); 417 count = status; 418 kfree (buffer); 419 } else { 420 spin_lock_irqsave(&priv->lock, flags); 421 ++priv->outstanding_urbs; 422 priv->bytes_out += count; 423 spin_unlock_irqrestore(&priv->lock, flags); 424 } 425 426 /* we are done with this urb, so let the host driver 427 * really free it when it is finished with it */ 428 usb_free_urb (urb); 429 430 return count; 431 } 432 433 434 static int visor_write_room (struct usb_serial_port *port) 435 { 436 dbg("%s - port %d", __FUNCTION__, port->number); 437 438 /* 439 * We really can take anything the user throws at us 440 * but let's pick a nice big number to tell the tty 441 * layer that we have lots of free space 442 */ 443 return 2048; 444 } 445 446 447 static int visor_chars_in_buffer (struct usb_serial_port *port) 448 { 449 dbg("%s - port %d", __FUNCTION__, port->number); 450 451 /* 452 * We can't really account for how much data we 453 * have sent out, but hasn't made it through to the 454 * device, so just tell the tty layer that everything 455 * is flushed. 456 */ 457 return 0; 458 } 459 460 461 static void visor_write_bulk_callback (struct urb *urb, struct pt_regs *regs) 462 { 463 struct usb_serial_port *port = (struct usb_serial_port *)urb->context; 464 struct visor_private *priv = usb_get_serial_port_data(port); 465 unsigned long flags; 466 467 /* free up the transfer buffer, as usb_free_urb() does not do this */ 468 kfree (urb->transfer_buffer); 469 470 dbg("%s - port %d", __FUNCTION__, port->number); 471 472 if (urb->status) 473 dbg("%s - nonzero write bulk status received: %d", 474 __FUNCTION__, urb->status); 475 476 spin_lock_irqsave(&priv->lock, flags); 477 --priv->outstanding_urbs; 478 spin_unlock_irqrestore(&priv->lock, flags); 479 480 schedule_work(&port->work); 481 } 482 483 484 static void visor_read_bulk_callback (struct urb *urb, struct pt_regs *regs) 485 { 486 struct usb_serial_port *port = (struct usb_serial_port *)urb->context; 487 struct visor_private *priv = usb_get_serial_port_data(port); 488 unsigned char *data = urb->transfer_buffer; 489 struct tty_struct *tty; 490 unsigned long flags; 491 int i; 492 int throttled; 493 int result; 494 495 dbg("%s - port %d", __FUNCTION__, port->number); 496 497 if (urb->status) { 498 dbg("%s - nonzero read bulk status received: %d", __FUNCTION__, urb->status); 499 return; 500 } 501 502 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data); 503 504 tty = port->tty; 505 if (tty && urb->actual_length) { 506 for (i = 0; i < urb->actual_length ; ++i) { 507 /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */ 508 if(tty->flip.count >= TTY_FLIPBUF_SIZE) { 509 tty_flip_buffer_push(tty); 510 } 511 /* this doesn't actually push the data through unless tty->low_latency is set */ 512 tty_insert_flip_char(tty, data[i], 0); 513 } 514 tty_flip_buffer_push(tty); 515 } 516 spin_lock_irqsave(&priv->lock, flags); 517 priv->bytes_in += urb->actual_length; 518 throttled = priv->throttled; 519 spin_unlock_irqrestore(&priv->lock, flags); 520 521 /* Continue trying to always read if we should */ 522 if (!throttled) { 523 usb_fill_bulk_urb (port->read_urb, port->serial->dev, 524 usb_rcvbulkpipe(port->serial->dev, 525 port->bulk_in_endpointAddress), 526 port->read_urb->transfer_buffer, 527 port->read_urb->transfer_buffer_length, 528 visor_read_bulk_callback, port); 529 result = usb_submit_urb(port->read_urb, GFP_ATOMIC); 530 if (result) 531 dev_err(&port->dev, "%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result); 532 } 533 return; 534 } 535 536 static void visor_read_int_callback (struct urb *urb, struct pt_regs *regs) 537 { 538 struct usb_serial_port *port = (struct usb_serial_port *)urb->context; 539 int result; 540 541 switch (urb->status) { 542 case 0: 543 /* success */ 544 break; 545 case -ECONNRESET: 546 case -ENOENT: 547 case -ESHUTDOWN: 548 /* this urb is terminated, clean up */ 549 dbg("%s - urb shutting down with status: %d", 550 __FUNCTION__, urb->status); 551 return; 552 default: 553 dbg("%s - nonzero urb status received: %d", 554 __FUNCTION__, urb->status); 555 goto exit; 556 } 557 558 /* 559 * This information is still unknown what it can be used for. 560 * If anyone has an idea, please let the author know... 561 * 562 * Rumor has it this endpoint is used to notify when data 563 * is ready to be read from the bulk ones. 564 */ 565 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, 566 urb->actual_length, urb->transfer_buffer); 567 568 exit: 569 result = usb_submit_urb (urb, GFP_ATOMIC); 570 if (result) 571 dev_err(&urb->dev->dev, "%s - Error %d submitting interrupt urb\n", 572 __FUNCTION__, result); 573 } 574 575 static void visor_throttle (struct usb_serial_port *port) 576 { 577 struct visor_private *priv = usb_get_serial_port_data(port); 578 unsigned long flags; 579 580 dbg("%s - port %d", __FUNCTION__, port->number); 581 spin_lock_irqsave(&priv->lock, flags); 582 priv->throttled = 1; 583 spin_unlock_irqrestore(&priv->lock, flags); 584 } 585 586 587 static void visor_unthrottle (struct usb_serial_port *port) 588 { 589 struct visor_private *priv = usb_get_serial_port_data(port); 590 unsigned long flags; 591 int result; 592 593 dbg("%s - port %d", __FUNCTION__, port->number); 594 spin_lock_irqsave(&priv->lock, flags); 595 priv->throttled = 0; 596 spin_unlock_irqrestore(&priv->lock, flags); 597 598 port->read_urb->dev = port->serial->dev; 599 result = usb_submit_urb(port->read_urb, GFP_ATOMIC); 600 if (result) 601 dev_err(&port->dev, "%s - failed submitting read urb, error %d\n", __FUNCTION__, result); 602 } 603 604 static int palm_os_3_probe (struct usb_serial *serial, const struct usb_device_id *id) 605 { 606 struct device *dev = &serial->dev->dev; 607 struct visor_connection_info *connection_info; 608 unsigned char *transfer_buffer; 609 char *string; 610 int retval = 0; 611 int i; 612 int num_ports = 0; 613 614 dbg("%s", __FUNCTION__); 615 616 transfer_buffer = kmalloc (sizeof (*connection_info), GFP_KERNEL); 617 if (!transfer_buffer) { 618 dev_err(dev, "%s - kmalloc(%Zd) failed.\n", __FUNCTION__, 619 sizeof(*connection_info)); 620 return -ENOMEM; 621 } 622 623 /* send a get connection info request */ 624 retval = usb_control_msg (serial->dev, 625 usb_rcvctrlpipe(serial->dev, 0), 626 VISOR_GET_CONNECTION_INFORMATION, 627 0xc2, 0x0000, 0x0000, transfer_buffer, 628 sizeof(*connection_info), 300); 629 if (retval < 0) { 630 dev_err(dev, "%s - error %d getting connection information\n", 631 __FUNCTION__, retval); 632 goto exit; 633 } 634 635 if (retval == sizeof(*connection_info)) { 636 connection_info = (struct visor_connection_info *)transfer_buffer; 637 638 num_ports = le16_to_cpu(connection_info->num_ports); 639 for (i = 0; i < num_ports; ++i) { 640 switch (connection_info->connections[i].port_function_id) { 641 case VISOR_FUNCTION_GENERIC: 642 string = "Generic"; 643 break; 644 case VISOR_FUNCTION_DEBUGGER: 645 string = "Debugger"; 646 break; 647 case VISOR_FUNCTION_HOTSYNC: 648 string = "HotSync"; 649 break; 650 case VISOR_FUNCTION_CONSOLE: 651 string = "Console"; 652 break; 653 case VISOR_FUNCTION_REMOTE_FILE_SYS: 654 string = "Remote File System"; 655 break; 656 default: 657 string = "unknown"; 658 break; 659 } 660 dev_info(dev, "%s: port %d, is for %s use\n", 661 serial->type->description, 662 connection_info->connections[i].port, string); 663 } 664 } 665 /* 666 * Handle devices that report invalid stuff here. 667 */ 668 if (num_ports == 0 || num_ports > 2) { 669 dev_warn (dev, "%s: No valid connect info available\n", 670 serial->type->description); 671 num_ports = 2; 672 } 673 674 dev_info(dev, "%s: Number of ports: %d\n", serial->type->description, 675 num_ports); 676 677 /* 678 * save off our num_ports info so that we can use it in the 679 * calc_num_ports callback 680 */ 681 usb_set_serial_data(serial, (void *)(long)num_ports); 682 683 /* ask for the number of bytes available, but ignore the response as it is broken */ 684 retval = usb_control_msg (serial->dev, 685 usb_rcvctrlpipe(serial->dev, 0), 686 VISOR_REQUEST_BYTES_AVAILABLE, 687 0xc2, 0x0000, 0x0005, transfer_buffer, 688 0x02, 300); 689 if (retval < 0) 690 dev_err(dev, "%s - error %d getting bytes available request\n", 691 __FUNCTION__, retval); 692 retval = 0; 693 694 exit: 695 kfree (transfer_buffer); 696 697 return retval; 698 } 699 700 static int palm_os_4_probe (struct usb_serial *serial, const struct usb_device_id *id) 701 { 702 struct device *dev = &serial->dev->dev; 703 struct palm_ext_connection_info *connection_info; 704 unsigned char *transfer_buffer; 705 int retval; 706 707 dbg("%s", __FUNCTION__); 708 709 transfer_buffer = kmalloc (sizeof (*connection_info), GFP_KERNEL); 710 if (!transfer_buffer) { 711 dev_err(dev, "%s - kmalloc(%Zd) failed.\n", __FUNCTION__, 712 sizeof(*connection_info)); 713 return -ENOMEM; 714 } 715 716 retval = usb_control_msg (serial->dev, 717 usb_rcvctrlpipe(serial->dev, 0), 718 PALM_GET_EXT_CONNECTION_INFORMATION, 719 0xc2, 0x0000, 0x0000, transfer_buffer, 720 sizeof (*connection_info), 300); 721 if (retval < 0) 722 dev_err(dev, "%s - error %d getting connection info\n", 723 __FUNCTION__, retval); 724 else 725 usb_serial_debug_data(debug, &serial->dev->dev, __FUNCTION__, 726 retval, transfer_buffer); 727 728 kfree (transfer_buffer); 729 return 0; 730 } 731 732 733 static int visor_probe (struct usb_serial *serial, const struct usb_device_id *id) 734 { 735 int retval = 0; 736 int (*startup) (struct usb_serial *serial, const struct usb_device_id *id); 737 738 dbg("%s", __FUNCTION__); 739 740 if (serial->dev->actconfig->desc.bConfigurationValue != 1) { 741 err("active config #%d != 1 ??", 742 serial->dev->actconfig->desc.bConfigurationValue); 743 return -ENODEV; 744 } 745 746 if (id->driver_info) { 747 startup = (void *)id->driver_info; 748 retval = startup(serial, id); 749 } 750 751 return retval; 752 } 753 754 static int visor_calc_num_ports (struct usb_serial *serial) 755 { 756 int num_ports = (int)(long)(usb_get_serial_data(serial)); 757 758 if (num_ports) 759 usb_set_serial_data(serial, NULL); 760 761 return num_ports; 762 } 763 764 static int generic_startup(struct usb_serial *serial) 765 { 766 struct visor_private *priv; 767 int i; 768 769 for (i = 0; i < serial->num_ports; ++i) { 770 priv = kmalloc (sizeof(*priv), GFP_KERNEL); 771 if (!priv) 772 return -ENOMEM; 773 memset (priv, 0x00, sizeof(*priv)); 774 spin_lock_init(&priv->lock); 775 usb_set_serial_port_data(serial->port[i], priv); 776 } 777 return 0; 778 } 779 780 static int clie_3_5_startup (struct usb_serial *serial) 781 { 782 struct device *dev = &serial->dev->dev; 783 int result; 784 u8 data; 785 786 dbg("%s", __FUNCTION__); 787 788 /* 789 * Note that PEG-300 series devices expect the following two calls. 790 */ 791 792 /* get the config number */ 793 result = usb_control_msg (serial->dev, usb_rcvctrlpipe(serial->dev, 0), 794 USB_REQ_GET_CONFIGURATION, USB_DIR_IN, 795 0, 0, &data, 1, 3000); 796 if (result < 0) { 797 dev_err(dev, "%s: get config number failed: %d\n", __FUNCTION__, result); 798 return result; 799 } 800 if (result != 1) { 801 dev_err(dev, "%s: get config number bad return length: %d\n", __FUNCTION__, result); 802 return -EIO; 803 } 804 805 /* get the interface number */ 806 result = usb_control_msg (serial->dev, usb_rcvctrlpipe(serial->dev, 0), 807 USB_REQ_GET_INTERFACE, 808 USB_DIR_IN | USB_RECIP_INTERFACE, 809 0, 0, &data, 1, 3000); 810 if (result < 0) { 811 dev_err(dev, "%s: get interface number failed: %d\n", __FUNCTION__, result); 812 return result; 813 } 814 if (result != 1) { 815 dev_err(dev, "%s: get interface number bad return length: %d\n", __FUNCTION__, result); 816 return -EIO; 817 } 818 819 return generic_startup(serial); 820 } 821 822 static int treo_attach (struct usb_serial *serial) 823 { 824 struct usb_serial_port *swap_port; 825 826 /* Only do this endpoint hack for the Handspring devices with 827 * interrupt in endpoints, which for now are the Treo devices. */ 828 if (!((le16_to_cpu(serial->dev->descriptor.idVendor) == HANDSPRING_VENDOR_ID) || 829 (le16_to_cpu(serial->dev->descriptor.idVendor) == KYOCERA_VENDOR_ID)) || 830 (serial->num_interrupt_in == 0)) 831 goto generic_startup; 832 833 dbg("%s", __FUNCTION__); 834 835 /* 836 * It appears that Treos and Kyoceras want to use the 837 * 1st bulk in endpoint to communicate with the 2nd bulk out endpoint, 838 * so let's swap the 1st and 2nd bulk in and interrupt endpoints. 839 * Note that swapping the bulk out endpoints would break lots of 840 * apps that want to communicate on the second port. 841 */ 842 #define COPY_PORT(dest, src) \ 843 dest->read_urb = src->read_urb; \ 844 dest->bulk_in_endpointAddress = src->bulk_in_endpointAddress; \ 845 dest->bulk_in_buffer = src->bulk_in_buffer; \ 846 dest->interrupt_in_urb = src->interrupt_in_urb; \ 847 dest->interrupt_in_endpointAddress = src->interrupt_in_endpointAddress; \ 848 dest->interrupt_in_buffer = src->interrupt_in_buffer; 849 850 swap_port = kmalloc(sizeof(*swap_port), GFP_KERNEL); 851 if (!swap_port) 852 return -ENOMEM; 853 COPY_PORT(swap_port, serial->port[0]); 854 COPY_PORT(serial->port[0], serial->port[1]); 855 COPY_PORT(serial->port[1], swap_port); 856 kfree(swap_port); 857 858 generic_startup: 859 return generic_startup(serial); 860 } 861 862 static int clie_5_attach (struct usb_serial *serial) 863 { 864 dbg("%s", __FUNCTION__); 865 866 /* TH55 registers 2 ports. 867 Communication in from the UX50/TH55 uses bulk_in_endpointAddress from port 0 868 Communication out to the UX50/TH55 uses bulk_out_endpointAddress from port 1 869 870 Lets do a quick and dirty mapping 871 */ 872 873 /* some sanity check */ 874 if (serial->num_ports < 2) 875 return -1; 876 877 /* port 0 now uses the modified endpoint Address */ 878 serial->port[0]->bulk_out_endpointAddress = serial->port[1]->bulk_out_endpointAddress; 879 880 return generic_startup(serial); 881 } 882 883 static void visor_shutdown (struct usb_serial *serial) 884 { 885 dbg("%s", __FUNCTION__); 886 } 887 888 static int visor_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg) 889 { 890 dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__, port->number, cmd); 891 892 return -ENOIOCTLCMD; 893 } 894 895 896 /* This function is all nice and good, but we don't change anything based on it :) */ 897 static void visor_set_termios (struct usb_serial_port *port, struct termios *old_termios) 898 { 899 unsigned int cflag; 900 901 dbg("%s - port %d", __FUNCTION__, port->number); 902 903 if ((!port->tty) || (!port->tty->termios)) { 904 dbg("%s - no tty structures", __FUNCTION__); 905 return; 906 } 907 908 cflag = port->tty->termios->c_cflag; 909 /* check that they really want us to change something */ 910 if (old_termios) { 911 if ((cflag == old_termios->c_cflag) && 912 (RELEVANT_IFLAG(port->tty->termios->c_iflag) == RELEVANT_IFLAG(old_termios->c_iflag))) { 913 dbg("%s - nothing to change...", __FUNCTION__); 914 return; 915 } 916 } 917 918 /* get the byte size */ 919 switch (cflag & CSIZE) { 920 case CS5: dbg("%s - data bits = 5", __FUNCTION__); break; 921 case CS6: dbg("%s - data bits = 6", __FUNCTION__); break; 922 case CS7: dbg("%s - data bits = 7", __FUNCTION__); break; 923 default: 924 case CS8: dbg("%s - data bits = 8", __FUNCTION__); break; 925 } 926 927 /* determine the parity */ 928 if (cflag & PARENB) 929 if (cflag & PARODD) 930 dbg("%s - parity = odd", __FUNCTION__); 931 else 932 dbg("%s - parity = even", __FUNCTION__); 933 else 934 dbg("%s - parity = none", __FUNCTION__); 935 936 /* figure out the stop bits requested */ 937 if (cflag & CSTOPB) 938 dbg("%s - stop bits = 2", __FUNCTION__); 939 else 940 dbg("%s - stop bits = 1", __FUNCTION__); 941 942 943 /* figure out the flow control settings */ 944 if (cflag & CRTSCTS) 945 dbg("%s - RTS/CTS is enabled", __FUNCTION__); 946 else 947 dbg("%s - RTS/CTS is disabled", __FUNCTION__); 948 949 /* determine software flow control */ 950 if (I_IXOFF(port->tty)) 951 dbg("%s - XON/XOFF is enabled, XON = %2x, XOFF = %2x", 952 __FUNCTION__, START_CHAR(port->tty), STOP_CHAR(port->tty)); 953 else 954 dbg("%s - XON/XOFF is disabled", __FUNCTION__); 955 956 /* get the baud rate wanted */ 957 dbg("%s - baud rate = %d", __FUNCTION__, tty_get_baud_rate(port->tty)); 958 959 return; 960 } 961 962 963 static int __init visor_init (void) 964 { 965 int i, retval; 966 /* Only if parameters were passed to us */ 967 if ((vendor>0) && (product>0)) { 968 struct usb_device_id usb_dev_temp[]= 969 {{USB_DEVICE(vendor, product), 970 .driver_info = (kernel_ulong_t)&palm_os_4_probe }}; 971 972 /* Find the last entry in id_table */ 973 for (i=0; ; i++) { 974 if (id_table[i].idVendor==0) { 975 id_table[i] = usb_dev_temp[0]; 976 break; 977 } 978 } 979 /* Find the last entry in id_table_combined */ 980 for (i=0; ; i++) { 981 if (id_table_combined[i].idVendor==0) { 982 id_table_combined[i] = usb_dev_temp[0]; 983 break; 984 } 985 } 986 info("Untested USB device specified at time of module insertion"); 987 info("Warning: This is not guaranteed to work"); 988 info("Using a newer kernel is preferred to this method"); 989 info("Adding Palm OS protocol 4.x support for unknown device: 0x%x/0x%x", 990 vendor, product); 991 } 992 retval = usb_serial_register(&handspring_device); 993 if (retval) 994 goto failed_handspring_register; 995 retval = usb_serial_register(&clie_3_5_device); 996 if (retval) 997 goto failed_clie_3_5_register; 998 retval = usb_serial_register(&clie_5_device); 999 if (retval) 1000 goto failed_clie_5_register; 1001 retval = usb_register(&visor_driver); 1002 if (retval) 1003 goto failed_usb_register; 1004 info(DRIVER_DESC); 1005 1006 return 0; 1007 failed_usb_register: 1008 usb_serial_deregister(&clie_5_device); 1009 failed_clie_5_register: 1010 usb_serial_deregister(&clie_3_5_device); 1011 failed_clie_3_5_register: 1012 usb_serial_deregister(&handspring_device); 1013 failed_handspring_register: 1014 return retval; 1015 } 1016 1017 1018 static void __exit visor_exit (void) 1019 { 1020 usb_deregister (&visor_driver); 1021 usb_serial_deregister (&handspring_device); 1022 usb_serial_deregister (&clie_3_5_device); 1023 usb_serial_deregister (&clie_5_device); 1024 } 1025 1026 1027 module_init(visor_init); 1028 module_exit(visor_exit); 1029 1030 MODULE_AUTHOR( DRIVER_AUTHOR ); 1031 MODULE_DESCRIPTION( DRIVER_DESC ); 1032 MODULE_LICENSE("GPL"); 1033 1034 module_param(debug, bool, S_IRUGO | S_IWUSR); 1035 MODULE_PARM_DESC(debug, "Debug enabled or not"); 1036 module_param(stats, bool, S_IRUGO | S_IWUSR); 1037 MODULE_PARM_DESC(stats, "Enables statistics or not"); 1038 1039 module_param(vendor, ushort, 0); 1040 MODULE_PARM_DESC(vendor, "User specified vendor ID"); 1041 module_param(product, ushort, 0); 1042 MODULE_PARM_DESC(product, "User specified product ID"); 1043 1044