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,
231 /* block if port is in the process of being closed */
232 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
233 wait_event_interruptible_tty(port->close_wait,
234 !(port->flags & ASYNC_CLOSING));
235 if (port->flags & ASYNC_HUP_NOTIFY)
242 the port has just hung up or is in another error state */
244 port->flags |= ASYNC_NORMAL_ACTIVE;
250 tty_port_raise_dtr_rts(port);
251 port->flags |= ASYNC_NORMAL_ACTIVE;
264 /* The port lock protects the port counts */
265 spin_lock_irqsave(&port->lock, flags);
267 port->count--;
268 port->blocked_open++;
269 spin_unlock_irqrestore(&port->lock, flags);
274 tty_port_raise_dtr_rts(port);
276 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
277 /* Check for a hangup or uninitialised port.
279 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
280 if (port->flags & ASYNC_HUP_NOTIFY)
292 if (!(port->flags & ASYNC_CLOSING) &&
293 (do_clocal || tty_port_carrier_raised(port)))
303 finish_wait(&port->open_wait, &wait);
307 spin_lock_irqsave(&port->lock, flags);
309 port->count++;
310 port->blocked_open--;
312 port->flags |= ASYNC_NORMAL_ACTIVE;
313 spin_unlock_irqrestore(&port->lock, flags);
318 int tty_port_close_start(struct tty_port *port,
323 spin_lock_irqsave(&port->lock, flags);
325 spin_unlock_irqrestore(&port->lock, flags);
329 if (tty->count == 1 && port->count != 1) {
331 "tty_port_close_start: tty->count = 1 port count = %d.\n",
332 port->count);
333 port->count = 1;
335 if (--port->count < 0) {
337 port->count);
338 port->count = 0;
341 if (port->count) {
342 spin_unlock_irqrestore(&port->lock, flags);
343 if (port->ops->drop)
344 port->ops->drop(port);
347 set_bit(ASYNCB_CLOSING, &port->flags);
349 spin_unlock_irqrestore(&port->lock, flags);
350 /* Don't block on a stalled port, just pull the chain */
353 if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
354 port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
355 tty_wait_until_sent_from_close(tty, port->closing_wait);
356 if (port->drain_delay) {
362 (HZ * 10 * port->drain_delay) / bps, HZ / 10);
373 tty_port_lower_dtr_rts(port);
375 /* Don't call port->drop for the last reference. Callers will want
382 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
386 spin_lock_irqsave(&port->lock, flags);
389 if (port->blocked_open) {
390 spin_unlock_irqrestore(&port->lock, flags);
391 if (port->close_delay) {
393 jiffies_to_msecs(port->close_delay));
395 spin_lock_irqsave(&port->lock, flags);
396 wake_up_interruptible(&port->open_wait);
398 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
399 wake_up_interruptible(&port->close_wait);
400 spin_unlock_irqrestore(&port->lock, flags);
404 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
407 if (tty_port_close_start(port, tty, filp) == 0)
409 tty_port_shutdown(port);
411 tty_port_close_end(port, tty);
412 tty_port_tty_set(port, NULL);
416 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
419 spin_lock_irq(&port->lock);
421 ++port->count;
422 spin_unlock_irq(&port->lock);
423 tty_port_tty_set(port, tty);
428 * port mutex.
431 mutex_lock(&port->mutex);
433 if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
435 if (port->ops->activate) {
436 int retval = port->ops->activate(port, tty);
438 mutex_unlock(&port->mutex);
442 set_bit(ASYNCB_INITIALIZED, &port->flags);
444 mutex_unlock(&port->mutex);
445 return tty_port_block_til_ready(port, tty, filp);