Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
7f81947b | 2 | * $Id: ctctty.c,v 1.29 2005/04/05 08:50:44 mschwide Exp $ |
1da177e4 LT |
3 | * |
4 | * CTC / ESCON network driver, tty interface. | |
5 | * | |
6 | * Copyright (C) 2001 IBM Deutschland Entwicklung GmbH, IBM Corporation | |
7 | * Author(s): Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com) | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License as published by | |
11 | * the Free Software Foundation; either version 2, or (at your option) | |
12 | * any later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | * GNU General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License | |
20 | * along with this program; if not, write to the Free Software | |
21 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
22 | * | |
23 | */ | |
24 | ||
25 | #include <linux/config.h> | |
26 | #include <linux/module.h> | |
27 | #include <linux/tty.h> | |
28 | #include <linux/serial_reg.h> | |
29 | #include <linux/interrupt.h> | |
30 | #include <linux/delay.h> | |
31 | #include <asm/uaccess.h> | |
32 | #include <linux/devfs_fs_kernel.h> | |
33 | #include "ctctty.h" | |
34 | #include "ctcdbug.h" | |
35 | ||
36 | #define CTC_TTY_MAJOR 43 | |
37 | #define CTC_TTY_MAX_DEVICES 64 | |
38 | ||
39 | #define CTC_ASYNC_MAGIC 0x49344C01 /* for paranoia-checking */ | |
40 | #define CTC_ASYNC_INITIALIZED 0x80000000 /* port was initialized */ | |
41 | #define CTC_ASYNC_NORMAL_ACTIVE 0x20000000 /* Normal device active */ | |
42 | #define CTC_ASYNC_CLOSING 0x08000000 /* Serial port is closing */ | |
43 | #define CTC_ASYNC_CTS_FLOW 0x04000000 /* Do CTS flow control */ | |
44 | #define CTC_ASYNC_CHECK_CD 0x02000000 /* i.e., CLOCAL */ | |
45 | #define CTC_ASYNC_HUP_NOTIFY 0x0001 /* Notify tty on hangups/closes */ | |
46 | #define CTC_ASYNC_NETDEV_OPEN 0x0002 /* Underlying netdev is open */ | |
47 | #define CTC_ASYNC_TX_LINESTAT 0x0004 /* Must send line status */ | |
48 | #define CTC_ASYNC_SPLIT_TERMIOS 0x0008 /* Sep. termios for dialin/out */ | |
49 | #define CTC_TTY_XMIT_SIZE 1024 /* Default bufsize for write */ | |
50 | #define CTC_SERIAL_XMIT_MAX 4000 /* Maximum bufsize for write */ | |
51 | ||
52 | /* Private data (similar to async_struct in <linux/serial.h>) */ | |
53 | typedef struct { | |
54 | int magic; | |
55 | int flags; /* defined in tty.h */ | |
56 | int mcr; /* Modem control register */ | |
57 | int msr; /* Modem status register */ | |
58 | int lsr; /* Line status register */ | |
59 | int line; | |
60 | int count; /* # of fd on device */ | |
61 | int blocked_open; /* # of blocked opens */ | |
62 | struct net_device *netdev; | |
63 | struct sk_buff_head tx_queue; /* transmit queue */ | |
64 | struct sk_buff_head rx_queue; /* receive queue */ | |
65 | struct tty_struct *tty; /* Pointer to corresponding tty */ | |
66 | wait_queue_head_t open_wait; | |
67 | wait_queue_head_t close_wait; | |
68 | struct semaphore write_sem; | |
69 | struct tasklet_struct tasklet; | |
70 | struct timer_list stoptimer; | |
71 | } ctc_tty_info; | |
72 | ||
73 | /* Description of one CTC-tty */ | |
74 | typedef struct { | |
75 | struct tty_driver *ctc_tty_device; /* tty-device */ | |
76 | ctc_tty_info info[CTC_TTY_MAX_DEVICES]; /* Private data */ | |
77 | } ctc_tty_driver; | |
78 | ||
79 | static ctc_tty_driver *driver; | |
80 | ||
81 | /* Leave this unchanged unless you know what you do! */ | |
82 | #define MODEM_PARANOIA_CHECK | |
83 | #define MODEM_DO_RESTART | |
84 | ||
85 | #define CTC_TTY_NAME "ctctty" | |
86 | ||
87 | static __u32 ctc_tty_magic = CTC_ASYNC_MAGIC; | |
88 | static int ctc_tty_shuttingdown = 0; | |
89 | ||
90 | static spinlock_t ctc_tty_lock; | |
91 | ||
92 | /* ctc_tty_try_read() is called from within ctc_tty_rcv_skb() | |
93 | * to stuff incoming data directly into a tty's flip-buffer. If the | |
94 | * flip buffer is full, the packet gets queued up. | |
95 | * | |
96 | * Return: | |
97 | * 1 = Success | |
98 | * 0 = Failure, data has to be buffered and later processed by | |
99 | * ctc_tty_readmodem(). | |
100 | */ | |
101 | static int | |
102 | ctc_tty_try_read(ctc_tty_info * info, struct sk_buff *skb) | |
103 | { | |
104 | int c; | |
105 | int len; | |
106 | struct tty_struct *tty; | |
107 | ||
108 | DBF_TEXT(trace, 5, __FUNCTION__); | |
109 | if ((tty = info->tty)) { | |
110 | if (info->mcr & UART_MCR_RTS) { | |
111 | c = TTY_FLIPBUF_SIZE - tty->flip.count; | |
112 | len = skb->len; | |
113 | if (c >= len) { | |
114 | memcpy(tty->flip.char_buf_ptr, skb->data, len); | |
115 | memset(tty->flip.flag_buf_ptr, 0, len); | |
116 | tty->flip.count += len; | |
117 | tty->flip.char_buf_ptr += len; | |
118 | tty->flip.flag_buf_ptr += len; | |
119 | tty_flip_buffer_push(tty); | |
120 | kfree_skb(skb); | |
121 | return 1; | |
122 | } | |
123 | } | |
124 | } | |
125 | return 0; | |
126 | } | |
127 | ||
128 | /* ctc_tty_readmodem() is called periodically from within timer-interrupt. | |
129 | * It tries getting received data from the receive queue an stuff it into | |
130 | * the tty's flip-buffer. | |
131 | */ | |
132 | static int | |
133 | ctc_tty_readmodem(ctc_tty_info *info) | |
134 | { | |
135 | int ret = 1; | |
136 | struct tty_struct *tty; | |
137 | ||
138 | DBF_TEXT(trace, 5, __FUNCTION__); | |
139 | if ((tty = info->tty)) { | |
140 | if (info->mcr & UART_MCR_RTS) { | |
141 | int c = TTY_FLIPBUF_SIZE - tty->flip.count; | |
142 | struct sk_buff *skb; | |
143 | ||
144 | if ((c > 0) && (skb = skb_dequeue(&info->rx_queue))) { | |
145 | int len = skb->len; | |
146 | if (len > c) | |
147 | len = c; | |
148 | memcpy(tty->flip.char_buf_ptr, skb->data, len); | |
149 | skb_pull(skb, len); | |
150 | memset(tty->flip.flag_buf_ptr, 0, len); | |
151 | tty->flip.count += len; | |
152 | tty->flip.char_buf_ptr += len; | |
153 | tty->flip.flag_buf_ptr += len; | |
154 | tty_flip_buffer_push(tty); | |
155 | if (skb->len > 0) | |
156 | skb_queue_head(&info->rx_queue, skb); | |
157 | else { | |
158 | kfree_skb(skb); | |
b03efcfb | 159 | ret = !skb_queue_empty(&info->rx_queue); |
1da177e4 LT |
160 | } |
161 | } | |
162 | } | |
163 | } | |
164 | return ret; | |
165 | } | |
166 | ||
167 | void | |
168 | ctc_tty_setcarrier(struct net_device *netdev, int on) | |
169 | { | |
170 | int i; | |
171 | ||
172 | DBF_TEXT(trace, 4, __FUNCTION__); | |
173 | if ((!driver) || ctc_tty_shuttingdown) | |
174 | return; | |
175 | for (i = 0; i < CTC_TTY_MAX_DEVICES; i++) | |
176 | if (driver->info[i].netdev == netdev) { | |
177 | ctc_tty_info *info = &driver->info[i]; | |
178 | if (on) | |
179 | info->msr |= UART_MSR_DCD; | |
180 | else | |
181 | info->msr &= ~UART_MSR_DCD; | |
182 | if ((info->flags & CTC_ASYNC_CHECK_CD) && (!on)) | |
183 | tty_hangup(info->tty); | |
184 | } | |
185 | } | |
186 | ||
187 | void | |
188 | ctc_tty_netif_rx(struct sk_buff *skb) | |
189 | { | |
190 | int i; | |
191 | ctc_tty_info *info = NULL; | |
192 | ||
193 | DBF_TEXT(trace, 5, __FUNCTION__); | |
194 | if (!skb) | |
195 | return; | |
196 | if ((!skb->dev) || (!driver) || ctc_tty_shuttingdown) { | |
197 | dev_kfree_skb(skb); | |
198 | return; | |
199 | } | |
200 | for (i = 0; i < CTC_TTY_MAX_DEVICES; i++) | |
201 | if (driver->info[i].netdev == skb->dev) { | |
202 | info = &driver->info[i]; | |
203 | break; | |
204 | } | |
205 | if (!info) { | |
206 | dev_kfree_skb(skb); | |
207 | return; | |
208 | } | |
209 | if (skb->len < 6) { | |
210 | dev_kfree_skb(skb); | |
211 | return; | |
212 | } | |
213 | if (memcmp(skb->data, &ctc_tty_magic, sizeof(__u32))) { | |
214 | dev_kfree_skb(skb); | |
215 | return; | |
216 | } | |
217 | skb_pull(skb, sizeof(__u32)); | |
218 | ||
219 | i = *((int *)skb->data); | |
220 | skb_pull(skb, sizeof(info->mcr)); | |
221 | if (i & UART_MCR_RTS) { | |
222 | info->msr |= UART_MSR_CTS; | |
223 | if (info->flags & CTC_ASYNC_CTS_FLOW) | |
224 | info->tty->hw_stopped = 0; | |
225 | } else { | |
226 | info->msr &= ~UART_MSR_CTS; | |
227 | if (info->flags & CTC_ASYNC_CTS_FLOW) | |
228 | info->tty->hw_stopped = 1; | |
229 | } | |
230 | if (i & UART_MCR_DTR) | |
231 | info->msr |= UART_MSR_DSR; | |
232 | else | |
233 | info->msr &= ~UART_MSR_DSR; | |
234 | if (skb->len <= 0) { | |
235 | kfree_skb(skb); | |
236 | return; | |
237 | } | |
238 | /* Try to deliver directly via tty-flip-buf if queue is empty */ | |
239 | if (skb_queue_empty(&info->rx_queue)) | |
240 | if (ctc_tty_try_read(info, skb)) | |
241 | return; | |
242 | /* Direct deliver failed or queue wasn't empty. | |
243 | * Queue up for later dequeueing via timer-irq. | |
244 | */ | |
245 | skb_queue_tail(&info->rx_queue, skb); | |
246 | /* Schedule dequeuing */ | |
247 | tasklet_schedule(&info->tasklet); | |
248 | } | |
249 | ||
250 | static int | |
251 | ctc_tty_tint(ctc_tty_info * info) | |
252 | { | |
253 | struct sk_buff *skb = skb_dequeue(&info->tx_queue); | |
254 | int stopped = (info->tty->hw_stopped || info->tty->stopped); | |
255 | int wake = 1; | |
256 | int rc; | |
257 | ||
258 | DBF_TEXT(trace, 4, __FUNCTION__); | |
259 | if (!info->netdev) { | |
260 | if (skb) | |
261 | kfree_skb(skb); | |
262 | return 0; | |
263 | } | |
264 | if (info->flags & CTC_ASYNC_TX_LINESTAT) { | |
265 | int skb_res = info->netdev->hard_header_len + | |
266 | sizeof(info->mcr) + sizeof(__u32); | |
267 | /* If we must update line status, | |
268 | * create an empty dummy skb and insert it. | |
269 | */ | |
270 | if (skb) | |
271 | skb_queue_head(&info->tx_queue, skb); | |
272 | ||
273 | skb = dev_alloc_skb(skb_res); | |
274 | if (!skb) { | |
275 | printk(KERN_WARNING | |
276 | "ctc_tty: Out of memory in %s%d tint\n", | |
277 | CTC_TTY_NAME, info->line); | |
278 | return 1; | |
279 | } | |
280 | skb_reserve(skb, skb_res); | |
281 | stopped = 0; | |
282 | wake = 0; | |
283 | } | |
284 | if (!skb) | |
285 | return 0; | |
286 | if (stopped) { | |
287 | skb_queue_head(&info->tx_queue, skb); | |
288 | return 1; | |
289 | } | |
290 | #if 0 | |
291 | if (skb->len > 0) | |
292 | printk(KERN_DEBUG "tint: %d %02x\n", skb->len, *(skb->data)); | |
293 | else | |
294 | printk(KERN_DEBUG "tint: %d STAT\n", skb->len); | |
295 | #endif | |
296 | memcpy(skb_push(skb, sizeof(info->mcr)), &info->mcr, sizeof(info->mcr)); | |
297 | memcpy(skb_push(skb, sizeof(__u32)), &ctc_tty_magic, sizeof(__u32)); | |
298 | rc = info->netdev->hard_start_xmit(skb, info->netdev); | |
299 | if (rc) { | |
300 | skb_pull(skb, sizeof(info->mcr) + sizeof(__u32)); | |
301 | if (skb->len > 0) | |
302 | skb_queue_head(&info->tx_queue, skb); | |
303 | else | |
304 | kfree_skb(skb); | |
305 | } else { | |
306 | struct tty_struct *tty = info->tty; | |
307 | ||
308 | info->flags &= ~CTC_ASYNC_TX_LINESTAT; | |
309 | if (tty) { | |
310 | tty_wakeup(tty); | |
311 | } | |
312 | } | |
313 | return (skb_queue_empty(&info->tx_queue) ? 0 : 1); | |
314 | } | |
315 | ||
316 | /************************************************************ | |
317 | * | |
318 | * Modem-functions | |
319 | * | |
320 | * mostly "stolen" from original Linux-serial.c and friends. | |
321 | * | |
322 | ************************************************************/ | |
323 | ||
324 | static inline int | |
325 | ctc_tty_paranoia_check(ctc_tty_info * info, char *name, const char *routine) | |
326 | { | |
327 | #ifdef MODEM_PARANOIA_CHECK | |
328 | if (!info) { | |
329 | printk(KERN_WARNING "ctc_tty: null info_struct for %s in %s\n", | |
330 | name, routine); | |
331 | return 1; | |
332 | } | |
333 | if (info->magic != CTC_ASYNC_MAGIC) { | |
334 | printk(KERN_WARNING "ctc_tty: bad magic for info struct %s in %s\n", | |
335 | name, routine); | |
336 | return 1; | |
337 | } | |
338 | #endif | |
339 | return 0; | |
340 | } | |
341 | ||
342 | static void | |
343 | ctc_tty_inject(ctc_tty_info *info, char c) | |
344 | { | |
345 | int skb_res; | |
346 | struct sk_buff *skb; | |
347 | ||
348 | DBF_TEXT(trace, 4, __FUNCTION__); | |
349 | if (ctc_tty_shuttingdown) | |
350 | return; | |
351 | skb_res = info->netdev->hard_header_len + sizeof(info->mcr) + | |
352 | sizeof(__u32) + 1; | |
353 | skb = dev_alloc_skb(skb_res); | |
354 | if (!skb) { | |
355 | printk(KERN_WARNING | |
356 | "ctc_tty: Out of memory in %s%d tx_inject\n", | |
357 | CTC_TTY_NAME, info->line); | |
358 | return; | |
359 | } | |
360 | skb_reserve(skb, skb_res); | |
361 | *(skb_put(skb, 1)) = c; | |
362 | skb_queue_head(&info->tx_queue, skb); | |
363 | tasklet_schedule(&info->tasklet); | |
364 | } | |
365 | ||
366 | static void | |
367 | ctc_tty_transmit_status(ctc_tty_info *info) | |
368 | { | |
369 | DBF_TEXT(trace, 5, __FUNCTION__); | |
370 | if (ctc_tty_shuttingdown) | |
371 | return; | |
372 | info->flags |= CTC_ASYNC_TX_LINESTAT; | |
373 | tasklet_schedule(&info->tasklet); | |
374 | } | |
375 | ||
376 | static void | |
377 | ctc_tty_change_speed(ctc_tty_info * info) | |
378 | { | |
379 | unsigned int cflag; | |
380 | unsigned int quot; | |
381 | int i; | |
382 | ||
383 | DBF_TEXT(trace, 3, __FUNCTION__); | |
384 | if (!info->tty || !info->tty->termios) | |
385 | return; | |
386 | cflag = info->tty->termios->c_cflag; | |
387 | ||
388 | quot = i = cflag & CBAUD; | |
389 | if (i & CBAUDEX) { | |
390 | i &= ~CBAUDEX; | |
391 | if (i < 1 || i > 2) | |
392 | info->tty->termios->c_cflag &= ~CBAUDEX; | |
393 | else | |
394 | i += 15; | |
395 | } | |
396 | if (quot) { | |
397 | info->mcr |= UART_MCR_DTR; | |
398 | info->mcr |= UART_MCR_RTS; | |
399 | ctc_tty_transmit_status(info); | |
400 | } else { | |
401 | info->mcr &= ~UART_MCR_DTR; | |
402 | info->mcr &= ~UART_MCR_RTS; | |
403 | ctc_tty_transmit_status(info); | |
404 | return; | |
405 | } | |
406 | ||
407 | /* CTS flow control flag and modem status interrupts */ | |
408 | if (cflag & CRTSCTS) { | |
409 | info->flags |= CTC_ASYNC_CTS_FLOW; | |
410 | } else | |
411 | info->flags &= ~CTC_ASYNC_CTS_FLOW; | |
412 | if (cflag & CLOCAL) | |
413 | info->flags &= ~CTC_ASYNC_CHECK_CD; | |
414 | else { | |
415 | info->flags |= CTC_ASYNC_CHECK_CD; | |
416 | } | |
417 | } | |
418 | ||
419 | static int | |
420 | ctc_tty_startup(ctc_tty_info * info) | |
421 | { | |
422 | DBF_TEXT(trace, 3, __FUNCTION__); | |
423 | if (info->flags & CTC_ASYNC_INITIALIZED) | |
424 | return 0; | |
425 | #ifdef CTC_DEBUG_MODEM_OPEN | |
426 | printk(KERN_DEBUG "starting up %s%d ...\n", CTC_TTY_NAME, info->line); | |
427 | #endif | |
428 | /* | |
429 | * Now, initialize the UART | |
430 | */ | |
431 | info->mcr = UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2; | |
432 | if (info->tty) | |
433 | clear_bit(TTY_IO_ERROR, &info->tty->flags); | |
434 | /* | |
435 | * and set the speed of the serial port | |
436 | */ | |
437 | ctc_tty_change_speed(info); | |
438 | ||
439 | info->flags |= CTC_ASYNC_INITIALIZED; | |
440 | if (!(info->flags & CTC_ASYNC_NETDEV_OPEN)) | |
441 | info->netdev->open(info->netdev); | |
442 | info->flags |= CTC_ASYNC_NETDEV_OPEN; | |
443 | return 0; | |
444 | } | |
445 | ||
446 | static void | |
447 | ctc_tty_stopdev(unsigned long data) | |
448 | { | |
449 | ctc_tty_info *info = (ctc_tty_info *)data; | |
450 | ||
451 | if ((!info) || (!info->netdev) || | |
452 | (info->flags & CTC_ASYNC_INITIALIZED)) | |
453 | return; | |
454 | info->netdev->stop(info->netdev); | |
455 | info->flags &= ~CTC_ASYNC_NETDEV_OPEN; | |
456 | } | |
457 | ||
458 | /* | |
459 | * This routine will shutdown a serial port; interrupts are disabled, and | |
460 | * DTR is dropped if the hangup on close termio flag is on. | |
461 | */ | |
462 | static void | |
463 | ctc_tty_shutdown(ctc_tty_info * info) | |
464 | { | |
465 | DBF_TEXT(trace, 3, __FUNCTION__); | |
466 | if (!(info->flags & CTC_ASYNC_INITIALIZED)) | |
467 | return; | |
468 | #ifdef CTC_DEBUG_MODEM_OPEN | |
469 | printk(KERN_DEBUG "Shutting down %s%d ....\n", CTC_TTY_NAME, info->line); | |
470 | #endif | |
471 | info->msr &= ~UART_MSR_RI; | |
472 | if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) | |
473 | info->mcr &= ~(UART_MCR_DTR | UART_MCR_RTS); | |
474 | if (info->tty) | |
475 | set_bit(TTY_IO_ERROR, &info->tty->flags); | |
476 | mod_timer(&info->stoptimer, jiffies + (10 * HZ)); | |
477 | skb_queue_purge(&info->tx_queue); | |
478 | skb_queue_purge(&info->rx_queue); | |
479 | info->flags &= ~CTC_ASYNC_INITIALIZED; | |
480 | } | |
481 | ||
482 | /* ctc_tty_write() is the main send-routine. It is called from the upper | |
483 | * levels within the kernel to perform sending data. Depending on the | |
484 | * online-flag it either directs output to the at-command-interpreter or | |
485 | * to the lower level. Additional tasks done here: | |
486 | * - If online, check for escape-sequence (+++) | |
487 | * - If sending audio-data, call ctc_tty_DLEdown() to parse DLE-codes. | |
488 | * - If receiving audio-data, call ctc_tty_end_vrx() to abort if needed. | |
489 | * - If dialing, abort dial. | |
490 | */ | |
491 | static int | |
492 | ctc_tty_write(struct tty_struct *tty, const u_char * buf, int count) | |
493 | { | |
494 | int c; | |
495 | int total = 0; | |
496 | ctc_tty_info *info = (ctc_tty_info *) tty->driver_data; | |
497 | ||
498 | DBF_TEXT(trace, 5, __FUNCTION__); | |
499 | if (ctc_tty_shuttingdown) | |
500 | goto ex; | |
501 | if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_write")) | |
502 | goto ex; | |
503 | if (!tty) | |
504 | goto ex; | |
505 | if (!info->netdev) { | |
506 | total = -ENODEV; | |
507 | goto ex; | |
508 | } | |
509 | while (1) { | |
510 | struct sk_buff *skb; | |
511 | int skb_res; | |
512 | ||
513 | c = (count < CTC_TTY_XMIT_SIZE) ? count : CTC_TTY_XMIT_SIZE; | |
514 | if (c <= 0) | |
515 | break; | |
516 | ||
517 | skb_res = info->netdev->hard_header_len + sizeof(info->mcr) + | |
518 | + sizeof(__u32); | |
519 | skb = dev_alloc_skb(skb_res + c); | |
520 | if (!skb) { | |
521 | printk(KERN_WARNING | |
522 | "ctc_tty: Out of memory in %s%d write\n", | |
523 | CTC_TTY_NAME, info->line); | |
524 | break; | |
525 | } | |
526 | skb_reserve(skb, skb_res); | |
527 | memcpy(skb_put(skb, c), buf, c); | |
528 | skb_queue_tail(&info->tx_queue, skb); | |
529 | buf += c; | |
530 | total += c; | |
531 | count -= c; | |
532 | } | |
b03efcfb | 533 | if (!skb_queue_empty(&info->tx_queue)) { |
1da177e4 LT |
534 | info->lsr &= ~UART_LSR_TEMT; |
535 | tasklet_schedule(&info->tasklet); | |
536 | } | |
537 | ex: | |
538 | DBF_TEXT(trace, 6, __FUNCTION__); | |
539 | return total; | |
540 | } | |
541 | ||
542 | static int | |
543 | ctc_tty_write_room(struct tty_struct *tty) | |
544 | { | |
545 | ctc_tty_info *info = (ctc_tty_info *) tty->driver_data; | |
546 | ||
547 | if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_write_room")) | |
548 | return 0; | |
549 | return CTC_TTY_XMIT_SIZE; | |
550 | } | |
551 | ||
552 | static int | |
553 | ctc_tty_chars_in_buffer(struct tty_struct *tty) | |
554 | { | |
555 | ctc_tty_info *info = (ctc_tty_info *) tty->driver_data; | |
556 | ||
557 | if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_chars_in_buffer")) | |
558 | return 0; | |
559 | return 0; | |
560 | } | |
561 | ||
562 | static void | |
563 | ctc_tty_flush_buffer(struct tty_struct *tty) | |
564 | { | |
565 | ctc_tty_info *info; | |
566 | unsigned long flags; | |
567 | ||
568 | DBF_TEXT(trace, 4, __FUNCTION__); | |
569 | if (!tty) | |
570 | goto ex; | |
571 | spin_lock_irqsave(&ctc_tty_lock, flags); | |
572 | info = (ctc_tty_info *) tty->driver_data; | |
573 | if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_flush_buffer")) { | |
574 | spin_unlock_irqrestore(&ctc_tty_lock, flags); | |
575 | goto ex; | |
576 | } | |
577 | skb_queue_purge(&info->tx_queue); | |
578 | info->lsr |= UART_LSR_TEMT; | |
579 | spin_unlock_irqrestore(&ctc_tty_lock, flags); | |
580 | wake_up_interruptible(&tty->write_wait); | |
581 | tty_wakeup(tty); | |
582 | ex: | |
583 | DBF_TEXT_(trace, 2, "ex: %s ", __FUNCTION__); | |
584 | return; | |
585 | } | |
586 | ||
587 | static void | |
588 | ctc_tty_flush_chars(struct tty_struct *tty) | |
589 | { | |
590 | ctc_tty_info *info = (ctc_tty_info *) tty->driver_data; | |
591 | ||
592 | DBF_TEXT(trace, 4, __FUNCTION__); | |
593 | if (ctc_tty_shuttingdown) | |
594 | return; | |
595 | if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_flush_chars")) | |
596 | return; | |
b03efcfb | 597 | if (tty->stopped || tty->hw_stopped || skb_queue_empty(&info->tx_queue)) |
1da177e4 LT |
598 | return; |
599 | tasklet_schedule(&info->tasklet); | |
600 | } | |
601 | ||
602 | /* | |
603 | * ------------------------------------------------------------ | |
604 | * ctc_tty_throttle() | |
605 | * | |
606 | * This routine is called by the upper-layer tty layer to signal that | |
607 | * incoming characters should be throttled. | |
608 | * ------------------------------------------------------------ | |
609 | */ | |
610 | static void | |
611 | ctc_tty_throttle(struct tty_struct *tty) | |
612 | { | |
613 | ctc_tty_info *info = (ctc_tty_info *) tty->driver_data; | |
614 | ||
615 | DBF_TEXT(trace, 4, __FUNCTION__); | |
616 | if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_throttle")) | |
617 | return; | |
618 | info->mcr &= ~UART_MCR_RTS; | |
619 | if (I_IXOFF(tty)) | |
620 | ctc_tty_inject(info, STOP_CHAR(tty)); | |
621 | ctc_tty_transmit_status(info); | |
622 | } | |
623 | ||
624 | static void | |
625 | ctc_tty_unthrottle(struct tty_struct *tty) | |
626 | { | |
627 | ctc_tty_info *info = (ctc_tty_info *) tty->driver_data; | |
628 | ||
629 | DBF_TEXT(trace, 4, __FUNCTION__); | |
630 | if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_unthrottle")) | |
631 | return; | |
632 | info->mcr |= UART_MCR_RTS; | |
633 | if (I_IXOFF(tty)) | |
634 | ctc_tty_inject(info, START_CHAR(tty)); | |
635 | ctc_tty_transmit_status(info); | |
636 | } | |
637 | ||
638 | /* | |
639 | * ------------------------------------------------------------ | |
640 | * ctc_tty_ioctl() and friends | |
641 | * ------------------------------------------------------------ | |
642 | */ | |
643 | ||
644 | /* | |
645 | * ctc_tty_get_lsr_info - get line status register info | |
646 | * | |
647 | * Purpose: Let user call ioctl() to get info when the UART physically | |
648 | * is emptied. On bus types like RS485, the transmitter must | |
649 | * release the bus after transmitting. This must be done when | |
650 | * the transmit shift register is empty, not be done when the | |
651 | * transmit holding register is empty. This functionality | |
652 | * allows RS485 driver to be written in user space. | |
653 | */ | |
654 | static int | |
655 | ctc_tty_get_lsr_info(ctc_tty_info * info, uint __user *value) | |
656 | { | |
657 | u_char status; | |
658 | uint result; | |
659 | ulong flags; | |
660 | ||
661 | DBF_TEXT(trace, 4, __FUNCTION__); | |
662 | spin_lock_irqsave(&ctc_tty_lock, flags); | |
663 | status = info->lsr; | |
664 | spin_unlock_irqrestore(&ctc_tty_lock, flags); | |
665 | result = ((status & UART_LSR_TEMT) ? TIOCSER_TEMT : 0); | |
666 | put_user(result, value); | |
667 | return 0; | |
668 | } | |
669 | ||
670 | ||
671 | static int ctc_tty_tiocmget(struct tty_struct *tty, struct file *file) | |
672 | { | |
673 | ctc_tty_info *info = (ctc_tty_info *) tty->driver_data; | |
674 | u_char control, | |
675 | status; | |
676 | uint result; | |
677 | ulong flags; | |
678 | ||
679 | DBF_TEXT(trace, 4, __FUNCTION__); | |
680 | if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_ioctl")) | |
681 | return -ENODEV; | |
682 | if (tty->flags & (1 << TTY_IO_ERROR)) | |
683 | return -EIO; | |
684 | ||
685 | control = info->mcr; | |
686 | spin_lock_irqsave(&ctc_tty_lock, flags); | |
687 | status = info->msr; | |
688 | spin_unlock_irqrestore(&ctc_tty_lock, flags); | |
689 | result = ((control & UART_MCR_RTS) ? TIOCM_RTS : 0) | |
690 | | ((control & UART_MCR_DTR) ? TIOCM_DTR : 0) | |
691 | | ((status & UART_MSR_DCD) ? TIOCM_CAR : 0) | |
692 | | ((status & UART_MSR_RI) ? TIOCM_RNG : 0) | |
693 | | ((status & UART_MSR_DSR) ? TIOCM_DSR : 0) | |
694 | | ((status & UART_MSR_CTS) ? TIOCM_CTS : 0); | |
695 | return result; | |
696 | } | |
697 | ||
698 | static int | |
699 | ctc_tty_tiocmset(struct tty_struct *tty, struct file *file, | |
700 | unsigned int set, unsigned int clear) | |
701 | { | |
702 | ctc_tty_info *info = (ctc_tty_info *) tty->driver_data; | |
703 | ||
704 | DBF_TEXT(trace, 4, __FUNCTION__); | |
705 | if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_ioctl")) | |
706 | return -ENODEV; | |
707 | if (tty->flags & (1 << TTY_IO_ERROR)) | |
708 | return -EIO; | |
709 | ||
710 | if (set & TIOCM_RTS) | |
711 | info->mcr |= UART_MCR_RTS; | |
712 | if (set & TIOCM_DTR) | |
713 | info->mcr |= UART_MCR_DTR; | |
714 | ||
715 | if (clear & TIOCM_RTS) | |
716 | info->mcr &= ~UART_MCR_RTS; | |
717 | if (clear & TIOCM_DTR) | |
718 | info->mcr &= ~UART_MCR_DTR; | |
719 | ||
720 | if ((set | clear) & (TIOCM_RTS|TIOCM_DTR)) | |
721 | ctc_tty_transmit_status(info); | |
722 | return 0; | |
723 | } | |
724 | ||
725 | static int | |
726 | ctc_tty_ioctl(struct tty_struct *tty, struct file *file, | |
727 | uint cmd, ulong arg) | |
728 | { | |
729 | ctc_tty_info *info = (ctc_tty_info *) tty->driver_data; | |
730 | int error; | |
731 | int retval; | |
732 | ||
733 | DBF_TEXT(trace, 4, __FUNCTION__); | |
734 | if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_ioctl")) | |
735 | return -ENODEV; | |
736 | if (tty->flags & (1 << TTY_IO_ERROR)) | |
737 | return -EIO; | |
738 | switch (cmd) { | |
739 | case TCSBRK: /* SVID version: non-zero arg --> no break */ | |
740 | #ifdef CTC_DEBUG_MODEM_IOCTL | |
741 | printk(KERN_DEBUG "%s%d ioctl TCSBRK\n", CTC_TTY_NAME, info->line); | |
742 | #endif | |
743 | retval = tty_check_change(tty); | |
744 | if (retval) | |
745 | return retval; | |
746 | tty_wait_until_sent(tty, 0); | |
747 | return 0; | |
748 | case TCSBRKP: /* support for POSIX tcsendbreak() */ | |
749 | #ifdef CTC_DEBUG_MODEM_IOCTL | |
750 | printk(KERN_DEBUG "%s%d ioctl TCSBRKP\n", CTC_TTY_NAME, info->line); | |
751 | #endif | |
752 | retval = tty_check_change(tty); | |
753 | if (retval) | |
754 | return retval; | |
755 | tty_wait_until_sent(tty, 0); | |
756 | return 0; | |
757 | case TIOCGSOFTCAR: | |
758 | #ifdef CTC_DEBUG_MODEM_IOCTL | |
759 | printk(KERN_DEBUG "%s%d ioctl TIOCGSOFTCAR\n", CTC_TTY_NAME, | |
760 | info->line); | |
761 | #endif | |
762 | error = put_user(C_CLOCAL(tty) ? 1 : 0, (ulong __user *) arg); | |
763 | return error; | |
764 | case TIOCSSOFTCAR: | |
765 | #ifdef CTC_DEBUG_MODEM_IOCTL | |
766 | printk(KERN_DEBUG "%s%d ioctl TIOCSSOFTCAR\n", CTC_TTY_NAME, | |
767 | info->line); | |
768 | #endif | |
769 | error = get_user(arg, (ulong __user *) arg); | |
770 | if (error) | |
771 | return error; | |
772 | tty->termios->c_cflag = | |
773 | ((tty->termios->c_cflag & ~CLOCAL) | | |
774 | (arg ? CLOCAL : 0)); | |
775 | return 0; | |
776 | case TIOCSERGETLSR: /* Get line status register */ | |
777 | #ifdef CTC_DEBUG_MODEM_IOCTL | |
778 | printk(KERN_DEBUG "%s%d ioctl TIOCSERGETLSR\n", CTC_TTY_NAME, | |
779 | info->line); | |
780 | #endif | |
781 | if (access_ok(VERIFY_WRITE, (void __user *) arg, sizeof(uint))) | |
782 | return ctc_tty_get_lsr_info(info, (uint __user *) arg); | |
783 | else | |
784 | return -EFAULT; | |
785 | default: | |
786 | #ifdef CTC_DEBUG_MODEM_IOCTL | |
787 | printk(KERN_DEBUG "UNKNOWN ioctl 0x%08x on %s%d\n", cmd, | |
788 | CTC_TTY_NAME, info->line); | |
789 | #endif | |
790 | return -ENOIOCTLCMD; | |
791 | } | |
792 | return 0; | |
793 | } | |
794 | ||
795 | static void | |
796 | ctc_tty_set_termios(struct tty_struct *tty, struct termios *old_termios) | |
797 | { | |
798 | ctc_tty_info *info = (ctc_tty_info *) tty->driver_data; | |
799 | unsigned int cflag = tty->termios->c_cflag; | |
800 | ||
801 | DBF_TEXT(trace, 4, __FUNCTION__); | |
802 | ctc_tty_change_speed(info); | |
803 | ||
804 | /* Handle transition to B0 */ | |
805 | if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD)) { | |
806 | info->mcr &= ~(UART_MCR_DTR|UART_MCR_RTS); | |
807 | ctc_tty_transmit_status(info); | |
808 | } | |
809 | ||
810 | /* Handle transition from B0 to other */ | |
811 | if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) { | |
812 | info->mcr |= UART_MCR_DTR; | |
813 | if (!(tty->termios->c_cflag & CRTSCTS) || | |
814 | !test_bit(TTY_THROTTLED, &tty->flags)) { | |
815 | info->mcr |= UART_MCR_RTS; | |
816 | } | |
817 | ctc_tty_transmit_status(info); | |
818 | } | |
819 | ||
820 | /* Handle turning off CRTSCTS */ | |
821 | if ((old_termios->c_cflag & CRTSCTS) && | |
822 | !(tty->termios->c_cflag & CRTSCTS)) | |
823 | tty->hw_stopped = 0; | |
824 | } | |
825 | ||
826 | /* | |
827 | * ------------------------------------------------------------ | |
828 | * ctc_tty_open() and friends | |
829 | * ------------------------------------------------------------ | |
830 | */ | |
831 | static int | |
832 | ctc_tty_block_til_ready(struct tty_struct *tty, struct file *filp, ctc_tty_info *info) | |
833 | { | |
834 | DECLARE_WAITQUEUE(wait, NULL); | |
835 | int do_clocal = 0; | |
836 | unsigned long flags; | |
837 | int retval; | |
838 | ||
839 | DBF_TEXT(trace, 4, __FUNCTION__); | |
840 | /* | |
841 | * If the device is in the middle of being closed, then block | |
842 | * until it's done, and then try again. | |
843 | */ | |
844 | if (tty_hung_up_p(filp) || | |
845 | (info->flags & CTC_ASYNC_CLOSING)) { | |
846 | if (info->flags & CTC_ASYNC_CLOSING) | |
847 | wait_event(info->close_wait, | |
848 | !(info->flags & CTC_ASYNC_CLOSING)); | |
849 | #ifdef MODEM_DO_RESTART | |
850 | if (info->flags & CTC_ASYNC_HUP_NOTIFY) | |
851 | return -EAGAIN; | |
852 | else | |
853 | return -ERESTARTSYS; | |
854 | #else | |
855 | return -EAGAIN; | |
856 | #endif | |
857 | } | |
858 | /* | |
859 | * If non-blocking mode is set, then make the check up front | |
860 | * and then exit. | |
861 | */ | |
862 | if ((filp->f_flags & O_NONBLOCK) || | |
863 | (tty->flags & (1 << TTY_IO_ERROR))) { | |
864 | info->flags |= CTC_ASYNC_NORMAL_ACTIVE; | |
865 | return 0; | |
866 | } | |
867 | if (tty->termios->c_cflag & CLOCAL) | |
868 | do_clocal = 1; | |
869 | /* | |
870 | * Block waiting for the carrier detect and the line to become | |
871 | * free (i.e., not in use by the callout). While we are in | |
872 | * this loop, info->count is dropped by one, so that | |
873 | * ctc_tty_close() knows when to free things. We restore it upon | |
874 | * exit, either normal or abnormal. | |
875 | */ | |
876 | retval = 0; | |
877 | add_wait_queue(&info->open_wait, &wait); | |
878 | #ifdef CTC_DEBUG_MODEM_OPEN | |
879 | printk(KERN_DEBUG "ctc_tty_block_til_ready before block: %s%d, count = %d\n", | |
880 | CTC_TTY_NAME, info->line, info->count); | |
881 | #endif | |
882 | spin_lock_irqsave(&ctc_tty_lock, flags); | |
883 | if (!(tty_hung_up_p(filp))) | |
884 | info->count--; | |
885 | spin_unlock_irqrestore(&ctc_tty_lock, flags); | |
886 | info->blocked_open++; | |
887 | while (1) { | |
888 | set_current_state(TASK_INTERRUPTIBLE); | |
889 | if (tty_hung_up_p(filp) || | |
890 | !(info->flags & CTC_ASYNC_INITIALIZED)) { | |
891 | #ifdef MODEM_DO_RESTART | |
892 | if (info->flags & CTC_ASYNC_HUP_NOTIFY) | |
893 | retval = -EAGAIN; | |
894 | else | |
895 | retval = -ERESTARTSYS; | |
896 | #else | |
897 | retval = -EAGAIN; | |
898 | #endif | |
899 | break; | |
900 | } | |
901 | if (!(info->flags & CTC_ASYNC_CLOSING) && | |
902 | (do_clocal || (info->msr & UART_MSR_DCD))) { | |
903 | break; | |
904 | } | |
905 | if (signal_pending(current)) { | |
906 | retval = -ERESTARTSYS; | |
907 | break; | |
908 | } | |
909 | #ifdef CTC_DEBUG_MODEM_OPEN | |
910 | printk(KERN_DEBUG "ctc_tty_block_til_ready blocking: %s%d, count = %d\n", | |
911 | CTC_TTY_NAME, info->line, info->count); | |
912 | #endif | |
913 | schedule(); | |
914 | } | |
915 | current->state = TASK_RUNNING; | |
916 | remove_wait_queue(&info->open_wait, &wait); | |
917 | if (!tty_hung_up_p(filp)) | |
918 | info->count++; | |
919 | info->blocked_open--; | |
920 | #ifdef CTC_DEBUG_MODEM_OPEN | |
921 | printk(KERN_DEBUG "ctc_tty_block_til_ready after blocking: %s%d, count = %d\n", | |
922 | CTC_TTY_NAME, info->line, info->count); | |
923 | #endif | |
924 | if (retval) | |
925 | return retval; | |
926 | info->flags |= CTC_ASYNC_NORMAL_ACTIVE; | |
927 | return 0; | |
928 | } | |
929 | ||
930 | /* | |
931 | * This routine is called whenever a serial port is opened. It | |
932 | * enables interrupts for a serial port, linking in its async structure into | |
933 | * the IRQ chain. It also performs the serial-specific | |
934 | * initialization for the tty structure. | |
935 | */ | |
936 | static int | |
937 | ctc_tty_open(struct tty_struct *tty, struct file *filp) | |
938 | { | |
939 | ctc_tty_info *info; | |
940 | unsigned long saveflags; | |
941 | int retval, | |
942 | line; | |
943 | ||
944 | DBF_TEXT(trace, 3, __FUNCTION__); | |
945 | line = tty->index; | |
946 | if (line < 0 || line > CTC_TTY_MAX_DEVICES) | |
947 | return -ENODEV; | |
948 | info = &driver->info[line]; | |
949 | if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_open")) | |
950 | return -ENODEV; | |
951 | if (!info->netdev) | |
952 | return -ENODEV; | |
953 | #ifdef CTC_DEBUG_MODEM_OPEN | |
954 | printk(KERN_DEBUG "ctc_tty_open %s, count = %d\n", tty->name, | |
955 | info->count); | |
956 | #endif | |
957 | spin_lock_irqsave(&ctc_tty_lock, saveflags); | |
958 | info->count++; | |
959 | tty->driver_data = info; | |
960 | info->tty = tty; | |
961 | spin_unlock_irqrestore(&ctc_tty_lock, saveflags); | |
962 | /* | |
963 | * Start up serial port | |
964 | */ | |
965 | retval = ctc_tty_startup(info); | |
966 | if (retval) { | |
967 | #ifdef CTC_DEBUG_MODEM_OPEN | |
968 | printk(KERN_DEBUG "ctc_tty_open return after startup\n"); | |
969 | #endif | |
970 | return retval; | |
971 | } | |
972 | retval = ctc_tty_block_til_ready(tty, filp, info); | |
973 | if (retval) { | |
974 | #ifdef CTC_DEBUG_MODEM_OPEN | |
975 | printk(KERN_DEBUG "ctc_tty_open return after ctc_tty_block_til_ready \n"); | |
976 | #endif | |
977 | return retval; | |
978 | } | |
979 | #ifdef CTC_DEBUG_MODEM_OPEN | |
980 | printk(KERN_DEBUG "ctc_tty_open %s successful...\n", tty->name); | |
981 | #endif | |
982 | return 0; | |
983 | } | |
984 | ||
985 | static void | |
986 | ctc_tty_close(struct tty_struct *tty, struct file *filp) | |
987 | { | |
988 | ctc_tty_info *info = (ctc_tty_info *) tty->driver_data; | |
989 | ulong flags; | |
990 | ulong timeout; | |
991 | DBF_TEXT(trace, 3, __FUNCTION__); | |
992 | if (!info || ctc_tty_paranoia_check(info, tty->name, "ctc_tty_close")) | |
993 | return; | |
994 | spin_lock_irqsave(&ctc_tty_lock, flags); | |
995 | if (tty_hung_up_p(filp)) { | |
996 | spin_unlock_irqrestore(&ctc_tty_lock, flags); | |
997 | #ifdef CTC_DEBUG_MODEM_OPEN | |
998 | printk(KERN_DEBUG "ctc_tty_close return after tty_hung_up_p\n"); | |
999 | #endif | |
1000 | return; | |
1001 | } | |
1002 | if ((tty->count == 1) && (info->count != 1)) { | |
1003 | /* | |
1004 | * Uh, oh. tty->count is 1, which means that the tty | |
1005 | * structure will be freed. Info->count should always | |
1006 | * be one in these conditions. If it's greater than | |
1007 | * one, we've got real problems, since it means the | |
1008 | * serial port won't be shutdown. | |
1009 | */ | |
1010 | printk(KERN_ERR "ctc_tty_close: bad port count; tty->count is 1, " | |
1011 | "info->count is %d\n", info->count); | |
1012 | info->count = 1; | |
1013 | } | |
1014 | if (--info->count < 0) { | |
1015 | printk(KERN_ERR "ctc_tty_close: bad port count for %s%d: %d\n", | |
1016 | CTC_TTY_NAME, info->line, info->count); | |
1017 | info->count = 0; | |
1018 | } | |
1019 | if (info->count) { | |
1020 | local_irq_restore(flags); | |
1021 | #ifdef CTC_DEBUG_MODEM_OPEN | |
1022 | printk(KERN_DEBUG "ctc_tty_close after info->count != 0\n"); | |
1023 | #endif | |
1024 | return; | |
1025 | } | |
1026 | info->flags |= CTC_ASYNC_CLOSING; | |
1027 | tty->closing = 1; | |
1028 | /* | |
1029 | * At this point we stop accepting input. To do this, we | |
1030 | * disable the receive line status interrupts, and tell the | |
1031 | * interrupt driver to stop checking the data ready bit in the | |
1032 | * line status register. | |
1033 | */ | |
1034 | if (info->flags & CTC_ASYNC_INITIALIZED) { | |
1035 | tty_wait_until_sent(tty, 30*HZ); /* 30 seconds timeout */ | |
1036 | /* | |
1037 | * Before we drop DTR, make sure the UART transmitter | |
1038 | * has completely drained; this is especially | |
1039 | * important if there is a transmit FIFO! | |
1040 | */ | |
1041 | timeout = jiffies + HZ; | |
1042 | while (!(info->lsr & UART_LSR_TEMT)) { | |
1043 | spin_unlock_irqrestore(&ctc_tty_lock, flags); | |
1044 | msleep(500); | |
1045 | spin_lock_irqsave(&ctc_tty_lock, flags); | |
1046 | if (time_after(jiffies,timeout)) | |
1047 | break; | |
1048 | } | |
1049 | } | |
1050 | ctc_tty_shutdown(info); | |
1051 | if (tty->driver->flush_buffer) { | |
1052 | skb_queue_purge(&info->tx_queue); | |
1053 | info->lsr |= UART_LSR_TEMT; | |
1054 | } | |
1055 | tty_ldisc_flush(tty); | |
1056 | info->tty = 0; | |
1057 | tty->closing = 0; | |
1058 | if (info->blocked_open) { | |
7f81947b | 1059 | msleep_interruptible(500); |
1da177e4 LT |
1060 | wake_up_interruptible(&info->open_wait); |
1061 | } | |
1062 | info->flags &= ~(CTC_ASYNC_NORMAL_ACTIVE | CTC_ASYNC_CLOSING); | |
1063 | wake_up_interruptible(&info->close_wait); | |
1064 | spin_unlock_irqrestore(&ctc_tty_lock, flags); | |
1065 | #ifdef CTC_DEBUG_MODEM_OPEN | |
1066 | printk(KERN_DEBUG "ctc_tty_close normal exit\n"); | |
1067 | #endif | |
1068 | } | |
1069 | ||
1070 | /* | |
1071 | * ctc_tty_hangup() --- called by tty_hangup() when a hangup is signaled. | |
1072 | */ | |
1073 | static void | |
1074 | ctc_tty_hangup(struct tty_struct *tty) | |
1075 | { | |
1076 | ctc_tty_info *info = (ctc_tty_info *)tty->driver_data; | |
1077 | unsigned long saveflags; | |
1078 | DBF_TEXT(trace, 3, __FUNCTION__); | |
1079 | if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_hangup")) | |
1080 | return; | |
1081 | ctc_tty_shutdown(info); | |
1082 | info->count = 0; | |
1083 | info->flags &= ~CTC_ASYNC_NORMAL_ACTIVE; | |
1084 | spin_lock_irqsave(&ctc_tty_lock, saveflags); | |
1085 | info->tty = 0; | |
1086 | spin_unlock_irqrestore(&ctc_tty_lock, saveflags); | |
1087 | wake_up_interruptible(&info->open_wait); | |
1088 | } | |
1089 | ||
1090 | ||
1091 | /* | |
1092 | * For all online tty's, try sending data to | |
1093 | * the lower levels. | |
1094 | */ | |
1095 | static void | |
1096 | ctc_tty_task(unsigned long arg) | |
1097 | { | |
1098 | ctc_tty_info *info = (void *)arg; | |
1099 | unsigned long saveflags; | |
1100 | int again; | |
1101 | ||
1102 | DBF_TEXT(trace, 3, __FUNCTION__); | |
1103 | spin_lock_irqsave(&ctc_tty_lock, saveflags); | |
1104 | if ((!ctc_tty_shuttingdown) && info) { | |
1105 | again = ctc_tty_tint(info); | |
1106 | if (!again) | |
1107 | info->lsr |= UART_LSR_TEMT; | |
1108 | again |= ctc_tty_readmodem(info); | |
1109 | if (again) { | |
1110 | tasklet_schedule(&info->tasklet); | |
1111 | } | |
1112 | } | |
1113 | spin_unlock_irqrestore(&ctc_tty_lock, saveflags); | |
1114 | } | |
1115 | ||
1116 | static struct tty_operations ctc_ops = { | |
1117 | .open = ctc_tty_open, | |
1118 | .close = ctc_tty_close, | |
1119 | .write = ctc_tty_write, | |
1120 | .flush_chars = ctc_tty_flush_chars, | |
1121 | .write_room = ctc_tty_write_room, | |
1122 | .chars_in_buffer = ctc_tty_chars_in_buffer, | |
1123 | .flush_buffer = ctc_tty_flush_buffer, | |
1124 | .ioctl = ctc_tty_ioctl, | |
1125 | .throttle = ctc_tty_throttle, | |
1126 | .unthrottle = ctc_tty_unthrottle, | |
1127 | .set_termios = ctc_tty_set_termios, | |
1128 | .hangup = ctc_tty_hangup, | |
1129 | .tiocmget = ctc_tty_tiocmget, | |
1130 | .tiocmset = ctc_tty_tiocmset, | |
1131 | }; | |
1132 | ||
1133 | int | |
1134 | ctc_tty_init(void) | |
1135 | { | |
1136 | int i; | |
1137 | ctc_tty_info *info; | |
1138 | struct tty_driver *device; | |
1139 | ||
1140 | DBF_TEXT(trace, 2, __FUNCTION__); | |
1141 | driver = kmalloc(sizeof(ctc_tty_driver), GFP_KERNEL); | |
1142 | if (driver == NULL) { | |
1143 | printk(KERN_WARNING "Out of memory in ctc_tty_modem_init\n"); | |
1144 | return -ENOMEM; | |
1145 | } | |
1146 | memset(driver, 0, sizeof(ctc_tty_driver)); | |
1147 | device = alloc_tty_driver(CTC_TTY_MAX_DEVICES); | |
1148 | if (!device) { | |
1149 | kfree(driver); | |
1150 | printk(KERN_WARNING "Out of memory in ctc_tty_modem_init\n"); | |
1151 | return -ENOMEM; | |
1152 | } | |
1153 | ||
1154 | device->devfs_name = "ctc/" CTC_TTY_NAME; | |
1155 | device->name = CTC_TTY_NAME; | |
1156 | device->major = CTC_TTY_MAJOR; | |
1157 | device->minor_start = 0; | |
1158 | device->type = TTY_DRIVER_TYPE_SERIAL; | |
1159 | device->subtype = SERIAL_TYPE_NORMAL; | |
1160 | device->init_termios = tty_std_termios; | |
1161 | device->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; | |
1162 | device->flags = TTY_DRIVER_REAL_RAW; | |
1163 | device->driver_name = "ctc_tty", | |
1164 | tty_set_operations(device, &ctc_ops); | |
1165 | if (tty_register_driver(device)) { | |
1166 | printk(KERN_WARNING "ctc_tty: Couldn't register serial-device\n"); | |
1167 | put_tty_driver(device); | |
1168 | kfree(driver); | |
1169 | return -1; | |
1170 | } | |
1171 | driver->ctc_tty_device = device; | |
1172 | for (i = 0; i < CTC_TTY_MAX_DEVICES; i++) { | |
1173 | info = &driver->info[i]; | |
1174 | init_MUTEX(&info->write_sem); | |
1175 | tasklet_init(&info->tasklet, ctc_tty_task, | |
1176 | (unsigned long) info); | |
1177 | info->magic = CTC_ASYNC_MAGIC; | |
1178 | info->line = i; | |
1179 | info->tty = 0; | |
1180 | info->count = 0; | |
1181 | info->blocked_open = 0; | |
1182 | init_waitqueue_head(&info->open_wait); | |
1183 | init_waitqueue_head(&info->close_wait); | |
1184 | skb_queue_head_init(&info->tx_queue); | |
1185 | skb_queue_head_init(&info->rx_queue); | |
1186 | init_timer(&info->stoptimer); | |
1187 | info->stoptimer.function = ctc_tty_stopdev; | |
1188 | info->stoptimer.data = (unsigned long)info; | |
1189 | info->mcr = UART_MCR_RTS; | |
1190 | } | |
1191 | return 0; | |
1192 | } | |
1193 | ||
1194 | int | |
1195 | ctc_tty_register_netdev(struct net_device *dev) { | |
1196 | int ttynum; | |
1197 | char *err; | |
1198 | char *p; | |
1199 | ||
1200 | DBF_TEXT(trace, 2, __FUNCTION__); | |
1201 | if ((!dev) || (!dev->name)) { | |
1202 | printk(KERN_WARNING | |
1203 | "ctc_tty_register_netdev called " | |
1204 | "with NULL dev or NULL dev-name\n"); | |
1205 | return -1; | |
1206 | } | |
1207 | ||
1208 | /* | |
1209 | * If the name is a format string the caller wants us to | |
1210 | * do a name allocation : format string must end with %d | |
1211 | */ | |
1212 | if (strchr(dev->name, '%')) | |
1213 | { | |
1214 | int err = dev_alloc_name(dev, dev->name); // dev->name is changed by this | |
1215 | if (err < 0) { | |
1216 | printk(KERN_DEBUG "dev_alloc returned error %d\n", err); | |
1217 | return err; | |
1218 | } | |
1219 | ||
1220 | } | |
1221 | ||
1222 | for (p = dev->name; p && ((*p < '0') || (*p > '9')); p++); | |
1223 | ttynum = simple_strtoul(p, &err, 0); | |
1224 | if ((ttynum < 0) || (ttynum >= CTC_TTY_MAX_DEVICES) || | |
1225 | (err && *err)) { | |
1226 | printk(KERN_WARNING | |
1227 | "ctc_tty_register_netdev called " | |
1228 | "with number in name '%s'\n", dev->name); | |
1229 | return -1; | |
1230 | } | |
1231 | if (driver->info[ttynum].netdev) { | |
1232 | printk(KERN_WARNING | |
1233 | "ctc_tty_register_netdev called " | |
1234 | "for already registered device '%s'\n", | |
1235 | dev->name); | |
1236 | return -1; | |
1237 | } | |
1238 | driver->info[ttynum].netdev = dev; | |
1239 | return 0; | |
1240 | } | |
1241 | ||
1242 | void | |
1243 | ctc_tty_unregister_netdev(struct net_device *dev) { | |
1244 | int i; | |
1245 | unsigned long saveflags; | |
1246 | ctc_tty_info *info = NULL; | |
1247 | ||
1248 | DBF_TEXT(trace, 2, __FUNCTION__); | |
1249 | spin_lock_irqsave(&ctc_tty_lock, saveflags); | |
1250 | for (i = 0; i < CTC_TTY_MAX_DEVICES; i++) | |
1251 | if (driver->info[i].netdev == dev) { | |
1252 | info = &driver->info[i]; | |
1253 | break; | |
1254 | } | |
1255 | if (info) { | |
1256 | info->netdev = NULL; | |
1257 | skb_queue_purge(&info->tx_queue); | |
1258 | skb_queue_purge(&info->rx_queue); | |
1259 | } | |
1260 | spin_unlock_irqrestore(&ctc_tty_lock, saveflags); | |
1261 | } | |
1262 | ||
1263 | void | |
1264 | ctc_tty_cleanup(void) { | |
1265 | unsigned long saveflags; | |
1266 | ||
1267 | DBF_TEXT(trace, 2, __FUNCTION__); | |
1268 | spin_lock_irqsave(&ctc_tty_lock, saveflags); | |
1269 | ctc_tty_shuttingdown = 1; | |
1270 | spin_unlock_irqrestore(&ctc_tty_lock, saveflags); | |
1271 | tty_unregister_driver(driver->ctc_tty_device); | |
1272 | put_tty_driver(driver->ctc_tty_device); | |
1273 | kfree(driver); | |
1274 | driver = NULL; | |
1275 | } |