linux USB虚拟串口驱动在内核3.1以下版本正常，3.9版本使用崩溃

hue2550

最近有个项目的目标板提供USB接口，主机这边通过驱动模块将USB虚拟成了一个串口，在内核3.1以下版本可正常使用，在内核3.9及以上版本使用可以加载成功，但是一旦对ttyVCOM进行读写操作时就系统崩溃了。驱动模块及错误指示如下，求大神指点。
在3.9内核里面tty_io.c中执行tty_init_dev()操作是比之前的3.1版本多出了一个tty->port的操作，请问这个tty->port该在哪里初始化？

1. /*
   
2. * Linux Virtual COM Port Driver for XinCOMM
   
3. */
   
4. 
   
5. #include <linux/kernel.h>
   
6. #include <linux/errno.h>
   
7. #include <linux/init.h>
   
8. #include <linux/module.h>
   
9. #include <linux/usb.h>
   
10. #include <linux/mutex.h>
    
11. #include <linux/spinlock.h>
    
12. #include <linux/slab.h>
    
13. #include <linux/wait.h>
    
14. #include <linux/tty.h>
    
15. #include <linux/tty_driver.h>
    
16. #include <linux/tty_flip.h>
    
17. #include <linux/serial.h>
    
18. #include <asm/uaccess.h>
    
19. #include <asm/byteorder.h>
    
20. #include <asm/unaligned.h>
    
21. 
    
22. 
    
23. 
    
24. #define VID 0x055f
    
25. #define PID 0x017B
    
26. 
    
27. //#define VID 0x046D
    
28. //#define PID 0x0A0C
    
29. 
    
30. #define DRIVER_VERSION "v1.0"
    
31. #define DRIVER_AUTHOR "Zhang"
    
32. #define DRIVER_DESC "Linux Virtual COM Driver For XinComm"
    
33. 
    
34. /* Module information */
    
35. MODULE_AUTHOR( DRIVER_AUTHOR );
    
36. MODULE_DESCRIPTION( DRIVER_DESC );
    
37. MODULE_LICENSE("GPL");
    
38. 
    
39. #define XIN_MAX_SUPPORTED_DEVICES 10
    
40. 
    
41. #define XIN_HID_INTERFACE_NUMBER 1
    
42. #define XIN_HID_EP_NUMBERS 1
    
43. 
    
44. #define XIN_TTY_MAJOR                240
    
45. #define XIN_TTY_MINORS                2
    
46. #define XIN_BUFFER_SIZE    2048
    
47. 
    
48. #define HID_REQ_GET_REPORT                0x01
    
49. #define HID_REQ_SET_REPORT                0x09
    
50. 
    
51. #define OUTPUT_REPORT 0x02
    
52. #define HID_INTERFACE_NUMBER 0x01
    
53. 
    
54. /* Our fake UART values */
    
55. #define MCR_DTR                0x01
    
56. #define MCR_RTS                0x02
    
57. #define MCR_LOOP        0x04
    
58. #define MSR_CTS                0x08
    
59. #define MSR_CD                0x10
    
60. #define MSR_RI                0x20
    
61. #define MSR_DSR                0x40
    
62. 
    
63. typedef unsigned short USHORT;
    
64. typedef unsigned char UCHAR;
    
65. typedef unsigned int UINT;
    
66. 
    
67. typedef struct __USB_HDR
    
68. {
    
69.         USHORT magicNumber; //0x55AA
    
70.         USHORT length;
    
71.         USHORT m_type: 4;
    
72.         USHORT sub_type: 12;
    
73.         UCHAR inOutFlag; // 0: read; 1: write
    
74.         UCHAR reserved;
    
75. }__attribute__((__packed__)) USB_HDR; // pay attention to ALIGNMENT
    
76. 
    
77. #define MAX_BUFFER_SIZE 2048
    
78. #define DATA_BUFFER_SIZE (MAX_BUFFER_SIZE - sizeof(USB_HDR))
    
79. #define MAX_REAL_DATA_SIZE DATA_BUFFER_SIZE
    
80. 
    
81. #define WRITE_PACKET_SIZE 60
    
82. #define READ_PACKET_SIZE (512 - 4)
    
83. 
    
84. //#define WRITE_PACKET_SIZE 60
    
85. //#define READ_PACKET_SIZE (2)
    
86. 
    
87. // for main type
    
88. #define MAIN_TYPE_IP 0
    
89. #define MAIN_TYPE_DEBUG 1
    
90. 
    
91. // for sub type
    
92. #define SUB_TYPE_IP        0
    
93. #define SUB_TYPE_MLOG      1
    
94. #define SUB_TYPE_Trace     2
    
95. #define SUB_TYPE_AtCommand 3
    
96. #define SUB_TYPE_ROM_UPDATE (256)
    
97. 
    
98. #define SUB_TYPE_INVALID   0xFF
    
99. 
    
100. // for in out flag
     
101. #define DIRECTION_READ  0
     
102. #define DIRECTION_WRITE 1
     
103. 
     
104. // for magic number
     
105. #define MAGIC_NUMBER 0x55AA
     
106. 
     
107. 
     
108. 
     
109. typedef struct __USB_BUF
     
110. {
     
111.         USB_HDR Hdr;
     
112.         UCHAR Buffer[DATA_BUFFER_SIZE];
     
113. } __attribute__((__packed__)) USB_BUF;  // pay attention to ALIGNMENT
     
114. 
     
115. 
     
116. struct xin_serial {
     
117.         struct tty_struct        *tty;                /* pointer to the tty for this device */
     
118.         int                        open_count;        /* number of times this port has been opened */
     
119. 
     
120.         /* for tiocmget and tiocmset functions */
     
121.         int                        msr;                /* MSR shadow */
     
122.         int                        mcr;                /* MCR shadow */       
     
123. 
     
124.         void*                   xinhid;
     
125. };
     
126. 
     
