source navigation diff markup identifier search freetext search Try Elixir Beta

Version: 2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

1 /*
2 * Copyr i ght 2007, Fr ank A Ki ngswood <f r ank@ki ngswood- consul t i ng. co. uk>
3 * Copyr i ght 2007, Wer ner Cor nel i us <wer ner @cor nel i us- consul t . de>
4 * Copyr i ght 2009, Bor i s Haj duk <bor i s@haj duk. or g>
5 *
6 * ch341. c i mpl ement s a ser i al por t dr i ver f or t he Wi nchi phead CH341.
7 *
8 * The CH341 devi ce can be used t o i mpl ement an RS232 asynchr onous
9 * ser i al por t , an I EEE- 1284 par al l el pr i nt er por t or a memor y- l i ke
10 * i nt er f ace. I n al l cases t he CH341 suppor t s an I 2C i nt er f ace as wel l .
11 * Thi s dr i ver onl y suppor t s t he asynchr onous ser i al i nt er f ace.
12 *
13 * Thi s pr ogr am i s f r ee sof t war e; you can r edi st r i but e i t and/ or
14 * modi f y i t under t he t er ms of t he GNU Gener al Publ i c Li cense ver si on
15 * 2 as publ i shed by t he Fr ee Sof t war e Foundat i on.
16 */
17
18 #include <linux/kernel.h>
19 #include <linux/init.h>
20 #include <linux/tty.h>
21 #include <linux/module.h>
22 #include <linux/usb.h>
23 #include <linux/usb/serial.h>
24 #include <linux/serial.h>
25
26 #define DEFAULT_BAUD_RATE 9600
27 #define DEFAULT_TIMEOUT 1000
28
29 / * f l ags f or I O- Bi t s * /
30 #define CH341_BIT_RTS (1 << 6)
31 #define CH341_BIT_DTR (1 << 5)
32
33 / ******************************/
34 / * i nt er r upt pi pe def i ni t i ons * /
35 / ******************************/
36 / * al ways 4 i nt er r upt byt es * /
37 / * f i r st i r q byt e nor mal l y 0x08 * /
38 / * second i r q byt e base 0x7d + bel ow * /
39 / * t hi r d i r q byt e base 0x94 + bel ow * /
40 / * f our t h i r q byt e nor mal l y 0xee * /
41
42 / * second i nt er r upt byt e * /
43 #define CH341_MULT_STAT 0x04 / * mul t i pl e st at us si nce l ast i nt er r upt event * /
44
45 / * st at us r et ur ned i n t hi r d i nt er r upt answer byt e, i nver t ed i n dat a
46 f r om i r q * /
47 #define CH341_BIT_CTS 0x01
 48 #define CH341_BIT_DSR 0x02
