blob: 41ac7938268be6ca07401bf0e9596c9e604444be [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*********************************************************************
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09002 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Filename: ircomm_tty.c
4 * Version: 1.0
5 * Description: IrCOMM serial TTY driver
6 * Status: Experimental.
7 * Author: Dag Brattli <dagb@cs.uit.no>
8 * Created at: Sun Jun 6 21:00:56 1999
9 * Modified at: Wed Feb 23 00:09:02 2000
10 * Modified by: Dag Brattli <dagb@cs.uit.no>
11 * Sources: serial.c and previous IrCOMM work by Takahide Higuchi
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +090012 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 * Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
14 * Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +090015 *
16 * This program is free software; you can redistribute it and/or
17 * modify it under the terms of the GNU General Public License as
18 * published by the Free Software Foundation; either version 2 of
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 * the License, or (at your option) any later version.
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +090020 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +090025 *
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
Linus Torvalds1da177e2005-04-16 15:20:36 -070029 * MA 02111-1307 USA
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +090030 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070031 ********************************************************************/
32
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/init.h>
34#include <linux/module.h>
35#include <linux/fs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090036#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/sched.h>
Alexey Dobriyan3d304172009-03-31 15:19:22 -070038#include <linux/seq_file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <linux/termios.h>
40#include <linux/tty.h>
Amit Virdicbfd1522011-05-12 01:04:40 +000041#include <linux/tty_flip.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/interrupt.h>
43#include <linux/device.h> /* for MODULE_ALIAS_CHARDEV_MAJOR */
44
45#include <asm/uaccess.h>
46
47#include <net/irda/irda.h>
48#include <net/irda/irmod.h>
49
50#include <net/irda/ircomm_core.h>
51#include <net/irda/ircomm_param.h>
52#include <net/irda/ircomm_tty_attach.h>
53#include <net/irda/ircomm_tty.h>
54
Jiri Slaby9c650ff2012-08-07 21:48:02 +020055static int ircomm_tty_install(struct tty_driver *driver,
56 struct tty_struct *tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057static int ircomm_tty_open(struct tty_struct *tty, struct file *filp);
58static void ircomm_tty_close(struct tty_struct * tty, struct file *filp);
59static int ircomm_tty_write(struct tty_struct * tty,
60 const unsigned char *buf, int count);
61static int ircomm_tty_write_room(struct tty_struct *tty);
62static void ircomm_tty_throttle(struct tty_struct *tty);
63static void ircomm_tty_unthrottle(struct tty_struct *tty);
64static int ircomm_tty_chars_in_buffer(struct tty_struct *tty);
65static void ircomm_tty_flush_buffer(struct tty_struct *tty);
66static void ircomm_tty_send_xchar(struct tty_struct *tty, char ch);
67static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout);
68static void ircomm_tty_hangup(struct tty_struct *tty);
David Howellsc4028952006-11-22 14:57:56 +000069static void ircomm_tty_do_softint(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -070070static void ircomm_tty_shutdown(struct ircomm_tty_cb *self);
71static void ircomm_tty_stop(struct tty_struct *tty);
72
73static int ircomm_tty_data_indication(void *instance, void *sap,
74 struct sk_buff *skb);
75static int ircomm_tty_control_indication(void *instance, void *sap,
76 struct sk_buff *skb);
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +090077static void ircomm_tty_flow_indication(void *instance, void *sap,
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 LOCAL_FLOW cmd);
79#ifdef CONFIG_PROC_FS
Alexey Dobriyan3d304172009-03-31 15:19:22 -070080static const struct file_operations ircomm_tty_proc_fops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070081#endif /* CONFIG_PROC_FS */
82static struct tty_driver *driver;
83
Adrian Bunkd76081f2007-10-26 03:56:43 -070084static hashbin_t *ircomm_tty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
Jeff Dikeb68e31d2006-10-02 02:17:18 -070086static const struct tty_operations ops = {
Jiri Slaby9c650ff2012-08-07 21:48:02 +020087 .install = ircomm_tty_install,
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 .open = ircomm_tty_open,
89 .close = ircomm_tty_close,
90 .write = ircomm_tty_write,
91 .write_room = ircomm_tty_write_room,
92 .chars_in_buffer = ircomm_tty_chars_in_buffer,
93 .flush_buffer = ircomm_tty_flush_buffer,
94 .ioctl = ircomm_tty_ioctl, /* ircomm_tty_ioctl.c */
95 .tiocmget = ircomm_tty_tiocmget, /* ircomm_tty_ioctl.c */
96 .tiocmset = ircomm_tty_tiocmset, /* ircomm_tty_ioctl.c */
97 .throttle = ircomm_tty_throttle,
98 .unthrottle = ircomm_tty_unthrottle,
99 .send_xchar = ircomm_tty_send_xchar,
100 .set_termios = ircomm_tty_set_termios,
101 .stop = ircomm_tty_stop,
102 .start = ircomm_tty_start,
103 .hangup = ircomm_tty_hangup,
104 .wait_until_sent = ircomm_tty_wait_until_sent,
105#ifdef CONFIG_PROC_FS
Alexey Dobriyan3d304172009-03-31 15:19:22 -0700106 .proc_fops = &ircomm_tty_proc_fops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107#endif /* CONFIG_PROC_FS */
108};
109
Jiri Slaby0ba9ff82012-06-04 13:35:23 +0200110static void ircomm_port_raise_dtr_rts(struct tty_port *port, int raise)
111{
112 struct ircomm_tty_cb *self = container_of(port, struct ircomm_tty_cb,
113 port);
114 /*
115 * Here, we use to lock those two guys, but as ircomm_param_request()
116 * does it itself, I don't see the point (and I see the deadlock).
117 * Jean II
118 */
119 if (raise)
120 self->settings.dte |= IRCOMM_RTS | IRCOMM_DTR;
121 else
122 self->settings.dte &= ~(IRCOMM_RTS | IRCOMM_DTR);
123
124 ircomm_param_request(self, IRCOMM_DTE, TRUE);
125}
126
127static int ircomm_port_carrier_raised(struct tty_port *port)
128{
129 struct ircomm_tty_cb *self = container_of(port, struct ircomm_tty_cb,
130 port);
131 return self->settings.dce & IRCOMM_CD;
132}
133
134static const struct tty_port_operations ircomm_port_ops = {
135 .dtr_rts = ircomm_port_raise_dtr_rts,
136 .carrier_raised = ircomm_port_carrier_raised,
137};
138
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139/*
140 * Function ircomm_tty_init()
141 *
142 * Init IrCOMM TTY layer/driver
143 *
144 */
145static int __init ircomm_tty_init(void)
146{
147 driver = alloc_tty_driver(IRCOMM_TTY_PORTS);
148 if (!driver)
149 return -ENOMEM;
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900150 ircomm_tty = hashbin_new(HB_LOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 if (ircomm_tty == NULL) {
Harvey Harrison0dc47872008-03-05 20:47:47 -0800152 IRDA_ERROR("%s(), can't allocate hashbin!\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 put_tty_driver(driver);
154 return -ENOMEM;
155 }
156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 driver->driver_name = "ircomm";
158 driver->name = "ircomm";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 driver->major = IRCOMM_TTY_MAJOR;
160 driver->minor_start = IRCOMM_TTY_MINOR;
161 driver->type = TTY_DRIVER_TYPE_SERIAL;
162 driver->subtype = SERIAL_TYPE_NORMAL;
163 driver->init_termios = tty_std_termios;
164 driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
165 driver->flags = TTY_DRIVER_REAL_RAW;
166 tty_set_operations(driver, &ops);
167 if (tty_register_driver(driver)) {
168 IRDA_ERROR("%s(): Couldn't register serial driver\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800169 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 put_tty_driver(driver);
171 return -1;
172 }
173 return 0;
174}
175
176static void __exit __ircomm_tty_cleanup(struct ircomm_tty_cb *self)
177{
Harvey Harrison0dc47872008-03-05 20:47:47 -0800178 IRDA_DEBUG(0, "%s()\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
180 IRDA_ASSERT(self != NULL, return;);
181 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
182
183 ircomm_tty_shutdown(self);
184
185 self->magic = 0;
Jiri Slaby191c5f12012-11-15 09:49:56 +0100186 tty_port_destroy(&self->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 kfree(self);
188}
189
190/*
191 * Function ircomm_tty_cleanup ()
192 *
193 * Remove IrCOMM TTY layer/driver
194 *
195 */
196static void __exit ircomm_tty_cleanup(void)
197{
198 int ret;
199
Harvey Harrison0dc47872008-03-05 20:47:47 -0800200 IRDA_DEBUG(4, "%s()\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
202 ret = tty_unregister_driver(driver);
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900203 if (ret) {
204 IRDA_ERROR("%s(), failed to unregister driver\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800205 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 return;
207 }
208
209 hashbin_delete(ircomm_tty, (FREE_FUNC) __ircomm_tty_cleanup);
210 put_tty_driver(driver);
211}
212
213/*
214 * Function ircomm_startup (self)
215 *
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900216 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 *
218 */
219static int ircomm_tty_startup(struct ircomm_tty_cb *self)
220{
221 notify_t notify;
222 int ret = -ENODEV;
223
Harvey Harrison0dc47872008-03-05 20:47:47 -0800224 IRDA_DEBUG(2, "%s()\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
226 IRDA_ASSERT(self != NULL, return -1;);
227 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
228
229 /* Check if already open */
Jiri Slaby849d5a92012-06-04 13:35:19 +0200230 if (test_and_set_bit(ASYNCB_INITIALIZED, &self->port.flags)) {
Harvey Harrison0dc47872008-03-05 20:47:47 -0800231 IRDA_DEBUG(2, "%s(), already open so break out!\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 return 0;
233 }
234
235 /* Register with IrCOMM */
236 irda_notify_init(&notify);
237 /* These callbacks we must handle ourselves */
238 notify.data_indication = ircomm_tty_data_indication;
239 notify.udata_indication = ircomm_tty_control_indication;
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900240 notify.flow_indication = ircomm_tty_flow_indication;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
242 /* Use the ircomm_tty interface for these ones */
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900243 notify.disconnect_indication = ircomm_tty_disconnect_indication;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 notify.connect_confirm = ircomm_tty_connect_confirm;
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900245 notify.connect_indication = ircomm_tty_connect_indication;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 strlcpy(notify.name, "ircomm_tty", sizeof(notify.name));
247 notify.instance = self;
248
249 if (!self->ircomm) {
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900250 self->ircomm = ircomm_open(&notify, self->service_type,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 self->line);
252 }
253 if (!self->ircomm)
254 goto err;
255
256 self->slsap_sel = self->ircomm->slsap_sel;
257
258 /* Connect IrCOMM link with remote device */
259 ret = ircomm_tty_attach_cable(self);
260 if (ret < 0) {
Harvey Harrison0dc47872008-03-05 20:47:47 -0800261 IRDA_ERROR("%s(), error attaching cable!\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 goto err;
263 }
264
265 return 0;
266err:
Jiri Slaby849d5a92012-06-04 13:35:19 +0200267 clear_bit(ASYNCB_INITIALIZED, &self->port.flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 return ret;
269}
270
271/*
272 * Function ircomm_block_til_ready (self, filp)
273 *
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900274 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 *
276 */
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900277static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self,
Jiri Slaby62f228a2012-06-04 13:35:21 +0200278 struct tty_struct *tty, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
Jiri Slaby38c58032012-06-04 13:35:22 +0200280 struct tty_port *port = &self->port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 DECLARE_WAITQUEUE(wait, current);
282 int retval;
Peter Hurleya4ed2e72013-03-05 06:09:04 +0000283 int do_clocal = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 unsigned long flags;
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900285
Harvey Harrison0dc47872008-03-05 20:47:47 -0800286 IRDA_DEBUG(2, "%s()\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 /*
289 * If non-blocking mode is set, or the port is not enabled,
290 * then make the check up front and then exit.
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900291 */
Peter Hurleyf74861c2013-03-05 06:09:07 +0000292 if (test_bit(TTY_IO_ERROR, &tty->flags)) {
293 port->flags |= ASYNC_NORMAL_ACTIVE;
294 return 0;
295 }
296
297 if (filp->f_flags & O_NONBLOCK) {
298 /* nonblock mode is set */
299 if (tty->termios.c_cflag & CBAUD)
300 tty_port_raise_dtr_rts(port);
Jiri Slaby38c58032012-06-04 13:35:22 +0200301 port->flags |= ASYNC_NORMAL_ACTIVE;
Harvey Harrison0dc47872008-03-05 20:47:47 -0800302 IRDA_DEBUG(1, "%s(), O_NONBLOCK requested!\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 return 0;
304 }
305
Alan Coxadc8d742012-07-14 15:31:47 +0100306 if (tty->termios.c_cflag & CLOCAL) {
Harvey Harrison0dc47872008-03-05 20:47:47 -0800307 IRDA_DEBUG(1, "%s(), doing CLOCAL!\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 do_clocal = 1;
309 }
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900310
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 /* Wait for carrier detect and the line to become
312 * free (i.e., not in use by the callout). While we are in
Jiri Slaby38c58032012-06-04 13:35:22 +0200313 * this loop, port->count is dropped by one, so that
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 * mgsl_close() knows when to free things. We restore it upon
315 * exit, either normal or abnormal.
316 */
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900317
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 retval = 0;
Jiri Slaby38c58032012-06-04 13:35:22 +0200319 add_wait_queue(&port->open_wait, &wait);
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900320
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 IRDA_DEBUG(2, "%s(%d):block_til_ready before block on %s open_count=%d\n",
Jiri Slaby38c58032012-06-04 13:35:22 +0200322 __FILE__, __LINE__, tty->driver->name, port->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
Jiri Slaby38c58032012-06-04 13:35:22 +0200324 spin_lock_irqsave(&port->lock, flags);
Peter Hurleya4ed2e72013-03-05 06:09:04 +0000325 if (!tty_hung_up_p(filp))
Jiri Slaby38c58032012-06-04 13:35:22 +0200326 port->count--;
Jiri Slaby38c58032012-06-04 13:35:22 +0200327 port->blocked_open++;
Peter Hurley2f7c0692013-03-05 06:09:05 +0000328 spin_unlock_irqrestore(&port->lock, flags);
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900329
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 while (1) {
Johan Hovolde1c969f2013-04-12 10:32:31 +0200331 if (C_BAUD(tty) && test_bit(ASYNCB_INITIALIZED, &port->flags))
Jiri Slaby0ba9ff82012-06-04 13:35:23 +0200332 tty_port_raise_dtr_rts(port);
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900333
Peter Hurley0b176ce2013-03-05 06:09:06 +0000334 set_current_state(TASK_INTERRUPTIBLE);
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900335
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 if (tty_hung_up_p(filp) ||
Jiri Slaby38c58032012-06-04 13:35:22 +0200337 !test_bit(ASYNCB_INITIALIZED, &port->flags)) {
338 retval = (port->flags & ASYNC_HUP_NOTIFY) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 -EAGAIN : -ERESTARTSYS;
340 break;
341 }
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900342
343 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 * Check if link is ready now. Even if CLOCAL is
345 * specified, we cannot return before the IrCOMM link is
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900346 * ready
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 */
Jiri Slaby38c58032012-06-04 13:35:22 +0200348 if (!test_bit(ASYNCB_CLOSING, &port->flags) &&
Jiri Slaby0ba9ff82012-06-04 13:35:23 +0200349 (do_clocal || tty_port_carrier_raised(port)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 self->state == IRCOMM_TTY_READY)
351 {
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900352 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 }
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 if (signal_pending(current)) {
356 retval = -ERESTARTSYS;
357 break;
358 }
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900359
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 IRDA_DEBUG(1, "%s(%d):block_til_ready blocking on %s open_count=%d\n",
Jiri Slaby38c58032012-06-04 13:35:22 +0200361 __FILE__, __LINE__, tty->driver->name, port->count);
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900362
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 schedule();
364 }
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 __set_current_state(TASK_RUNNING);
Jiri Slaby38c58032012-06-04 13:35:22 +0200367 remove_wait_queue(&port->open_wait, &wait);
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900368
Peter Hurleya4ed2e72013-03-05 06:09:04 +0000369 spin_lock_irqsave(&port->lock, flags);
370 if (!tty_hung_up_p(filp))
Jiri Slaby38c58032012-06-04 13:35:22 +0200371 port->count++;
Jiri Slaby38c58032012-06-04 13:35:22 +0200372 port->blocked_open--;
Peter Hurley2f7c0692013-03-05 06:09:05 +0000373 spin_unlock_irqrestore(&port->lock, flags);
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900374
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 IRDA_DEBUG(1, "%s(%d):block_til_ready after blocking on %s open_count=%d\n",
Jiri Slaby38c58032012-06-04 13:35:22 +0200376 __FILE__, __LINE__, tty->driver->name, port->count);
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900377
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 if (!retval)
Jiri Slaby38c58032012-06-04 13:35:22 +0200379 port->flags |= ASYNC_NORMAL_ACTIVE;
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900380
381 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382}
383
Jiri Slaby9c650ff2012-08-07 21:48:02 +0200384
385static int ircomm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386{
387 struct ircomm_tty_cb *self;
Jiri Slaby410235f2012-03-05 14:52:01 +0100388 unsigned int line = tty->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 /* Check if instance already exists */
391 self = hashbin_lock_find(ircomm_tty, line, NULL);
392 if (!self) {
393 /* No, so make new instance */
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700394 self = kzalloc(sizeof(struct ircomm_tty_cb), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 if (self == NULL) {
Harvey Harrison0dc47872008-03-05 20:47:47 -0800396 IRDA_ERROR("%s(), kmalloc failed!\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 return -ENOMEM;
398 }
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900399
Jiri Slabya3cc9fc2012-06-04 13:35:16 +0200400 tty_port_init(&self->port);
Jiri Slaby0ba9ff82012-06-04 13:35:23 +0200401 self->port.ops = &ircomm_port_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 self->magic = IRCOMM_TTY_MAGIC;
403 self->flow = FLOW_STOP;
404
405 self->line = line;
David Howellsc4028952006-11-22 14:57:56 +0000406 INIT_WORK(&self->tqueue, ircomm_tty_do_softint);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 self->max_header_size = IRCOMM_TTY_HDR_UNINITIALISED;
408 self->max_data_size = IRCOMM_TTY_DATA_UNINITIALISED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
410 /* Init some important stuff */
411 init_timer(&self->watchdog_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 spin_lock_init(&self->spinlock);
413
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900414 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 * Force TTY into raw mode by default which is usually what
416 * we want for IrCOMM and IrLPT. This way applications will
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900417 * not have to twiddle with printcap etc.
Alan Coxad36b882009-01-02 13:50:20 +0000418 *
419 * Note this is completely usafe and doesn't work properly
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 */
Alan Coxadc8d742012-07-14 15:31:47 +0100421 tty->termios.c_iflag = 0;
422 tty->termios.c_oflag = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
424 /* Insert into hash */
425 hashbin_insert(ircomm_tty, (irda_queue_t *) self, line, NULL);
426 }
Jiri Slaby9c650ff2012-08-07 21:48:02 +0200427
Sasha Levin6f560122012-10-04 20:01:21 -0400428 tty->driver_data = self;
429
Jiri Slaby9c650ff2012-08-07 21:48:02 +0200430 return tty_port_install(&self->port, driver, tty);
431}
432
433/*
434 * Function ircomm_tty_open (tty, filp)
435 *
436 * This routine is called when a particular tty device is opened. This
437 * routine is mandatory; if this routine is not filled in, the attempted
438 * open will fail with ENODEV.
439 */
440static int ircomm_tty_open(struct tty_struct *tty, struct file *filp)
441{
442 struct ircomm_tty_cb *self = tty->driver_data;
443 unsigned long flags;
444 int ret;
445
446 IRDA_DEBUG(2, "%s()\n", __func__ );
447
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 /* ++ is not atomic, so this should be protected - Jean II */
Jiri Slabye6739272012-06-04 13:35:20 +0200449 spin_lock_irqsave(&self->port.lock, flags);
Jiri Slaby580d27b2012-06-04 13:35:18 +0200450 self->port.count++;
Jiri Slabye6739272012-06-04 13:35:20 +0200451 spin_unlock_irqrestore(&self->port.lock, flags);
Jiri Slaby62f228a2012-06-04 13:35:21 +0200452 tty_port_tty_set(&self->port, tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
Harvey Harrison0dc47872008-03-05 20:47:47 -0800454 IRDA_DEBUG(1, "%s(), %s%d, count = %d\n", __func__ , tty->driver->name,
Jiri Slaby580d27b2012-06-04 13:35:18 +0200455 self->line, self->port.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
457 /* Not really used by us, but lets do it anyway */
Jiri Slabyd6c53c02013-01-03 15:53:05 +0100458 self->port.low_latency = (self->port.flags & ASYNC_LOW_LATENCY) ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
460 /*
461 * If the port is the middle of closing, bail out now
462 */
463 if (tty_hung_up_p(filp) ||
Jiri Slaby849d5a92012-06-04 13:35:19 +0200464 test_bit(ASYNCB_CLOSING, &self->port.flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
466 /* Hm, why are we blocking on ASYNC_CLOSING if we
467 * do return -EAGAIN/-ERESTARTSYS below anyway?
468 * IMHO it's either not needed in the first place
469 * or for some reason we need to make sure the async
470 * closing has been finished - if so, wouldn't we
471 * probably better sleep uninterruptible?
472 */
473
Jiri Slabya3cc9fc2012-06-04 13:35:16 +0200474 if (wait_event_interruptible(self->port.close_wait,
Jiri Slaby849d5a92012-06-04 13:35:19 +0200475 !test_bit(ASYNCB_CLOSING, &self->port.flags))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 IRDA_WARNING("%s - got signal while blocking on ASYNC_CLOSING!\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800477 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 return -ERESTARTSYS;
479 }
480
481#ifdef SERIAL_DO_RESTART
Jiri Slaby849d5a92012-06-04 13:35:19 +0200482 return (self->port.flags & ASYNC_HUP_NOTIFY) ?
Eric Dumazeta02cec22010-09-22 20:43:57 +0000483 -EAGAIN : -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484#else
485 return -EAGAIN;
486#endif
487 }
488
489 /* Check if this is a "normal" ircomm device, or an irlpt device */
Jiri Slaby9c650ff2012-08-07 21:48:02 +0200490 if (self->line < 0x10) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 self->service_type = IRCOMM_3_WIRE | IRCOMM_9_WIRE;
492 self->settings.service_type = IRCOMM_9_WIRE; /* 9 wire as default */
493 /* Jan Kiszka -> add DSR/RI -> Conform to IrCOMM spec */
494 self->settings.dce = IRCOMM_CTS | IRCOMM_CD | IRCOMM_DSR | IRCOMM_RI; /* Default line settings */
Harvey Harrison0dc47872008-03-05 20:47:47 -0800495 IRDA_DEBUG(2, "%s(), IrCOMM device\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 } else {
Harvey Harrison0dc47872008-03-05 20:47:47 -0800497 IRDA_DEBUG(2, "%s(), IrLPT device\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 self->service_type = IRCOMM_3_WIRE_RAW;
499 self->settings.service_type = IRCOMM_3_WIRE_RAW; /* Default */
500 }
501
502 ret = ircomm_tty_startup(self);
503 if (ret)
504 return ret;
505
Jiri Slaby62f228a2012-06-04 13:35:21 +0200506 ret = ircomm_tty_block_til_ready(self, tty, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 if (ret) {
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900508 IRDA_DEBUG(2,
Harvey Harrison0dc47872008-03-05 20:47:47 -0800509 "%s(), returning after block_til_ready with %d\n", __func__ ,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 ret);
511
512 return ret;
513 }
514 return 0;
515}
516
517/*
518 * Function ircomm_tty_close (tty, filp)
519 *
520 * This routine is called when a particular tty device is closed.
521 *
522 */
523static void ircomm_tty_close(struct tty_struct *tty, struct file *filp)
524{
525 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
Jiri Slaby38c58032012-06-04 13:35:22 +0200526 struct tty_port *port = &self->port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527
Harvey Harrison0dc47872008-03-05 20:47:47 -0800528 IRDA_DEBUG(0, "%s()\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 IRDA_ASSERT(self != NULL, return;);
531 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
532
Jiri Slabyc0e78652012-06-04 13:35:25 +0200533 if (tty_port_close_start(port, tty, filp) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535
536 ircomm_tty_shutdown(self);
537
Alan Coxf34d7a52008-04-30 00:54:13 -0700538 tty_driver_flush_buffer(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
Jiri Slabya1e84402012-06-04 13:35:24 +0200540 tty_port_close_end(port, tty);
Jiri Slaby38c58032012-06-04 13:35:22 +0200541 tty_port_tty_set(port, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542}
543
544/*
545 * Function ircomm_tty_flush_buffer (tty)
546 *
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900547 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 *
549 */
550static void ircomm_tty_flush_buffer(struct tty_struct *tty)
551{
552 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
553
554 IRDA_ASSERT(self != NULL, return;);
555 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
556
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900557 /*
558 * Let do_softint() do this to avoid race condition with
559 * do_softint() ;-)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 */
561 schedule_work(&self->tqueue);
562}
563
564/*
David Howellsc4028952006-11-22 14:57:56 +0000565 * Function ircomm_tty_do_softint (work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 *
567 * We use this routine to give the write wakeup to the user at at a
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900568 * safe time (as fast as possible after write have completed). This
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 * can be compared to the Tx interrupt.
570 */
David Howellsc4028952006-11-22 14:57:56 +0000571static void ircomm_tty_do_softint(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572{
David Howellsc4028952006-11-22 14:57:56 +0000573 struct ircomm_tty_cb *self =
574 container_of(work, struct ircomm_tty_cb, tqueue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 struct tty_struct *tty;
576 unsigned long flags;
577 struct sk_buff *skb, *ctrl_skb;
578
Harvey Harrison0dc47872008-03-05 20:47:47 -0800579 IRDA_DEBUG(2, "%s()\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
581 if (!self || self->magic != IRCOMM_TTY_MAGIC)
582 return;
583
Jiri Slaby62f228a2012-06-04 13:35:21 +0200584 tty = tty_port_tty_get(&self->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 if (!tty)
586 return;
587
588 /* Unlink control buffer */
589 spin_lock_irqsave(&self->spinlock, flags);
590
591 ctrl_skb = self->ctrl_skb;
592 self->ctrl_skb = NULL;
593
594 spin_unlock_irqrestore(&self->spinlock, flags);
595
596 /* Flush control buffer if any */
597 if(ctrl_skb) {
598 if(self->flow == FLOW_START)
599 ircomm_control_request(self->ircomm, ctrl_skb);
600 /* Drop reference count - see ircomm_ttp_data_request(). */
601 dev_kfree_skb(ctrl_skb);
602 }
603
604 if (tty->hw_stopped)
Jiri Slaby62f228a2012-06-04 13:35:21 +0200605 goto put;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
607 /* Unlink transmit buffer */
608 spin_lock_irqsave(&self->spinlock, flags);
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900609
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 skb = self->tx_skb;
611 self->tx_skb = NULL;
612
613 spin_unlock_irqrestore(&self->spinlock, flags);
614
615 /* Flush transmit buffer if any */
616 if (skb) {
617 ircomm_tty_do_event(self, IRCOMM_TTY_DATA_REQUEST, skb, NULL);
618 /* Drop reference count - see ircomm_ttp_data_request(). */
619 dev_kfree_skb(skb);
620 }
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900621
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 /* Check if user (still) wants to be waken up */
Alan Coxa352def2008-07-16 21:53:12 +0100623 tty_wakeup(tty);
Jiri Slaby62f228a2012-06-04 13:35:21 +0200624put:
625 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626}
627
628/*
629 * Function ircomm_tty_write (tty, buf, count)
630 *
631 * This routine is called by the kernel to write a series of characters
632 * to the tty device. The characters may come from user space or kernel
633 * space. This routine will return the number of characters actually
634 * accepted for writing. This routine is mandatory.
635 */
636static int ircomm_tty_write(struct tty_struct *tty,
637 const unsigned char *buf, int count)
638{
639 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
640 unsigned long flags;
641 struct sk_buff *skb;
642 int tailroom = 0;
643 int len = 0;
644 int size;
645
Harvey Harrison0dc47872008-03-05 20:47:47 -0800646 IRDA_DEBUG(2, "%s(), count=%d, hw_stopped=%d\n", __func__ , count,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 tty->hw_stopped);
648
649 IRDA_ASSERT(self != NULL, return -1;);
650 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
651
652 /* We may receive packets from the TTY even before we have finished
653 * our setup. Not cool.
654 * The problem is that we don't know the final header and data size
655 * to create the proper skb, so any skb we would create would have
656 * bogus header and data size, so need care.
657 * We use a bogus header size to safely detect this condition.
658 * Another problem is that hw_stopped was set to 0 way before it
659 * should be, so we would drop this skb. It should now be fixed.
660 * One option is to not accept data until we are properly setup.
661 * But, I suspect that when it happens, the ppp line discipline
662 * just "drops" the data, which might screw up connect scripts.
663 * The second option is to create a "safe skb", with large header
664 * and small size (see ircomm_tty_open() for values).
665 * We just need to make sure that when the real values get filled,
666 * we don't mess up the original "safe skb" (see tx_data_size).
667 * Jean II */
668 if (self->max_header_size == IRCOMM_TTY_HDR_UNINITIALISED) {
Harvey Harrison0dc47872008-03-05 20:47:47 -0800669 IRDA_DEBUG(1, "%s() : not initialised\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670#ifdef IRCOMM_NO_TX_BEFORE_INIT
671 /* We didn't consume anything, TTY will retry */
672 return 0;
673#endif
674 }
675
676 if (count < 1)
677 return 0;
678
679 /* Protect our manipulation of self->tx_skb and related */
680 spin_lock_irqsave(&self->spinlock, flags);
681
682 /* Fetch current transmit buffer */
683 skb = self->tx_skb;
684
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900685 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 * Send out all the data we get, possibly as multiple fragmented
687 * frames, but this will only happen if the data is larger than the
688 * max data size. The normal case however is just the opposite, and
689 * this function may be called multiple times, and will then actually
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900690 * defragment the data and send it out as one packet as soon as
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 * possible, but at a safer point in time
692 */
693 while (count) {
694 size = count;
695
696 /* Adjust data size to the max data size */
697 if (size > self->max_data_size)
698 size = self->max_data_size;
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900699
700 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 * Do we already have a buffer ready for transmit, or do
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900702 * we need to allocate a new frame
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 */
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900704 if (skb) {
705 /*
706 * Any room for more data at the end of the current
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 * transmit buffer? Cannot use skb_tailroom, since
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900708 * dev_alloc_skb gives us a larger skb than we
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 * requested
710 * Note : use tx_data_size, because max_data_size
711 * may have changed and we don't want to overwrite
712 * the skb. - Jean II
713 */
714 if ((tailroom = (self->tx_data_size - skb->len)) > 0) {
715 /* Adjust data to tailroom */
716 if (size > tailroom)
717 size = tailroom;
718 } else {
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900719 /*
720 * Current transmit frame is full, so break
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 * out, so we can send it as soon as possible
722 */
723 break;
724 }
725 } else {
726 /* Prepare a full sized frame */
Samuel Ortiz485fb2c2006-07-21 14:50:41 -0700727 skb = alloc_skb(self->max_data_size+
728 self->max_header_size,
729 GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 if (!skb) {
731 spin_unlock_irqrestore(&self->spinlock, flags);
732 return -ENOBUFS;
733 }
734 skb_reserve(skb, self->max_header_size);
735 self->tx_skb = skb;
736 /* Remember skb size because max_data_size may
737 * change later on - Jean II */
738 self->tx_data_size = self->max_data_size;
739 }
740
741 /* Copy data */
742 memcpy(skb_put(skb,size), buf + len, size);
743
744 count -= size;
745 len += size;
746 }
747
748 spin_unlock_irqrestore(&self->spinlock, flags);
749
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900750 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 * Schedule a new thread which will transmit the frame as soon
752 * as possible, but at a safe point in time. We do this so the
753 * "user" can give us data multiple times, as PPP does (because of
754 * its 256 byte tx buffer). We will then defragment and send out
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900755 * all this data as one single packet.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 */
757 schedule_work(&self->tqueue);
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900758
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 return len;
760}
761
762/*
763 * Function ircomm_tty_write_room (tty)
764 *
765 * This routine returns the numbers of characters the tty driver will
766 * accept for queuing to be written. This number is subject to change as
767 * output buffers get emptied, or if the output flow control is acted.
768 */
769static int ircomm_tty_write_room(struct tty_struct *tty)
770{
771 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
772 unsigned long flags;
773 int ret;
774
775 IRDA_ASSERT(self != NULL, return -1;);
776 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
777
778#ifdef IRCOMM_NO_TX_BEFORE_INIT
779 /* max_header_size tells us if the channel is initialised or not. */
780 if (self->max_header_size == IRCOMM_TTY_HDR_UNINITIALISED)
781 /* Don't bother us yet */
782 return 0;
783#endif
784
785 /* Check if we are allowed to transmit any data.
786 * hw_stopped is the regular flow control.
787 * Jean II */
788 if (tty->hw_stopped)
789 ret = 0;
790 else {
791 spin_lock_irqsave(&self->spinlock, flags);
792 if (self->tx_skb)
793 ret = self->tx_data_size - self->tx_skb->len;
794 else
795 ret = self->max_data_size;
796 spin_unlock_irqrestore(&self->spinlock, flags);
797 }
Harvey Harrison0dc47872008-03-05 20:47:47 -0800798 IRDA_DEBUG(2, "%s(), ret=%d\n", __func__ , ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799
800 return ret;
801}
802
803/*
804 * Function ircomm_tty_wait_until_sent (tty, timeout)
805 *
806 * This routine waits until the device has written out all of the
807 * characters in its transmitter FIFO.
808 */
809static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
810{
811 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
812 unsigned long orig_jiffies, poll_time;
813 unsigned long flags;
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900814
Harvey Harrison0dc47872008-03-05 20:47:47 -0800815 IRDA_DEBUG(2, "%s()\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
817 IRDA_ASSERT(self != NULL, return;);
818 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
819
820 orig_jiffies = jiffies;
821
822 /* Set poll time to 200 ms */
823 poll_time = IRDA_MIN(timeout, msecs_to_jiffies(200));
824
825 spin_lock_irqsave(&self->spinlock, flags);
826 while (self->tx_skb && self->tx_skb->len) {
827 spin_unlock_irqrestore(&self->spinlock, flags);
Nishanth Aravamudan121caf52005-09-12 14:15:34 -0700828 schedule_timeout_interruptible(poll_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 spin_lock_irqsave(&self->spinlock, flags);
830 if (signal_pending(current))
831 break;
832 if (timeout && time_after(jiffies, orig_jiffies + timeout))
833 break;
834 }
835 spin_unlock_irqrestore(&self->spinlock, flags);
836 current->state = TASK_RUNNING;
837}
838
839/*
840 * Function ircomm_tty_throttle (tty)
841 *
842 * This routine notifies the tty driver that input buffers for the line
843 * discipline are close to full, and it should somehow signal that no
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900844 * more characters should be sent to the tty.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 */
846static void ircomm_tty_throttle(struct tty_struct *tty)
847{
848 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
849
Harvey Harrison0dc47872008-03-05 20:47:47 -0800850 IRDA_DEBUG(2, "%s()\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851
852 IRDA_ASSERT(self != NULL, return;);
853 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
854
855 /* Software flow control? */
856 if (I_IXOFF(tty))
857 ircomm_tty_send_xchar(tty, STOP_CHAR(tty));
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900858
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 /* Hardware flow control? */
Alan Coxadc8d742012-07-14 15:31:47 +0100860 if (tty->termios.c_cflag & CRTSCTS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 self->settings.dte &= ~IRCOMM_RTS;
862 self->settings.dte |= IRCOMM_DELTA_RTS;
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900863
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 ircomm_param_request(self, IRCOMM_DTE, TRUE);
865 }
866
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900867 ircomm_flow_request(self->ircomm, FLOW_STOP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868}
869
870/*
871 * Function ircomm_tty_unthrottle (tty)
872 *
873 * This routine notifies the tty drivers that it should signals that
874 * characters can now be sent to the tty without fear of overrunning the
875 * input buffers of the line disciplines.
876 */
877static void ircomm_tty_unthrottle(struct tty_struct *tty)
878{
879 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
880
Harvey Harrison0dc47872008-03-05 20:47:47 -0800881 IRDA_DEBUG(2, "%s()\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882
883 IRDA_ASSERT(self != NULL, return;);
884 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
885
886 /* Using software flow control? */
887 if (I_IXOFF(tty)) {
888 ircomm_tty_send_xchar(tty, START_CHAR(tty));
889 }
890
891 /* Using hardware flow control? */
Alan Coxadc8d742012-07-14 15:31:47 +0100892 if (tty->termios.c_cflag & CRTSCTS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 self->settings.dte |= (IRCOMM_RTS|IRCOMM_DELTA_RTS);
894
895 ircomm_param_request(self, IRCOMM_DTE, TRUE);
Harvey Harrison0dc47872008-03-05 20:47:47 -0800896 IRDA_DEBUG(1, "%s(), FLOW_START\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 }
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900898 ircomm_flow_request(self->ircomm, FLOW_START);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899}
900
901/*
902 * Function ircomm_tty_chars_in_buffer (tty)
903 *
904 * Indicates if there are any data in the buffer
905 *
906 */
907static int ircomm_tty_chars_in_buffer(struct tty_struct *tty)
908{
909 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
910 unsigned long flags;
911 int len = 0;
912
913 IRDA_ASSERT(self != NULL, return -1;);
914 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
915
916 spin_lock_irqsave(&self->spinlock, flags);
917
918 if (self->tx_skb)
919 len = self->tx_skb->len;
920
921 spin_unlock_irqrestore(&self->spinlock, flags);
922
923 return len;
924}
925
926static void ircomm_tty_shutdown(struct ircomm_tty_cb *self)
927{
928 unsigned long flags;
929
930 IRDA_ASSERT(self != NULL, return;);
931 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
932
Harvey Harrison0dc47872008-03-05 20:47:47 -0800933 IRDA_DEBUG(0, "%s()\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934
Jiri Slaby849d5a92012-06-04 13:35:19 +0200935 if (!test_and_clear_bit(ASYNCB_INITIALIZED, &self->port.flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 return;
937
938 ircomm_tty_detach_cable(self);
939
940 spin_lock_irqsave(&self->spinlock, flags);
941
942 del_timer(&self->watchdog_timer);
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900943
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 /* Free parameter buffer */
945 if (self->ctrl_skb) {
946 dev_kfree_skb(self->ctrl_skb);
947 self->ctrl_skb = NULL;
948 }
949
950 /* Free transmit buffer */
951 if (self->tx_skb) {
952 dev_kfree_skb(self->tx_skb);
953 self->tx_skb = NULL;
954 }
955
956 if (self->ircomm) {
957 ircomm_close(self->ircomm);
958 self->ircomm = NULL;
959 }
960
961 spin_unlock_irqrestore(&self->spinlock, flags);
962}
963
964/*
965 * Function ircomm_tty_hangup (tty)
966 *
967 * This routine notifies the tty driver that it should hangup the tty
968 * device.
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +0900969 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 */
971static void ircomm_tty_hangup(struct tty_struct *tty)
972{
973 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
Jiri Slaby38c58032012-06-04 13:35:22 +0200974 struct tty_port *port = &self->port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 unsigned long flags;
976
Harvey Harrison0dc47872008-03-05 20:47:47 -0800977 IRDA_DEBUG(0, "%s()\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978
979 IRDA_ASSERT(self != NULL, return;);
980 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
981
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 /* ircomm_tty_flush_buffer(tty); */
983 ircomm_tty_shutdown(self);
984
Jiri Slaby38c58032012-06-04 13:35:22 +0200985 spin_lock_irqsave(&port->lock, flags);
986 port->flags &= ~ASYNC_NORMAL_ACTIVE;
987 if (port->tty) {
988 set_bit(TTY_IO_ERROR, &port->tty->flags);
989 tty_kref_put(port->tty);
Jiri Slaby62f228a2012-06-04 13:35:21 +0200990 }
Jiri Slaby38c58032012-06-04 13:35:22 +0200991 port->tty = NULL;
992 port->count = 0;
993 spin_unlock_irqrestore(&port->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994
Jiri Slaby38c58032012-06-04 13:35:22 +0200995 wake_up_interruptible(&port->open_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996}
997
998/*
999 * Function ircomm_tty_send_xchar (tty, ch)
1000 *
1001 * This routine is used to send a high-priority XON/XOFF character to
1002 * the device.
1003 */
1004static void ircomm_tty_send_xchar(struct tty_struct *tty, char ch)
1005{
Harvey Harrison0dc47872008-03-05 20:47:47 -08001006 IRDA_DEBUG(0, "%s(), not impl\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007}
1008
1009/*
1010 * Function ircomm_tty_start (tty)
1011 *
1012 * This routine notifies the tty driver that it resume sending
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001013 * characters to the tty device.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 */
1015void ircomm_tty_start(struct tty_struct *tty)
1016{
1017 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
1018
1019 ircomm_flow_request(self->ircomm, FLOW_START);
1020}
1021
1022/*
1023 * Function ircomm_tty_stop (tty)
1024 *
1025 * This routine notifies the tty driver that it should stop outputting
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001026 * characters to the tty device.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 */
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001028static void ircomm_tty_stop(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029{
1030 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
1031
1032 IRDA_ASSERT(self != NULL, return;);
1033 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
1034
1035 ircomm_flow_request(self->ircomm, FLOW_STOP);
1036}
1037
1038/*
1039 * Function ircomm_check_modem_status (self)
1040 *
1041 * Check for any changes in the DCE's line settings. This function should
1042 * be called whenever the dce parameter settings changes, to update the
1043 * flow control settings and other things
1044 */
1045void ircomm_tty_check_modem_status(struct ircomm_tty_cb *self)
1046{
1047 struct tty_struct *tty;
1048 int status;
1049
Harvey Harrison0dc47872008-03-05 20:47:47 -08001050 IRDA_DEBUG(0, "%s()\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051
1052 IRDA_ASSERT(self != NULL, return;);
1053 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
1054
Jiri Slaby62f228a2012-06-04 13:35:21 +02001055 tty = tty_port_tty_get(&self->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056
1057 status = self->settings.dce;
1058
1059 if (status & IRCOMM_DCE_DELTA_ANY) {
1060 /*wake_up_interruptible(&self->delta_msr_wait);*/
1061 }
Jiri Slaby849d5a92012-06-04 13:35:19 +02001062 if ((self->port.flags & ASYNC_CHECK_CD) && (status & IRCOMM_DELTA_CD)) {
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001063 IRDA_DEBUG(2,
Harvey Harrison0dc47872008-03-05 20:47:47 -08001064 "%s(), ircomm%d CD now %s...\n", __func__ , self->line,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 (status & IRCOMM_CD) ? "on" : "off");
1066
1067 if (status & IRCOMM_CD) {
Jiri Slabya3cc9fc2012-06-04 13:35:16 +02001068 wake_up_interruptible(&self->port.open_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 } else {
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001070 IRDA_DEBUG(2,
Harvey Harrison0dc47872008-03-05 20:47:47 -08001071 "%s(), Doing serial hangup..\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 if (tty)
1073 tty_hangup(tty);
1074
1075 /* Hangup will remote the tty, so better break out */
Jiri Slaby62f228a2012-06-04 13:35:21 +02001076 goto put;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 }
1078 }
Huang Shijief21ec3d2012-08-22 22:13:36 -04001079 if (tty && tty_port_cts_enabled(&self->port)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 if (tty->hw_stopped) {
1081 if (status & IRCOMM_CTS) {
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001082 IRDA_DEBUG(2,
Harvey Harrison0dc47872008-03-05 20:47:47 -08001083 "%s(), CTS tx start...\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 tty->hw_stopped = 0;
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001085
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 /* Wake up processes blocked on open */
Jiri Slabya3cc9fc2012-06-04 13:35:16 +02001087 wake_up_interruptible(&self->port.open_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088
1089 schedule_work(&self->tqueue);
Jiri Slaby62f228a2012-06-04 13:35:21 +02001090 goto put;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 }
1092 } else {
1093 if (!(status & IRCOMM_CTS)) {
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001094 IRDA_DEBUG(2,
Harvey Harrison0dc47872008-03-05 20:47:47 -08001095 "%s(), CTS tx stop...\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 tty->hw_stopped = 1;
1097 }
1098 }
1099 }
Jiri Slaby62f228a2012-06-04 13:35:21 +02001100put:
1101 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102}
1103
1104/*
1105 * Function ircomm_tty_data_indication (instance, sap, skb)
1106 *
1107 * Handle incoming data, and deliver it to the line discipline
1108 *
1109 */
1110static int ircomm_tty_data_indication(void *instance, void *sap,
1111 struct sk_buff *skb)
1112{
1113 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
Jiri Slaby62f228a2012-06-04 13:35:21 +02001114 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
Harvey Harrison0dc47872008-03-05 20:47:47 -08001116 IRDA_DEBUG(2, "%s()\n", __func__ );
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001117
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 IRDA_ASSERT(self != NULL, return -1;);
1119 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
1120 IRDA_ASSERT(skb != NULL, return -1;);
1121
Jiri Slaby62f228a2012-06-04 13:35:21 +02001122 tty = tty_port_tty_get(&self->port);
1123 if (!tty) {
Harvey Harrison0dc47872008-03-05 20:47:47 -08001124 IRDA_DEBUG(0, "%s(), no tty!\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 return 0;
1126 }
1127
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001128 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 * If we receive data when hardware is stopped then something is wrong.
1130 * We try to poll the peers line settings to check if we are up todate.
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001131 * Devices like WinCE can do this, and since they don't send any
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 * params, we can just as well declare the hardware for running.
1133 */
Jiri Slaby62f228a2012-06-04 13:35:21 +02001134 if (tty->hw_stopped && (self->flow == FLOW_START)) {
Harvey Harrison0dc47872008-03-05 20:47:47 -08001135 IRDA_DEBUG(0, "%s(), polling for line settings!\n", __func__ );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 ircomm_param_request(self, IRCOMM_POLL, TRUE);
1137
1138 /* We can just as well declare the hardware for running */
1139 ircomm_tty_send_initial_parameters(self);
1140 ircomm_tty_link_established(self);
1141 }
Jiri Slaby2e124b42013-01-03 15:53:06 +01001142 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001144 /*
Amit Virdicbfd1522011-05-12 01:04:40 +00001145 * Use flip buffer functions since the code may be called from interrupt
1146 * context
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 */
Jiri Slaby05c7cd32013-01-03 15:53:04 +01001148 tty_insert_flip_string(&self->port, skb->data, skb->len);
Jiri Slaby2e124b42013-01-03 15:53:06 +01001149 tty_flip_buffer_push(&self->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150
1151 /* No need to kfree_skb - see ircomm_ttp_data_indication() */
1152
1153 return 0;
1154}
1155
1156/*
1157 * Function ircomm_tty_control_indication (instance, sap, skb)
1158 *
1159 * Parse all incoming parameters (easy!)
1160 *
1161 */
1162static int ircomm_tty_control_indication(void *instance, void *sap,
1163 struct sk_buff *skb)
1164{
1165 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
1166 int clen;
1167
Harvey Harrison0dc47872008-03-05 20:47:47 -08001168 IRDA_DEBUG(4, "%s()\n", __func__ );
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001169
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 IRDA_ASSERT(self != NULL, return -1;);
1171 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
1172 IRDA_ASSERT(skb != NULL, return -1;);
1173
1174 clen = skb->data[0];
1175
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001176 irda_param_extract_all(self, skb->data+1, IRDA_MIN(skb->len-1, clen),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 &ircomm_param_info);
1178
1179 /* No need to kfree_skb - see ircomm_control_indication() */
1180
1181 return 0;
1182}
1183
1184/*
1185 * Function ircomm_tty_flow_indication (instance, sap, cmd)
1186 *
1187 * This function is called by IrTTP when it wants us to slow down the
1188 * transmission of data. We just mark the hardware as stopped, and wait
1189 * for IrTTP to notify us that things are OK again.
1190 */
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001191static void ircomm_tty_flow_indication(void *instance, void *sap,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 LOCAL_FLOW cmd)
1193{
1194 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
1195 struct tty_struct *tty;
1196
1197 IRDA_ASSERT(self != NULL, return;);
1198 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
1199
Jiri Slaby62f228a2012-06-04 13:35:21 +02001200 tty = tty_port_tty_get(&self->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201
1202 switch (cmd) {
1203 case FLOW_START:
Harvey Harrison0dc47872008-03-05 20:47:47 -08001204 IRDA_DEBUG(2, "%s(), hw start!\n", __func__ );
Jiri Slaby62f228a2012-06-04 13:35:21 +02001205 if (tty)
1206 tty->hw_stopped = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207
1208 /* ircomm_tty_do_softint will take care of the rest */
1209 schedule_work(&self->tqueue);
1210 break;
1211 default: /* If we get here, something is very wrong, better stop */
1212 case FLOW_STOP:
Harvey Harrison0dc47872008-03-05 20:47:47 -08001213 IRDA_DEBUG(2, "%s(), hw stopped!\n", __func__ );
Jiri Slaby62f228a2012-06-04 13:35:21 +02001214 if (tty)
1215 tty->hw_stopped = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 break;
1217 }
Jiri Slaby62f228a2012-06-04 13:35:21 +02001218
1219 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 self->flow = cmd;
1221}
1222
Pavel Emelyanov92b05e132007-12-05 02:18:48 -08001223#ifdef CONFIG_PROC_FS
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001224static void ircomm_tty_line_info(struct ircomm_tty_cb *self, struct seq_file *m)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225{
Jiri Slaby62f228a2012-06-04 13:35:21 +02001226 struct tty_struct *tty;
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001227 char sep;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001229 seq_printf(m, "State: %s\n", ircomm_tty_state[self->state]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001231 seq_puts(m, "Service type: ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 if (self->service_type & IRCOMM_9_WIRE)
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001233 seq_puts(m, "9_WIRE");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 else if (self->service_type & IRCOMM_3_WIRE)
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001235 seq_puts(m, "3_WIRE");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 else if (self->service_type & IRCOMM_3_WIRE_RAW)
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001237 seq_puts(m, "3_WIRE_RAW");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 else
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001239 seq_puts(m, "No common service type!\n");
1240 seq_putc(m, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001242 seq_printf(m, "Port name: %s\n", self->settings.port_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001244 seq_printf(m, "DTE status:");
1245 sep = ' ';
1246 if (self->settings.dte & IRCOMM_RTS) {
1247 seq_printf(m, "%cRTS", sep);
1248 sep = '|';
1249 }
1250 if (self->settings.dte & IRCOMM_DTR) {
1251 seq_printf(m, "%cDTR", sep);
1252 sep = '|';
1253 }
1254 seq_putc(m, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001256 seq_puts(m, "DCE status:");
1257 sep = ' ';
1258 if (self->settings.dce & IRCOMM_CTS) {
1259 seq_printf(m, "%cCTS", sep);
1260 sep = '|';
1261 }
1262 if (self->settings.dce & IRCOMM_DSR) {
1263 seq_printf(m, "%cDSR", sep);
1264 sep = '|';
1265 }
1266 if (self->settings.dce & IRCOMM_CD) {
1267 seq_printf(m, "%cCD", sep);
1268 sep = '|';
1269 }
1270 if (self->settings.dce & IRCOMM_RI) {
1271 seq_printf(m, "%cRI", sep);
1272 sep = '|';
1273 }
1274 seq_putc(m, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001276 seq_puts(m, "Configuration: ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 if (!self->settings.null_modem)
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001278 seq_puts(m, "DTE <-> DCE\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 else
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001280 seq_puts(m, "DTE <-> DTE (null modem emulation)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001282 seq_printf(m, "Data rate: %d\n", self->settings.data_rate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001284 seq_puts(m, "Flow control:");
1285 sep = ' ';
1286 if (self->settings.flow_control & IRCOMM_XON_XOFF_IN) {
1287 seq_printf(m, "%cXON_XOFF_IN", sep);
1288 sep = '|';
1289 }
1290 if (self->settings.flow_control & IRCOMM_XON_XOFF_OUT) {
1291 seq_printf(m, "%cXON_XOFF_OUT", sep);
1292 sep = '|';
1293 }
1294 if (self->settings.flow_control & IRCOMM_RTS_CTS_IN) {
1295 seq_printf(m, "%cRTS_CTS_IN", sep);
1296 sep = '|';
1297 }
1298 if (self->settings.flow_control & IRCOMM_RTS_CTS_OUT) {
1299 seq_printf(m, "%cRTS_CTS_OUT", sep);
1300 sep = '|';
1301 }
1302 if (self->settings.flow_control & IRCOMM_DSR_DTR_IN) {
1303 seq_printf(m, "%cDSR_DTR_IN", sep);
1304 sep = '|';
1305 }
1306 if (self->settings.flow_control & IRCOMM_DSR_DTR_OUT) {
1307 seq_printf(m, "%cDSR_DTR_OUT", sep);
1308 sep = '|';
1309 }
1310 if (self->settings.flow_control & IRCOMM_ENQ_ACK_IN) {
1311 seq_printf(m, "%cENQ_ACK_IN", sep);
1312 sep = '|';
1313 }
1314 if (self->settings.flow_control & IRCOMM_ENQ_ACK_OUT) {
1315 seq_printf(m, "%cENQ_ACK_OUT", sep);
1316 sep = '|';
1317 }
1318 seq_putc(m, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001320 seq_puts(m, "Flags:");
1321 sep = ' ';
Huang Shijief21ec3d2012-08-22 22:13:36 -04001322 if (tty_port_cts_enabled(&self->port)) {
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001323 seq_printf(m, "%cASYNC_CTS_FLOW", sep);
1324 sep = '|';
1325 }
Jiri Slaby849d5a92012-06-04 13:35:19 +02001326 if (self->port.flags & ASYNC_CHECK_CD) {
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001327 seq_printf(m, "%cASYNC_CHECK_CD", sep);
1328 sep = '|';
1329 }
Jiri Slaby849d5a92012-06-04 13:35:19 +02001330 if (self->port.flags & ASYNC_INITIALIZED) {
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001331 seq_printf(m, "%cASYNC_INITIALIZED", sep);
1332 sep = '|';
1333 }
Jiri Slaby849d5a92012-06-04 13:35:19 +02001334 if (self->port.flags & ASYNC_LOW_LATENCY) {
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001335 seq_printf(m, "%cASYNC_LOW_LATENCY", sep);
1336 sep = '|';
1337 }
Jiri Slaby849d5a92012-06-04 13:35:19 +02001338 if (self->port.flags & ASYNC_CLOSING) {
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001339 seq_printf(m, "%cASYNC_CLOSING", sep);
1340 sep = '|';
1341 }
Jiri Slaby849d5a92012-06-04 13:35:19 +02001342 if (self->port.flags & ASYNC_NORMAL_ACTIVE) {
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001343 seq_printf(m, "%cASYNC_NORMAL_ACTIVE", sep);
1344 sep = '|';
1345 }
1346 seq_putc(m, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001348 seq_printf(m, "Role: %s\n", self->client ? "client" : "server");
Jiri Slaby580d27b2012-06-04 13:35:18 +02001349 seq_printf(m, "Open count: %d\n", self->port.count);
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001350 seq_printf(m, "Max data size: %d\n", self->max_data_size);
1351 seq_printf(m, "Max header size: %d\n", self->max_header_size);
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001352
Jiri Slaby62f228a2012-06-04 13:35:21 +02001353 tty = tty_port_tty_get(&self->port);
1354 if (tty) {
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001355 seq_printf(m, "Hardware: %s\n",
Jiri Slaby62f228a2012-06-04 13:35:21 +02001356 tty->hw_stopped ? "Stopped" : "Running");
1357 tty_kref_put(tty);
1358 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359}
1360
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001361static int ircomm_tty_proc_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362{
1363 struct ircomm_tty_cb *self;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 unsigned long flags;
1365
1366 spin_lock_irqsave(&ircomm_tty->hb_spinlock, flags);
1367
1368 self = (struct ircomm_tty_cb *) hashbin_get_first(ircomm_tty);
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001369 while (self != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 if (self->magic != IRCOMM_TTY_MAGIC)
1371 break;
1372
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001373 ircomm_tty_line_info(self, m);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 self = (struct ircomm_tty_cb *) hashbin_get_next(ircomm_tty);
YOSHIFUJI Hideaki6819bc22007-02-09 23:24:53 +09001375 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 spin_unlock_irqrestore(&ircomm_tty->hb_spinlock, flags);
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001377 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378}
Alexey Dobriyan3d304172009-03-31 15:19:22 -07001379
1380static int ircomm_tty_proc_open(struct inode *inode, struct file *file)
1381{
1382 return single_open(file, ircomm_tty_proc_show, NULL);
1383}
1384
1385static const struct file_operations ircomm_tty_proc_fops = {
1386 .owner = THIS_MODULE,
1387 .open = ircomm_tty_proc_open,
1388 .read = seq_read,
1389 .llseek = seq_lseek,
1390 .release = single_release,
1391};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392#endif /* CONFIG_PROC_FS */
1393
1394MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
1395MODULE_DESCRIPTION("IrCOMM serial TTY driver");
1396MODULE_LICENSE("GPL");
1397MODULE_ALIAS_CHARDEV_MAJOR(IRCOMM_TTY_MAJOR);
1398
1399module_init(ircomm_tty_init);
1400module_exit(ircomm_tty_cleanup);