3 * Controls the Moschip 7720 usb to dual port serial convertor
5 * Copyright 2006 Moschip Semiconductor Tech. Ltd.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, version 2 of the License.
12 * Vijaya Kumar <vijaykumar.gn@gmail.com>
13 * Ajay Kumar <naanuajay@yahoo.com>
14 * Gurudeva <ngurudeva@yahoo.com>
16 * Cleaned up from the original by:
17 * Greg Kroah-Hartman <gregkh@suse.de>
19 * Originally based on drivers/usb/serial/io_edgeport.c which is:
20 * Copyright (C) 2000 Inside Out Networks, All rights reserved.
21 * Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>
23 #include <linux/kernel.h>
24 #include <linux/errno.h>
25 #include <linux/init.h>
26 #include <linux/slab.h>
27 #include <linux/tty.h>
28 #include <linux/tty_driver.h>
29 #include <linux/tty_flip.h>
30 #include <linux/module.h>
31 #include <linux/spinlock.h>
32 #include <linux/serial.h>
33 #include <linux/serial_reg.h>
34 #include <linux/usb.h>
35 #include <linux/usb/serial.h>
36 #include <linux/uaccess.h>
42 #define DRIVER_VERSION "1.0.0.4F"
43 #define DRIVER_AUTHOR "Aspire Communications pvt Ltd."
44 #define DRIVER_DESC "Moschip USB Serial Driver"
46 /* default urb timeout */
47 #define MOS_WDR_TIMEOUT (HZ * 5)
49 #define MOS_PORT1 0x0200
50 #define MOS_PORT2 0x0300
51 #define MOS_VENREG 0x0000
52 #define MOS_MAX_PORT 0x02
53 #define MOS_WRITE 0x0E
56 /* Interrupt Rotinue Defines */
57 #define SERIAL_IIR_RLS 0x06
58 #define SERIAL_IIR_RDA 0x04
59 #define SERIAL_IIR_CTI 0x0c
60 #define SERIAL_IIR_THR 0x02
61 #define SERIAL_IIR_MS 0x00
63 #define NUM_URBS 16 /* URB Count */
64 #define URB_TRANSFER_BUFFER_SIZE 32 /* URB Size */
66 /* This structure holds all of the local port information */
68 __u8 shadowLCR
; /* last LCR value received */
69 __u8 shadowMCR
; /* last MCR value received */
70 __u8 shadowMSR
; /* last MSR value received */
72 struct async_icount icount
;
73 struct usb_serial_port
*port
; /* loop back to the owner */
74 struct urb
*write_urb_pool
[NUM_URBS
];
77 /* This structure holds all of the individual serial device information */
78 struct moschip_serial
{
79 int interrupt_started
;
84 #define USB_VENDOR_ID_MOSCHIP 0x9710
85 #define MOSCHIP_DEVICE_ID_7720 0x7720
86 #define MOSCHIP_DEVICE_ID_7715 0x7715
88 static struct usb_device_id moschip_port_id_table
[] = {
89 { USB_DEVICE(USB_VENDOR_ID_MOSCHIP
, MOSCHIP_DEVICE_ID_7720
) },
90 { } /* terminating entry */
92 MODULE_DEVICE_TABLE(usb
, moschip_port_id_table
);
96 * mos7720_interrupt_callback
97 * this is the callback function for when we have received data on the
100 static void mos7720_interrupt_callback(struct urb
*urb
)
104 int status
= urb
->status
;
109 dbg("%s", " : Entering\n");
118 /* this urb is terminated, clean up */
119 dbg("%s - urb shutting down with status: %d", __func__
,
123 dbg("%s - nonzero urb status received: %d", __func__
,
128 length
= urb
->actual_length
;
129 data
= urb
->transfer_buffer
;
131 /* Moschip get 4 bytes
132 * Byte 1 IIR Port 1 (port.number is 0)
133 * Byte 2 IIR Port 2 (port.number is 1)
134 * Byte 3 --------------
135 * Byte 4 FIFO status for both */
137 /* the above description is inverted
138 * oneukum 2007-03-14 */
140 if (unlikely(length
!= 4)) {
141 dbg("Wrong data !!!");
148 if ((sp1
| sp2
) & 0x01) {
149 /* No Interrupt Pending in both the ports */
150 dbg("No Interrupt !!!");
152 switch (sp1
& 0x0f) {
154 dbg("Serial Port 1: Receiver status error or address "
155 "bit detected in 9-bit mode\n");
158 dbg("Serial Port 1: Receiver time out");
161 dbg("Serial Port 1: Modem status change");
165 switch (sp2
& 0x0f) {
167 dbg("Serial Port 2: Receiver status error or address "
168 "bit detected in 9-bit mode");
171 dbg("Serial Port 2: Receiver time out");
174 dbg("Serial Port 2: Modem status change");
180 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
182 dev_err(&urb
->dev
->dev
,
183 "%s - Error %d submitting control urb\n",
189 * mos7720_bulk_in_callback
190 * this is the callback function for when we have received data on the
193 static void mos7720_bulk_in_callback(struct urb
*urb
)
196 unsigned char *data
;
197 struct usb_serial_port
*port
;
198 struct moschip_port
*mos7720_port
;
199 struct tty_struct
*tty
;
200 int status
= urb
->status
;
203 dbg("nonzero read bulk status received: %d", status
);
207 mos7720_port
= urb
->context
;
209 dbg("%s", "NULL mos7720_port pointer \n");
213 port
= mos7720_port
->port
;
215 dbg("Entering...%s", __func__
);
217 data
= urb
->transfer_buffer
;
219 tty
= tty_port_tty_get(&port
->port
);
220 if (tty
&& urb
->actual_length
) {
221 tty_buffer_request_room(tty
, urb
->actual_length
);
222 tty_insert_flip_string(tty
, data
, urb
->actual_length
);
223 tty_flip_buffer_push(tty
);
227 if (!port
->read_urb
) {
228 dbg("URB KILLED !!!");
232 if (port
->read_urb
->status
!= -EINPROGRESS
) {
233 port
->read_urb
->dev
= port
->serial
->dev
;
235 retval
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
237 dbg("usb_submit_urb(read bulk) failed, retval = %d",
243 * mos7720_bulk_out_data_callback
244 * this is the callback function for when we have finished sending serial
245 * data on the bulk out endpoint.
247 static void mos7720_bulk_out_data_callback(struct urb
*urb
)
249 struct moschip_port
*mos7720_port
;
250 struct tty_struct
*tty
;
251 int status
= urb
->status
;
254 dbg("nonzero write bulk status received:%d", status
);
258 mos7720_port
= urb
->context
;
260 dbg("NULL mos7720_port pointer");
264 dbg("Entering .........");
266 tty
= tty_port_tty_get(&mos7720_port
->port
->port
);
268 if (tty
&& mos7720_port
->open
)
275 * this function will be used for sending command to device
277 static int send_mos_cmd(struct usb_serial
*serial
, __u8 request
, __u16 value
,
278 __u16 index
, void *data
)
282 u16 product
= le16_to_cpu(serial
->dev
->descriptor
.idProduct
);
286 if (value
< MOS_MAX_PORT
) {
287 if (product
== MOSCHIP_DEVICE_ID_7715
)
288 value
= value
*0x100+0x100;
290 value
= value
*0x100+0x200;
293 if ((product
== MOSCHIP_DEVICE_ID_7715
) &&
295 dbg("serial->product== MOSCHIP_DEVICE_ID_7715");
300 if (request
== MOS_WRITE
) {
301 request
= (__u8
)MOS_WRITE
;
302 requesttype
= (__u8
)0x40;
303 value
= value
+ (__u16
)*((unsigned char *)data
);
305 pipe
= usb_sndctrlpipe(serial
->dev
, 0);
307 request
= (__u8
)MOS_READ
;
308 requesttype
= (__u8
)0xC0;
310 pipe
= usb_rcvctrlpipe(serial
->dev
, 0);
313 status
= usb_control_msg(serial
->dev
, pipe
, request
, requesttype
,
314 value
, index
, data
, size
, MOS_WDR_TIMEOUT
);
317 dbg("Command Write failed Value %x index %x\n", value
, index
);
322 static int mos7720_open(struct tty_struct
*tty
,
323 struct usb_serial_port
*port
, struct file
*filp
)
325 struct usb_serial
*serial
;
326 struct usb_serial_port
*port0
;
328 struct moschip_serial
*mos7720_serial
;
329 struct moschip_port
*mos7720_port
;
333 int allocated_urbs
= 0;
336 serial
= port
->serial
;
338 mos7720_port
= usb_get_serial_port_data(port
);
339 if (mos7720_port
== NULL
)
342 port0
= serial
->port
[0];
344 mos7720_serial
= usb_get_serial_data(serial
);
346 if (mos7720_serial
== NULL
|| port0
== NULL
)
349 usb_clear_halt(serial
->dev
, port
->write_urb
->pipe
);
350 usb_clear_halt(serial
->dev
, port
->read_urb
->pipe
);
352 /* Initialising the write urb pool */
353 for (j
= 0; j
< NUM_URBS
; ++j
) {
354 urb
= usb_alloc_urb(0, GFP_KERNEL
);
355 mos7720_port
->write_urb_pool
[j
] = urb
;
358 dev_err(&port
->dev
, "No more urbs???\n");
362 urb
->transfer_buffer
= kmalloc(URB_TRANSFER_BUFFER_SIZE
,
364 if (!urb
->transfer_buffer
) {
366 "%s-out of memory for urb buffers.\n",
368 usb_free_urb(mos7720_port
->write_urb_pool
[j
]);
369 mos7720_port
->write_urb_pool
[j
] = NULL
;
378 /* Initialize MCS7720 -- Write Init values to corresponding Registers
386 * 0x08 : SP1/2 Control Reg
388 port_number
= port
->number
- port
->serial
->minor
;
389 send_mos_cmd(port
->serial
, MOS_READ
, port_number
, UART_LSR
, &data
);
390 dbg("SS::%p LSR:%x\n", mos7720_port
, data
);
392 dbg("Check:Sending Command ..........");
395 send_mos_cmd(serial
, MOS_WRITE
, MOS_MAX_PORT
, 0x01, &data
);
397 send_mos_cmd(serial
, MOS_WRITE
, MOS_MAX_PORT
, 0x02, &data
);
400 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x01, &data
);
402 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x02, &data
);
405 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x02, &data
);
407 mos7720_port
->shadowLCR
= data
;
408 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x03, &data
);
410 mos7720_port
->shadowMCR
= data
;
411 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x04, &data
);
413 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x04, &data
);
416 send_mos_cmd(serial
, MOS_READ
, MOS_MAX_PORT
, 0x08, &data
);
418 send_mos_cmd(serial
, MOS_WRITE
, MOS_MAX_PORT
, 0x08, &data
);
421 send_mos_cmd(serial, MOS_READ, MOS_MAX_PORT, port_number + 1, &data);
423 send_mos_cmd(serial, MOS_WRITE, MOS_MAX_PORT, port_number + 1, &data);
425 send_mos_cmd(port->serial, MOS_WRITE, MOS_MAX_PORT,
426 port_number + 1, &data);
429 send_mos_cmd(serial
, MOS_READ
, MOS_MAX_PORT
, 0x08, &data
);
431 data
= data
| (port
->number
- port
->serial
->minor
+ 1);
432 send_mos_cmd(serial
, MOS_WRITE
, MOS_MAX_PORT
, 0x08, &data
);
435 mos7720_port
->shadowLCR
= data
;
436 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x03, &data
);
438 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x00, &data
);
440 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x01, &data
);
442 mos7720_port
->shadowLCR
= data
;
443 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x03, &data
);
445 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x01, &data
);
447 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x01, &data
);
449 /* see if we've set up our endpoint info yet *
450 * (can't set it up in mos7720_startup as the *
451 * structures were not set up at that time.) */
452 if (!mos7720_serial
->interrupt_started
) {
453 dbg("Interrupt buffer NULL !!!");
455 /* not set up yet, so do it now */
456 mos7720_serial
->interrupt_started
= 1;
458 dbg("To Submit URB !!!");
460 /* set up our interrupt urb */
461 usb_fill_int_urb(port0
->interrupt_in_urb
, serial
->dev
,
462 usb_rcvintpipe(serial
->dev
,
463 port
->interrupt_in_endpointAddress
),
464 port0
->interrupt_in_buffer
,
465 port0
->interrupt_in_urb
->transfer_buffer_length
,
466 mos7720_interrupt_callback
, mos7720_port
,
467 port0
->interrupt_in_urb
->interval
);
469 /* start interrupt read for this mos7720 this interrupt *
470 * will continue as long as the mos7720 is connected */
471 dbg("Submit URB over !!!");
472 response
= usb_submit_urb(port0
->interrupt_in_urb
, GFP_KERNEL
);
475 "%s - Error %d submitting control urb\n",
479 /* set up our bulk in urb */
480 usb_fill_bulk_urb(port
->read_urb
, serial
->dev
,
481 usb_rcvbulkpipe(serial
->dev
,
482 port
->bulk_in_endpointAddress
),
483 port
->bulk_in_buffer
,
484 port
->read_urb
->transfer_buffer_length
,
485 mos7720_bulk_in_callback
, mos7720_port
);
486 response
= usb_submit_urb(port
->read_urb
, GFP_KERNEL
);
488 dev_err(&port
->dev
, "%s - Error %d submitting read urb\n",
491 /* initialize our icount structure */
492 memset(&(mos7720_port
->icount
), 0x00, sizeof(mos7720_port
->icount
));
494 /* initialize our port settings */
495 mos7720_port
->shadowMCR
= UART_MCR_OUT2
; /* Must set to enable ints! */
497 /* send a open port command */
498 mos7720_port
->open
= 1;
504 * mos7720_chars_in_buffer
505 * this function is called by the tty driver when it wants to know how many
506 * bytes of data we currently have outstanding in the port (data that has
507 * been written, but hasn't made it out the port yet)
508 * If successful, we return the number of bytes left to be written in the
510 * Otherwise we return a negative error number.
512 static int mos7720_chars_in_buffer(struct tty_struct
*tty
)
514 struct usb_serial_port
*port
= tty
->driver_data
;
517 struct moschip_port
*mos7720_port
;
519 dbg("%s:entering ...........", __func__
);
521 mos7720_port
= usb_get_serial_port_data(port
);
522 if (mos7720_port
== NULL
) {
523 dbg("%s:leaving ...........", __func__
);
527 for (i
= 0; i
< NUM_URBS
; ++i
) {
528 if (mos7720_port
->write_urb_pool
[i
] &&
529 mos7720_port
->write_urb_pool
[i
]->status
== -EINPROGRESS
)
530 chars
+= URB_TRANSFER_BUFFER_SIZE
;
532 dbg("%s - returns %d", __func__
, chars
);
536 static void mos7720_close(struct tty_struct
*tty
,
537 struct usb_serial_port
*port
, struct file
*filp
)
539 struct usb_serial
*serial
;
540 struct moschip_port
*mos7720_port
;
544 dbg("mos7720_close:entering...");
546 serial
= port
->serial
;
548 mos7720_port
= usb_get_serial_port_data(port
);
549 if (mos7720_port
== NULL
)
552 for (j
= 0; j
< NUM_URBS
; ++j
)
553 usb_kill_urb(mos7720_port
->write_urb_pool
[j
]);
555 /* Freeing Write URBs */
556 for (j
= 0; j
< NUM_URBS
; ++j
) {
557 if (mos7720_port
->write_urb_pool
[j
]) {
558 kfree(mos7720_port
->write_urb_pool
[j
]->transfer_buffer
);
559 usb_free_urb(mos7720_port
->write_urb_pool
[j
]);
563 /* While closing port, shutdown all bulk read, write *
564 * and interrupt read if they exists, otherwise nop */
565 dbg("Shutdown bulk write");
566 usb_kill_urb(port
->write_urb
);
567 dbg("Shutdown bulk read");
568 usb_kill_urb(port
->read_urb
);
570 mutex_lock(&serial
->disc_mutex
);
571 /* these commands must not be issued if the device has
572 * been disconnected */
573 if (!serial
->disconnected
) {
575 send_mos_cmd(serial
, MOS_WRITE
,
576 port
->number
- port
->serial
->minor
, 0x04, &data
);
579 send_mos_cmd(serial
, MOS_WRITE
,
580 port
->number
- port
->serial
->minor
, 0x01, &data
);
582 mutex_unlock(&serial
->disc_mutex
);
583 mos7720_port
->open
= 0;
585 dbg("Leaving %s", __func__
);
588 static void mos7720_break(struct tty_struct
*tty
, int break_state
)
590 struct usb_serial_port
*port
= tty
->driver_data
;
592 struct usb_serial
*serial
;
593 struct moschip_port
*mos7720_port
;
595 dbg("Entering %s", __func__
);
597 serial
= port
->serial
;
599 mos7720_port
= usb_get_serial_port_data(port
);
600 if (mos7720_port
== NULL
)
603 if (break_state
== -1)
604 data
= mos7720_port
->shadowLCR
| UART_LCR_SBC
;
606 data
= mos7720_port
->shadowLCR
& ~UART_LCR_SBC
;
608 mos7720_port
->shadowLCR
= data
;
609 send_mos_cmd(serial
, MOS_WRITE
, port
->number
- port
->serial
->minor
,
617 * this function is called by the tty driver when it wants to know how many
618 * bytes of data we can accept for a specific port.
619 * If successful, we return the amount of room that we have for this port
620 * Otherwise we return a negative error number.
622 static int mos7720_write_room(struct tty_struct
*tty
)
624 struct usb_serial_port
*port
= tty
->driver_data
;
625 struct moschip_port
*mos7720_port
;
629 dbg("%s:entering ...........", __func__
);
631 mos7720_port
= usb_get_serial_port_data(port
);
632 if (mos7720_port
== NULL
) {
633 dbg("%s:leaving ...........", __func__
);
638 for (i
= 0; i
< NUM_URBS
; ++i
) {
639 if (mos7720_port
->write_urb_pool
[i
] &&
640 mos7720_port
->write_urb_pool
[i
]->status
!= -EINPROGRESS
)
641 room
+= URB_TRANSFER_BUFFER_SIZE
;
644 dbg("%s - returns %d", __func__
, room
);
648 static int mos7720_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
649 const unsigned char *data
, int count
)
656 struct moschip_port
*mos7720_port
;
657 struct usb_serial
*serial
;
659 const unsigned char *current_position
= data
;
661 dbg("%s:entering ...........", __func__
);
663 serial
= port
->serial
;
665 mos7720_port
= usb_get_serial_port_data(port
);
666 if (mos7720_port
== NULL
) {
667 dbg("mos7720_port is NULL");
671 /* try to find a free urb in the list */
674 for (i
= 0; i
< NUM_URBS
; ++i
) {
675 if (mos7720_port
->write_urb_pool
[i
] &&
676 mos7720_port
->write_urb_pool
[i
]->status
!= -EINPROGRESS
) {
677 urb
= mos7720_port
->write_urb_pool
[i
];
684 dbg("%s - no more free urbs", __func__
);
688 if (urb
->transfer_buffer
== NULL
) {
689 urb
->transfer_buffer
= kmalloc(URB_TRANSFER_BUFFER_SIZE
,
691 if (urb
->transfer_buffer
== NULL
) {
692 dev_err(&port
->dev
, "%s no more kernel memory...\n",
697 transfer_size
= min(count
, URB_TRANSFER_BUFFER_SIZE
);
699 memcpy(urb
->transfer_buffer
, current_position
, transfer_size
);
700 usb_serial_debug_data(debug
, &port
->dev
, __func__
, transfer_size
,
701 urb
->transfer_buffer
);
703 /* fill urb with data and submit */
704 usb_fill_bulk_urb(urb
, serial
->dev
,
705 usb_sndbulkpipe(serial
->dev
,
706 port
->bulk_out_endpointAddress
),
707 urb
->transfer_buffer
, transfer_size
,
708 mos7720_bulk_out_data_callback
, mos7720_port
);
710 /* send it down the pipe */
711 status
= usb_submit_urb(urb
, GFP_ATOMIC
);
713 dev_err(&port
->dev
, "%s - usb_submit_urb(write bulk) failed "
714 "with status = %d\n", __func__
, status
);
718 bytes_sent
= transfer_size
;
724 static void mos7720_throttle(struct tty_struct
*tty
)
726 struct usb_serial_port
*port
= tty
->driver_data
;
727 struct moschip_port
*mos7720_port
;
730 dbg("%s- port %d\n", __func__
, port
->number
);
732 mos7720_port
= usb_get_serial_port_data(port
);
734 if (mos7720_port
== NULL
)
737 if (!mos7720_port
->open
) {
738 dbg("port not opened");
742 dbg("%s: Entering ..........", __func__
);
744 /* if we are implementing XON/XOFF, send the stop character */
746 unsigned char stop_char
= STOP_CHAR(tty
);
747 status
= mos7720_write(tty
, port
, &stop_char
, 1);
752 /* if we are implementing RTS/CTS, toggle that line */
753 if (tty
->termios
->c_cflag
& CRTSCTS
) {
754 mos7720_port
->shadowMCR
&= ~UART_MCR_RTS
;
755 status
= send_mos_cmd(port
->serial
, MOS_WRITE
,
756 port
->number
- port
->serial
->minor
,
757 UART_MCR
, &mos7720_port
->shadowMCR
);
763 static void mos7720_unthrottle(struct tty_struct
*tty
)
765 struct usb_serial_port
*port
= tty
->driver_data
;
766 struct moschip_port
*mos7720_port
= usb_get_serial_port_data(port
);
769 if (mos7720_port
== NULL
)
772 if (!mos7720_port
->open
) {
773 dbg("%s - port not opened", __func__
);
777 dbg("%s: Entering ..........", __func__
);
779 /* if we are implementing XON/XOFF, send the start character */
781 unsigned char start_char
= START_CHAR(tty
);
782 status
= mos7720_write(tty
, port
, &start_char
, 1);
787 /* if we are implementing RTS/CTS, toggle that line */
788 if (tty
->termios
->c_cflag
& CRTSCTS
) {
789 mos7720_port
->shadowMCR
|= UART_MCR_RTS
;
790 status
= send_mos_cmd(port
->serial
, MOS_WRITE
,
791 port
->number
- port
->serial
->minor
,
792 UART_MCR
, &mos7720_port
->shadowMCR
);
798 static int set_higher_rates(struct moschip_port
*mos7720_port
,
802 struct usb_serial_port
*port
;
803 struct usb_serial
*serial
;
806 if (mos7720_port
== NULL
)
809 port
= mos7720_port
->port
;
810 serial
= port
->serial
;
812 /***********************************************
813 * Init Sequence for higher rates
814 ***********************************************/
815 dbg("Sending Setting Commands ..........");
816 port_number
= port
->number
- port
->serial
->minor
;
819 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x01, &data
);
821 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x02, &data
);
823 send_mos_cmd(serial
, MOS_WRITE
, port
->number
, 0x02, &data
);
825 mos7720_port
->shadowMCR
= data
;
826 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x04, &data
);
828 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x04, &data
);
831 send_mos_cmd(serial
, MOS_READ
, MOS_MAX_PORT
, 0x08, &data
);
833 send_mos_cmd(serial
, MOS_WRITE
, MOS_MAX_PORT
, 0x08, &data
);
836 /***********************************************
837 * Set for higher rates *
838 ***********************************************/
841 send_mos_cmd(serial
, MOS_WRITE
, MOS_MAX_PORT
, port_number
+ 1, &data
);
844 send_mos_cmd(serial
, MOS_READ
, MOS_MAX_PORT
, 0x08, &data
);
846 send_mos_cmd(serial
, MOS_WRITE
, MOS_MAX_PORT
, 0x08, &data
);
849 mos7720_port
->shadowMCR
= data
;
850 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x04, &data
);
852 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x04, &data
);
854 /***********************************************
856 ***********************************************/
858 data
= mos7720_port
->shadowLCR
| UART_LCR_DLAB
;
859 mos7720_port
->shadowLCR
= data
;
860 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x03, &data
);
862 data
= 0x001; /* DLL */
863 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x00, &data
);
864 data
= 0x000; /* DLM */
865 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x01, &data
);
867 data
= mos7720_port
->shadowLCR
& ~UART_LCR_DLAB
;
868 mos7720_port
->shadowLCR
= data
;
869 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x03, &data
);
874 /* baud rate information */
875 struct divisor_table_entry
{
880 /* Define table of divisors for moschip 7720 hardware *
881 * These assume a 3.6864MHz crystal, the standard /16, and *
883 static struct divisor_table_entry divisor_table
[] = {
885 { 110, 1047}, /* 2094.545455 => 230450 => .0217 % over */
886 { 134, 857}, /* 1713.011152 => 230398.5 => .00065% under */
902 /*****************************************************************************
903 * calc_baud_rate_divisor
904 * this function calculates the proper baud rate divisor for the specified
906 *****************************************************************************/
907 static int calc_baud_rate_divisor(int baudrate
, int *divisor
)
915 dbg("%s - %d", __func__
, baudrate
);
917 for (i
= 0; i
< ARRAY_SIZE(divisor_table
); i
++) {
918 if (divisor_table
[i
].baudrate
== baudrate
) {
919 *divisor
= divisor_table
[i
].divisor
;
924 /* After trying for all the standard baud rates *
925 * Try calculating the divisor for this baud rate */
926 if (baudrate
> 75 && baudrate
< 230400) {
927 /* get the divisor */
928 custom
= (__u16
)(230400L / baudrate
);
930 /* Check for round off */
931 round1
= (__u16
)(2304000L / baudrate
);
932 round
= (__u16
)(round1
- (custom
* 10));
937 dbg("Baud %d = %d", baudrate
, custom
);
941 dbg("Baud calculation Failed...");
946 * send_cmd_write_baud_rate
947 * this function sends the proper command to change the baud rate of the
950 static int send_cmd_write_baud_rate(struct moschip_port
*mos7720_port
,
953 struct usb_serial_port
*port
;
954 struct usb_serial
*serial
;
958 unsigned char number
;
960 if (mos7720_port
== NULL
)
963 port
= mos7720_port
->port
;
964 serial
= port
->serial
;
966 dbg("%s: Entering ..........", __func__
);
968 number
= port
->number
- port
->serial
->minor
;
969 dbg("%s - port = %d, baud = %d", __func__
, port
->number
, baudrate
);
971 /* Calculate the Divisor */
972 status
= calc_baud_rate_divisor(baudrate
, &divisor
);
974 dev_err(&port
->dev
, "%s - bad baud rate\n", __func__
);
978 /* Enable access to divisor latch */
979 data
= mos7720_port
->shadowLCR
| UART_LCR_DLAB
;
980 mos7720_port
->shadowLCR
= data
;
981 send_mos_cmd(serial
, MOS_WRITE
, number
, UART_LCR
, &data
);
983 /* Write the divisor */
984 data
= ((unsigned char)(divisor
& 0xff));
985 send_mos_cmd(serial
, MOS_WRITE
, number
, 0x00, &data
);
987 data
= ((unsigned char)((divisor
& 0xff00) >> 8));
988 send_mos_cmd(serial
, MOS_WRITE
, number
, 0x01, &data
);
990 /* Disable access to divisor latch */
991 data
= mos7720_port
->shadowLCR
& ~UART_LCR_DLAB
;
992 mos7720_port
->shadowLCR
= data
;
993 send_mos_cmd(serial
, MOS_WRITE
, number
, 0x03, &data
);
999 * change_port_settings
1000 * This routine is called to set the UART on the device to match
1001 * the specified new settings.
1003 static void change_port_settings(struct tty_struct
*tty
,
1004 struct moschip_port
*mos7720_port
,
1005 struct ktermios
*old_termios
)
1007 struct usb_serial_port
*port
;
1008 struct usb_serial
*serial
;
1020 if (mos7720_port
== NULL
)
1023 port
= mos7720_port
->port
;
1024 serial
= port
->serial
;
1025 port_number
= port
->number
- port
->serial
->minor
;
1027 dbg("%s - port %d", __func__
, port
->number
);
1029 if (!mos7720_port
->open
) {
1030 dbg("%s - port not opened", __func__
);
1034 dbg("%s: Entering ..........", __func__
);
1036 lData
= UART_LCR_WLEN8
;
1037 lStop
= 0x00; /* 1 stop bit */
1038 lParity
= 0x00; /* No parity */
1040 cflag
= tty
->termios
->c_cflag
;
1041 iflag
= tty
->termios
->c_iflag
;
1043 /* Change the number of bits */
1044 switch (cflag
& CSIZE
) {
1046 lData
= UART_LCR_WLEN5
;
1051 lData
= UART_LCR_WLEN6
;
1056 lData
= UART_LCR_WLEN7
;
1061 lData
= UART_LCR_WLEN8
;
1065 /* Change the Parity bit */
1066 if (cflag
& PARENB
) {
1067 if (cflag
& PARODD
) {
1068 lParity
= UART_LCR_PARITY
;
1069 dbg("%s - parity = odd", __func__
);
1071 lParity
= (UART_LCR_EPAR
| UART_LCR_PARITY
);
1072 dbg("%s - parity = even", __func__
);
1076 dbg("%s - parity = none", __func__
);
1080 lParity
= lParity
| 0x20;
1082 /* Change the Stop bit */
1083 if (cflag
& CSTOPB
) {
1084 lStop
= UART_LCR_STOP
;
1085 dbg("%s - stop bits = 2", __func__
);
1088 dbg("%s - stop bits = 1", __func__
);
1091 #define LCR_BITS_MASK 0x03 /* Mask for bits/char field */
1092 #define LCR_STOP_MASK 0x04 /* Mask for stop bits field */
1093 #define LCR_PAR_MASK 0x38 /* Mask for parity field */
1095 /* Update the LCR with the correct value */
1096 mos7720_port
->shadowLCR
&=
1097 ~(LCR_BITS_MASK
| LCR_STOP_MASK
| LCR_PAR_MASK
);
1098 mos7720_port
->shadowLCR
|= (lData
| lParity
| lStop
);
1101 /* Disable Interrupts */
1103 send_mos_cmd(serial
, MOS_WRITE
, port
->number
- port
->serial
->minor
,
1107 send_mos_cmd(serial
, MOS_WRITE
, port_number
, UART_FCR
, &data
);
1110 send_mos_cmd(serial
, MOS_WRITE
, port_number
, UART_FCR
, &data
);
1112 /* Send the updated LCR value to the mos7720 */
1113 data
= mos7720_port
->shadowLCR
;
1114 send_mos_cmd(serial
, MOS_WRITE
, port_number
, UART_LCR
, &data
);
1117 mos7720_port
->shadowMCR
= data
;
1118 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x04, &data
);
1120 send_mos_cmd(serial
, MOS_WRITE
, port_number
, 0x04, &data
);
1122 /* set up the MCR register and send it to the mos7720 */
1123 mos7720_port
->shadowMCR
= UART_MCR_OUT2
;
1125 mos7720_port
->shadowMCR
|= (UART_MCR_DTR
| UART_MCR_RTS
);
1127 if (cflag
& CRTSCTS
) {
1128 mos7720_port
->shadowMCR
|= (UART_MCR_XONANY
);
1129 /* To set hardware flow control to the specified *
1130 * serial port, in SP1/2_CONTROL_REG */
1133 send_mos_cmd(serial
, MOS_WRITE
, MOS_MAX_PORT
,
1137 send_mos_cmd(serial
, MOS_WRITE
, MOS_MAX_PORT
,
1141 mos7720_port
->shadowMCR
&= ~(UART_MCR_XONANY
);
1144 data
= mos7720_port
->shadowMCR
;
1145 send_mos_cmd(serial
, MOS_WRITE
, port_number
, UART_MCR
, &data
);
1147 /* Determine divisor based on baud rate */
1148 baud
= tty_get_baud_rate(tty
);
1150 /* pick a default, any default... */
1151 dbg("Picked default baud...");
1155 if (baud
>= 230400) {
1156 set_higher_rates(mos7720_port
, baud
);
1157 /* Enable Interrupts */
1159 send_mos_cmd(serial
, MOS_WRITE
, port_number
, UART_IER
, &data
);
1163 dbg("%s - baud rate = %d", __func__
, baud
);
1164 status
= send_cmd_write_baud_rate(mos7720_port
, baud
);
1165 /* FIXME: needs to write actual resulting baud back not just
1168 tty_encode_baud_rate(tty
, baud
, baud
);
1169 /* Enable Interrupts */
1171 send_mos_cmd(serial
, MOS_WRITE
, port_number
, UART_IER
, &data
);
1173 if (port
->read_urb
->status
!= -EINPROGRESS
) {
1174 port
->read_urb
->dev
= serial
->dev
;
1176 status
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
1178 dbg("usb_submit_urb(read bulk) failed, status = %d",
1185 * mos7720_set_termios
1186 * this function is called by the tty driver when it wants to change the
1187 * termios structure.
1189 static void mos7720_set_termios(struct tty_struct
*tty
,
1190 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
1194 struct usb_serial
*serial
;
1195 struct moschip_port
*mos7720_port
;
1197 serial
= port
->serial
;
1199 mos7720_port
= usb_get_serial_port_data(port
);
1201 if (mos7720_port
== NULL
)
1204 if (!mos7720_port
->open
) {
1205 dbg("%s - port not opened", __func__
);
1209 dbg("%s\n", "setting termios - ASPIRE");
1211 cflag
= tty
->termios
->c_cflag
;
1213 dbg("%s - cflag %08x iflag %08x", __func__
,
1214 tty
->termios
->c_cflag
,
1215 RELEVANT_IFLAG(tty
->termios
->c_iflag
));
1217 dbg("%s - old cflag %08x old iflag %08x", __func__
,
1218 old_termios
->c_cflag
,
1219 RELEVANT_IFLAG(old_termios
->c_iflag
));
1221 dbg("%s - port %d", __func__
, port
->number
);
1223 /* change the port settings to the new ones specified */
1224 change_port_settings(tty
, mos7720_port
, old_termios
);
1226 if (!port
->read_urb
) {
1227 dbg("%s", "URB KILLED !!!!!\n");
1231 if (port
->read_urb
->status
!= -EINPROGRESS
) {
1232 port
->read_urb
->dev
= serial
->dev
;
1233 status
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
1235 dbg("usb_submit_urb(read bulk) failed, status = %d",
1242 * get_lsr_info - get line status register info
1244 * Purpose: Let user call ioctl() to get info when the UART physically
1245 * is emptied. On bus types like RS485, the transmitter must
1246 * release the bus after transmitting. This must be done when
1247 * the transmit shift register is empty, not be done when the
1248 * transmit holding register is empty. This functionality
1249 * allows an RS485 driver to be written in user space.
1251 static int get_lsr_info(struct tty_struct
*tty
,
1252 struct moschip_port
*mos7720_port
, unsigned int __user
*value
)
1255 unsigned int result
= 0;
1257 count
= mos7720_chars_in_buffer(tty
);
1259 dbg("%s -- Empty", __func__
);
1260 result
= TIOCSER_TEMT
;
1263 if (copy_to_user(value
, &result
, sizeof(int)))
1268 static int set_modem_info(struct moschip_port
*mos7720_port
, unsigned int cmd
,
1269 unsigned int __user
*value
)
1275 struct usb_serial_port
*port
;
1277 if (mos7720_port
== NULL
)
1280 port
= (struct usb_serial_port
*)mos7720_port
->port
;
1281 mcr
= mos7720_port
->shadowMCR
;
1283 if (copy_from_user(&arg
, value
, sizeof(int)))
1288 if (arg
& TIOCM_RTS
)
1289 mcr
|= UART_MCR_RTS
;
1290 if (arg
& TIOCM_DTR
)
1291 mcr
|= UART_MCR_RTS
;
1292 if (arg
& TIOCM_LOOP
)
1293 mcr
|= UART_MCR_LOOP
;
1297 if (arg
& TIOCM_RTS
)
1298 mcr
&= ~UART_MCR_RTS
;
1299 if (arg
& TIOCM_DTR
)
1300 mcr
&= ~UART_MCR_RTS
;
1301 if (arg
& TIOCM_LOOP
)
1302 mcr
&= ~UART_MCR_LOOP
;
1306 /* turn off the RTS and DTR and LOOPBACK
1307 * and then only turn on what was asked to */
1308 mcr
&= ~(UART_MCR_RTS
| UART_MCR_DTR
| UART_MCR_LOOP
);
1309 mcr
|= ((arg
& TIOCM_RTS
) ? UART_MCR_RTS
: 0);
1310 mcr
|= ((arg
& TIOCM_DTR
) ? UART_MCR_DTR
: 0);
1311 mcr
|= ((arg
& TIOCM_LOOP
) ? UART_MCR_LOOP
: 0);
1315 mos7720_port
->shadowMCR
= mcr
;
1317 data
= mos7720_port
->shadowMCR
;
1318 send_mos_cmd(port
->serial
, MOS_WRITE
,
1319 port
->number
- port
->serial
->minor
, UART_MCR
, &data
);
1324 static int get_modem_info(struct moschip_port
*mos7720_port
,
1325 unsigned int __user
*value
)
1327 unsigned int result
= 0;
1328 unsigned int msr
= mos7720_port
->shadowMSR
;
1329 unsigned int mcr
= mos7720_port
->shadowMCR
;
1331 result
= ((mcr
& UART_MCR_DTR
) ? TIOCM_DTR
: 0) /* 0x002 */
1332 | ((mcr
& UART_MCR_RTS
) ? TIOCM_RTS
: 0) /* 0x004 */
1333 | ((msr
& UART_MSR_CTS
) ? TIOCM_CTS
: 0) /* 0x020 */
1334 | ((msr
& UART_MSR_DCD
) ? TIOCM_CAR
: 0) /* 0x040 */
1335 | ((msr
& UART_MSR_RI
) ? TIOCM_RI
: 0) /* 0x080 */
1336 | ((msr
& UART_MSR_DSR
) ? TIOCM_DSR
: 0); /* 0x100 */
1339 dbg("%s -- %x", __func__
, result
);
1341 if (copy_to_user(value
, &result
, sizeof(int)))
1346 static int get_serial_info(struct moschip_port
*mos7720_port
,
1347 struct serial_struct __user
*retinfo
)
1349 struct serial_struct tmp
;
1354 memset(&tmp
, 0, sizeof(tmp
));
1356 tmp
.type
= PORT_16550A
;
1357 tmp
.line
= mos7720_port
->port
->serial
->minor
;
1358 tmp
.port
= mos7720_port
->port
->number
;
1360 tmp
.flags
= ASYNC_SKIP_TEST
| ASYNC_AUTO_IRQ
;
1361 tmp
.xmit_fifo_size
= NUM_URBS
* URB_TRANSFER_BUFFER_SIZE
;
1362 tmp
.baud_base
= 9600;
1363 tmp
.close_delay
= 5*HZ
;
1364 tmp
.closing_wait
= 30*HZ
;
1366 if (copy_to_user(retinfo
, &tmp
, sizeof(*retinfo
)))
1371 static int mos7720_ioctl(struct tty_struct
*tty
, struct file
*file
,
1372 unsigned int cmd
, unsigned long arg
)
1374 struct usb_serial_port
*port
= tty
->driver_data
;
1375 struct moschip_port
*mos7720_port
;
1376 struct async_icount cnow
;
1377 struct async_icount cprev
;
1378 struct serial_icounter_struct icount
;
1380 mos7720_port
= usb_get_serial_port_data(port
);
1381 if (mos7720_port
== NULL
)
1384 dbg("%s - port %d, cmd = 0x%x", __func__
, port
->number
, cmd
);
1388 dbg("%s (%d) TIOCSERGETLSR", __func__
, port
->number
);
1389 return get_lsr_info(tty
, mos7720_port
,
1390 (unsigned int __user
*)arg
);
1393 /* FIXME: These should be using the mode methods */
1397 dbg("%s (%d) TIOCMSET/TIOCMBIC/TIOCMSET",
1398 __func__
, port
->number
);
1399 return set_modem_info(mos7720_port
, cmd
,
1400 (unsigned int __user
*)arg
);
1403 dbg("%s (%d) TIOCMGET", __func__
, port
->number
);
1404 return get_modem_info(mos7720_port
,
1405 (unsigned int __user
*)arg
);
1408 dbg("%s (%d) TIOCGSERIAL", __func__
, port
->number
);
1409 return get_serial_info(mos7720_port
,
1410 (struct serial_struct __user
*)arg
);
1413 dbg("%s (%d) TIOCMIWAIT", __func__
, port
->number
);
1414 cprev
= mos7720_port
->icount
;
1416 if (signal_pending(current
))
1417 return -ERESTARTSYS
;
1418 cnow
= mos7720_port
->icount
;
1419 if (cnow
.rng
== cprev
.rng
&& cnow
.dsr
== cprev
.dsr
&&
1420 cnow
.dcd
== cprev
.dcd
&& cnow
.cts
== cprev
.cts
)
1421 return -EIO
; /* no change => error */
1422 if (((arg
& TIOCM_RNG
) && (cnow
.rng
!= cprev
.rng
)) ||
1423 ((arg
& TIOCM_DSR
) && (cnow
.dsr
!= cprev
.dsr
)) ||
1424 ((arg
& TIOCM_CD
) && (cnow
.dcd
!= cprev
.dcd
)) ||
1425 ((arg
& TIOCM_CTS
) && (cnow
.cts
!= cprev
.cts
))) {
1434 cnow
= mos7720_port
->icount
;
1435 icount
.cts
= cnow
.cts
;
1436 icount
.dsr
= cnow
.dsr
;
1437 icount
.rng
= cnow
.rng
;
1438 icount
.dcd
= cnow
.dcd
;
1439 icount
.rx
= cnow
.rx
;
1440 icount
.tx
= cnow
.tx
;
1441 icount
.frame
= cnow
.frame
;
1442 icount
.overrun
= cnow
.overrun
;
1443 icount
.parity
= cnow
.parity
;
1444 icount
.brk
= cnow
.brk
;
1445 icount
.buf_overrun
= cnow
.buf_overrun
;
1447 dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d", __func__
,
1448 port
->number
, icount
.rx
, icount
.tx
);
1449 if (copy_to_user((void __user
*)arg
, &icount
, sizeof(icount
)))
1454 return -ENOIOCTLCMD
;
1457 static int mos7720_startup(struct usb_serial
*serial
)
1459 struct moschip_serial
*mos7720_serial
;
1460 struct moschip_port
*mos7720_port
;
1461 struct usb_device
*dev
;
1465 dbg("%s: Entering ..........", __func__
);
1468 dbg("Invalid Handler");
1474 /* create our private serial structure */
1475 mos7720_serial
= kzalloc(sizeof(struct moschip_serial
), GFP_KERNEL
);
1476 if (mos7720_serial
== NULL
) {
1477 dev_err(&dev
->dev
, "%s - Out of memory\n", __func__
);
1481 usb_set_serial_data(serial
, mos7720_serial
);
1483 /* we set up the pointers to the endpoints in the mos7720_open *
1484 * function, as the structures aren't created yet. */
1486 /* set up port private structures */
1487 for (i
= 0; i
< serial
->num_ports
; ++i
) {
1488 mos7720_port
= kzalloc(sizeof(struct moschip_port
), GFP_KERNEL
);
1489 if (mos7720_port
== NULL
) {
1490 dev_err(&dev
->dev
, "%s - Out of memory\n", __func__
);
1491 usb_set_serial_data(serial
, NULL
);
1492 kfree(mos7720_serial
);
1496 /* Initialize all port interrupt end point to port 0 int
1497 * endpoint. Our device has only one interrupt endpoint
1498 * comman to all ports */
1499 serial
->port
[i
]->interrupt_in_endpointAddress
=
1500 serial
->port
[0]->interrupt_in_endpointAddress
;
1502 mos7720_port
->port
= serial
->port
[i
];
1503 usb_set_serial_port_data(serial
->port
[i
], mos7720_port
);
1505 dbg("port number is %d", serial
->port
[i
]->number
);
1506 dbg("serial number is %d", serial
->minor
);
1510 /* setting configuration feature to one */
1511 usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
1512 (__u8
)0x03, 0x00, 0x01, 0x00, NULL
, 0x00, 5*HZ
);
1514 /* LSR For Port 1 */
1515 send_mos_cmd(serial
, MOS_READ
, 0x00, UART_LSR
, &data
);
1516 dbg("LSR:%x", data
);
1518 /* LSR For Port 2 */
1519 send_mos_cmd(serial
, MOS_READ
, 0x01, UART_LSR
, &data
);
1520 dbg("LSR:%x", data
);
1525 static void mos7720_shutdown(struct usb_serial
*serial
)
1529 /* free private structure allocated for serial port */
1530 for (i
= 0; i
< serial
->num_ports
; ++i
) {
1531 kfree(usb_get_serial_port_data(serial
->port
[i
]));
1532 usb_set_serial_port_data(serial
->port
[i
], NULL
);
1535 /* free private structure allocated for serial device */
1536 kfree(usb_get_serial_data(serial
));
1537 usb_set_serial_data(serial
, NULL
);
1540 static struct usb_driver usb_driver
= {
1541 .name
= "moschip7720",
1542 .probe
= usb_serial_probe
,
1543 .disconnect
= usb_serial_disconnect
,
1544 .id_table
= moschip_port_id_table
,
1548 static struct usb_serial_driver moschip7720_2port_driver
= {
1550 .owner
= THIS_MODULE
,
1551 .name
= "moschip7720",
1553 .description
= "Moschip 2 port adapter",
1554 .usb_driver
= &usb_driver
,
1555 .id_table
= moschip_port_id_table
,
1557 .open
= mos7720_open
,
1558 .close
= mos7720_close
,
1559 .throttle
= mos7720_throttle
,
1560 .unthrottle
= mos7720_unthrottle
,
1561 .attach
= mos7720_startup
,
1562 .shutdown
= mos7720_shutdown
,
1563 .ioctl
= mos7720_ioctl
,
1564 .set_termios
= mos7720_set_termios
,
1565 .write
= mos7720_write
,
1566 .write_room
= mos7720_write_room
,
1567 .chars_in_buffer
= mos7720_chars_in_buffer
,
1568 .break_ctl
= mos7720_break
,
1569 .read_bulk_callback
= mos7720_bulk_in_callback
,
1570 .read_int_callback
= mos7720_interrupt_callback
,
1573 static int __init
moschip7720_init(void)
1577 dbg("%s: Entering ..........", __func__
);
1579 /* Register with the usb serial */
1580 retval
= usb_serial_register(&moschip7720_2port_driver
);
1582 goto failed_port_device_register
;
1584 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_VERSION
":"
1587 /* Register with the usb */
1588 retval
= usb_register(&usb_driver
);
1590 goto failed_usb_register
;
1594 failed_usb_register
:
1595 usb_serial_deregister(&moschip7720_2port_driver
);
1597 failed_port_device_register
:
1601 static void __exit
moschip7720_exit(void)
1603 usb_deregister(&usb_driver
);
1604 usb_serial_deregister(&moschip7720_2port_driver
);
1607 module_init(moschip7720_init
);
1608 module_exit(moschip7720_exit
);
1610 /* Module information */
1611 MODULE_AUTHOR(DRIVER_AUTHOR
);
1612 MODULE_DESCRIPTION(DRIVER_DESC
);
1613 MODULE_LICENSE("GPL");
1615 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1616 MODULE_PARM_DESC(debug
, "Debug enabled or not");