Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
visor.c
Go to the documentation of this file.
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 ([email protected])
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License version
10  * 2 as published by the Free Software Foundation.
11  *
12  * See Documentation/usb/usb-serial.txt for more information on using this
13  * driver
14  *
15  */
16 
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 <linux/uaccess.h>
28 #include <linux/usb.h>
29 #include <linux/usb/serial.h>
30 #include <linux/usb/cdc.h>
31 #include "visor.h"
32 
33 /*
34  * Version Information
35  */
36 #define DRIVER_AUTHOR "Greg Kroah-Hartman <[email protected]>"
37 #define DRIVER_DESC "USB HandSpring Visor / Palm OS driver"
38 
39 /* function prototypes for a handspring visor */
40 static int visor_open(struct tty_struct *tty, struct usb_serial_port *port);
41 static void visor_close(struct usb_serial_port *port);
42 static int visor_probe(struct usb_serial *serial,
43  const struct usb_device_id *id);
44 static int visor_calc_num_ports(struct usb_serial *serial);
45 static void visor_read_int_callback(struct urb *urb);
46 static int clie_3_5_startup(struct usb_serial *serial);
47 static int treo_attach(struct usb_serial *serial);
48 static int clie_5_attach(struct usb_serial *serial);
49 static int palm_os_3_probe(struct usb_serial *serial,
50  const struct usb_device_id *id);
51 static int palm_os_4_probe(struct usb_serial *serial,
52  const struct usb_device_id *id);
53 
54 static struct usb_device_id id_table [] = {
55  { USB_DEVICE(HANDSPRING_VENDOR_ID, HANDSPRING_VISOR_ID),
56  .driver_info = (kernel_ulong_t)&palm_os_3_probe },
57  { USB_DEVICE(HANDSPRING_VENDOR_ID, HANDSPRING_TREO_ID),
58  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
59  { USB_DEVICE(HANDSPRING_VENDOR_ID, HANDSPRING_TREO600_ID),
60  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
61  { USB_DEVICE(GSPDA_VENDOR_ID, GSPDA_XPLORE_M68_ID),
62  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
63  { USB_DEVICE(PALM_VENDOR_ID, PALM_M500_ID),
64  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
65  { USB_DEVICE(PALM_VENDOR_ID, PALM_M505_ID),
66  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
67  { USB_DEVICE(PALM_VENDOR_ID, PALM_M515_ID),
68  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
69  { USB_DEVICE(PALM_VENDOR_ID, PALM_I705_ID),
70  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
71  { USB_DEVICE(PALM_VENDOR_ID, PALM_M100_ID),
72  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
73  { USB_DEVICE(PALM_VENDOR_ID, PALM_M125_ID),
74  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
75  { USB_DEVICE(PALM_VENDOR_ID, PALM_M130_ID),
76  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
77  { USB_DEVICE(PALM_VENDOR_ID, PALM_TUNGSTEN_T_ID),
78  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
79  { USB_DEVICE(PALM_VENDOR_ID, PALM_TREO_650),
80  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
81  { USB_DEVICE(PALM_VENDOR_ID, PALM_TUNGSTEN_Z_ID),
82  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
83  { USB_DEVICE(PALM_VENDOR_ID, PALM_ZIRE_ID),
84  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
85  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_4_0_ID),
86  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
87  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_S360_ID),
88  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
89  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_4_1_ID),
90  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
91  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_NX60_ID),
92  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
93  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_NZ90V_ID),
94  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
95  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_TJ25_ID),
96  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
97  { USB_DEVICE(ACER_VENDOR_ID, ACER_S10_ID),
98  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
99  { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_SCH_I330_ID),
100  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
101  { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_SPH_I500_ID),
102  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
103  { USB_DEVICE(TAPWAVE_VENDOR_ID, TAPWAVE_ZODIAC_ID),
104  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
105  { USB_DEVICE(GARMIN_VENDOR_ID, GARMIN_IQUE_3600_ID),
106  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
107  { USB_DEVICE(ACEECA_VENDOR_ID, ACEECA_MEZ1000_ID),
108  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
109  { USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_7135_ID),
110  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
111  { USB_DEVICE(FOSSIL_VENDOR_ID, FOSSIL_ABACUS_ID),
112  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
113  { } /* Terminating entry */
114 };
115 
116 static struct usb_device_id clie_id_5_table [] = {
117  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_UX50_ID),
118  .driver_info = (kernel_ulong_t)&palm_os_4_probe },
119  { } /* Terminating entry */
120 };
121 
122 static struct usb_device_id clie_id_3_5_table [] = {
123  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_3_5_ID) },
124  { } /* Terminating entry */
125 };
126 
127 static struct usb_device_id id_table_combined [] = {
128  { USB_DEVICE(HANDSPRING_VENDOR_ID, HANDSPRING_VISOR_ID) },
129  { USB_DEVICE(HANDSPRING_VENDOR_ID, HANDSPRING_TREO_ID) },
130  { USB_DEVICE(HANDSPRING_VENDOR_ID, HANDSPRING_TREO600_ID) },
131  { USB_DEVICE(GSPDA_VENDOR_ID, GSPDA_XPLORE_M68_ID) },
132  { USB_DEVICE(PALM_VENDOR_ID, PALM_M500_ID) },
133  { USB_DEVICE(PALM_VENDOR_ID, PALM_M505_ID) },
134  { USB_DEVICE(PALM_VENDOR_ID, PALM_M515_ID) },
135  { USB_DEVICE(PALM_VENDOR_ID, PALM_I705_ID) },
136  { USB_DEVICE(PALM_VENDOR_ID, PALM_M100_ID) },
137  { USB_DEVICE(PALM_VENDOR_ID, PALM_M125_ID) },
138  { USB_DEVICE(PALM_VENDOR_ID, PALM_M130_ID) },
139  { USB_DEVICE(PALM_VENDOR_ID, PALM_TUNGSTEN_T_ID) },
140  { USB_DEVICE(PALM_VENDOR_ID, PALM_TREO_650) },
141  { USB_DEVICE(PALM_VENDOR_ID, PALM_TUNGSTEN_Z_ID) },
142  { USB_DEVICE(PALM_VENDOR_ID, PALM_ZIRE_ID) },
143  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_3_5_ID) },
144  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_4_0_ID) },
145  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_S360_ID) },
146  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_4_1_ID) },
147  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_NX60_ID) },
148  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_NZ90V_ID) },
149  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_UX50_ID) },
150  { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_TJ25_ID) },
151  { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_SCH_I330_ID) },
152  { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_SPH_I500_ID) },
153  { USB_DEVICE(TAPWAVE_VENDOR_ID, TAPWAVE_ZODIAC_ID) },
154  { USB_DEVICE(GARMIN_VENDOR_ID, GARMIN_IQUE_3600_ID) },
155  { USB_DEVICE(ACEECA_VENDOR_ID, ACEECA_MEZ1000_ID) },
156  { USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_7135_ID) },
157  { USB_DEVICE(FOSSIL_VENDOR_ID, FOSSIL_ABACUS_ID) },
158  { } /* Terminating entry */
159 };
160 
161 MODULE_DEVICE_TABLE(usb, id_table_combined);
162 
163 /* All of the device info needed for the Handspring Visor,
164  and Palm 4.0 devices */
165 static struct usb_serial_driver handspring_device = {
166  .driver = {
167  .owner = THIS_MODULE,
168  .name = "visor",
169  },
170  .description = "Handspring Visor / Palm OS",
171  .id_table = id_table,
172  .num_ports = 2,
173  .bulk_out_size = 256,
174  .open = visor_open,
175  .close = visor_close,
176  .throttle = usb_serial_generic_throttle,
177  .unthrottle = usb_serial_generic_unthrottle,
178  .attach = treo_attach,
179  .probe = visor_probe,
180  .calc_num_ports = visor_calc_num_ports,
181  .read_int_callback = visor_read_int_callback,
182 };
183 
184 /* All of the device info needed for the Clie UX50, TH55 Palm 5.0 devices */
185 static struct usb_serial_driver clie_5_device = {
186  .driver = {
187  .owner = THIS_MODULE,
188  .name = "clie_5",
189  },
190  .description = "Sony Clie 5.0",
191  .id_table = clie_id_5_table,
192  .num_ports = 2,
193  .bulk_out_size = 256,
194  .open = visor_open,
195  .close = visor_close,
196  .throttle = usb_serial_generic_throttle,
197  .unthrottle = usb_serial_generic_unthrottle,
198  .attach = clie_5_attach,
199  .probe = visor_probe,
200  .calc_num_ports = visor_calc_num_ports,
201  .read_int_callback = visor_read_int_callback,
202 };
203 
204 /* device info for the Sony Clie OS version 3.5 */
205 static struct usb_serial_driver clie_3_5_device = {
206  .driver = {
207  .owner = THIS_MODULE,
208  .name = "clie_3.5",
209  },
210  .description = "Sony Clie 3.5",
211  .id_table = clie_id_3_5_table,
212  .num_ports = 1,
213  .bulk_out_size = 256,
214  .open = visor_open,
215  .close = visor_close,
216  .throttle = usb_serial_generic_throttle,
217  .unthrottle = usb_serial_generic_unthrottle,
218  .attach = clie_3_5_startup,
219 };
220 
221 static struct usb_serial_driver * const serial_drivers[] = {
222  &handspring_device, &clie_5_device, &clie_3_5_device, NULL
223 };
224 
225 /******************************************************************************
226  * Handspring Visor specific driver functions
227  ******************************************************************************/
228 static int visor_open(struct tty_struct *tty, struct usb_serial_port *port)
229 {
230  int result = 0;
231 
232  if (!port->read_urb) {
233  /* this is needed for some brain dead Sony devices */
234  dev_err(&port->dev, "Device lied about number of ports, please use a lower one.\n");
235  return -ENODEV;
236  }
237 
238  /* Start reading from the device */
239  result = usb_serial_generic_open(tty, port);
240  if (result)
241  goto exit;
242 
243  if (port->interrupt_in_urb) {
244  dev_dbg(&port->dev, "adding interrupt input for treo\n");
245  result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
246  if (result)
247  dev_err(&port->dev,
248  "%s - failed submitting interrupt urb, error %d\n",
249  __func__, result);
250  }
251 exit:
252  return result;
253 }
254 
255 
256 static void visor_close(struct usb_serial_port *port)
257 {
258  unsigned char *transfer_buffer;
259 
260  /* shutdown our urbs */
261  usb_serial_generic_close(port);
262  usb_kill_urb(port->interrupt_in_urb);
263 
264  mutex_lock(&port->serial->disc_mutex);
265  if (!port->serial->disconnected) {
266  /* Try to send shutdown message, unless the device is gone */
267  transfer_buffer = kmalloc(0x12, GFP_KERNEL);
268  if (transfer_buffer) {
269  usb_control_msg(port->serial->dev,
270  usb_rcvctrlpipe(port->serial->dev, 0),
271  VISOR_CLOSE_NOTIFICATION, 0xc2,
272  0x0000, 0x0000,
273  transfer_buffer, 0x12, 300);
274  kfree(transfer_buffer);
275  }
276  }
277  mutex_unlock(&port->serial->disc_mutex);
278 }
279 
280 static void visor_read_int_callback(struct urb *urb)
281 {
282  struct usb_serial_port *port = urb->context;
283  int status = urb->status;
284  int result;
285 
286  switch (status) {
287  case 0:
288  /* success */
289  break;
290  case -ECONNRESET:
291  case -ENOENT:
292  case -ESHUTDOWN:
293  /* this urb is terminated, clean up */
294  dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
295  __func__, status);
296  return;
297  default:
298  dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
299  __func__, status);
300  goto exit;
301  }
302 
303  /*
304  * This information is still unknown what it can be used for.
305  * If anyone has an idea, please let the author know...
306  *
307  * Rumor has it this endpoint is used to notify when data
308  * is ready to be read from the bulk ones.
309  */
310  usb_serial_debug_data(&port->dev, __func__, urb->actual_length,
311  urb->transfer_buffer);
312 
313 exit:
314  result = usb_submit_urb(urb, GFP_ATOMIC);
315  if (result)
316  dev_err(&urb->dev->dev,
317  "%s - Error %d submitting interrupt urb\n",
318  __func__, result);
319 }
320 
321 static int palm_os_3_probe(struct usb_serial *serial,
322  const struct usb_device_id *id)
323 {
324  struct device *dev = &serial->dev->dev;
325  struct visor_connection_info *connection_info;
326  unsigned char *transfer_buffer;
327  char *string;
328  int retval = 0;
329  int i;
330  int num_ports = 0;
331 
332  transfer_buffer = kmalloc(sizeof(*connection_info), GFP_KERNEL);
333  if (!transfer_buffer) {
334  dev_err(dev, "%s - kmalloc(%Zd) failed.\n", __func__,
335  sizeof(*connection_info));
336  return -ENOMEM;
337  }
338 
339  /* send a get connection info request */
340  retval = usb_control_msg(serial->dev,
341  usb_rcvctrlpipe(serial->dev, 0),
342  VISOR_GET_CONNECTION_INFORMATION,
343  0xc2, 0x0000, 0x0000, transfer_buffer,
344  sizeof(*connection_info), 300);
345  if (retval < 0) {
346  dev_err(dev, "%s - error %d getting connection information\n",
347  __func__, retval);
348  goto exit;
349  }
350 
351  if (retval == sizeof(*connection_info)) {
352  connection_info = (struct visor_connection_info *)
353  transfer_buffer;
354 
355  num_ports = le16_to_cpu(connection_info->num_ports);
356  for (i = 0; i < num_ports; ++i) {
357  switch (
358  connection_info->connections[i].port_function_id) {
359  case VISOR_FUNCTION_GENERIC:
360  string = "Generic";
361  break;
362  case VISOR_FUNCTION_DEBUGGER:
363  string = "Debugger";
364  break;
365  case VISOR_FUNCTION_HOTSYNC:
366  string = "HotSync";
367  break;
368  case VISOR_FUNCTION_CONSOLE:
369  string = "Console";
370  break;
371  case VISOR_FUNCTION_REMOTE_FILE_SYS:
372  string = "Remote File System";
373  break;
374  default:
375  string = "unknown";
376  break;
377  }
378  dev_info(dev, "%s: port %d, is for %s use\n",
379  serial->type->description,
380  connection_info->connections[i].port, string);
381  }
382  }
383  /*
384  * Handle devices that report invalid stuff here.
385  */
386  if (num_ports == 0 || num_ports > 2) {
387  dev_warn(dev, "%s: No valid connect info available\n",
388  serial->type->description);
389  num_ports = 2;
390  }
391 
392  dev_info(dev, "%s: Number of ports: %d\n", serial->type->description,
393  num_ports);
394 
395  /*
396  * save off our num_ports info so that we can use it in the
397  * calc_num_ports callback
398  */
399  usb_set_serial_data(serial, (void *)(long)num_ports);
400 
401  /* ask for the number of bytes available, but ignore the
402  response as it is broken */
403  retval = usb_control_msg(serial->dev,
404  usb_rcvctrlpipe(serial->dev, 0),
405  VISOR_REQUEST_BYTES_AVAILABLE,
406  0xc2, 0x0000, 0x0005, transfer_buffer,
407  0x02, 300);
408  if (retval < 0)
409  dev_err(dev, "%s - error %d getting bytes available request\n",
410  __func__, retval);
411  retval = 0;
412 
413 exit:
414  kfree(transfer_buffer);
415 
416  return retval;
417 }
418 
419 static int palm_os_4_probe(struct usb_serial *serial,
420  const struct usb_device_id *id)
421 {
422  struct device *dev = &serial->dev->dev;
423  struct palm_ext_connection_info *connection_info;
424  unsigned char *transfer_buffer;
425  int retval;
426 
427  transfer_buffer = kmalloc(sizeof(*connection_info), GFP_KERNEL);
428  if (!transfer_buffer) {
429  dev_err(dev, "%s - kmalloc(%Zd) failed.\n", __func__,
430  sizeof(*connection_info));
431  return -ENOMEM;
432  }
433 
434  retval = usb_control_msg(serial->dev,
435  usb_rcvctrlpipe(serial->dev, 0),
436  PALM_GET_EXT_CONNECTION_INFORMATION,
437  0xc2, 0x0000, 0x0000, transfer_buffer,
438  sizeof(*connection_info), 300);
439  if (retval < 0)
440  dev_err(dev, "%s - error %d getting connection info\n",
441  __func__, retval);
442  else
443  usb_serial_debug_data(dev, __func__, retval, transfer_buffer);
444 
445  kfree(transfer_buffer);
446  return 0;
447 }
448 
449 
450 static int visor_probe(struct usb_serial *serial,
451  const struct usb_device_id *id)
452 {
453  int retval = 0;
454  int (*startup)(struct usb_serial *serial,
455  const struct usb_device_id *id);
456 
457  /*
458  * some Samsung Android phones in modem mode have the same ID
459  * as SPH-I500, but they are ACM devices, so dont bind to them
460  */
461  if (id->idVendor == SAMSUNG_VENDOR_ID &&
462  id->idProduct == SAMSUNG_SPH_I500_ID &&
463  serial->dev->descriptor.bDeviceClass == USB_CLASS_COMM &&
464  serial->dev->descriptor.bDeviceSubClass ==
465  USB_CDC_SUBCLASS_ACM)
466  return -ENODEV;
467 
468  if (serial->dev->actconfig->desc.bConfigurationValue != 1) {
469  dev_err(&serial->dev->dev, "active config #%d != 1 ??\n",
470  serial->dev->actconfig->desc.bConfigurationValue);
471  return -ENODEV;
472  }
473 
474  if (id->driver_info) {
475  startup = (void *)id->driver_info;
476  retval = startup(serial, id);
477  }
478 
479  return retval;
480 }
481 
482 static int visor_calc_num_ports(struct usb_serial *serial)
483 {
484  int num_ports = (int)(long)(usb_get_serial_data(serial));
485 
486  if (num_ports)
487  usb_set_serial_data(serial, NULL);
488 
489  return num_ports;
490 }
491 
492 static int clie_3_5_startup(struct usb_serial *serial)
493 {
494  struct device *dev = &serial->dev->dev;
495  int result;
496  u8 *data;
497 
498  data = kmalloc(1, GFP_KERNEL);
499  if (!data)
500  return -ENOMEM;
501 
502  /*
503  * Note that PEG-300 series devices expect the following two calls.
504  */
505 
506  /* get the config number */
507  result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
508  USB_REQ_GET_CONFIGURATION, USB_DIR_IN,
509  0, 0, data, 1, 3000);
510  if (result < 0) {
511  dev_err(dev, "%s: get config number failed: %d\n",
512  __func__, result);
513  goto out;
514  }
515  if (result != 1) {
516  dev_err(dev, "%s: get config number bad return length: %d\n",
517  __func__, result);
518  result = -EIO;
519  goto out;
520  }
521 
522  /* get the interface number */
523  result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
524  USB_REQ_GET_INTERFACE,
525  USB_DIR_IN | USB_RECIP_INTERFACE,
526  0, 0, data, 1, 3000);
527  if (result < 0) {
528  dev_err(dev, "%s: get interface number failed: %d\n",
529  __func__, result);
530  goto out;
531  }
532  if (result != 1) {
533  dev_err(dev,
534  "%s: get interface number bad return length: %d\n",
535  __func__, result);
536  result = -EIO;
537  goto out;
538  }
539 
540  result = 0;
541 out:
542  kfree(data);
543 
544  return result;
545 }
546 
547 static int treo_attach(struct usb_serial *serial)
548 {
549  struct usb_serial_port *swap_port;
550 
551  /* Only do this endpoint hack for the Handspring devices with
552  * interrupt in endpoints, which for now are the Treo devices. */
553  if (!((le16_to_cpu(serial->dev->descriptor.idVendor)
554  == HANDSPRING_VENDOR_ID) ||
555  (le16_to_cpu(serial->dev->descriptor.idVendor)
556  == KYOCERA_VENDOR_ID)) ||
557  (serial->num_interrupt_in == 0))
558  return 0;
559 
560  /*
561  * It appears that Treos and Kyoceras want to use the
562  * 1st bulk in endpoint to communicate with the 2nd bulk out endpoint,
563  * so let's swap the 1st and 2nd bulk in and interrupt endpoints.
564  * Note that swapping the bulk out endpoints would break lots of
565  * apps that want to communicate on the second port.
566  */
567 #define COPY_PORT(dest, src) \
568  do { \
569  dest->read_urb = src->read_urb; \
570  dest->bulk_in_endpointAddress = src->bulk_in_endpointAddress;\
571  dest->bulk_in_buffer = src->bulk_in_buffer; \
572  dest->interrupt_in_urb = src->interrupt_in_urb; \
573  dest->interrupt_in_endpointAddress = \
574  src->interrupt_in_endpointAddress;\
575  dest->interrupt_in_buffer = src->interrupt_in_buffer; \
576  } while (0);
577 
578  swap_port = kmalloc(sizeof(*swap_port), GFP_KERNEL);
579  if (!swap_port)
580  return -ENOMEM;
581  COPY_PORT(swap_port, serial->port[0]);
582  COPY_PORT(serial->port[0], serial->port[1]);
583  COPY_PORT(serial->port[1], swap_port);
584  kfree(swap_port);
585 
586  return 0;
587 }
588 
589 static int clie_5_attach(struct usb_serial *serial)
590 {
591  struct usb_serial_port *port;
592  unsigned int pipe;
593  int j;
594 
595  /* TH55 registers 2 ports.
596  Communication in from the UX50/TH55 uses bulk_in_endpointAddress
597  from port 0. Communication out to the UX50/TH55 uses
598  bulk_out_endpointAddress from port 1
599 
600  Lets do a quick and dirty mapping
601  */
602 
603  /* some sanity check */
604  if (serial->num_ports < 2)
605  return -1;
606 
607  /* port 0 now uses the modified endpoint Address */
608  port = serial->port[0];
609  port->bulk_out_endpointAddress =
610  serial->port[1]->bulk_out_endpointAddress;
611 
612  pipe = usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress);
613  for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j)
614  port->write_urbs[j]->pipe = pipe;
615 
616  return 0;
617 }
618 
619 module_usb_serial_driver(serial_drivers, id_table_combined);
620 
621 MODULE_AUTHOR(DRIVER_AUTHOR);
622 MODULE_DESCRIPTION(DRIVER_DESC);
623 MODULE_LICENSE("GPL");
Generated on Thu Jan 10 2013 14:38:34 for Linux Kernel by   doxygen 1.8.2