127. struct xin_hid {
     
128.         struct usb_device *usbdev;
     
129. 
     
130.         // interrupt in xfer
     
131.         struct urb *irq;
     
132.         char * irq_buf;
     
133.         dma_addr_t irq_dma;
     
134. 
     
135.         // buffer for read hid data
     
136.         USB_BUF read_buffer;
     
137.         int read_buffer_total_length;
     
138.         int read_buffer_index;
     
139. 
     
140.         // buffer for write hid data
     
141.         USB_BUF write_buffer;
     
142.         char* send_buffer;
     
143. 
     
144.         // mutex for this HID device
     
145.         spinlock_t hid_lock;
     
146. 
     
147.         // info for serial
     
148.         struct xin_serial *xin_table[XIN_TTY_MINORS];        /* initially all NULL */       
     
149.         int hid_index; // the index for this HID device
     
150. 
     
151.         // info about USB Port where this device is connected to
     
152.         int xin_minor_index; // ((busnum * 1000) + (level * 100) + (portnum * 10))
     
153.         int busnum;
     
154.         int level;
     
155.         int portnum;       
     
156. };
     
157. 
     
158. static struct tty_driver *xin_tty_driver = NULL;
     
159. static struct xin_hid* hid_device_table[XIN_MAX_SUPPORTED_DEVICES] = {NULL};
     
160. static DEFINE_MUTEX(global_mutex);
     
161. 
     
162. /********************
     
163. ttyVCOM0: AT command
     
164. ttyVCOM1:
     
165. 
     
166. 
     
167. *********************/
     
168. 
     
169. static int xin_get_subtype_by_tty(struct xin_hid* xinhid, struct xin_serial *xin)
     
170. {
     
171.         int i = 0;
     
172.         int subtype = SUB_TYPE_INVALID;
     
173. 
     
174.         if(xinhid == NULL)
     
175.         {
     
176.                 return SUB_TYPE_INVALID;
     
177.         }
     
178. 
     
179.         for(i = 0; i < XIN_TTY_MINORS; i++)
     
180.         {
     
181.                 if(xin == xinhid->xin_table[i])
     
182.                 {
     
183.                     break;
     
184.                 }
     
185.         }
     
186. 
     
187.         if(i == XIN_TTY_MINORS)
     
188.         {
     
189.                 return SUB_TYPE_INVALID;
     
190.         }
     
191. 
     
192.         if(i == 0)
     
193.         {
     
194.                 subtype = SUB_TYPE_AtCommand;
     
195.         }
     
196.         else if(i == 1)
     
197.         {
     
198.                 subtype = SUB_TYPE_ROM_UPDATE;
     
199.         }
     
200.        
     
201. 
     
202.         return subtype;
     
203. }
     
204. 
     
205. static struct tty_struct *xin_get_tty_by_subtype(struct xin_hid* xinhid, int subtype)
     
206. {
     
207.         struct tty_struct *tty = NULL;
     
208.         struct xin_serial * serial = NULL;
     
209. 
     
210.         if(xinhid == NULL)
     
211.         {
     
212.                 return NULL;
     
213.         }
     
214. 
     
215.         if(subtype == SUB_TYPE_AtCommand)
     
216.         {
     
217.                 serial = xinhid->xin_table[0];
     
218.         }
     
219.         else if(subtype == SUB_TYPE_ROM_UPDATE)
     
220.         {
     
221.                 serial = xinhid->xin_table[1];
     
222.         }
     
223.        
     
224.         if(!serial)
     
225.         {               
     
226.                 //printk(KERN_ERR "[%s] destination VCOM does not exist", __FUNCTION__);
     
227.                 goto exit;
     
228.         }
     
229. 
     
230.         if (!serial->open_count)
     
231.         {
     
232.                 printk("[%s] no destination ttyVCOM is not opened", __FUNCTION__);
     
233.                 tty = NULL;
     
234.                 /* port was not opened */
     
235.                 goto exit;
     
236.         }
     
237. 
     
238.         tty = serial->tty;
     
239. 
     
240. exit:
     
241.         return tty;
     
242. }
     
243. 
     
244. static int xin_open(struct tty_struct *tty, struct file *file)
     