49 #define CH341_BIT_RI 0x04
50 #define CH341_BIT_DCD 0x08
51 #define CH341_BITS_MODEM_STAT 0x0f / * al l bi t s * /
52
53 / *******************************/
54 / * baudr at e cal cul at i on f act or * /
55 / *******************************/
56 #define CH341_BAUDBASE_FACTOR 1532620800
57 #define CH341_BAUDBASE_DIVMAX 3
58
59 / * Br eak suppor t - t he i nf or mat i on used t o i mpl ement t hi s was gl eaned f r om
60 * t he Net / Fr eeBSD uchcom. c dr i ver by Takanor i Wat anabe. Domo ar i gat o.
61 */
62
63 #define CH341_REQ_WRITE_REG 0x9A
64 #define CH341_REQ_READ_REG 0x95
65 #define CH341_REG_BREAK1 0x05
66 #define CH341_REG_BREAK2 0x18
67 #define CH341_NBREAK_BITS_REG1 0x01
68 #define CH341_NBREAK_BITS_REG2 0x40
69
70
71 static int debug;
72
73 static struct usb_device_id id_table [] = {
74 { USB_DEVICE(0x4348, 0x5523) },
75 { USB_DEVICE(0x1a86, 0x7523) },
76 { USB_DEVICE(0x1a86, 0x5523) },
77 { },
78 };
79 MODULE_DEVICE_TABLE(usb, id_table);
80
81 struct ch341_private {
82 spinlock_t lock; / * access l ock * /
83 wait_queue_head_t delta_msr_wait; / * wai t queue f or modem st at us * /
84 unsigned baud_rate; / * set baud r at e * /
85 u8 line_control; / * set l i ne cont r ol val ue RTS/ DTR * /
86 u8 line_status; / * act i ve st at us of modem cont r ol i nput s * /
87 u8 multi_status_change; / * st at us changed mul t i pl e si nc e l ast cal l * /
88 };
89
90 static int ch341_control_out(struct usb_device *dev, u8 request,
91 u16 value, u16 index)
92 {
93 int r;
94 dbg(" ch341_cont r ol _out ( %02x, %02x, %04x, %04x) " , USB_DIR_OUT|0x40,
95 (int)request, (int)value, (int)index);
96
97 r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
98 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
99 value, index, NULL, 0, DEFAULT_TIMEOUT);
100
101 return r;
102 }
103
104 static int ch341_control_in(struct usb_device *dev,
105 u8 request, u16 value, u16 index,
106 char *buf, unsigned bufsize)
107 {
108 int r;
109 dbg(" ch341_cont r ol _i n( %02x, %02x, %04x, %04x, %p, %u) " , USB_DIR_IN|0x40,
110 (int)request, (int)value, (int)index, buf, (int)bufsize);
111
112 r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request,
113 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
114 value, index, buf, bufsize, DEFAULT_TIMEOUT);
115 return r;
116 }
117
118 static int ch341_set_baudrate(struct usb_device *dev,
119 struct ch341_private *priv)
120 {
121 short a, b;
122 int r;
123 unsigned long factor;
124 short divisor;
125
126 dbg(" ch341_set _baudr at e( %d) " , priv->baud_rate);
127
128 if (!priv->baud_rate)
129 return -EINVAL;
130 factor = (CH341_BAUDBASE_FACTOR / priv->baud_rate);
131 divisor = CH341_BAUDBASE_DIVMAX;
132
133 while ((factor > 0xfff0) && divisor) {
134 factor >>= 3;
135 divisor--;
136 }
137
138 if (factor > 0xfff0)
139 return -EINVAL;
140
141 factor = 0x10000 - factor;
142 a = (factor & 0xff00) | divisor;
143 b = factor & 0xff;
144
145 r = ch341_control_out(dev, 0x9a, 0x1312, a);
146 if (!r)
147 r = ch341_control_out(dev, 0x9a, 0x0f2c, b);
148
149 return r;
150 }
151
152 static int ch341_set_handshake(struct usb_device *dev, u8 control)
153 {
154 dbg(" ch341_set _handshake( 0x%02x) " , control);
155 return ch341_control_out(dev, 0xa4, ~control, 0);
156 }
157
158 static int ch341_get_status(struct usb_device *dev, struct ch341_private *priv)
159 {
160 char *buffer;
161 int r;
162 const unsigned size = 8;
163 unsigned long flags;
164
165 dbg(" ch341_get _st at us( ) " );
166
167 buffer = kmalloc(size, GFP_KERNEL);
168 if (!buffer)
169 return -ENOMEM;
170
171 r = ch341_control_in(dev, 0x95, 0x0706, 0, buffer, size);
172 if (r < 0)
173 goto out;
174
175 / * set up t he pr i vat e st at us i f avai l abl e * /
176 if (r == 2) {
177 r = 0;
178 spin_lock_irqsave(&priv->lock, flags);
179 priv->line_status = (~(*buffer)) & CH341_BITS_MODEM_STAT;
180 priv->multi_status_change = 0;
181 spin_unlock_irqrestore(&priv->lock, flags);
182 } else
183 r = -EPROTO;
184
185 out: kfree(buffer);
186 return r;
187 }
188
189 / * -------------------------------------------------------------------------- */
190
191 static int ch341_configure(struct usb_device *dev, struct ch341_private *priv)
192 {
193 char *buffer;
194 int r;
195 const unsigned size = 8;
196
197 dbg(" ch341_conf i gur e( ) " );
198
199 buffer = kmalloc(size, GFP_KERNEL);
200 if (!buffer)
201 return -ENOMEM;
202
203 / * expect t wo byt es 0x27 0x00 * /
204 r = ch341_control_in(dev, 0x5f, 0, 0, buffer, size);
205 if (r < 0)
206 goto out;
207
208 r = ch341_control_out(dev, 0xa1, 0, 0);
209 if (r < 0)
210 goto out;
211
212 r = ch341_set_baudrate(dev, priv);
213 if (r < 0)
214 goto out;
215
216 / * expect t wo byt es 0x56 0x00 * /
217 r = ch341_control_in(dev, 0x95, 0x2518, 0, buffer, size);
218 if (r < 0)
219 goto out;
220
221 r = ch341_control_out(dev, 0x9a, 0x2518, 0x0050);
222 if (r < 0)
223 goto out;
224
225 / * expect 0xf f 0xee * /
226 r = ch341_get_status(dev, priv);
227 if (r < 0)
228 goto out;
229
230 r = ch341_control_out(dev, 0xa1, 0x501f, 0xd90a);
231 if (r < 0)
232 goto out;
233
234 r = ch341_set_baudrate(dev, priv);
235 if (r < 0)
236 goto out;
237
238 r = ch341_set_handshake(dev, priv->line_control);
239 if (r < 0)
240 goto out;
241
242 / * expect 0x9f 0xee * /
243 r = ch341_get_status(dev, priv);
244
245 out: kfree(buffer);
246 return r;
247 }
248
249 / * al l ocat e pr i vat e dat a * /
250 static int ch341_attach(struct usb_serial *serial)
251 {
252 struct ch341_private *priv;
253 int r;
254
255 dbg(" ch341_at t ach( ) " );
256
257 / * pr i vat e dat a * /
258 priv = kzalloc(sizeof(struct ch341_private), GFP_KERNEL);
259 if (!priv)
260 return -ENOMEM;
261
262 spin_lock_init(&priv->lock);
263 init_waitqueue_head(&priv->delta_msr_wait);
264 priv->baud_rate = DEFAULT_BAUD_RATE;
265 priv->line_control = CH341_BIT_RTS | CH341_BIT_DTR;
266
267 r = ch341_configure(serial->dev, priv);
268 if (r < 0)
269 goto error;
270
271 usb_set_serial_port_data(serial->port[0], priv);
272 return 0;
273
274 error: kfree(priv);
275 return r;
276 }
277
278 static int ch341_carrier_raised(struct usb_serial_port *port)
279 {
280 struct ch341_private *priv = usb_get_serial_port_data(port);
281 if (priv->line_status & CH341_BIT_DCD)
282 return 1;
283 return 0;
284 }
285
286 static void ch341_dtr_rts(struct usb_serial_port *port, int on)
287 {
288 struct ch341_private *priv = usb_get_serial_port_data(port);
289 unsigned long flags;
290
291 dbg(" %s - por t %d" , __func__, port->number);
292 / * dr op DTR and RTS * /
293 spin_lock_irqsave(&priv->lock, flags);
294 if (on)
295 priv->line_control |= CH341_BIT_RTS | CH341_BIT_DTR;
296 else
297 priv->line_control &= ~(CH341_BIT_RTS | CH341_BIT_DTR);
298 spin_unlock_irqrestore(&priv->lock, flags);
299 ch341_set_handshake(port->serial->dev, priv->line_control);
300 wake_up_interruptible(&priv->delta_msr_wait);
301 }
302
303 static void ch341_close(struct usb_serial_port *port)
304 {
305 dbg(" %s - por t %d" , __func__, port->number);
306
307 / * shut down our ur bs * /
308 dbg(" %s - shut t i ng down ur bs" , __func__);
309 usb_kill_urb(port->write_urb);
310 usb_kill_urb(port->read_urb);
311 usb_kill_urb(port->interrupt_in_urb);
312 }
313
314
315 / * open t hi s devi ce, set def aul t par amet er s * /
316 static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port)
317 {
318 struct usb_serial *serial = port->serial;
319 struct ch341_private *priv = usb_get_serial_port_data(serial->port[0]);
320 int r;
321
322 dbg(" ch341_open( ) " );
323
324 priv->baud_rate = DEFAULT_BAUD_RATE;
325
326 r = ch341_configure(serial->dev, priv);
327 if (r)
328 goto out;
329
330 r = ch341_set_handshake(serial->dev, priv->line_control);
331 if (r)
332 goto out;
333
334 r = ch341_set_baudrate(serial->dev, priv);
335 if (r)
336 goto out;
337
338 dbg(" %s - submi t t i ng i nt er r upt ur b" , __func__);
339 port->interrupt_in_urb->dev = serial->dev;
340 r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
341 if (r) {
342 dev_err(&port->dev, " %s - f ai l ed submi t t i ng i nt er r upt ur b, "
343 " er r or %d\ n" , __func__, r);
344 ch341_close(port);
345 return -EPROTO;
346 }
347
348 r = usb_serial_generic_open(tty, port);
349
350 out: return r;
351 }
352
353 / * Ol d_t er mi os cont ai ns t he or i gi nal t er mi os set t i ngs and
354 * t t y- >t er mi os cont ai ns t he new set t i ng t o be used.
355 */
356 static void ch341_set_termios(struct tty_struct *tty,
357 struct usb_serial_port *port, struct ktermios *old_termios)
358 {
359 struct ch341_private *priv = usb_get_serial_port_data(port);
360 unsigned baud_rate;
361 unsigned long flags;
362
363 dbg(" ch341_set _t er mi os( ) " );
364
365 baud_rate = tty_get_baud_rate(tty);
366
367 priv->baud_rate = baud_rate;
368
369 if (baud_rate) {
370 spin_lock_irqsave(&priv->lock, flags);
371 priv->line_control |= (CH341_BIT_DTR | CH341_BIT_RTS);
372 spin_unlock_irqrestore(&priv->lock, flags);
373 ch341_set_baudrate(port->serial->dev, priv);
374 } else {
375 spin_lock_irqsave(&priv->lock, flags);
376 priv->line_control &= ~(CH341_BIT_DTR | CH341_BIT_RTS);
377 spin_unlock_irqrestore(&priv->lock, flags);
378 }
379
380 ch341_set_handshake(port->serial->dev, priv->line_control);
381
382 /* Uni mpl ement ed:
383 * ( cf l ag & CSI ZE) : dat a bi t s [ 5, 8]
384 * ( cf l ag & PARENB) : par i t y { NONE, EVEN, ODD}
385 * ( cf l ag & CSTOPB) : st op bi t s [ 1, 2]
386 */
387 }
388
389 static void ch341_break_ctl(struct tty_struct *tty, int break_state)
390 {
391 const uint16_t ch341_break_reg =
392 CH341_REG_BREAK1 | ((uint16_t) CH341_REG_BREAK2 << 8);
393 struct usb_serial_port *port = tty->driver_data;
394 int r;
395 uint16_t reg_contents;
396 uint8_t break_reg[2];
397
398 dbg(" %s( ) " , __func__);
399
400 r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG,
401 ch341_break_reg, 0, break_reg, sizeof(break_reg));
402 if (r < 0) {
403 printk(KERN_WARNING " %s: USB cont r ol r ead er r or whi l st get t i ng"
404 " br eak r egi st er cont ent s. \ n" , __FILE__);
405 return;
406 }
407 dbg(" %s - i ni t i al ch341 br eak r egi st er cont ent s - r eg1: %x, r eg2: %x" ,
408 __func__, break_reg[0], break_reg[1]);
409 if (break_state != 0) {
410 dbg(" %s - Ent er br eak st at e r equest ed" , __func__);
411 break_reg[0] &= ~CH341_NBREAK_BITS_REG1;
412 break_reg[1] &= ~CH341_NBREAK_BITS_REG2;
413 } else {
414 dbg(" %s - Leave br eak st at e r equest ed" , __func__);
415 break_reg[0] |= CH341_NBREAK_BITS_REG1;
416 break_reg[1] |= CH341_NBREAK_BITS_REG2;
417 }
418 dbg(" %s - New ch341 br eak r egi st er cont ent s - r eg1: %x, r eg2: %x" ,
419 __func__, break_reg[0], break_reg[1]);
420 reg_contents = (uint16_t)break_reg[0] | ((uint16_t)break_reg[1] << 8);
421 r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG,
422 ch341_break_reg, reg_contents);
423 if (r < 0)
424 printk(KERN_WARNING " %s: USB cont r ol wr i t e er r or whi l st set t i ng"
425 " br eak r egi st er cont ent s. \ n" , __FILE__);
426 }
427
428 static int ch341_tiocmset(struct tty_struct *tty, struct file *file,
429 unsigned int set, unsigned int clear)
430 {
431 struct usb_serial_port *port = tty->driver_data;
432 struct ch341_private *priv = usb_get_serial_port_data(port);
433 unsigned long flags;
434 u8 control;
435
436 spin_lock_irqsave(&priv->lock, flags);
437 if (set & TIOCM_RTS)
438 priv->line_control |= CH341_BIT_RTS;
439 if (set & TIOCM_DTR)
440 priv->line_control |= CH341_BIT_DTR;
441 if (clear & TIOCM_RTS)
442 priv->line_control &= ~CH341_BIT_RTS;
443 if (clear & TIOCM_DTR)
444 priv->line_control &= ~CH341_BIT_DTR;
445 control = priv->line_control;
446 spin_unlock_irqrestore(&priv->lock, flags);
447
448 return ch341_set_handshake(port->serial->dev, control);
449 }
450
451 static void ch341_read_int_callback(struct urb *urb)
452 {
453 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
454 unsigned char *data = urb->transfer_buffer;
455 unsigned int actual_length = urb->actual_length;
456 int status;
457
458 dbg(" %s ( %d) " , __func__, port->number);
459
460 switch (urb->status) {
461 case 0:
462 / * success * /
463 break;
464 case -ECONNRESET:
465 case -ENOENT:
466 case -ESHUTDOWN:
467 / * t hi s ur b i s t er mi nat ed, cl ean up * /
468 dbg(" %s - ur b shut t i ng down wi t h st at us: %d" , __func__,
469 urb->status);
470 return;
471 default:
472 dbg(" %s - nonzer o ur b st at us r ecei ved: %d" , __func__,
473 urb->status);
474 goto exit;
475 }
476
477 usb_serial_debug_data(debug, &port->dev, __func__,
478 urb->actual_length, urb->transfer_buffer);
479
480 if (actual_length >= 4) {
481 struct ch341_private *priv = usb_get_serial_port_data(port);
482 unsigned long flags;
483 u8 prev_line_status = priv->line_status;
484
485 spin_lock_irqsave(&priv->lock, flags);
486 priv->line_status = (~(data[2])) & CH341_BITS_MODEM_STAT;
487 if ((data[1] & CH341_MULT_STAT))
488 priv->multi_status_change = 1;
489 spin_unlock_irqrestore(&priv->lock, flags);
490
491 if ((priv->line_status ^ prev_line_status) & CH341_BIT_DCD) {
492 struct tty_struct *tty = tty_port_tty_get(&port->port);
493 if (tty)
494 usb_serial_handle_dcd_change(port, tty,
495 priv->line_status & CH341_BIT_DCD);
496 tty_kref_put(tty);
497 }
498
499 wake_up_interruptible(&priv->delta_msr_wait);
500 }
501
502 exit:
503 status = usb_submit_urb(urb, GFP_ATOMIC);
504 if (status)
505 dev_err(&urb->dev->dev,
506 " %s - usb_submi t _ur b f ai l ed wi t h r esul t %d\ n" ,
507 __func__, status);
508 }
509
510 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
511 {
512 struct ch341_private *priv = usb_get_serial_port_data(port);
513 unsigned long flags;
514 u8 prevstatus;
515 u8 status;
516 u8 changed;
517 u8 multi_change = 0;
518
519 spin_lock_irqsave(&priv->lock, flags);
520 prevstatus = priv->line_status;
521 priv->multi_status_change = 0;
522 spin_unlock_irqrestore(&priv->lock, flags);
523
524 while (!multi_change) {
525 interruptible_sleep_on(&priv->delta_msr_wait);
526 / * see i f a si gnal di d i t * /
527 if (signal_pending(current))
528 return -ERESTARTSYS;
529
530 spin_lock_irqsave(&priv->lock, flags);
531 status = priv->line_status;
532 multi_change = priv->multi_status_change;
533 spin_unlock_irqrestore(&priv->lock, flags);
534
535 changed = prevstatus ^ status;
536
537 if (((arg & TIOCM_RNG) && (changed & CH341_BIT_RI)) ||
538 ((arg & TIOCM_DSR) && (changed & CH341_BIT_DSR)) ||
539 ((arg & TIOCM_CD) && (changed & CH341_BIT_DCD)) ||
540 ((arg & TIOCM_CTS) && (changed & CH341_BIT_CTS))) {
541 return 0;
542 }
543 prevstatus = status;
544 }
545
546 return 0;
547 }
548
549 / * st at i c i nt ch341_i oct l ( st r uct usb_ser i al _por t * por t , st r uct f i l e * f i l e, * /
550 static int ch341_ioctl(struct tty_struct *tty, struct file *file,
551 unsigned int cmd, unsigned long arg)
552 {
553 struct usb_serial_port *port = tty->driver_data;
554 dbg(" %s ( %d) cmd = 0x%04x" , __func__, port->number, cmd);
555
556 switch (cmd) {
557 case TIOCMIWAIT:
558 dbg(" %s ( %d) TI OCMI WAI T" , __func__, port->number);
559 return wait_modem_info(port, arg);
560
561 default:
562 dbg(" %s not suppor t ed = 0x%04x" , __func__, cmd);
563 break;
564 }
565
566 return -ENOIOCTLCMD;
567 }
568
569 static int ch341_tiocmget(struct tty_struct *tty, struct file *file)
570 {
571 struct usb_serial_port *port = tty->driver_data;
572 struct ch341_private *priv = usb_get_serial_port_data(port);
573 unsigned long flags;
574 u8 mcr;
575 u8 status;
576 unsigned int result;
577
578 dbg(" %s ( %d) " , __func__, port->number);
579
580 spin_lock_irqsave(&priv->lock, flags);
581 mcr = priv->line_control;
582 status = priv->line_status;
583 spin_unlock_irqrestore(&priv->lock, flags);
584
585 result = ((mcr & CH341_BIT_DTR) ? TIOCM_DTR : 0)
586 | ((mcr & CH341_BIT_RTS) ? TIOCM_RTS : 0)
587 | ((status & CH341_BIT_CTS) ? TIOCM_CTS : 0)
588 | ((status & CH341_BIT_DSR) ? TIOCM_DSR : 0)
589 | ((status & CH341_BIT_RI) ? TIOCM_RI : 0)
590 | ((status & CH341_BIT_DCD) ? TIOCM_CD : 0);
591
592 dbg(" %s - r esul t = %x" , __func__, result);
593
594 return result;
595 }
596
597
598 static int ch341_reset_resume(struct usb_interface *intf)
599 {
600 struct usb_device *dev = interface_to_usbdev(intf);
601 struct usb_serial *serial = NULL;
602 struct ch341_private *priv;
603
604 serial = usb_get_intfdata(intf);
605 priv = usb_get_serial_port_data(serial->port[0]);
606
607 / * r econf i gur e ch341 ser i al por t af t er bus- r eset * /
608 ch341_configure(dev, priv);
609
610 usb_serial_resume(intf);
611
612 return 0;
613 }
614
615 static struct usb_driver ch341_driver = {
616 .name = " ch341" ,
617 .probe = usb_serial_probe,
618 .disconnect = usb_serial_disconnect,
619 .suspend = usb_serial_suspend,
620 .resume = usb_serial_resume,
621 .reset_resume = ch341_reset_resume,
622 .id_table = id_table,
623 .no_dynamic_id = 1,
624 .supports_autosuspend = 1,
625 };
626
627 static struct usb_serial_driver ch341_device = {
628 .driver = {
629 .owner = THIS_MODULE,
630 .name = " ch341- uar t " ,
631 },
632 .id_table = id_table,
633 .usb_driver = &ch341_driver,
634 .num_ports = 1,
635 .open = ch341_open,
636 .dtr_rts = ch341_dtr_rts,
637 .carrier_raised = ch341_carrier_raised,
638 .close = ch341_close,
639 .ioctl = ch341_ioctl,
640 .set_termios = ch341_set_termios,
641 .break_ctl = ch341_break_ctl,
642 .tiocmget = ch341_tiocmget,
643 .tiocmset = ch341_tiocmset,
644 .read_int_callback = ch341_read_int_callback,
645 .attach = ch341_attach,
646 };
647
648 static int __init ch341_init(void)
649 {
650 int retval;
651
652 retval = usb_serial_register(&ch341_device);
653 if (retval)
654 return retval;
655 retval = usb_register(&ch341_driver);
656 if (retval)
657 usb_serial_deregister(&ch341_device);
658 return retval;
659 }
660
661 static void __exit ch341_exit(void)
662 {
663 usb_deregister(&ch341_driver);
664 usb_serial_deregister(&ch341_device);
665 }
666
667 module_init(ch341_init);
668 module_exit(ch341_exit);
669 MODULE_LICENSE(" GPL" );
670
671 module_param(debug, bool, S_IRUGO | S_IWUSR);
672 MODULE_PARM_DESC(debug, " Debug enabl ed or not " );
673
674 / * EOF ch341. c * /
675

This page was automatically generated by LXR 0.3.1 (source). Linux is a registered trademark of Linus Torvalds
Contact us

Home
Engineering
Training
Docs
Community
Company
Blog