Lines Matching refs:port
2 * Tty port functions
21 void tty_port_init(struct tty_port *port)
23 memset(port, 0, sizeof(*port));
24 init_waitqueue_head(&port->open_wait);
25 init_waitqueue_head(&port->close_wait);
26 init_waitqueue_head(&port->delta_msr_wait);
27 mutex_init(&port->mutex);
28 mutex_init(&port->buf_mutex);
29 spin_lock_init(&port->lock);
30 port->close_delay = (50 * HZ) / 100;
31 port->closing_wait = (3000 * HZ) / 100;
32 kref_init(&port->kref);
36 int tty_port_alloc_xmit_buf(struct tty_port *port)
39 mutex_lock(&port->buf_mutex);
40 if (port->xmit_buf == NULL)
41 port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
42 mutex_unlock(&port->buf_mutex);
43 if (port->xmit_buf == NULL)
49 void tty_port_free_xmit_buf(struct tty_port *port)
51 mutex_lock(&port->buf_mutex);
52 if (port->xmit_buf != NULL) {
53 free_page((unsigned long)port->xmit_buf);
54 port->xmit_buf = NULL;
56 mutex_unlock(&port->buf_mutex);
62 struct tty_port *port = container_of(kref, struct tty_port, kref);
63 if (port->xmit_buf)
64 free_page((unsigned long)port->xmit_buf);
65 if (port->ops->destruct)
66 port->ops->destruct(port);
68 kfree(port);
71 void tty_port_put(struct tty_port *port)
73 if (port)
74 kref_put(&port->kref, tty_port_destructor);
80 * @port: tty port
82 * Return a refcount protected tty instance or NULL if the port is not
86 struct tty_struct *tty_port_tty_get(struct tty_port *port)
91 spin_lock_irqsave(&port->lock, flags);
92 tty = tty_kref_get(port->tty);
93 spin_unlock_irqrestore(&port->lock, flags);
99 * tty_port_tty_set - set the tty of a port
100 * @port: tty port
103 * Associate the port and tty pair. Manages any internal refcounts.
104 * Pass NULL to deassociate a port
107 void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
111 spin_lock_irqsave(&port->lock, flags);
112 if (port->tty)
113 tty_kref_put(port->tty);
114 port->tty = tty_kref_get(tty);
115 spin_unlock_irqrestore(&port->lock, flags);
119 static void tty_port_shutdown(struct tty_port *port)
121 mutex_lock(&port->mutex);
122 if (port->ops->shutdown && !port->console &&
123 test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags))
124 port->ops->shutdown(port);
125 mutex_unlock(&port->mutex);
130 * @port: tty port
132 * Perform port level tty hangup flag and count changes. Drop the tty
136 void tty_port_hangup(struct tty_port *port)
140 spin_lock_irqsave(&port->lock, flags);
141 port->count = 0;
142 port->flags &= ~ASYNC_NORMAL_ACTIVE;
143 if (port->tty) {
144 set_bit(TTY_IO_ERROR, &port->tty->flags);
145 tty_kref_put(port->tty);
147 port->tty = NULL;
148 spin_unlock_irqrestore(&port->lock, flags);
149 wake_up_interruptible(&port->open_wait);
150 wake_up_interruptible(&port->delta_msr_wait);
151 tty_port_shutdown(port);
157 * @port: tty port
161 * internal to the tty port.
164 int tty_port_carrier_raised(struct tty_port *port)
166 if (port->ops->carrier_raised == NULL)
168 return port->ops->carrier_raised(port);
174 * @port: tty port
178 * internal to the tty port.
181 void tty_port_raise_dtr_rts(struct tty_port *port)
183 if (port->ops->dtr_rts)
184 port->ops->dtr_rts(port, 1);
190 * @port: tty port
194 * internal to the tty port.
197 void tty_port_lower_dtr_rts(struct tty_port *port)
199 if (port->ops->dtr_rts)
200 port->ops->dtr_rts(port, 0);
206 * @port: the tty port being opened
216 * - port flags and counts
224 int tty_port_block_til_ready(struct tty_port *port,
232 /* block if port is in the process of being closed */
233 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
234 wait_event_interruptible_tty(port->close_wait,
235 !(port->flags & ASYNC_CLOSING));
236 if (port->flags & ASYNC_HUP_NOTIFY)
243 the port has just hung up or is in another error state */
245 port->flags |= ASYNC_NORMAL_ACTIVE;
251 tty_port_raise_dtr_rts(port);
252 port->flags |= ASYNC_NORMAL_ACTIVE;
265 /* The port lock protects the port counts */
266 spin_lock_irqsave(&port->lock, flags);
268 port->count--;
269 port->blocked_open++;
270 spin_unlock_irqrestore(&port->lock, flags);
275 tty_port_raise_dtr_rts(port);
277 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
278 /* Check for a hangup or uninitialised port.
280 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
281 if (port->flags & ASYNC_HUP_NOTIFY)
289 cd = tty_port_carrier_raised(port);
290 if (!(port->flags & ASYNC_CLOSING) &&
301 finish_wait(&port->open_wait, &wait);
305 spin_lock_irqsave(&port->lock, flags);
307 port->count++;
308 port->blocked_open--;
310 port->flags |= ASYNC_NORMAL_ACTIVE;
311 spin_unlock_irqrestore(&port->lock, flags);
316 int tty_port_close_start(struct tty_port *port,
321 spin_lock_irqsave(&port->lock, flags);
323 spin_unlock_irqrestore(&port->lock, flags);
327 if (tty->count == 1 && port->count != 1) {
329 "tty_port_close_start: tty->count = 1 port count = %d.\n",
330 port->count);
331 port->count = 1;
333 if (--port->count < 0) {
335 port->count);
336 port->count = 0;
339 if (port->count) {
340 spin_unlock_irqrestore(&port->lock, flags);
341 if (port->ops->drop)
342 port->ops->drop(port);
345 set_bit(ASYNCB_CLOSING, &port->flags);
347 spin_unlock_irqrestore(&port->lock, flags);
348 /* Don't block on a stalled port, just pull the chain */
351 if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
352 port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
353 tty_wait_until_sent(tty, port->closing_wait);
354 if (port->drain_delay) {
360 (HZ * 10 * port->drain_delay) / bps, HZ / 10);
371 tty_port_lower_dtr_rts(port);
373 /* Don't call port->drop for the last reference. Callers will want
380 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
384 spin_lock_irqsave(&port->lock, flags);
387 if (port->blocked_open) {
388 spin_unlock_irqrestore(&port->lock, flags);
389 if (port->close_delay) {
391 jiffies_to_msecs(port->close_delay));
393 spin_lock_irqsave(&port->lock, flags);
394 wake_up_interruptible(&port->open_wait);
396 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
397 wake_up_interruptible(&port->close_wait);
398 spin_unlock_irqrestore(&port->lock, flags);
402 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
405 if (tty_port_close_start(port, tty, filp) == 0)
407 tty_port_shutdown(port);
409 tty_port_close_end(port, tty);
410 tty_port_tty_set(port, NULL);
414 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
417 spin_lock_irq(&port->lock);
419 ++port->count;
420 spin_unlock_irq(&port->lock);
421 tty_port_tty_set(port, tty);
426 * port mutex.
429 mutex_lock(&port->mutex);
431 if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
433 if (port->ops->activate) {
434 int retval = port->ops->activate(port, tty);
436 mutex_unlock(&port->mutex);
440 set_bit(ASYNCB_INITIALIZED, &port->flags);
442 mutex_unlock(&port->mutex);
443 return tty_port_block_til_ready(port, tty, filp);