245. {
     
246.         struct xin_serial *xin = NULL;
     
247.         int index = 0;
     
248.         int ttyindex = 0;
     
249.         int result = 0;
     
250.         struct xin_hid * xinhid = NULL;
     
251.         int hid_index = XIN_MAX_SUPPORTED_DEVICES;
     
252.         int xin_minor_index = 0;
     
253.         int i = 0;
     
254. 
     
255.         /* initialize the pointer in case something fails */
     
256.         tty->driver_data = NULL;
     
257. 
     
258.         /* get the serial object associated with this tty pointer */
     
259.         ttyindex = tty->index;
     
260.         printk("[%s] open ttyVCOM%d", __FUNCTION__, ttyindex);
     
261. 
     
262.         // get the hid index and serial index from the ttyindex
     
263.         xin_minor_index = ttyindex / 10;
     
264.         xin_minor_index = 10 * xin_minor_index;
     
265.         printk("[%s] the xin minor index for this tty is: %d", __FUNCTION__, xin_minor_index);       
     
266. 
     
267.         for(i = 0; i < XIN_MAX_SUPPORTED_DEVICES; i++)
     
268.         {
     
269.                 if((hid_device_table[i] != NULL) && (hid_device_table[i]->xin_minor_index == xin_minor_index))
     
270.                 {
     
271.                         hid_index = i;
     
272.                         break;
     
273.                 }
     
274.         }
     
275. 
     
276.         if(hid_index >= XIN_MAX_SUPPORTED_DEVICES)
     
277.         {
     
278.                 printk("[%s] open ttyVCOM%d failed because the HID device cannot be found!!!", __FUNCTION__, ttyindex);
     
279.                 return -ENODEV;
     
280.         }
     
281.        
     
282.         xinhid = hid_device_table[hid_index];
     
283.         if(xinhid == NULL)
     
284.         {
     
285.                 printk("[%s] open ttyVCOM%d failed because the hid device is not connected!!!", __FUNCTION__, ttyindex);
     
286.                 return -ENODEV;
     
287.         }
     
288. 
     
289.         index = ttyindex - xin_minor_index;
     
290.         if(index >= XIN_TTY_MINORS)
     
291.         {
     
292.                 printk("[%s] open ttyVCOM%d failed because of incorrect index, index = %d", __FUNCTION__, ttyindex, index);
     
293.                 return -ENODEV;               
     
294.         }
     
295. 
     
296.         // open the deivce
     
297.         spin_lock(&xinhid->hid_lock);
     
298.        
     
299.         xin = xinhid->xin_table[index];
     
300.         if (xin == NULL) {
     
301.                 printk("[%s] the first time to open ttyVCOM%d", __FUNCTION__, ttyindex );
     
302.                 /* first time accessing this device, let's create it */
     
303.                 xin = kmalloc(sizeof(*xin), GFP_KERNEL);
     
304.                 if (!xin)
     
305.                 {
     
306.                     printk("[%s] failed to allocate memory for ttyVCOM%d", __FUNCTION__ ,ttyindex);
     
307.                         result = -ENOMEM;
     
308.                         goto Exit;
     
309.                 }
     
310. 
     
311.                 xin->open_count = 0;
     
312.                 xin->xinhid = (void*)xinhid;
     
313.                 xinhid->xin_table[index] = xin;
     
314.                 xin->msr = (MSR_CD | MSR_DSR | MSR_CTS);
     
315.         }
     
316. 
     
317.         /* save our structure within the tty structure */
     
318.         tty->driver_data = xin;
     
319.         xin->tty = tty;
     
320.         ++xin->open_count;
     
321.         //tty_wakeup(tty);
     
322.         printk("[%s] open ttyVCOM%d OK, count = %d", __FUNCTION__, ttyindex, xin->open_count);
     
323. 
     
324. Exit:
     
325.         spin_unlock(&xinhid->hid_lock);
     
326.         return result;
     
327. }
     
328. 
     
329. static void do_close(struct xin_serial *xin)
     
330. {
     
331.         // the lock will be used in the function who call this function
     
332.         // so no any protection in this function
     
333. 
     
334.         if (!xin->open_count) {
     
335.                 /* port was never opened */
     
336.                 return;
     
337.         }
     
338. 
     
339.         --xin->open_count;
     
340. }
     
341. 
     
342. static void xin_close(struct tty_struct *tty, struct file *file)
     
343. {
     
344.         struct xin_serial *xin = NULL;
     
345.         //struct xin_hid* xinhid = NULL; // we should not handle xinhid here. Evevything will be done when disconnect!
     
346. 
     
347.         if(tty == NULL)
     
348.         {
     
349.                 printk("[%s] wrong parameter because tty is NULL !!!", __FUNCTION__);
     
350.                 return;
     
351.         }
     
352. 
     
353.         printk("[%s] close ttyVCOM%d", __FUNCTION__, tty->index);
     
354. 
     
355.         xin = tty->driver_data;
     
356.         if(xin == NULL)
     
357.         {
     
358.                 printk("[%s] tty->driver_data is NULL!!!", __FUNCTION__);
     
359.                 return;
     
360.         }
     
361. 
     
362.         if (xin)
     
363.         {
     
364.                 do_close(xin);
     
365.         }
     
366. }       
     
367. 
     
368. 
     
369. static int xin_write(struct tty_struct *tty,
     
370.                       const unsigned char *buffer, int count)
     
