2 * IPWireless 3G PCMCIA Network Driver
5 * by Stephen Blackheath <stephen@blacksapphire.com>,
6 * Ben Martel <benm@symmetric.co.nz>
8 * Copyrighted as follows:
9 * Copyright (C) 2004 by Symmetric Systems Ltd (NZ)
11 * Various driver changes and rewrites, port to new kernels
12 * Copyright (C) 2006-2007 Jiri Kosina
14 * Misc code cleanups and updates
15 * Copyright (C) 2007 David Sterba
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/mutex.h>
21 #include <linux/ppp_defs.h>
23 #include <linux/ppp-ioctl.h>
24 #include <linux/sched.h>
25 #include <linux/serial.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/uaccess.h>
37 #define IPWIRELESS_PCMCIA_START (0)
38 #define IPWIRELESS_PCMCIA_MINORS (24)
39 #define IPWIRELESS_PCMCIA_MINOR_RANGE (8)
41 #define TTYTYPE_MODEM (0)
42 #define TTYTYPE_MONITOR (1)
43 #define TTYTYPE_RAS_RAW (2)
48 struct ipw_hardware
*hardware
;
49 unsigned int channel_idx
;
50 unsigned int secondary_channel_idx
;
52 struct ipw_network
*network
;
53 unsigned int control_lines
;
54 struct mutex ipw_tty_mutex
;
59 static struct ipw_tty
*ttys
[IPWIRELESS_PCMCIA_MINORS
];
61 static struct tty_driver
*ipw_tty_driver
;
63 static char *tty_type_name(int tty_type
)
65 static char *channel_names
[] = {
71 return channel_names
[tty_type
];
74 static struct ipw_tty
*get_tty(int index
)
77 * The 'ras_raw' channel is only available when 'loopback' mode
79 * Number of minor starts with 16 (_RANGE * _RAS_RAW).
81 if (!ipwireless_loopback
&& index
>=
82 IPWIRELESS_PCMCIA_MINOR_RANGE
* TTYTYPE_RAS_RAW
)
88 static int ipw_open(struct tty_struct
*linux_tty
, struct file
*filp
)
90 struct ipw_tty
*tty
= get_tty(linux_tty
->index
);
95 mutex_lock(&tty
->ipw_tty_mutex
);
98 mutex_unlock(&tty
->ipw_tty_mutex
);
101 if (tty
->port
.count
== 0)
102 tty
->tx_bytes_queued
= 0;
106 tty
->port
.tty
= linux_tty
;
107 linux_tty
->driver_data
= tty
;
108 tty
->port
.low_latency
= 1;
110 if (tty
->tty_type
== TTYTYPE_MODEM
)
111 ipwireless_ppp_open(tty
->network
);
113 mutex_unlock(&tty
->ipw_tty_mutex
);
118 static void do_ipw_close(struct ipw_tty
*tty
)
122 if (tty
->port
.count
== 0) {
123 struct tty_struct
*linux_tty
= tty
->port
.tty
;
125 if (linux_tty
!= NULL
) {
126 tty
->port
.tty
= NULL
;
127 linux_tty
->driver_data
= NULL
;
129 if (tty
->tty_type
== TTYTYPE_MODEM
)
130 ipwireless_ppp_close(tty
->network
);
135 static void ipw_hangup(struct tty_struct
*linux_tty
)
137 struct ipw_tty
*tty
= linux_tty
->driver_data
;
142 mutex_lock(&tty
->ipw_tty_mutex
);
143 if (tty
->port
.count
== 0) {
144 mutex_unlock(&tty
->ipw_tty_mutex
);
150 mutex_unlock(&tty
->ipw_tty_mutex
);
153 static void ipw_close(struct tty_struct
*linux_tty
, struct file
*filp
)
155 ipw_hangup(linux_tty
);
158 /* Take data received from hardware, and send it out the tty */
159 void ipwireless_tty_received(struct ipw_tty
*tty
, unsigned char *data
,
164 mutex_lock(&tty
->ipw_tty_mutex
);
166 if (!tty
->port
.count
) {
167 mutex_unlock(&tty
->ipw_tty_mutex
);
170 mutex_unlock(&tty
->ipw_tty_mutex
);
172 work
= tty_insert_flip_string(&tty
->port
, data
, length
);
175 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
176 ": %d chars not inserted to flip buffer!\n",
180 tty_flip_buffer_push(&tty
->port
);
183 static void ipw_write_packet_sent_callback(void *callback_data
,
184 unsigned int packet_length
)
186 struct ipw_tty
*tty
= callback_data
;
189 * Packet has been sent, so we subtract the number of bytes from our
190 * tally of outstanding TX bytes.
192 tty
->tx_bytes_queued
-= packet_length
;
195 static int ipw_write(struct tty_struct
*linux_tty
,
196 const unsigned char *buf
, int count
)
198 struct ipw_tty
*tty
= linux_tty
->driver_data
;
204 mutex_lock(&tty
->ipw_tty_mutex
);
205 if (!tty
->port
.count
) {
206 mutex_unlock(&tty
->ipw_tty_mutex
);
210 room
= IPWIRELESS_TX_QUEUE_SIZE
- tty
->tx_bytes_queued
;
213 /* Don't allow caller to write any more than we have room for */
218 mutex_unlock(&tty
->ipw_tty_mutex
);
222 ret
= ipwireless_send_packet(tty
->hardware
, IPW_CHANNEL_RAS
,
224 ipw_write_packet_sent_callback
, tty
);
226 mutex_unlock(&tty
->ipw_tty_mutex
);
230 tty
->tx_bytes_queued
+= count
;
231 mutex_unlock(&tty
->ipw_tty_mutex
);
236 static int ipw_write_room(struct tty_struct
*linux_tty
)
238 struct ipw_tty
*tty
= linux_tty
->driver_data
;
241 /* FIXME: Exactly how is the tty object locked here .. */
245 if (!tty
->port
.count
)
248 room
= IPWIRELESS_TX_QUEUE_SIZE
- tty
->tx_bytes_queued
;
255 static int ipwireless_get_serial_info(struct ipw_tty
*tty
,
256 struct serial_struct __user
*retinfo
)
258 struct serial_struct tmp
;
263 memset(&tmp
, 0, sizeof(tmp
));
264 tmp
.type
= PORT_UNKNOWN
;
265 tmp
.line
= tty
->index
;
269 tmp
.baud_base
= 115200;
271 tmp
.closing_wait
= 0;
272 tmp
.custom_divisor
= 0;
274 if (copy_to_user(retinfo
, &tmp
, sizeof(*retinfo
)))
280 static int ipw_chars_in_buffer(struct tty_struct
*linux_tty
)
282 struct ipw_tty
*tty
= linux_tty
->driver_data
;
287 if (!tty
->port
.count
)
290 return tty
->tx_bytes_queued
;
293 static int get_control_lines(struct ipw_tty
*tty
)
295 unsigned int my
= tty
->control_lines
;
296 unsigned int out
= 0;
298 if (my
& IPW_CONTROL_LINE_RTS
)
300 if (my
& IPW_CONTROL_LINE_DTR
)
302 if (my
& IPW_CONTROL_LINE_CTS
)
304 if (my
& IPW_CONTROL_LINE_DSR
)
306 if (my
& IPW_CONTROL_LINE_DCD
)
312 static int set_control_lines(struct ipw_tty
*tty
, unsigned int set
,
317 if (set
& TIOCM_RTS
) {
318 ret
= ipwireless_set_RTS(tty
->hardware
, tty
->channel_idx
, 1);
321 if (tty
->secondary_channel_idx
!= -1) {
322 ret
= ipwireless_set_RTS(tty
->hardware
,
323 tty
->secondary_channel_idx
, 1);
328 if (set
& TIOCM_DTR
) {
329 ret
= ipwireless_set_DTR(tty
->hardware
, tty
->channel_idx
, 1);
332 if (tty
->secondary_channel_idx
!= -1) {
333 ret
= ipwireless_set_DTR(tty
->hardware
,
334 tty
->secondary_channel_idx
, 1);
339 if (clear
& TIOCM_RTS
) {
340 ret
= ipwireless_set_RTS(tty
->hardware
, tty
->channel_idx
, 0);
341 if (tty
->secondary_channel_idx
!= -1) {
342 ret
= ipwireless_set_RTS(tty
->hardware
,
343 tty
->secondary_channel_idx
, 0);
348 if (clear
& TIOCM_DTR
) {
349 ret
= ipwireless_set_DTR(tty
->hardware
, tty
->channel_idx
, 0);
350 if (tty
->secondary_channel_idx
!= -1) {
351 ret
= ipwireless_set_DTR(tty
->hardware
,
352 tty
->secondary_channel_idx
, 0);
360 static int ipw_tiocmget(struct tty_struct
*linux_tty
)
362 struct ipw_tty
*tty
= linux_tty
->driver_data
;
363 /* FIXME: Exactly how is the tty object locked here .. */
368 if (!tty
->port
.count
)
371 return get_control_lines(tty
);
375 ipw_tiocmset(struct tty_struct
*linux_tty
,
376 unsigned int set
, unsigned int clear
)
378 struct ipw_tty
*tty
= linux_tty
->driver_data
;
379 /* FIXME: Exactly how is the tty object locked here .. */
384 if (!tty
->port
.count
)
387 return set_control_lines(tty
, set
, clear
);
390 static int ipw_ioctl(struct tty_struct
*linux_tty
,
391 unsigned int cmd
, unsigned long arg
)
393 struct ipw_tty
*tty
= linux_tty
->driver_data
;
398 if (!tty
->port
.count
)
401 /* FIXME: Exactly how is the tty object locked here .. */
405 return ipwireless_get_serial_info(tty
, (void __user
*) arg
);
408 return 0; /* Keeps the PCMCIA scripts happy. */
411 if (tty
->tty_type
== TTYTYPE_MODEM
) {
415 int chan
= ipwireless_ppp_channel_index(
420 if (put_user(chan
, (int __user
*) arg
))
427 int unit
= ipwireless_ppp_unit_number(
432 if (put_user(unit
, (int __user
*) arg
))
441 if (put_user(val
, (int __user
*) arg
))
446 return tty_perform_flush(linux_tty
, arg
);
452 static int add_tty(int j
,
453 struct ipw_hardware
*hardware
,
454 struct ipw_network
*network
, int channel_idx
,
455 int secondary_channel_idx
, int tty_type
)
457 ttys
[j
] = kzalloc(sizeof(struct ipw_tty
), GFP_KERNEL
);
461 ttys
[j
]->hardware
= hardware
;
462 ttys
[j
]->channel_idx
= channel_idx
;
463 ttys
[j
]->secondary_channel_idx
= secondary_channel_idx
;
464 ttys
[j
]->network
= network
;
465 ttys
[j
]->tty_type
= tty_type
;
466 mutex_init(&ttys
[j
]->ipw_tty_mutex
);
467 tty_port_init(&ttys
[j
]->port
);
469 tty_port_register_device(&ttys
[j
]->port
, ipw_tty_driver
, j
, NULL
);
470 ipwireless_associate_network_tty(network
, channel_idx
, ttys
[j
]);
472 if (secondary_channel_idx
!= -1)
473 ipwireless_associate_network_tty(network
,
474 secondary_channel_idx
,
476 /* check if we provide raw device (if loopback is enabled) */
478 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
479 ": registering %s device ttyIPWp%d\n",
480 tty_type_name(tty_type
), j
);
485 struct ipw_tty
*ipwireless_tty_create(struct ipw_hardware
*hardware
,
486 struct ipw_network
*network
)
490 for (i
= 0; i
< IPWIRELESS_PCMCIA_MINOR_RANGE
; i
++) {
493 for (j
= i
; j
< IPWIRELESS_PCMCIA_MINORS
;
494 j
+= IPWIRELESS_PCMCIA_MINOR_RANGE
)
495 if (ttys
[j
] != NULL
) {
503 if (add_tty(j
, hardware
, network
,
504 IPW_CHANNEL_DIALLER
, IPW_CHANNEL_RAS
,
508 j
+= IPWIRELESS_PCMCIA_MINOR_RANGE
;
509 if (add_tty(j
, hardware
, network
,
510 IPW_CHANNEL_DIALLER
, -1,
514 j
+= IPWIRELESS_PCMCIA_MINOR_RANGE
;
515 if (add_tty(j
, hardware
, network
,
527 * Must be called before ipwireless_network_free().
529 void ipwireless_tty_free(struct ipw_tty
*tty
)
532 struct ipw_network
*network
= ttys
[tty
->index
]->network
;
534 for (j
= tty
->index
; j
< IPWIRELESS_PCMCIA_MINORS
;
535 j
+= IPWIRELESS_PCMCIA_MINOR_RANGE
) {
536 struct ipw_tty
*ttyj
= ttys
[j
];
539 mutex_lock(&ttyj
->ipw_tty_mutex
);
541 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
542 ": deregistering %s device ttyIPWp%d\n",
543 tty_type_name(ttyj
->tty_type
), j
);
545 if (ttyj
->port
.tty
!= NULL
) {
546 mutex_unlock(&ttyj
->ipw_tty_mutex
);
547 tty_vhangup(ttyj
->port
.tty
);
548 /* FIXME: Exactly how is the tty object locked here
549 against a parallel ioctl etc */
550 /* FIXME2: hangup does not mean all processes
552 mutex_lock(&ttyj
->ipw_tty_mutex
);
554 while (ttyj
->port
.count
)
556 ipwireless_disassociate_network_ttys(network
,
558 tty_unregister_device(ipw_tty_driver
, j
);
559 tty_port_destroy(&ttyj
->port
);
561 mutex_unlock(&ttyj
->ipw_tty_mutex
);
567 static const struct tty_operations tty_ops
= {
570 .hangup
= ipw_hangup
,
572 .write_room
= ipw_write_room
,
574 .chars_in_buffer
= ipw_chars_in_buffer
,
575 .tiocmget
= ipw_tiocmget
,
576 .tiocmset
= ipw_tiocmset
,
579 int ipwireless_tty_init(void)
583 ipw_tty_driver
= alloc_tty_driver(IPWIRELESS_PCMCIA_MINORS
);
587 ipw_tty_driver
->driver_name
= IPWIRELESS_PCCARD_NAME
;
588 ipw_tty_driver
->name
= "ttyIPWp";
589 ipw_tty_driver
->major
= 0;
590 ipw_tty_driver
->minor_start
= IPWIRELESS_PCMCIA_START
;
591 ipw_tty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
592 ipw_tty_driver
->subtype
= SERIAL_TYPE_NORMAL
;
593 ipw_tty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
594 ipw_tty_driver
->init_termios
= tty_std_termios
;
595 ipw_tty_driver
->init_termios
.c_cflag
=
596 B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
597 ipw_tty_driver
->init_termios
.c_ispeed
= 9600;
598 ipw_tty_driver
->init_termios
.c_ospeed
= 9600;
599 tty_set_operations(ipw_tty_driver
, &tty_ops
);
600 result
= tty_register_driver(ipw_tty_driver
);
602 printk(KERN_ERR IPWIRELESS_PCCARD_NAME
603 ": failed to register tty driver\n");
604 put_tty_driver(ipw_tty_driver
);
611 void ipwireless_tty_release(void)
615 ret
= tty_unregister_driver(ipw_tty_driver
);
616 put_tty_driver(ipw_tty_driver
);
618 printk(KERN_ERR IPWIRELESS_PCCARD_NAME
619 ": tty_unregister_driver failed with code %d\n", ret
);
622 int ipwireless_tty_is_modem(struct ipw_tty
*tty
)
624 return tty
->tty_type
== TTYTYPE_MODEM
;
628 ipwireless_tty_notify_control_line_change(struct ipw_tty
*tty
,
629 unsigned int channel_idx
,
630 unsigned int control_lines
,
631 unsigned int changed_mask
)
633 unsigned int old_control_lines
= tty
->control_lines
;
635 tty
->control_lines
= (tty
->control_lines
& ~changed_mask
)
636 | (control_lines
& changed_mask
);
639 * If DCD is de-asserted, we close the tty so pppd can tell that we
642 if ((old_control_lines
& IPW_CONTROL_LINE_DCD
)
643 && !(tty
->control_lines
& IPW_CONTROL_LINE_DCD
)
645 tty_hangup(tty
->port
.tty
);