371. {
     
372.         struct xin_serial *xin = tty->driver_data;
     
373.         struct xin_hid* xinhid = NULL;
     
374.         int subtype = SUB_TYPE_INVALID;
     
375.         int retval = -EINVAL;
     
376.         int copylength = 0;
     
377.         int copy_index = 0;
     
378.         char* startptr = NULL;
     
379. 
     
380.         printk("[%s] ttyVCOM%d write %d bytes", __FUNCTION__, tty->index, count);
     
381. 
     
382.         if (!xin)
     
383.         {       
     
384.                 printk("[%s] ttyVCOM%d doesnot exist", __FUNCTION__, tty->index);
     
385.                 retval = -ENODEV;
     
386.                 return retval;
     
387.         }
     
388. 
     
389.         if(!count)
     
390.         {
     
391.                 printk("[%s] data length is ZERO, so shortcut!", __FUNCTION__);
     
392.                     retval = 0;
     
393.                 return retval;               
     
394.         }
     
395. 
     
396.         xinhid = (struct xin_hid*)xin->xinhid;
     
397.         if(xinhid == NULL)
     
398.         {
     
399.                 printk("[%s] xin hid device is not connected", __FUNCTION__);       
     
400.                 retval = -ENODEV;
     
401.                 return retval;
     
402.         }
     
403. 
     
404.         spin_lock(&xinhid->hid_lock);
     
405. 
     
406.         if (!xin->open_count)
     
407.         {
     
408.                 printk("[%s] ttyVCOM%d is not opened", __FUNCTION__, tty->index);
     
409.                 /* port was not opened */
     
410.                 goto exit;
     
411.         }
     
412. 
     
413.         subtype = xin_get_subtype_by_tty(xinhid, xin);
     
414.         if(subtype == SUB_TYPE_INVALID)
     
415.         {
     
416.                 printk("[%s] cannot get subtype for ttyVCOM%d", __FUNCTION__, tty->index);
     
417.                 goto exit;
     
418.         }
     
419.        
     
420.         printk("[%s] send data from ttyVCOM%d to hid device- ", __FUNCTION__, tty->index);
     
421. 
     
422.         copylength = count > MAX_REAL_DATA_SIZE ? MAX_REAL_DATA_SIZE : count;
     
423.         memset(&xinhid->write_buffer, 0, sizeof(USB_BUF));
     
424.         memcpy(&xinhid->write_buffer.Buffer[0], buffer, copylength);
     
425.         xinhid->write_buffer.Hdr.magicNumber = MAGIC_NUMBER;
     
426.         xinhid->write_buffer.Hdr.length = sizeof(USB_HDR) + copylength;
     
427.         xinhid->write_buffer.Hdr.m_type = MAIN_TYPE_DEBUG;
     
428.             xinhid->write_buffer.Hdr.inOutFlag = DIRECTION_WRITE;
     
429.         xinhid->write_buffer.Hdr.sub_type = subtype;
     
430. 
     
431.         copylength = 0;
     
432.         copy_index = 0;
     
433.         while(1)
     
434.         {
     
435.                 if(xinhid->write_buffer.Hdr.length - copy_index >= WRITE_PACKET_SIZE)
     
436.                 {
     
437.                         copylength = WRITE_PACKET_SIZE;
     
438.                 }
     
439.                 else
     
440.                 {
     
441.                     copylength = xinhid->write_buffer.Hdr.length - copy_index;
     
442.                 }
     
443.                 startptr = ((char*)(&xinhid->write_buffer)) + copy_index;
     
444.                 memset(xinhid->send_buffer, 0, WRITE_PACKET_SIZE);
     
445.                 memcpy(xinhid->send_buffer, startptr, copylength);               
     
446.             retval = usb_control_msg(xinhid->usbdev, usb_sndctrlpipe(xinhid->usbdev, 0),
     
447.                                 HID_REQ_SET_REPORT,
     
448.                                 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
     
449.                                 (OUTPUT_REPORT << 8) | 0,
     
450.                                 HID_INTERFACE_NUMBER, xinhid->send_buffer, WRITE_PACKET_SIZE,
     
451.                                 USB_CTRL_SET_TIMEOUT);
     
452.                 if(retval < 0)
     
453.                 {
     
454.                         printk("[%s] failed to write to HID device!, result = %d\n",__FUNCTION__, retval);
     
455.                         goto exit;
     
456.                 }
     
457.             
     
458.                 if(retval < WRITE_PACKET_SIZE)
     
459.                 {
     
460.                     printk("[%s] failed to write to HID device!, result = %d != %d\n", __FUNCTION__, retval, copylength);
     
461.                 }
     
462.                 copy_index += copylength;
     
463. 
     
464.                 if(copy_index >= xinhid->write_buffer.Hdr.length)
     
465.                 {
     
466.                     printk("[%s] write complete!\n", __FUNCTION__);
     
467.                         break;
     
468.                 }
     
469.         }
     
470.        
     
471.         retval = count;
     
472.                
     
473. exit:
     
474.         spin_unlock(&xinhid->hid_lock);
     
475.         return retval;
     
476. }
     
477. 
     
478. static int xin_write_room(struct tty_struct *tty)
     
479. {
     
480.         struct xin_serial *xin = tty->driver_data;
     
481.         int room = -EINVAL;
     
482.         struct xin_hid *xinhid = NULL;
     
483. 
     
484.         if (!xin)
     
485.                 return -ENODEV;
     
486. 
     
487.         xinhid = (struct xin_hid*)xin->xinhid;
     
488.         if (!xinhid)
     
489.                 return -ENODEV;       
     
490. 
     
491.         spin_lock(&xinhid->hid_lock);
     
492.        
     
493.         if (!xin->open_count) {
     
494.                 /* port was not opened */
     
495.                 goto exit;
     
496.         }
     
497. 
     
498.         /* calculate how much room is left in the device */
     
499.         room = XIN_BUFFER_SIZE;
     
500. 
     
501. exit:
     
502.         spin_unlock(&xinhid->hid_lock);
     
503.         return room;
     
504. }
     
505. 
     
506. #define RELEVANT_IFLAG(iflag) ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
     
507. 
     
508. static void xin_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
     
509. {
     
510.         unsigned int cflag;
     
511. 
     
512.         cflag = tty->termios.c_cflag;
     
513. 
     
514.         /* check that they really want us to change something */
     
515.         if (old_termios) {
     
516.                 if ((cflag == old_termios->c_cflag) &&
     
517.                     (RELEVANT_IFLAG(tty->termios.c_iflag) ==
     
518.                      RELEVANT_IFLAG(old_termios->c_iflag))) {
     
519.                         printk(" - nothing to change...\n");
     
520.                         return;
     
521.                 }
     
522.         }
     
523. 
     
524.         /* get the byte size */
     
525.         switch (cflag & CSIZE) {
     
526.                 case CS5:
     
527.                         printk(" - data bits = 5\n");
     
528.                         break;
     
529.                 case CS6:
     
530.                         printk(" - data bits = 6\n");
     
531.                         break;
     
532.                 case CS7:
     
533.                         printk(" - data bits = 7\n");
     
534.                         break;
     
535.                 default:
     
536.                 case CS8:
     
537.                         printk(" - data bits = 8\n");
     
538.                         break;
     
539.         }
     
540.        
     
541.         /* determine the parity */
     
542.         if (cflag & PARENB)
     
543.                 if (cflag & PARODD)
     
544.                         printk(" - parity = odd\n");
     
545.                 else
     
546.                         printk(" - parity = even\n");
     
547.         else
     
548.                 printk(" - parity = none\n");
     
549. 
     
550.         /* figure out the stop bits requested */
     
551.         if (cflag & CSTOPB)
     
552.                 printk(" - stop bits = 2\n");
     
553.         else
     
554.                 printk(" - stop bits = 1\n");
     
555. 
     
556.         /* figure out the hardware flow control settings */
     
557.         if (cflag & CRTSCTS)
     
558.                 printk(" - RTS/CTS is enabled\n");
     
559.         else
     
560.                 printk(" - RTS/CTS is disabled\n");
     
561.        
     
562.         /* determine software flow control */
     
563.         /* if we are implementing XON/XOFF, set the start and
     
564.          * stop character in the device */
     
565.         if (I_IXOFF(tty) || I_IXON(tty)) {
     
566.                 unsigned char stop_char  = STOP_CHAR(tty);
     
567.                 unsigned char start_char = START_CHAR(tty);
     
568. 
     
569.                 /* if we are implementing INBOUND XON/XOFF */
     
570.                 if (I_IXOFF(tty))
     
571.                         printk(" - INBOUND XON/XOFF is enabled, "
     
572.                                 "XON = %2x, XOFF = %2x", start_char, stop_char);
     
573.                 else
     
574.                         printk(" - INBOUND XON/XOFF is disabled");
     
575. 
     
576.                 /* if we are implementing OUTBOUND XON/XOFF */
     
577.                 if (I_IXON(tty))
     
578.                         printk(" - OUTBOUND XON/XOFF is enabled, "
     
579.                                 "XON = %2x, XOFF = %2x", start_char, stop_char);
     
580.                 else
     
581.                         printk(" - OUTBOUND XON/XOFF is disabled");
     
582.         }
     
583. 
     
584.         /* get the baud rate wanted */
     
585.         printk(" - baud rate = %d", tty_get_baud_rate(tty));
     
586. }
     
587. 
     
588. 
     
589. static int xin_tiocmget(struct tty_struct *tty)
     
590. {
     
591.         struct xin_serial *xin = tty->driver_data;
     
592. 
     
593.         unsigned int result = 0;
     
594.         unsigned int msr = xin->msr;
     
595.         unsigned int mcr = xin->mcr;
     
596. 
     
597.         result = ((mcr & MCR_DTR)  ? TIOCM_DTR  : 0) |        /* DTR is set */
     
598.              ((mcr & MCR_RTS)  ? TIOCM_RTS  : 0) |        /* RTS is set */
     
599.              ((mcr & MCR_LOOP) ? TIOCM_LOOP : 0) |        /* LOOP is set */
     
600.              ((msr & MSR_CTS)  ? TIOCM_CTS  : 0) |        /* CTS is set */
     
601.              ((msr & MSR_CD)   ? TIOCM_CAR  : 0) |        /* Carrier detect is set*/
     
602.              ((msr & MSR_RI)   ? TIOCM_RI   : 0) |        /* Ring Indicator is set */
     
603.              ((msr & MSR_DSR)  ? TIOCM_DSR  : 0);        /* DSR is set */
     
604. 
     
605.         return result;
     
606. }
     
607. 
     
608. static int xin_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear)
     
609. {
     
610.         struct xin_serial *xin = tty->driver_data;
     
611.         unsigned int mcr = xin->mcr;
     
612. 
     
613.         if (set & TIOCM_RTS)
     
614.                 mcr |= MCR_RTS;
     
615.         if (set & TIOCM_DTR)
     
616.                 mcr |= MCR_RTS;
     
617. 
     
618.         if (clear & TIOCM_RTS)
     
619.                 mcr &= ~MCR_RTS;
     
620.         if (clear & TIOCM_DTR)
     
621.                 mcr &= ~MCR_RTS;
     
622. 
     
623.         /* set the new MCR value in the device */
     
624.         xin->mcr = mcr;
     
625.         return 0;
     
626. }
     
627. 
     
628. static int xin_hid_alloc_mem(struct usb_device *dev, struct xin_hid *xinhid)
     
629. {
     
630.         if (!(xinhid->irq = usb_alloc_urb(0, GFP_KERNEL)))
     
631.                 return -1;
     
632. 
     
633.         //if (!(xinhid->irq_buf = usb_buffer_alloc(dev, READ_PACKET_SIZE, GFP_ATOMIC, &xinhid->irq_dma)))
     
634.         if (!(xinhid->irq_buf = usb_alloc_coherent(dev, READ_PACKET_SIZE, GFP_KERNEL, &xinhid->irq_dma)))
     
635.                 return -1;
     
636. 
     
637.         if (!(xinhid->send_buffer = kmalloc(WRITE_PACKET_SIZE, GFP_KERNEL)))
     
638.                 return -1;       
     
639. 
     
640.         return 0;
     
641. }
     
642. 
     
643. static void xin_hid_free_mem(struct usb_device *dev, struct xin_hid *xinhid)
     
644. {
     
645.         usb_free_urb(xinhid->irq);
     
646.         //usb_free_coherent(dev, READ_PACKET_SIZE, xinhid->irq_buf, xinhid->irq_dma);
     
647.         usb_free_coherent(dev, READ_PACKET_SIZE, xinhid->irq_buf, xinhid->irq_dma);
     
648.         kfree(xinhid->send_buffer);
     
649. }
     
650. 
     
651. 
     
652. static void xin_irq(struct urb *urb)
     
653. {
     
654.         struct xin_hid *xinhid = urb->context;
     
655.         int i;
     
656.         int datalength = 0;
     
657.         int copylength = 0;
     
658.         char* startptr = NULL;
     
659.        
     
660.         struct tty_struct *tty = NULL;
     
661.         int subtype = SUB_TYPE_INVALID;
     
662. 
     
663.         if(xinhid == NULL)
     
664.         {
     
665.             printk("[%s] xinhid is NULL\n", __FUNCTION__);
     
666.                 return;
     
667.         }
     
668. 
     
669.         switch (urb->status) {
     
670.         case 0:                        /* success */
     
671.                 break;
     
672.         case -ECONNRESET:        /* unlink */
     
673.         case -ENOENT:
     
674.         case -ESHUTDOWN:
     
675.                 printk("[%s] irq complete error in place 1, status: %d\n", __FUNCTION__, urb->status);
     
676.                 return;
     
677.         /* -EPIPE:  should clear the halt */
     
678.         default:                /* error */
     
679.                 printk("[%s] irq complete error in place 2, status: %d\n", __FUNCTION__, urb->status);
     
680.                 goto resubmit;
     
681.         }
     
682. 
     
683.         //
     
684.         datalength = urb->actual_length;
     
685.         //printk(KERN_ERR "[%s] get %d bytes from xin100 hid device\n", __FUNCTION__, datalength);
     
686.         if(xinhid->read_buffer_total_length == 0)
     
687.         {
     
688.                 copylength = datalength;
     
689.         }
     
690.         else if( datalength + xinhid->read_buffer_index >= xinhid->read_buffer_total_length)
     
691.         {
     
692.                 copylength = xinhid->read_buffer_total_length - xinhid->read_buffer_index;
     
693.         }
     
694.         else
     
695.         {
     
696.                 copylength = datalength;
     
697.         }
     
698. 
     
699.         startptr = ((char*)&xinhid->read_buffer) + xinhid->read_buffer_index;
     
700.         memcpy(startptr, urb->transfer_buffer, copylength);
     
701.         if(xinhid->read_buffer_total_length == 0)
     
702.         {
     
703.             xinhid->read_buffer_total_length = xinhid->read_buffer.Hdr.length;
     
704.                 if(xinhid->read_buffer_total_length > MAX_BUFFER_SIZE)
     
705.                 {
     
706.                         //device should not send much messages but AT responses.
     
707.                         /*printk(KERN_ERR "[%s] wrong length %d in header (should <= 2048 )\n", __FUNCTION__, xinhid->read_buffer_total_length);*/
     
708.                         xinhid->read_buffer_total_length = MAX_BUFFER_SIZE;
     
709.                 }
     
710.         }
     
711.         xinhid->read_buffer_index += copylength;
     
712. 
     
713.         if(xinhid->read_buffer_index >= xinhid->read_buffer_total_length)
     
714.         {
     
715.             // get the whole data
     
716.             //printk(KERN_ERR "[%s] get whole %d bytes from xin100 hid device\n", __FUNCTION__, xinhid->read_buffer_total_length);
     
717. 
     
718.                 // send the data to tty com port
     
719.         if(xinhid->read_buffer.Hdr.magicNumber != MAGIC_NUMBER)
     
720.         {
     
721.                         printk("[%s] wrong magic number: 0x%04x (should 0x55AA)\n", __FUNCTION__, xinhid->read_buffer.Hdr.magicNumber);
     
722.                 goto cleanbuffer;
     
723.         }
     
724. 
     
725.                 if(xinhid->read_buffer.Hdr.m_type != MAIN_TYPE_DEBUG)
     
726.                 {
     
727.                         printk("[%s] wrong major type\n", __FUNCTION__);
     
728.                         goto cleanbuffer;
     
729.                 }
     
730. 
     
731.                 subtype = xinhid->read_buffer.Hdr.sub_type;
     
732.                 tty = xin_get_tty_by_subtype(xinhid, subtype);
     
733.                 if(tty != NULL)
     
734.                 {
     
735.                         tty_insert_flip_string(tty->port, &xinhid->read_buffer.Buffer[0], xinhid->read_buffer_total_length - sizeof(USB_HDR));
     
736.                         tty_flip_buffer_push(tty->port);
     
737.                 }
     
738.                 else
     
739.                 {
     
740.                         //printk(KERN_ERR "[%s] no available tty for the received data\n", __FUNCTION__);
     
741.                         goto cleanbuffer;
     
742.                 }
     
743.                
     
744. cleanbuffer:
     
745.                 memset(&xinhid->read_buffer, 0, sizeof(USB_BUF));
     
746.                 xinhid->read_buffer_index = 0;
     
747.                 xinhid->read_buffer_total_length = 0;               
     
748.         }
     
749. 
     
750. resubmit:
     
751.         i = usb_submit_urb (urb, GFP_ATOMIC);
     
752.         if (i)
     
753.                 printk("[%s] can't resubmit intr, status %d", __FUNCTION__, i);
     
754. }
     
755. 
     
756. 
     
757. static int xin_probe(struct usb_interface *iface,
     
758.                          const struct usb_device_id *id)
     
759. {
     
760.         struct usb_device *dev = NULL;
     
761.         struct usb_host_interface *interface = NULL;
     
762.         struct usb_endpoint_descriptor *endpoint = NULL;
     
763.         struct xin_hid *xinhid = NULL;
     
764.         int pipe = 0, maxp = 0;
     
765.         int error = -ENOMEM;
     
766.         int i = 0;
     
767.         int hid_index = XIN_MAX_SUPPORTED_DEVICES;
     
768. 
     
769.         printk("[%s] xin_probe start...\n", __FUNCTION__);
     
770. 
     
771.         if(iface == NULL)
     
772.         {
     
773.                 printk("[%s] iface is NULL\n", __FUNCTION__);
     
774.                 return -ENODEV;
     
775.         }
     
776. 
     
777.         dev = interface_to_usbdev(iface);
     
778. 
     
779.         interface = iface->cur_altsetting;
     
780.         if ((interface->desc.bInterfaceNumber != XIN_HID_INTERFACE_NUMBER) || (interface->desc.bNumEndpoints != XIN_HID_EP_NUMBERS))
     
781.         {
     
782.                 printk("[%s] Not HID Interface, because bInterfaceNumber or bNumEndpoints are wrong!\n", __FUNCTION__);
     
783.                 return -ENODEV;
     
784.         }
     
785. 
     
786.         endpoint = &interface->endpoint[0].desc;
     
787.         if (!usb_endpoint_is_int_in(endpoint))
     
788.         {
     
789.                 printk("[%s] endpoint type for HID interface is wrong! (should be interrupt in)!\n", __FUNCTION__);
     
790.                 return -ENODEV;
     
791.         }
     
792. 
     
793.         pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
     
794.         maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
     
795. 
     
796.         xinhid = kzalloc(sizeof(struct xin_hid), GFP_KERNEL);
     
797.         if (!xinhid)
     
798.         {
     
799.                 printk("[%s] failed to allocate memory for struct xinhid!\n", __FUNCTION__);
     
800.                 goto fail1;
     
801.         }
     
802. 
     
803.         if (xin_hid_alloc_mem(dev, xinhid))
     
804.         {
     
805.                 printk("[%s] failed to allocate memory for urb and buffer!\n", __FUNCTION__);
     
806.                 goto fail2;
     
807.         }
     
808.        
     
809.         spin_lock_init(&xinhid->hid_lock);
     
810. 
     
811.         xinhid->read_buffer_total_length = 0;
     
812.         xinhid->read_buffer_index = 0;
     
813.        
     
814.         xinhid->usbdev = dev;
     
815. 
     
816.         xinhid->busnum = dev->bus->busnum;
     
817.         xinhid->level = dev->level;
     
818.         xinhid->portnum = dev->portnum;
     
819. 
     
820.         xinhid->xin_minor_index = (xinhid->busnum * 1000) + (xinhid->level * 100) + (xinhid->portnum * 10);
     
821. 
     
822.         printk("[%s] xin_minor_index: %d, busnum: %d, level: %d, portnum: %d", __FUNCTION__, xinhid->xin_minor_index, xinhid->busnum, xinhid->level, xinhid->portnum);
     
823. 
     
824.         // find the available serial index for this hid device
     
825.         mutex_lock(&global_mutex);
     
826.         for(i = 0; i < XIN_MAX_SUPPORTED_DEVICES; i++)
     
827.         {
     
828.                 if(hid_device_table[i] == NULL)
     
829.                 {
     
830.                         hid_index = i;                       
     
831.                         break;
     
832.                 }
     
833.         }
     
834. 
     
835.         if(hid_index >= XIN_MAX_SUPPORTED_DEVICES)
     
836.         {
     
837.                 printk("[%s] too many devices are inserted!!!", __FUNCTION__);
     
838.                 mutex_unlock(&global_mutex);
     
839.                 goto fail2;
     
840.         }
     
841. 
     
842.         xinhid->hid_index = hid_index;
     
843.         hid_device_table[hid_index] = xinhid;
     
844. 
     
845.         for (i = 0; i < XIN_TTY_MINORS; i++)
     
846.         {
     
847.                 printk("[%s] register ttyVCOM%d\n", __FUNCTION__, xinhid->xin_minor_index + i);
     
848.                 tty_register_device(xin_tty_driver, xinhid->xin_minor_index + i, NULL);
     
849.         }
     
850. 
     
851.                mutex_unlock(&global_mutex);
     
852. 
     
853.         // init the interrupt in urb and submit the first urb
     
854. 
     
855.         usb_fill_int_urb(xinhid->irq, dev, pipe,
     
856.                          xinhid->irq_buf, (maxp > 1024 ? 1024 : maxp),
     
857.                          xin_irq, xinhid, endpoint->bInterval);
     
858.         xinhid->irq->transfer_dma = xinhid->irq_dma;
     
859.         xinhid->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
     
860. 
     
861.         if (usb_submit_urb(xinhid->irq, GFP_ATOMIC))
     
862.         {
     
863.                 error = -EIO;               
     
864.                 printk("[%s] failed to submit interrupt in urb!\n", __FUNCTION__);
     
865.                 goto fail3;
     
866.         }
     
867. 
     
868.         usb_set_intfdata(iface, xinhid);
     
869. 
     
870.         printk("[%s] xin_probe success!\n", __FUNCTION__);
     
871.        
     
872.         return 0;
     
873. 
     
874. fail3:
     
875.         mutex_lock(&global_mutex);
     
876.         for (i = 0; i < XIN_TTY_MINORS; ++i)
     
877.         {
     
878.                 tty_unregister_device(xin_tty_driver, xinhid->xin_minor_index + i);
     
879.         }       
     
880.         hid_device_table[xinhid->hid_index] = NULL;
     
881.         mutex_unlock(&global_mutex);       
     
882. 
     
883. fail2:       
     
884.         xin_hid_free_mem(dev, xinhid);
     
885. fail1:       
     
886.         kfree(xinhid);
     
887.         return error;
     
888. }
     
889. 
     
890. static void xin_disconnect(struct usb_interface *intf)
     
891. {
     
892.         struct xin_hid *xinhid = usb_get_intfdata (intf);
     
893.         int i = 0;
     
894.         struct xin_serial *xin = NULL;
     
895.         int hid_index = 0;
     
896. 
     
897.         printk("[%s] xin_disconnect\n", __FUNCTION__);
     
898. 
     
899.         if(xinhid == NULL)
     
900.         {
     
901.                 printk("[%s] no available hid device in disconnect!!!\n", __FUNCTION__);
     
902.                 return;
     
903.         }
     
904. 
     
905.         hid_index = xinhid->hid_index;
     
906. 
     
907.         printk("[%s] before unregister VCOM device\n", __FUNCTION__);
     
908. 
     
909.         mutex_lock(&global_mutex);
     
910.         for (i = 0; i < XIN_TTY_MINORS; ++i)
     
911.         {
     
912.                 printk("[%s] unregister ttyVCOM%d device\n", __FUNCTION__, xinhid->xin_minor_index + i);
     
913.                 tty_unregister_device(xin_tty_driver, xinhid->xin_minor_index + i);
     
914.         }
     
915.         hid_device_table[hid_index] = NULL;
     
916.         mutex_unlock(&global_mutex);
     
917. 
     
918.         printk("[%s] shut down hid device\n", __FUNCTION__);
     
919. 
     
920.         spin_lock(&xinhid->hid_lock);
     
921. 
     
922.         /* shut down all serial device and free the memory */
     
923.         for (i = 0; i < XIN_TTY_MINORS; ++i) {
     
924.                 xin = xinhid->xin_table[i];
     
925.                 if (xin) {
     
926.                         /* close the port */
     
927.                         while (xin->open_count)
     
928.                                 do_close(xin);
     
929. 
     
930.                         /* free the memory */
     
931.                         kfree(xin);
     
932.                         xinhid->xin_table[i] = NULL;
     
933.                 }
     
934.         }       
     
935. 
     
936.         usb_set_intfdata(intf, NULL);
     
937.         usb_kill_urb(xinhid->irq);
     
938.         xin_hid_free_mem(interface_to_usbdev(intf), xinhid);
     
939. 
     
940.         spin_unlock(&xinhid->hid_lock);
     
941. 
     
942.         kfree(xinhid);
     
943. 
     
944.         xinhid = NULL;
     
945.        
     
946.         printk(KERN_ERR "[%s] xin_disconnect success\n", __FUNCTION__);
     
947. }
     
948. 
     
949. static struct tty_operations serial_ops = {
     
950.         .open = xin_open,
     
951.         .close = xin_close,
     
952.         .write = xin_write,
     
953.         .write_room = xin_write_room,
     
954.         .set_termios = xin_set_termios,
     
955.         .tiocmget =        xin_tiocmget,       
     
956.         .tiocmset =        xin_tiocmset,
     
957. };
     
958. 
     
959. static const struct usb_device_id        products [] = {
     
960. 
     
961. #define        XIN100_HID_INTERFACE \
     
962.         .bInterfaceClass        = 0xff, \
     
963.         .bInterfaceSubClass        = 0xff, \
     
964.         .bInterfaceProtocol        = 0xff
     
965. 
     
966. /*
     
967. * Xin100 USB HID uses just one USB interface.
     
968. */
     
969. {
     
970.         .match_flags        =   USB_DEVICE_ID_MATCH_INT_INFO
     
971.                           | USB_DEVICE_ID_MATCH_DEVICE,
     
972.         .idVendor                = VID,
     
973.         .idProduct                = PID,
     
974.         XIN100_HID_INTERFACE
     
975. },{ },                // END
     
976. };
     
977. MODULE_DEVICE_TABLE(usb, products);
     
978. 
     
979. static struct usb_driver xin_hid_driver = {
     
980.         .name =                "ttyxin",
     
981.         .id_table =        products,
     
982.         .probe =        xin_probe,
     
983.         .disconnect =        xin_disconnect,
     
984. };
     
985. static int __init xin_init(void)
     
986. {
     
987.         int retval;
     
988.         int i = 0;
     
989.         int max_tty_index = 0;
     
990. 
     
991.         printk("[%s] init ttyxin driver", __FUNCTION__);
     
992. 
     
993.         for(i = 0; i < XIN_MAX_SUPPORTED_DEVICES; i++)
     
994.         {
     
995.                 hid_device_table[i] = NULL;
     
996.         }
     
997. 
     
998.         /* allocate the tty driver */
     
999.         max_tty_index = 0xFFFF;
     
1000.         xin_tty_driver = alloc_tty_driver(max_tty_index);
      
1001.         if (!xin_tty_driver)
      
1002.         {
      
1003.             printk("[%s] failed to alloc tty driver", __FUNCTION__);
      
1004.                 return -ENOMEM;
      
1005.         }
      
1006. 
      
1007.         //printk(KERN_ERR "[%s] xin_tty_driver is 0x%08x", __FUNCTION__, (unsigned int)xin_tty_driver);
      
1008. 
      
1009.         /* initialize the tty driver */
      
1010.         xin_tty_driver->owner = THIS_MODULE;
      
1011.         xin_tty_driver->driver_name = "ttyxin";
      
1012.         xin_tty_driver->name = "ttyVCOM";
      
1013.         xin_tty_driver->major = XIN_TTY_MAJOR,
      
1014.     xin_tty_driver->minor_start = 0,
      
1015.         xin_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
      
1016.         xin_tty_driver->subtype = SERIAL_TYPE_NORMAL,
      
1017.         xin_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV,
      
1018.         xin_tty_driver->init_termios = tty_std_termios;
      
1019.         xin_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
      
1020.         xin_tty_driver->init_termios.c_lflag &= ~(ECHO|ECHONL|ICANON|ECHOE);
      
1021.         tty_set_operations(xin_tty_driver, &serial_ops);
      
1022. 
      
1023.         /* register the tty driver */
      
1024.         retval = tty_register_driver(xin_tty_driver);
      
1025.         if (retval) {
      
1026.                 printk("[%s] failed to register xin tty driver", __FUNCTION__);
      
1027.                 put_tty_driver(xin_tty_driver);
      
1028.                 return retval;
      
1029.         }
      
1030. 
      
1031.         retval = usb_register(&xin_hid_driver);
      
1032.         if(retval)
      
1033.         {
      
1034.                 printk("[%s] failed to register xin hid driver", __FUNCTION__);
      
1035.                 put_tty_driver(xin_tty_driver);
      
1036.                 tty_unregister_driver(xin_tty_driver);
      
1037.                 return retval;
      
1038.         }
      
1039. 
      
1040.         printk(KERN_ERR DRIVER_DESC " " DRIVER_VERSION);
      
1041.         return retval;
      
1042. }
      
1043. 
      
1044. static void __exit xin_exit(void)
      
1045. {
      
1046.         printk("[%s] uninit xin com driver", __FUNCTION__);
      
1047. 
      
1048.         usb_deregister(&xin_hid_driver);
      
1049.         tty_unregister_driver(xin_tty_driver);
      
1050.         xin_tty_driver = NULL;
      
1051. 
      
1052.         printk("[%s] uninit xin com driver success", __FUNCTION__);
      
1053. 
      
1054. }
      
1055. 
      
1056. module_init(xin_init);
      
1057. module_exit(xin_exit);
      

复制代码

hue2550

问题以解决，在probe函数中增加tty port与tty device的对应即可