aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--drivers/char/Kconfig10
-rw-r--r--drivers/char/Makefile1
-rw-r--r--drivers/char/isicom.c8
-rw-r--r--drivers/char/n_gsm.c2763
-rw-r--r--drivers/char/serial167.c223
-rw-r--r--drivers/char/tty_buffer.c2
-rw-r--r--drivers/serial/Kconfig82
-rw-r--r--drivers/serial/Makefile2
-rw-r--r--drivers/serial/altera_jtaguart.c504
-rw-r--r--drivers/serial/altera_uart.c570
-rw-r--r--drivers/serial/bfin_sport_uart.c209
-rw-r--r--drivers/serial/bfin_sport_uart.h27
-rw-r--r--drivers/serial/timbuart.c25
-rw-r--r--drivers/serial/uartlite.c32
-rw-r--r--include/linux/altera_jtaguart.h16
-rw-r--r--include/linux/altera_uart.h14
-rw-r--r--include/linux/gsmmux.h25
-rw-r--r--include/linux/serial_core.h4
-rw-r--r--include/linux/tty.h3
19 files changed, 4196 insertions, 324 deletions
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 3141dd3b6e53..e21175be25d0 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -276,11 +276,19 @@ config N_HDLC
276 Allows synchronous HDLC communications with tty device drivers that 276 Allows synchronous HDLC communications with tty device drivers that
277 support synchronous HDLC such as the Microgate SyncLink adapter. 277 support synchronous HDLC such as the Microgate SyncLink adapter.
278 278
279 This driver can only be built as a module ( = code which can be 279 This driver can be built as a module ( = code which can be
280 inserted in and removed from the running kernel whenever you want). 280 inserted in and removed from the running kernel whenever you want).
281 The module will be called n_hdlc. If you want to do that, say M 281 The module will be called n_hdlc. If you want to do that, say M
282 here. 282 here.
283 283
284config N_GSM
285 tristate "GSM MUX line discipline support (EXPERIMENTAL)"
286 depends on EXPERIMENTAL
287 depends on NET
288 help
289 This line discipline provides support for the GSM MUX protocol and
290 presents the mux as a set of 61 individual tty devices.
291
284config RISCOM8 292config RISCOM8
285 tristate "SDL RISCom/8 card support" 293 tristate "SDL RISCom/8 card support"
286 depends on SERIAL_NONSTANDARD 294 depends on SERIAL_NONSTANDARD
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index f957edf7e45d..d39be4cf1f5d 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -40,6 +40,7 @@ obj-$(CONFIG_SYNCLINK) += synclink.o
40obj-$(CONFIG_SYNCLINKMP) += synclinkmp.o 40obj-$(CONFIG_SYNCLINKMP) += synclinkmp.o
41obj-$(CONFIG_SYNCLINK_GT) += synclink_gt.o 41obj-$(CONFIG_SYNCLINK_GT) += synclink_gt.o
42obj-$(CONFIG_N_HDLC) += n_hdlc.o 42obj-$(CONFIG_N_HDLC) += n_hdlc.o
43obj-$(CONFIG_N_GSM) += n_gsm.o
43obj-$(CONFIG_AMIGA_BUILTIN_SERIAL) += amiserial.o 44obj-$(CONFIG_AMIGA_BUILTIN_SERIAL) += amiserial.o
44obj-$(CONFIG_SX) += sx.o generic_serial.o 45obj-$(CONFIG_SX) += sx.o generic_serial.o
45obj-$(CONFIG_RIO) += rio/ generic_serial.o 46obj-$(CONFIG_RIO) += rio/ generic_serial.o
diff --git a/drivers/char/isicom.c b/drivers/char/isicom.c
index c1ab303455cf..98310e1aae30 100644
--- a/drivers/char/isicom.c
+++ b/drivers/char/isicom.c
@@ -1573,11 +1573,16 @@ static int __devinit isicom_probe(struct pci_dev *pdev,
1573 dev_info(&pdev->dev, "ISI PCI Card(Device ID 0x%x)\n", ent->device); 1573 dev_info(&pdev->dev, "ISI PCI Card(Device ID 0x%x)\n", ent->device);
1574 1574
1575 /* allot the first empty slot in the array */ 1575 /* allot the first empty slot in the array */
1576 for (index = 0; index < BOARD_COUNT; index++) 1576 for (index = 0; index < BOARD_COUNT; index++) {
1577 if (isi_card[index].base == 0) { 1577 if (isi_card[index].base == 0) {
1578 board = &isi_card[index]; 1578 board = &isi_card[index];
1579 break; 1579 break;
1580 } 1580 }
1581 }
1582 if (index == BOARD_COUNT) {
1583 retval = -ENODEV;
1584 goto err_disable;
1585 }
1581 1586
1582 board->index = index; 1587 board->index = index;
1583 board->base = pci_resource_start(pdev, 3); 1588 board->base = pci_resource_start(pdev, 3);
@@ -1624,6 +1629,7 @@ errunrr:
1624errdec: 1629errdec:
1625 board->base = 0; 1630 board->base = 0;
1626 card_count--; 1631 card_count--;
1632err_disable:
1627 pci_disable_device(pdev); 1633 pci_disable_device(pdev);
1628err: 1634err:
1629 return retval; 1635 return retval;
diff --git a/drivers/char/n_gsm.c b/drivers/char/n_gsm.c
new file mode 100644
index 000000000000..c4161d5e053d
--- /dev/null
+++ b/drivers/char/n_gsm.c
@@ -0,0 +1,2763 @@
1/*
2 * n_gsm.c GSM 0710 tty multiplexor
3 * Copyright (c) 2009/10 Intel Corporation
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 *
18 * * THIS IS A DEVELOPMENT SNAPSHOT IT IS NOT A FINAL RELEASE *
19 *
20 * TO DO:
21 * Mostly done: ioctls for setting modes/timing
22 * Partly done: hooks so you can pull off frames to non tty devs
23 * Restart DLCI 0 when it closes ?
24 * Test basic encoding
25 * Improve the tx engine
26 * Resolve tx side locking by adding a queue_head and routing
27 * all control traffic via it
28 * General tidy/document
29 * Review the locking/move to refcounts more (mux now moved to an
30 * alloc/free model ready)
31 * Use newest tty open/close port helpers and install hooks
32 * What to do about power functions ?
33 * Termios setting and negotiation
34 * Do we need a 'which mux are you' ioctl to correlate mux and tty sets
35 *
36 */
37
38#include <linux/types.h>
39#include <linux/major.h>
40#include <linux/errno.h>
41#include <linux/signal.h>
42#include <linux/fcntl.h>
43#include <linux/sched.h>
44#include <linux/interrupt.h>
45#include <linux/tty.h>
46#include <linux/timer.h>
47#include <linux/ctype.h>
48#include <linux/mm.h>
49#include <linux/string.h>
50#include <linux/slab.h>
51#include <linux/poll.h>
52#include <linux/bitops.h>
53#include <linux/file.h>
54#include <linux/uaccess.h>
55#include <linux/module.h>
56#include <linux/timer.h>
57#include <linux/tty_flip.h>
58#include <linux/tty_driver.h>
59#include <linux/serial.h>
60#include <linux/kfifo.h>
61#include <linux/skbuff.h>
62#include <linux/gsmmux.h>
63
64static int debug;
65module_param(debug, int, 0600);
66
67#define T1 (HZ/10)
68#define T2 (HZ/3)
69#define N2 3
70
71/* Use long timers for testing at low speed with debug on */
72#ifdef DEBUG_TIMING
73#define T1 HZ
74#define T2 (2 * HZ)
75#endif
76
77/* Semi-arbitary buffer size limits. 0710 is normally run with 32-64 byte
78 limits so this is plenty */
79#define MAX_MRU 512
80#define MAX_MTU 512
81
82/*
83 * Each block of data we have queued to go out is in the form of
84 * a gsm_msg which holds everything we need in a link layer independant
85 * format
86 */
87
88struct gsm_msg {
89 struct gsm_msg *next;
90 u8 addr; /* DLCI address + flags */
91 u8 ctrl; /* Control byte + flags */
92 unsigned int len; /* Length of data block (can be zero) */
93 unsigned char *data; /* Points into buffer but not at the start */
94 unsigned char buffer[0];
95};
96
97/*
98 * Each active data link has a gsm_dlci structure associated which ties
99 * the link layer to an optional tty (if the tty side is open). To avoid
100 * complexity right now these are only ever freed up when the mux is
101 * shut down.
102 *
103 * At the moment we don't free DLCI objects until the mux is torn down
104 * this avoid object life time issues but might be worth review later.
105 */
106
107struct gsm_dlci {
108 struct gsm_mux *gsm;
109 int addr;
110 int state;
111#define DLCI_CLOSED 0
112#define DLCI_OPENING 1 /* Sending SABM not seen UA */
113#define DLCI_OPEN 2 /* SABM/UA complete */
114#define DLCI_CLOSING 3 /* Sending DISC not seen UA/DM */
115
116 /* Link layer */
117 spinlock_t lock; /* Protects the internal state */
118 struct timer_list t1; /* Retransmit timer for SABM and UA */
119 int retries;
120 /* Uplink tty if active */
121 struct tty_port port; /* The tty bound to this DLCI if there is one */
122 struct kfifo *fifo; /* Queue fifo for the DLCI */
123 struct kfifo _fifo; /* For new fifo API porting only */
124 int adaption; /* Adaption layer in use */
125 u32 modem_rx; /* Our incoming virtual modem lines */
126 u32 modem_tx; /* Our outgoing modem lines */
127 int dead; /* Refuse re-open */
128 /* Flow control */
129 int throttled; /* Private copy of throttle state */
130 int constipated; /* Throttle status for outgoing */
131 /* Packetised I/O */
132 struct sk_buff *skb; /* Frame being sent */
133 struct sk_buff_head skb_list; /* Queued frames */
134 /* Data handling callback */
135 void (*data)(struct gsm_dlci *dlci, u8 *data, int len);
136};
137
138/* DLCI 0, 62/63 are special or reseved see gsmtty_open */
139
140#define NUM_DLCI 64
141
142/*
143 * DLCI 0 is used to pass control blocks out of band of the data
144 * flow (and with a higher link priority). One command can be outstanding
145 * at a time and we use this structure to manage them. They are created
146 * and destroyed by the user context, and updated by the receive paths
147 * and timers
148 */
149
150struct gsm_control {
151 u8 cmd; /* Command we are issuing */
152 u8 *data; /* Data for the command in case we retransmit */
153 int len; /* Length of block for retransmission */
154 int done; /* Done flag */
155 int error; /* Error if any */
156};
157
158/*
159 * Each GSM mux we have is represented by this structure. If we are
160 * operating as an ldisc then we use this structure as our ldisc
161 * state. We need to sort out lifetimes and locking with respect
162 * to the gsm mux array. For now we don't free DLCI objects that
163 * have been instantiated until the mux itself is terminated.
164 *
165 * To consider further: tty open versus mux shutdown.
166 */
167
168struct gsm_mux {
169 struct tty_struct *tty; /* The tty our ldisc is bound to */
170 spinlock_t lock;
171
172 /* Events on the GSM channel */
173 wait_queue_head_t event;
174
175 /* Bits for GSM mode decoding */
176
177 /* Framing Layer */
178 unsigned char *buf;
179 int state;
180#define GSM_SEARCH 0
181#define GSM_START 1
182#define GSM_ADDRESS 2
183#define GSM_CONTROL 3
184#define GSM_LEN 4
185#define GSM_DATA 5
186#define GSM_FCS 6
187#define GSM_OVERRUN 7
188 unsigned int len;
189 unsigned int address;
190 unsigned int count;
191 int escape;
192 int encoding;
193 u8 control;
194 u8 fcs;
195 u8 *txframe; /* TX framing buffer */
196
197 /* Methods for the receiver side */
198 void (*receive)(struct gsm_mux *gsm, u8 ch);
199 void (*error)(struct gsm_mux *gsm, u8 ch, u8 flag);
200 /* And transmit side */
201 int (*output)(struct gsm_mux *mux, u8 *data, int len);
202
203 /* Link Layer */
204 unsigned int mru;
205 unsigned int mtu;
206 int initiator; /* Did we initiate connection */
207 int dead; /* Has the mux been shut down */
208 struct gsm_dlci *dlci[NUM_DLCI];
209 int constipated; /* Asked by remote to shut up */
210
211 spinlock_t tx_lock;
212 unsigned int tx_bytes; /* TX data outstanding */
213#define TX_THRESH_HI 8192
214#define TX_THRESH_LO 2048
215 struct gsm_msg *tx_head; /* Pending data packets */
216 struct gsm_msg *tx_tail;
217
218 /* Control messages */
219 struct timer_list t2_timer; /* Retransmit timer for commands */
220 int cretries; /* Command retry counter */
221 struct gsm_control *pending_cmd;/* Our current pending command */
222 spinlock_t control_lock; /* Protects the pending command */
223
224 /* Configuration */
225 int adaption; /* 1 or 2 supported */
226 u8 ftype; /* UI or UIH */
227 int t1, t2; /* Timers in 1/100th of a sec */
228 int n2; /* Retry count */
229
230 /* Statistics (not currently exposed) */
231 unsigned long bad_fcs;
232 unsigned long malformed;
233 unsigned long io_error;
234 unsigned long bad_size;
235 unsigned long unsupported;
236};
237
238
239/*
240 * Mux objects - needed so that we can translate a tty index into the
241 * relevant mux and DLCI.
242 */
243
244#define MAX_MUX 4 /* 256 minors */
245static struct gsm_mux *gsm_mux[MAX_MUX]; /* GSM muxes */
246static spinlock_t gsm_mux_lock;
247
248/*
249 * This section of the driver logic implements the GSM encodings
250 * both the basic and the 'advanced'. Reliable transport is not
251 * supported.
252 */
253
254#define CR 0x02
255#define EA 0x01
256#define PF 0x10
257
258/* I is special: the rest are ..*/
259#define RR 0x01
260#define UI 0x03
261#define RNR 0x05
262#define REJ 0x09
263#define DM 0x0F
264#define SABM 0x2F
265#define DISC 0x43
266#define UA 0x63
267#define UIH 0xEF
268
269/* Channel commands */
270#define CMD_NSC 0x09
271#define CMD_TEST 0x11
272#define CMD_PSC 0x21
273#define CMD_RLS 0x29
274#define CMD_FCOFF 0x31
275#define CMD_PN 0x41
276#define CMD_RPN 0x49
277#define CMD_FCON 0x51
278#define CMD_CLD 0x61
279#define CMD_SNC 0x69
280#define CMD_MSC 0x71
281
282/* Virtual modem bits */
283#define MDM_FC 0x01
284#define MDM_RTC 0x02
285#define MDM_RTR 0x04
286#define MDM_IC 0x20
287#define MDM_DV 0x40
288
289#define GSM0_SOF 0xF9
290#define GSM1_SOF 0x7E
291#define GSM1_ESCAPE 0x7D
292#define GSM1_ESCAPE_BITS 0x20
293#define XON 0x11
294#define XOFF 0x13
295
296static const struct tty_port_operations gsm_port_ops;
297
298/*
299 * CRC table for GSM 0710
300 */
301
302static const u8 gsm_fcs8[256] = {
303 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
304 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
305 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
306 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
307 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
308 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
309 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
310 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
311 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
312 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
313 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
314 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
315 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
316 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
317 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
318 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
319 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
320 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
321 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
322 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
323 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
324 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
325 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
326 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
327 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
328 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
329 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
330 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
331 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
332 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
333 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
334 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
335};
336
337#define INIT_FCS 0xFF
338#define GOOD_FCS 0xCF
339
340/**
341 * gsm_fcs_add - update FCS
342 * @fcs: Current FCS
343 * @c: Next data
344 *
345 * Update the FCS to include c. Uses the algorithm in the specification
346 * notes.
347 */
348
349static inline u8 gsm_fcs_add(u8 fcs, u8 c)
350{
351 return gsm_fcs8[fcs ^ c];
352}
353
354/**
355 * gsm_fcs_add_block - update FCS for a block
356 * @fcs: Current FCS
357 * @c: buffer of data
358 * @len: length of buffer
359 *
360 * Update the FCS to include c. Uses the algorithm in the specification
361 * notes.
362 */
363
364static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len)
365{
366 while (len--)
367 fcs = gsm_fcs8[fcs ^ *c++];
368 return fcs;
369}
370
371/**
372 * gsm_read_ea - read a byte into an EA
373 * @val: variable holding value
374 * c: byte going into the EA
375 *
376 * Processes one byte of an EA. Updates the passed variable
377 * and returns 1 if the EA is now completely read
378 */
379
380static int gsm_read_ea(unsigned int *val, u8 c)
381{
382 /* Add the next 7 bits into the value */
383 *val <<= 7;
384 *val |= c >> 1;
385 /* Was this the last byte of the EA 1 = yes*/
386 return c & EA;
387}
388
389/**
390 * gsm_encode_modem - encode modem data bits
391 * @dlci: DLCI to encode from
392 *
393 * Returns the correct GSM encoded modem status bits (6 bit field) for
394 * the current status of the DLCI and attached tty object
395 */
396
397static u8 gsm_encode_modem(const struct gsm_dlci *dlci)
398{
399 u8 modembits = 0;
400 /* FC is true flow control not modem bits */
401 if (dlci->throttled)
402 modembits |= MDM_FC;
403 if (dlci->modem_tx & TIOCM_DTR)
404 modembits |= MDM_RTC;
405 if (dlci->modem_tx & TIOCM_RTS)
406 modembits |= MDM_RTR;
407 if (dlci->modem_tx & TIOCM_RI)
408 modembits |= MDM_IC;
409 if (dlci->modem_tx & TIOCM_CD)
410 modembits |= MDM_DV;
411 return modembits;
412}
413
414/**
415 * gsm_print_packet - display a frame for debug
416 * @hdr: header to print before decode
417 * @addr: address EA from the frame
418 * @cr: C/R bit from the frame
419 * @control: control including PF bit
420 * @data: following data bytes
421 * @dlen: length of data
422 *
423 * Displays a packet in human readable format for debugging purposes. The
424 * style is based on amateur radio LAP-B dump display.
425 */
426
427static void gsm_print_packet(const char *hdr, int addr, int cr,
428 u8 control, const u8 *data, int dlen)
429{
430 if (!(debug & 1))
431 return;
432
433 printk(KERN_INFO "%s %d) %c: ", hdr, addr, "RC"[cr]);
434
435 switch (control & ~PF) {
436 case SABM:
437 printk(KERN_CONT "SABM");
438 break;
439 case UA:
440 printk(KERN_CONT "UA");
441 break;
442 case DISC:
443 printk(KERN_CONT "DISC");
444 break;
445 case DM:
446 printk(KERN_CONT "DM");
447 break;
448 case UI:
449 printk(KERN_CONT "UI");
450 break;
451 case UIH:
452 printk(KERN_CONT "UIH");
453 break;
454 default:
455 if (!(control & 0x01)) {
456 printk(KERN_CONT "I N(S)%d N(R)%d",
457 (control & 0x0E) >> 1, (control & 0xE)>> 5);
458 } else switch (control & 0x0F) {
459 case RR:
460 printk("RR(%d)", (control & 0xE0) >> 5);
461 break;
462 case RNR:
463 printk("RNR(%d)", (control & 0xE0) >> 5);
464 break;
465 case REJ:
466 printk("REJ(%d)", (control & 0xE0) >> 5);
467 break;
468 default:
469 printk(KERN_CONT "[%02X]", control);
470 }
471 }
472
473 if (control & PF)
474 printk(KERN_CONT "(P)");
475 else
476 printk(KERN_CONT "(F)");
477
478 if (dlen) {
479 int ct = 0;
480 while (dlen--) {
481 if (ct % 8 == 0)
482 printk(KERN_CONT "\n ");
483 printk(KERN_CONT "%02X ", *data++);
484 ct++;
485 }
486 }
487 printk(KERN_CONT "\n");
488}
489
490
491/*
492 * Link level transmission side
493 */
494
495/**
496 * gsm_stuff_packet - bytestuff a packet
497 * @ibuf: input
498 * @obuf: output
499 * @len: length of input
500 *
501 * Expand a buffer by bytestuffing it. The worst case size change
502 * is doubling and the caller is responsible for handing out
503 * suitable sized buffers.
504 */
505
506static int gsm_stuff_frame(const u8 *input, u8 *output, int len)
507{
508 int olen = 0;
509 while (len--) {
510 if (*input == GSM1_SOF || *input == GSM1_ESCAPE
511 || *input == XON || *input == XOFF) {
512 *output++ = GSM1_ESCAPE;
513 *output++ = *input++ ^ GSM1_ESCAPE_BITS;
514 olen++;
515 } else
516 *output++ = *input++;
517 olen++;
518 }
519 return olen;
520}
521
522static void hex_packet(const unsigned char *p, int len)
523{
524 int i;
525 for (i = 0; i < len; i++) {
526 if (i && (i % 16) == 0)
527 printk("\n");
528 printk("%02X ", *p++);
529 }
530 printk("\n");
531}
532
533/**
534 * gsm_send - send a control frame
535 * @gsm: our GSM mux
536 * @addr: address for control frame
537 * @cr: command/response bit
538 * @control: control byte including PF bit
539 *
540 * Format up and transmit a control frame. These do not go via the
541 * queueing logic as they should be transmitted ahead of data when
542 * they are needed.
543 *
544 * FIXME: Lock versus data TX path
545 */
546
547static void gsm_send(struct gsm_mux *gsm, int addr, int cr, int control)
548{
549 int len;
550 u8 cbuf[10];
551 u8 ibuf[3];
552
553 switch (gsm->encoding) {
554 case 0:
555 cbuf[0] = GSM0_SOF;
556 cbuf[1] = (addr << 2) | (cr << 1) | EA;
557 cbuf[2] = control;
558 cbuf[3] = EA; /* Length of data = 0 */
559 cbuf[4] = 0xFF - gsm_fcs_add_block(INIT_FCS, cbuf + 1, 3);
560 cbuf[5] = GSM0_SOF;
561 len = 6;
562 break;
563 case 1:
564 case 2:
565 /* Control frame + packing (but not frame stuffing) in mode 1 */
566 ibuf[0] = (addr << 2) | (cr << 1) | EA;
567 ibuf[1] = control;
568 ibuf[2] = 0xFF - gsm_fcs_add_block(INIT_FCS, ibuf, 2);
569 /* Stuffing may double the size worst case */
570 len = gsm_stuff_frame(ibuf, cbuf + 1, 3);
571 /* Now add the SOF markers */
572 cbuf[0] = GSM1_SOF;
573 cbuf[len + 1] = GSM1_SOF;
574 /* FIXME: we can omit the lead one in many cases */
575 len += 2;
576 break;
577 default:
578 WARN_ON(1);
579 return;
580 }
581 gsm->output(gsm, cbuf, len);
582 gsm_print_packet("-->", addr, cr, control, NULL, 0);
583}
584
585/**
586 * gsm_response - send a control response
587 * @gsm: our GSM mux
588 * @addr: address for control frame
589 * @control: control byte including PF bit
590 *
591 * Format up and transmit a link level response frame.
592 */
593
594static inline void gsm_response(struct gsm_mux *gsm, int addr, int control)
595{
596 gsm_send(gsm, addr, 0, control);
597}
598
599/**
600 * gsm_command - send a control command
601 * @gsm: our GSM mux
602 * @addr: address for control frame
603 * @control: control byte including PF bit
604 *
605 * Format up and transmit a link level command frame.
606 */
607
608static inline void gsm_command(struct gsm_mux *gsm, int addr, int control)
609{
610 gsm_send(gsm, addr, 1, control);
611}
612
613/* Data transmission */
614
615#define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */
616
617/**
618 * gsm_data_alloc - allocate data frame
619 * @gsm: GSM mux
620 * @addr: DLCI address
621 * @len: length excluding header and FCS
622 * @ctrl: control byte
623 *
624 * Allocate a new data buffer for sending frames with data. Space is left
625 * at the front for header bytes but that is treated as an implementation
626 * detail and not for the high level code to use
627 */
628
629static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len,
630 u8 ctrl)
631{
632 struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN,
633 GFP_ATOMIC);
634 if (m == NULL)
635 return NULL;
636 m->data = m->buffer + HDR_LEN - 1; /* Allow for FCS */
637 m->len = len;
638 m->addr = addr;
639 m->ctrl = ctrl;
640 m->next = NULL;
641 return m;
642}
643
644/**
645 * gsm_data_kick - poke the queue
646 * @gsm: GSM Mux
647 *
648 * The tty device has called us to indicate that room has appeared in
649 * the transmit queue. Ram more data into the pipe if we have any
650 *
651 * FIXME: lock against link layer control transmissions
652 */
653
654static void gsm_data_kick(struct gsm_mux *gsm)
655{
656 struct gsm_msg *msg = gsm->tx_head;
657 int len;
658 int skip_sof = 0;
659
660 /* FIXME: We need to apply this solely to data messages */
661 if (gsm->constipated)
662 return;
663
664 while (gsm->tx_head != NULL) {
665 msg = gsm->tx_head;
666 if (gsm->encoding != 0) {
667 gsm->txframe[0] = GSM1_SOF;
668 len = gsm_stuff_frame(msg->data,
669 gsm->txframe + 1, msg->len);
670 gsm->txframe[len + 1] = GSM1_SOF;
671 len += 2;
672 } else {
673 gsm->txframe[0] = GSM0_SOF;
674 memcpy(gsm->txframe + 1 , msg->data, msg->len);
675 gsm->txframe[msg->len + 1] = GSM0_SOF;
676 len = msg->len + 2;
677 }
678
679 if (debug & 4) {
680 printk("gsm_data_kick: \n");
681 hex_packet(gsm->txframe, len);
682 }
683
684 if (gsm->output(gsm, gsm->txframe + skip_sof,
685 len - skip_sof) < 0)
686 break;
687 /* FIXME: Can eliminate one SOF in many more cases */
688 gsm->tx_head = msg->next;
689 if (gsm->tx_head == NULL)
690 gsm->tx_tail = NULL;
691 gsm->tx_bytes -= msg->len;
692 kfree(msg);
693 /* For a burst of frames skip the extra SOF within the
694 burst */
695 skip_sof = 1;
696 }
697}
698
699/**
700 * __gsm_data_queue - queue a UI or UIH frame
701 * @dlci: DLCI sending the data
702 * @msg: message queued
703 *
704 * Add data to the transmit queue and try and get stuff moving
705 * out of the mux tty if not already doing so. The Caller must hold
706 * the gsm tx lock.
707 */
708
709static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
710{
711 struct gsm_mux *gsm = dlci->gsm;
712 u8 *dp = msg->data;
713 u8 *fcs = dp + msg->len;
714
715 /* Fill in the header */
716 if (gsm->encoding == 0) {
717 if (msg->len < 128)
718 *--dp = (msg->len << 1) | EA;
719 else {
720 *--dp = (msg->len >> 6) | EA;
721 *--dp = (msg->len & 127) << 1;
722 }
723 }
724
725 *--dp = msg->ctrl;
726 if (gsm->initiator)
727 *--dp = (msg->addr << 2) | 2 | EA;
728 else
729 *--dp = (msg->addr << 2) | EA;
730 *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp);
731 /* Ugly protocol layering violation */
732 if (msg->ctrl == UI || msg->ctrl == (UI|PF))
733 *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len);
734 *fcs = 0xFF - *fcs;
735
736 gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl,
737 msg->data, msg->len);
738
739 /* Move the header back and adjust the length, also allow for the FCS
740 now tacked on the end */
741 msg->len += (msg->data - dp) + 1;
742 msg->data = dp;
743
744 /* Add to the actual output queue */
745 if (gsm->tx_tail)
746 gsm->tx_tail->next = msg;
747 else
748 gsm->tx_head = msg;
749 gsm->tx_tail = msg;
750 gsm->tx_bytes += msg->len;
751 gsm_data_kick(gsm);
752}
753
754/**
755 * gsm_data_queue - queue a UI or UIH frame
756 * @dlci: DLCI sending the data
757 * @msg: message queued
758 *
759 * Add data to the transmit queue and try and get stuff moving
760 * out of the mux tty if not already doing so. Take the
761 * the gsm tx lock and dlci lock.
762 */
763
764static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
765{
766 unsigned long flags;
767 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
768 __gsm_data_queue(dlci, msg);
769 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
770}
771
772/**
773 * gsm_dlci_data_output - try and push data out of a DLCI
774 * @gsm: mux
775 * @dlci: the DLCI to pull data from
776 *
777 * Pull data from a DLCI and send it into the transmit queue if there
778 * is data. Keep to the MRU of the mux. This path handles the usual tty
779 * interface which is a byte stream with optional modem data.
780 *
781 * Caller must hold the tx_lock of the mux.
782 */
783
784static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)
785{
786 struct gsm_msg *msg;
787 u8 *dp;
788 int len, size;
789 int h = dlci->adaption - 1;
790
791 len = kfifo_len(dlci->fifo);
792 if (len == 0)
793 return 0;
794
795 /* MTU/MRU count only the data bits */
796 if (len > gsm->mtu)
797 len = gsm->mtu;
798
799 size = len + h;
800
801 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
802 /* FIXME: need a timer or something to kick this so it can't
803 get stuck with no work outstanding and no buffer free */
804 if (msg == NULL)
805 return -ENOMEM;
806 dp = msg->data;
807 switch (dlci->adaption) {
808 case 1: /* Unstructured */
809 break;
810 case 2: /* Unstructed with modem bits. Always one byte as we never
811 send inline break data */
812 *dp += gsm_encode_modem(dlci);
813 len--;
814 break;
815 }
816 WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
817 __gsm_data_queue(dlci, msg);
818 /* Bytes of data we used up */
819 return size;
820}
821
822/**
823 * gsm_dlci_data_output_framed - try and push data out of a DLCI
824 * @gsm: mux
825 * @dlci: the DLCI to pull data from
826 *
827 * Pull data from a DLCI and send it into the transmit queue if there
828 * is data. Keep to the MRU of the mux. This path handles framed data
829 * queued as skbuffs to the DLCI.
830 *
831 * Caller must hold the tx_lock of the mux.
832 */
833
834static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,
835 struct gsm_dlci *dlci)
836{
837 struct gsm_msg *msg;
838 u8 *dp;
839 int len, size;
840 int last = 0, first = 0;
841 int overhead = 0;
842
843 /* One byte per frame is used for B/F flags */
844 if (dlci->adaption == 4)
845 overhead = 1;
846
847 /* dlci->skb is locked by tx_lock */
848 if (dlci->skb == NULL) {
849 dlci->skb = skb_dequeue(&dlci->skb_list);
850 if (dlci->skb == NULL)
851 return 0;
852 first = 1;
853 }
854 len = dlci->skb->len + overhead;
855
856 /* MTU/MRU count only the data bits */
857 if (len > gsm->mtu) {
858 if (dlci->adaption == 3) {
859 /* Over long frame, bin it */
860 kfree_skb(dlci->skb);
861 dlci->skb = NULL;
862 return 0;
863 }
864 len = gsm->mtu;
865 } else
866 last = 1;
867
868 size = len + overhead;
869 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
870
871 /* FIXME: need a timer or something to kick this so it can't
872 get stuck with no work outstanding and no buffer free */
873 if (msg == NULL)
874 return -ENOMEM;
875 dp = msg->data;
876
877 if (dlci->adaption == 4) { /* Interruptible framed (Packetised Data) */
878 /* Flag byte to carry the start/end info */
879 *dp++ = last << 7 | first << 6 | 1; /* EA */
880 len--;
881 }
882 memcpy(dp, skb_pull(dlci->skb, len), len);
883 __gsm_data_queue(dlci, msg);
884 if (last)
885 dlci->skb = NULL;
886 return size;
887}
888
889/**
890 * gsm_dlci_data_sweep - look for data to send
891 * @gsm: the GSM mux
892 *
893 * Sweep the GSM mux channels in priority order looking for ones with
894 * data to send. We could do with optimising this scan a bit. We aim
895 * to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
896 * TX_THRESH_LO we get called again
897 *
898 * FIXME: We should round robin between groups and in theory you can
899 * renegotiate DLCI priorities with optional stuff. Needs optimising.
900 */
901
902static void gsm_dlci_data_sweep(struct gsm_mux *gsm)
903{
904 int len;
905 /* Priority ordering: We should do priority with RR of the groups */
906 int i = 1;
907 unsigned long flags;
908
909 spin_lock_irqsave(&gsm->tx_lock, flags);
910 while (i < NUM_DLCI) {
911 struct gsm_dlci *dlci;
912
913 if (gsm->tx_bytes > TX_THRESH_HI)
914 break;
915 dlci = gsm->dlci[i];
916 if (dlci == NULL || dlci->constipated) {
917 i++;
918 continue;
919 }
920 if (dlci->adaption < 3)
921 len = gsm_dlci_data_output(gsm, dlci);
922 else
923 len = gsm_dlci_data_output_framed(gsm, dlci);
924 if (len < 0)
925 return;
926 /* DLCI empty - try the next */
927 if (len == 0)
928 i++;
929 }
930 spin_unlock_irqrestore(&gsm->tx_lock, flags);
931}
932
933/**
934 * gsm_dlci_data_kick - transmit if possible
935 * @dlci: DLCI to kick
936 *
937 * Transmit data from this DLCI if the queue is empty. We can't rely on
938 * a tty wakeup except when we filled the pipe so we need to fire off
939 * new data ourselves in other cases.
940 */
941
942static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
943{
944 unsigned long flags;
945
946 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
947 /* If we have nothing running then we need to fire up */
948 if (dlci->gsm->tx_bytes == 0)
949 gsm_dlci_data_output(dlci->gsm, dlci);
950 else if (dlci->gsm->tx_bytes < TX_THRESH_LO)
951 gsm_dlci_data_sweep(dlci->gsm);
952 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
953}
954
955/*
956 * Control message processing
957 */
958
959
960/**
961 * gsm_control_reply - send a response frame to a control
962 * @gsm: gsm channel
963 * @cmd: the command to use
964 * @data: data to follow encoded info
965 * @dlen: length of data
966 *
967 * Encode up and queue a UI/UIH frame containing our response.
968 */
969
970static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,
971 int dlen)
972{
973 struct gsm_msg *msg;
974 msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
975 msg->data[0] = (cmd & 0xFE) << 1 | EA; /* Clear C/R */
976 msg->data[1] = (dlen << 1) | EA;
977 memcpy(msg->data + 2, data, dlen);
978 gsm_data_queue(gsm->dlci[0], msg);
979}
980
981/**
982 * gsm_process_modem - process received modem status
983 * @tty: virtual tty bound to the DLCI
984 * @dlci: DLCI to affect
985 * @modem: modem bits (full EA)
986 *
987 * Used when a modem control message or line state inline in adaption
988 * layer 2 is processed. Sort out the local modem state and throttles
989 */
990
991static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
992 u32 modem)
993{
994 int mlines = 0;
995 u8 brk = modem >> 6;
996
997 /* Flow control/ready to communicate */
998 if (modem & MDM_FC) {
999 /* Need to throttle our output on this device */
1000 dlci->constipated = 1;
1001 }
1002 if (modem & MDM_RTC) {
1003 mlines |= TIOCM_DSR | TIOCM_DTR;
1004 dlci->constipated = 0;
1005 gsm_dlci_data_kick(dlci);
1006 }
1007 /* Map modem bits */
1008 if (modem & MDM_RTR)
1009 mlines |= TIOCM_RTS | TIOCM_CTS;
1010 if (modem & MDM_IC)
1011 mlines |= TIOCM_RI;
1012 if (modem & MDM_DV)
1013 mlines |= TIOCM_CD;
1014
1015 /* Carrier drop -> hangup */
1016 if (tty) {
1017 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
1018 if (!(tty->termios->c_cflag & CLOCAL))
1019 tty_hangup(tty);
1020 if (brk & 0x01)
1021 tty_insert_flip_char(tty, 0, TTY_BREAK);
1022 }
1023 dlci->modem_rx = mlines;
1024}
1025
1026/**
1027 * gsm_control_modem - modem status received
1028 * @gsm: GSM channel
1029 * @data: data following command
1030 * @clen: command length
1031 *
1032 * We have received a modem status control message. This is used by
1033 * the GSM mux protocol to pass virtual modem line status and optionally
1034 * to indicate break signals. Unpack it, convert to Linux representation
1035 * and if need be stuff a break message down the tty.
1036 */
1037
1038static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
1039{
1040 unsigned int addr = 0;
1041 unsigned int modem = 0;
1042 struct gsm_dlci *dlci;
1043 int len = clen;
1044 u8 *dp = data;
1045 struct tty_struct *tty;
1046
1047 while (gsm_read_ea(&addr, *dp++) == 0) {
1048 len--;
1049 if (len == 0)
1050 return;
1051 }
1052 /* Must be at least one byte following the EA */
1053 len--;
1054 if (len <= 0)
1055 return;
1056
1057 addr >>= 1;
1058 /* Closed port, or invalid ? */
1059 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1060 return;
1061 dlci = gsm->dlci[addr];
1062
1063 while (gsm_read_ea(&modem, *dp++) == 0) {
1064 len--;
1065 if (len == 0)
1066 return;
1067 }
1068 tty = tty_port_tty_get(&dlci->port);
1069 gsm_process_modem(tty, dlci, modem);
1070 if (tty) {
1071 tty_wakeup(tty);
1072 tty_kref_put(tty);
1073 }
1074 gsm_control_reply(gsm, CMD_MSC, data, clen);
1075}
1076
1077/**
1078 * gsm_control_rls - remote line status
1079 * @gsm: GSM channel
1080 * @data: data bytes
1081 * @clen: data length
1082 *
1083 * The modem sends us a two byte message on the control channel whenever
1084 * it wishes to send us an error state from the virtual link. Stuff
1085 * this into the uplink tty if present
1086 */
1087
1088static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
1089{
1090 struct tty_struct *tty;
1091 unsigned int addr = 0 ;
1092 u8 bits;
1093 int len = clen;
1094 u8 *dp = data;
1095
1096 while (gsm_read_ea(&addr, *dp++) == 0) {
1097 len--;
1098 if (len == 0)
1099 return;
1100 }
1101 /* Must be at least one byte following ea */
1102 len--;
1103 if (len <= 0)
1104 return;
1105 addr >>= 1;
1106 /* Closed port, or invalid ? */
1107 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1108 return;
1109 /* No error ? */
1110 bits = *dp;
1111 if ((bits & 1) == 0)
1112 return;
1113 /* See if we have an uplink tty */
1114 tty = tty_port_tty_get(&gsm->dlci[addr]->port);
1115
1116 if (tty) {
1117 if (bits & 2)
1118 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1119 if (bits & 4)
1120 tty_insert_flip_char(tty, 0, TTY_PARITY);
1121 if (bits & 8)
1122 tty_insert_flip_char(tty, 0, TTY_FRAME);
1123 tty_flip_buffer_push(tty);
1124 tty_kref_put(tty);
1125 }
1126 gsm_control_reply(gsm, CMD_RLS, data, clen);
1127}
1128
1129static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
1130
1131/**
1132 * gsm_control_message - DLCI 0 control processing
1133 * @gsm: our GSM mux
1134 * @command: the command EA
1135 * @data: data beyond the command/length EAs
1136 * @clen: length
1137 *
1138 * Input processor for control messages from the other end of the link.
1139 * Processes the incoming request and queues a response frame or an
1140 * NSC response if not supported
1141 */
1142
1143static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
1144 u8 *data, int clen)
1145{
1146 u8 buf[1];
1147 switch (command) {
1148 case CMD_CLD: {
1149 struct gsm_dlci *dlci = gsm->dlci[0];
1150 /* Modem wishes to close down */
1151 if (dlci) {
1152 dlci->dead = 1;
1153 gsm->dead = 1;
1154 gsm_dlci_begin_close(dlci);
1155 }
1156 }
1157 break;
1158 case CMD_TEST:
1159 /* Modem wishes to test, reply with the data */
1160 gsm_control_reply(gsm, CMD_TEST, data, clen);
1161 break;
1162 case CMD_FCON:
1163 /* Modem wants us to STFU */
1164 gsm->constipated = 1;
1165 gsm_control_reply(gsm, CMD_FCON, NULL, 0);
1166 break;
1167 case CMD_FCOFF:
1168 /* Modem can accept data again */
1169 gsm->constipated = 0;
1170 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
1171 /* Kick the link in case it is idling */
1172 gsm_data_kick(gsm);
1173 break;
1174 case CMD_MSC:
1175 /* Out of band modem line change indicator for a DLCI */
1176 gsm_control_modem(gsm, data, clen);
1177 break;
1178 case CMD_RLS:
1179 /* Out of band error reception for a DLCI */
1180 gsm_control_rls(gsm, data, clen);
1181 break;
1182 case CMD_PSC:
1183 /* Modem wishes to enter power saving state */
1184 gsm_control_reply(gsm, CMD_PSC, NULL, 0);
1185 break;
1186 /* Optional unsupported commands */
1187 case CMD_PN: /* Parameter negotiation */
1188 case CMD_RPN: /* Remote port negotation */
1189 case CMD_SNC: /* Service negotation command */
1190 default:
1191 /* Reply to bad commands with an NSC */
1192 buf[0] = command;
1193 gsm_control_reply(gsm, CMD_NSC, buf, 1);
1194 break;
1195 }
1196}
1197
1198/**
1199 * gsm_control_response - process a response to our control
1200 * @gsm: our GSM mux
1201 * @command: the command (response) EA
1202 * @data: data beyond the command/length EA
1203 * @clen: length
1204 *
1205 * Process a response to an outstanding command. We only allow a single
1206 * control message in flight so this is fairly easy. All the clean up
1207 * is done by the caller, we just update the fields, flag it as done
1208 * and return
1209 */
1210
1211static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
1212 u8 *data, int clen)
1213{
1214 struct gsm_control *ctrl;
1215 unsigned long flags;
1216
1217 spin_lock_irqsave(&gsm->control_lock, flags);
1218
1219 ctrl = gsm->pending_cmd;
1220 /* Does the reply match our command */
1221 command |= 1;
1222 if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
1223 /* Our command was replied to, kill the retry timer */
1224 del_timer(&gsm->t2_timer);
1225 gsm->pending_cmd = NULL;
1226 /* Rejected by the other end */
1227 if (command == CMD_NSC)
1228 ctrl->error = -EOPNOTSUPP;
1229 ctrl->done = 1;
1230 wake_up(&gsm->event);
1231 }
1232 spin_unlock_irqrestore(&gsm->control_lock, flags);
1233}
1234
1235/**
1236 * gsm_control_transmit - send control packet
1237 * @gsm: gsm mux
1238 * @ctrl: frame to send
1239 *
1240 * Send out a pending control command (called under control lock)
1241 */
1242
1243static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
1244{
1245 struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 1,
1246 gsm->ftype|PF);
1247 if (msg == NULL)
1248 return;
1249 msg->data[0] = (ctrl->cmd << 1) | 2 | EA; /* command */
1250 memcpy(msg->data + 1, ctrl->data, ctrl->len);
1251 gsm_data_queue(gsm->dlci[0], msg);
1252}
1253
1254/**
1255 * gsm_control_retransmit - retransmit a control frame
1256 * @data: pointer to our gsm object
1257 *
1258 * Called off the T2 timer expiry in order to retransmit control frames
1259 * that have been lost in the system somewhere. The control_lock protects
1260 * us from colliding with another sender or a receive completion event.
1261 * In that situation the timer may still occur in a small window but
1262 * gsm->pending_cmd will be NULL and we just let the timer expire.
1263 */
1264
1265static void gsm_control_retransmit(unsigned long data)
1266{
1267 struct gsm_mux *gsm = (struct gsm_mux *)data;
1268 struct gsm_control *ctrl;
1269 unsigned long flags;
1270 spin_lock_irqsave(&gsm->control_lock, flags);
1271 ctrl = gsm->pending_cmd;
1272 if (ctrl) {
1273 gsm->cretries--;
1274 if (gsm->cretries == 0) {
1275 gsm->pending_cmd = NULL;
1276 ctrl->error = -ETIMEDOUT;
1277 ctrl->done = 1;
1278 spin_unlock_irqrestore(&gsm->control_lock, flags);
1279 wake_up(&gsm->event);
1280 return;
1281 }
1282 gsm_control_transmit(gsm, ctrl);
1283 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1284 }
1285 spin_unlock_irqrestore(&gsm->control_lock, flags);
1286}
1287
1288/**
1289 * gsm_control_send - send a control frame on DLCI 0
1290 * @gsm: the GSM channel
1291 * @command: command to send including CR bit
1292 * @data: bytes of data (must be kmalloced)
1293 * @len: length of the block to send
1294 *
1295 * Queue and dispatch a control command. Only one command can be
1296 * active at a time. In theory more can be outstanding but the matching
1297 * gets really complicated so for now stick to one outstanding.
1298 */
1299
1300static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
1301 unsigned int command, u8 *data, int clen)
1302{
1303 struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
1304 GFP_KERNEL);
1305 unsigned long flags;
1306 if (ctrl == NULL)
1307 return NULL;
1308retry:
1309 wait_event(gsm->event, gsm->pending_cmd == NULL);
1310 spin_lock_irqsave(&gsm->control_lock, flags);
1311 if (gsm->pending_cmd != NULL) {
1312 spin_unlock_irqrestore(&gsm->control_lock, flags);
1313 goto retry;
1314 }
1315 ctrl->cmd = command;
1316 ctrl->data = data;
1317 ctrl->len = clen;
1318 gsm->pending_cmd = ctrl;
1319 gsm->cretries = gsm->n2;
1320 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1321 gsm_control_transmit(gsm, ctrl);
1322 spin_unlock_irqrestore(&gsm->control_lock, flags);
1323 return ctrl;
1324}
1325
1326/**
1327 * gsm_control_wait - wait for a control to finish
1328 * @gsm: GSM mux
1329 * @control: control we are waiting on
1330 *
1331 * Waits for the control to complete or time out. Frees any used
1332 * resources and returns 0 for success, or an error if the remote
1333 * rejected or ignored the request.
1334 */
1335
1336static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
1337{
1338 int err;
1339 wait_event(gsm->event, control->done == 1);
1340 err = control->error;
1341 kfree(control);
1342 return err;
1343}
1344
1345
1346/*
1347 * DLCI level handling: Needs krefs
1348 */
1349
1350/*
1351 * State transitions and timers
1352 */
1353
1354/**
1355 * gsm_dlci_close - a DLCI has closed
1356 * @dlci: DLCI that closed
1357 *
1358 * Perform processing when moving a DLCI into closed state. If there
1359 * is an attached tty this is hung up
1360 */
1361
1362static void gsm_dlci_close(struct gsm_dlci *dlci)
1363{
1364 del_timer(&dlci->t1);
1365 if (debug & 8)
1366 printk("DLCI %d goes closed.\n", dlci->addr);
1367 dlci->state = DLCI_CLOSED;
1368 if (dlci->addr != 0) {
1369 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1370 if (tty) {
1371 tty_hangup(tty);
1372 tty_kref_put(tty);
1373 }
1374 kfifo_reset(dlci->fifo);
1375 } else
1376 dlci->gsm->dead = 1;
1377 wake_up(&dlci->gsm->event);
1378 /* A DLCI 0 close is a MUX termination so we need to kick that
1379 back to userspace somehow */
1380}
1381
1382/**
1383 * gsm_dlci_open - a DLCI has opened
1384 * @dlci: DLCI that opened
1385 *
1386 * Perform processing when moving a DLCI into open state.
1387 */
1388
1389static void gsm_dlci_open(struct gsm_dlci *dlci)
1390{
1391 /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1392 open -> open */
1393 del_timer(&dlci->t1);
1394 /* This will let a tty open continue */
1395 dlci->state = DLCI_OPEN;
1396 if (debug & 8)
1397 printk("DLCI %d goes open.\n", dlci->addr);
1398 wake_up(&dlci->gsm->event);
1399}
1400
1401/**
1402 * gsm_dlci_t1 - T1 timer expiry
1403 * @dlci: DLCI that opened
1404 *
1405 * The T1 timer handles retransmits of control frames (essentially of
1406 * SABM and DISC). We resend the command until the retry count runs out
1407 * in which case an opening port goes back to closed and a closing port
1408 * is simply put into closed state (any further frames from the other
1409 * end will get a DM response)
1410 */
1411
1412static void gsm_dlci_t1(unsigned long data)
1413{
1414 struct gsm_dlci *dlci = (struct gsm_dlci *)data;
1415 struct gsm_mux *gsm = dlci->gsm;
1416
1417 switch (dlci->state) {
1418 case DLCI_OPENING:
1419 dlci->retries--;
1420 if (dlci->retries) {
1421 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1422 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1423 } else
1424 gsm_dlci_close(dlci);
1425 break;
1426 case DLCI_CLOSING:
1427 dlci->retries--;
1428 if (dlci->retries) {
1429 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1430 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1431 } else
1432 gsm_dlci_close(dlci);
1433 break;
1434 }
1435}
1436
1437/**
1438 * gsm_dlci_begin_open - start channel open procedure
1439 * @dlci: DLCI to open
1440 *
1441 * Commence opening a DLCI from the Linux side. We issue SABM messages
1442 * to the modem which should then reply with a UA, at which point we
1443 * will move into open state. Opening is done asynchronously with retry
1444 * running off timers and the responses.
1445 */
1446
1447static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
1448{
1449 struct gsm_mux *gsm = dlci->gsm;
1450 if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
1451 return;
1452 dlci->retries = gsm->n2;
1453 dlci->state = DLCI_OPENING;
1454 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1455 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1456}
1457
1458/**
1459 * gsm_dlci_begin_close - start channel open procedure
1460 * @dlci: DLCI to open
1461 *
1462 * Commence closing a DLCI from the Linux side. We issue DISC messages
1463 * to the modem which should then reply with a UA, at which point we
1464 * will move into closed state. Closing is done asynchronously with retry
1465 * off timers. We may also receive a DM reply from the other end which
1466 * indicates the channel was already closed.
1467 */
1468
1469static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
1470{
1471 struct gsm_mux *gsm = dlci->gsm;
1472 if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
1473 return;
1474 dlci->retries = gsm->n2;
1475 dlci->state = DLCI_CLOSING;
1476 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1477 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1478}
1479
1480/**
1481 * gsm_dlci_data - data arrived
1482 * @dlci: channel
1483 * @data: block of bytes received
1484 * @len: length of received block
1485 *
1486 * A UI or UIH frame has arrived which contains data for a channel
1487 * other than the control channel. If the relevant virtual tty is
1488 * open we shovel the bits down it, if not we drop them.
1489 */
1490
1491static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int len)
1492{
1493 /* krefs .. */
1494 struct tty_port *port = &dlci->port;
1495 struct tty_struct *tty = tty_port_tty_get(port);
1496 unsigned int modem = 0;
1497
1498 if (debug & 16)
1499 printk("%d bytes for tty %p\n", len, tty);
1500 if (tty) {
1501 switch (dlci->adaption) {
1502 /* Unsupported types */
1503 /* Packetised interruptible data */
1504 case 4:
1505 break;
1506 /* Packetised uininterruptible voice/data */
1507 case 3:
1508 break;
1509 /* Asynchronous serial with line state in each frame */
1510 case 2:
1511 while (gsm_read_ea(&modem, *data++) == 0) {
1512 len--;
1513 if (len == 0)
1514 return;
1515 }
1516 gsm_process_modem(tty, dlci, modem);
1517 /* Line state will go via DLCI 0 controls only */
1518 case 1:
1519 default:
1520 tty_insert_flip_string(tty, data, len);
1521 tty_flip_buffer_push(tty);
1522 }
1523 tty_kref_put(tty);
1524 }
1525}
1526
1527/**
1528 * gsm_dlci_control - data arrived on control channel
1529 * @dlci: channel
1530 * @data: block of bytes received
1531 * @len: length of received block
1532 *
1533 * A UI or UIH frame has arrived which contains data for DLCI 0 the
1534 * control channel. This should contain a command EA followed by
1535 * control data bytes. The command EA contains a command/response bit
1536 * and we divide up the work accordingly.
1537 */
1538
1539static void gsm_dlci_command(struct gsm_dlci *dlci, u8 *data, int len)
1540{
1541 /* See what command is involved */
1542 unsigned int command = 0;
1543 while (len-- > 0) {
1544 if (gsm_read_ea(&command, *data++) == 1) {
1545 int clen = *data++;
1546 len--;
1547 /* FIXME: this is properly an EA */
1548 clen >>= 1;
1549 /* Malformed command ? */
1550 if (clen > len)
1551 return;
1552 if (command & 1)
1553 gsm_control_message(dlci->gsm, command,
1554 data, clen);
1555 else
1556 gsm_control_response(dlci->gsm, command,
1557 data, clen);
1558 return;
1559 }
1560 }
1561}
1562
1563/*
1564 * Allocate/Free DLCI channels
1565 */
1566
1567/**
1568 * gsm_dlci_alloc - allocate a DLCI
1569 * @gsm: GSM mux
1570 * @addr: address of the DLCI
1571 *
1572 * Allocate and install a new DLCI object into the GSM mux.
1573 *
1574 * FIXME: review locking races
1575 */
1576
1577static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
1578{
1579 struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
1580 if (dlci == NULL)
1581 return NULL;
1582 spin_lock_init(&dlci->lock);
1583 dlci->fifo = &dlci->_fifo;
1584 if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
1585 kfree(dlci);
1586 return NULL;
1587 }
1588
1589 skb_queue_head_init(&dlci->skb_list);
1590 init_timer(&dlci->t1);
1591 dlci->t1.function = gsm_dlci_t1;
1592 dlci->t1.data = (unsigned long)dlci;
1593 tty_port_init(&dlci->port);
1594 dlci->port.ops = &gsm_port_ops;
1595 dlci->gsm = gsm;
1596 dlci->addr = addr;
1597 dlci->adaption = gsm->adaption;
1598 dlci->state = DLCI_CLOSED;
1599 if (addr)
1600 dlci->data = gsm_dlci_data;
1601 else
1602 dlci->data = gsm_dlci_command;
1603 gsm->dlci[addr] = dlci;
1604 return dlci;
1605}
1606
1607/**
1608 * gsm_dlci_free - release DLCI
1609 * @dlci: DLCI to destroy
1610 *
1611 * Free up a DLCI. Currently to keep the lifetime rules sane we only
1612 * clean up DLCI objects when the MUX closes rather than as the port
1613 * is closed down on both the tty and mux levels.
1614 *
1615 * Can sleep.
1616 */
1617static void gsm_dlci_free(struct gsm_dlci *dlci)
1618{
1619 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1620 if (tty) {
1621 tty_vhangup(tty);
1622 tty_kref_put(tty);
1623 }
1624 del_timer_sync(&dlci->t1);
1625 dlci->gsm->dlci[dlci->addr] = NULL;
1626 kfifo_free(dlci->fifo);
1627 kfree(dlci);
1628}
1629
1630
1631/*
1632 * LAPBish link layer logic
1633 */
1634
1635/**
1636 * gsm_queue - a GSM frame is ready to process
1637 * @gsm: pointer to our gsm mux
1638 *
1639 * At this point in time a frame has arrived and been demangled from
1640 * the line encoding. All the differences between the encodings have
1641 * been handled below us and the frame is unpacked into the structures.
1642 * The fcs holds the header FCS but any data FCS must be added here.
1643 */
1644
1645static void gsm_queue(struct gsm_mux *gsm)
1646{
1647 struct gsm_dlci *dlci;
1648 u8 cr;
1649 int address;
1650 /* We have to sneak a look at the packet body to do the FCS.
1651 A somewhat layering violation in the spec */
1652
1653 if ((gsm->control & ~PF) == UI)
1654 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len);
1655 if (gsm->fcs != GOOD_FCS) {
1656 gsm->bad_fcs++;
1657 if (debug & 4)
1658 printk("BAD FCS %02x\n", gsm->fcs);
1659 return;
1660 }
1661 address = gsm->address >> 1;
1662 if (address >= NUM_DLCI)
1663 goto invalid;
1664
1665 cr = gsm->address & 1; /* C/R bit */
1666
1667 gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
1668
1669 cr ^= 1 - gsm->initiator; /* Flip so 1 always means command */
1670 dlci = gsm->dlci[address];
1671
1672 switch (gsm->control) {
1673 case SABM|PF:
1674 if (cr == 0)
1675 goto invalid;
1676 if (dlci == NULL)
1677 dlci = gsm_dlci_alloc(gsm, address);
1678 if (dlci == NULL)
1679 return;
1680 if (dlci->dead)
1681 gsm_response(gsm, address, DM);
1682 else {
1683 gsm_response(gsm, address, UA);
1684 gsm_dlci_open(dlci);
1685 }
1686 break;
1687 case DISC|PF:
1688 if (cr == 0)
1689 goto invalid;
1690 if (dlci == NULL || dlci->state == DLCI_CLOSED) {
1691 gsm_response(gsm, address, DM);
1692 return;
1693 }
1694 /* Real close complete */
1695 gsm_response(gsm, address, UA);
1696 gsm_dlci_close(dlci);
1697 break;
1698 case UA:
1699 case UA|PF:
1700 if (cr == 0 || dlci == NULL)
1701 break;
1702 switch (dlci->state) {
1703 case DLCI_CLOSING:
1704 gsm_dlci_close(dlci);
1705 break;
1706 case DLCI_OPENING:
1707 gsm_dlci_open(dlci);
1708 break;
1709 }
1710 break;
1711 case DM: /* DM can be valid unsolicited */
1712 case DM|PF:
1713 if (cr)
1714 goto invalid;
1715 if (dlci == NULL)
1716 return;
1717 gsm_dlci_close(dlci);
1718 break;
1719 case UI:
1720 case UI|PF:
1721 case UIH:
1722 case UIH|PF:
1723#if 0
1724 if (cr)
1725 goto invalid;
1726#endif
1727 if (dlci == NULL || dlci->state != DLCI_OPEN) {
1728 gsm_command(gsm, address, DM|PF);
1729 return;
1730 }
1731 dlci->data(dlci, gsm->buf, gsm->len);
1732 break;
1733 default:
1734 goto invalid;
1735 }
1736 return;
1737invalid:
1738 gsm->malformed++;
1739 return;
1740}
1741
1742
1743/**
1744 * gsm0_receive - perform processing for non-transparency
1745 * @gsm: gsm data for this ldisc instance
1746 * @c: character
1747 *
1748 * Receive bytes in gsm mode 0
1749 */
1750
1751static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
1752{
1753 switch (gsm->state) {
1754 case GSM_SEARCH: /* SOF marker */
1755 if (c == GSM0_SOF) {
1756 gsm->state = GSM_ADDRESS;
1757 gsm->address = 0;
1758 gsm->len = 0;
1759 gsm->fcs = INIT_FCS;
1760 }
1761 break; /* Address EA */
1762 case GSM_ADDRESS:
1763 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1764 if (gsm_read_ea(&gsm->address, c))
1765 gsm->state = GSM_CONTROL;
1766 break;
1767 case GSM_CONTROL: /* Control Byte */
1768 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1769 gsm->control = c;
1770 gsm->state = GSM_LEN;
1771 break;
1772 case GSM_LEN: /* Length EA */
1773 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1774 if (gsm_read_ea(&gsm->len, c)) {
1775 if (gsm->len > gsm->mru) {
1776 gsm->bad_size++;
1777 gsm->state = GSM_SEARCH;
1778 break;
1779 }
1780 gsm->count = 0;
1781 gsm->state = GSM_DATA;
1782 }
1783 break;
1784 case GSM_DATA: /* Data */
1785 gsm->buf[gsm->count++] = c;
1786 if (gsm->count == gsm->len)
1787 gsm->state = GSM_FCS;
1788 break;
1789 case GSM_FCS: /* FCS follows the packet */
1790 gsm->fcs = c;
1791 gsm_queue(gsm);
1792 /* And then back for the next frame */
1793 gsm->state = GSM_SEARCH;
1794 break;
1795 }
1796}
1797
1798/**
1799 * gsm0_receive - perform processing for non-transparency
1800 * @gsm: gsm data for this ldisc instance
1801 * @c: character
1802 *
1803 * Receive bytes in mode 1 (Advanced option)
1804 */
1805
1806static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
1807{
1808 if (c == GSM1_SOF) {
1809 /* EOF is only valid in frame if we have got to the data state
1810 and received at least one byte (the FCS) */
1811 if (gsm->state == GSM_DATA && gsm->count) {
1812 /* Extract the FCS */
1813 gsm->count--;
1814 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
1815 gsm->len = gsm->count;
1816 gsm_queue(gsm);
1817 gsm->state = GSM_START;
1818 return;
1819 }
1820 /* Any partial frame was a runt so go back to start */
1821 if (gsm->state != GSM_START) {
1822 gsm->malformed++;
1823 gsm->state = GSM_START;
1824 }
1825 /* A SOF in GSM_START means we are still reading idling or
1826 framing bytes */
1827 return;
1828 }
1829
1830 if (c == GSM1_ESCAPE) {
1831 gsm->escape = 1;
1832 return;
1833 }
1834
1835 /* Only an unescaped SOF gets us out of GSM search */
1836 if (gsm->state == GSM_SEARCH)
1837 return;
1838
1839 if (gsm->escape) {
1840 c ^= GSM1_ESCAPE_BITS;
1841 gsm->escape = 0;
1842 }
1843 switch (gsm->state) {
1844 case GSM_START: /* First byte after SOF */
1845 gsm->address = 0;
1846 gsm->state = GSM_ADDRESS;
1847 gsm->fcs = INIT_FCS;
1848 /* Drop through */
1849 case GSM_ADDRESS: /* Address continuation */
1850 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1851 if (gsm_read_ea(&gsm->address, c))
1852 gsm->state = GSM_CONTROL;
1853 break;
1854 case GSM_CONTROL: /* Control Byte */
1855 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1856 gsm->control = c;
1857 gsm->count = 0;
1858 gsm->state = GSM_DATA;
1859 break;
1860 case GSM_DATA: /* Data */
1861 if (gsm->count > gsm->mru ) { /* Allow one for the FCS */
1862 gsm->state = GSM_OVERRUN;
1863 gsm->bad_size++;
1864 } else
1865 gsm->buf[gsm->count++] = c;
1866 break;
1867 case GSM_OVERRUN: /* Over-long - eg a dropped SOF */
1868 break;
1869 }
1870}
1871
1872/**
1873 * gsm_error - handle tty error
1874 * @gsm: ldisc data
1875 * @data: byte received (may be invalid)
1876 * @flag: error received
1877 *
1878 * Handle an error in the receipt of data for a frame. Currently we just
1879 * go back to hunting for a SOF.
1880 *
1881 * FIXME: better diagnostics ?
1882 */
1883
1884static void gsm_error(struct gsm_mux *gsm,
1885 unsigned char data, unsigned char flag)
1886{
1887 gsm->state = GSM_SEARCH;
1888 gsm->io_error++;
1889}
1890
1891/**
1892 * gsm_cleanup_mux - generic GSM protocol cleanup
1893 * @gsm: our mux
1894 *
1895 * Clean up the bits of the mux which are the same for all framing
1896 * protocols. Remove the mux from the mux table, stop all the timers
1897 * and then shut down each device hanging up the channels as we go.
1898 */
1899
1900void gsm_cleanup_mux(struct gsm_mux *gsm)
1901{
1902 int i;
1903 struct gsm_dlci *dlci = gsm->dlci[0];
1904 struct gsm_msg *txq;
1905
1906 gsm->dead = 1;
1907
1908 spin_lock(&gsm_mux_lock);
1909 for (i = 0; i < MAX_MUX; i++) {
1910 if (gsm_mux[i] == gsm) {
1911 gsm_mux[i] = NULL;
1912 break;
1913 }
1914 }
1915 spin_unlock(&gsm_mux_lock);
1916 WARN_ON(i == MAX_MUX);
1917
1918 del_timer_sync(&gsm->t2_timer);
1919 /* Now we are sure T2 has stopped */
1920 if (dlci) {
1921 dlci->dead = 1;
1922 gsm_dlci_begin_close(dlci);
1923 wait_event_interruptible(gsm->event,
1924 dlci->state == DLCI_CLOSED);
1925 }
1926 /* Free up any link layer users */
1927 for (i = 0; i < NUM_DLCI; i++)
1928 if (gsm->dlci[i])
1929 gsm_dlci_free(gsm->dlci[i]);
1930 /* Now wipe the queues */
1931 for (txq = gsm->tx_head; txq != NULL; txq = gsm->tx_head) {
1932 gsm->tx_head = txq->next;
1933 kfree(txq);
1934 }
1935 gsm->tx_tail = NULL;
1936}
1937EXPORT_SYMBOL_GPL(gsm_cleanup_mux);
1938
1939/**
1940 * gsm_activate_mux - generic GSM setup
1941 * @gsm: our mux
1942 *
1943 * Set up the bits of the mux which are the same for all framing
1944 * protocols. Add the mux to the mux table so it can be opened and
1945 * finally kick off connecting to DLCI 0 on the modem.
1946 */
1947
1948int gsm_activate_mux(struct gsm_mux *gsm)
1949{
1950 struct gsm_dlci *dlci;
1951 int i = 0;
1952
1953 init_timer(&gsm->t2_timer);
1954 gsm->t2_timer.function = gsm_control_retransmit;
1955 gsm->t2_timer.data = (unsigned long)gsm;
1956 init_waitqueue_head(&gsm->event);
1957 spin_lock_init(&gsm->control_lock);
1958 spin_lock_init(&gsm->tx_lock);
1959
1960 if (gsm->encoding == 0)
1961 gsm->receive = gsm0_receive;
1962 else
1963 gsm->receive = gsm1_receive;
1964 gsm->error = gsm_error;
1965
1966 spin_lock(&gsm_mux_lock);
1967 for (i = 0; i < MAX_MUX; i++) {
1968 if (gsm_mux[i] == NULL) {
1969 gsm_mux[i] = gsm;
1970 break;
1971 }
1972 }
1973 spin_unlock(&gsm_mux_lock);
1974 if (i == MAX_MUX)
1975 return -EBUSY;
1976
1977 dlci = gsm_dlci_alloc(gsm, 0);
1978 if (dlci == NULL)
1979 return -ENOMEM;
1980 gsm->dead = 0; /* Tty opens are now permissible */
1981 return 0;
1982}
1983EXPORT_SYMBOL_GPL(gsm_activate_mux);
1984
1985/**
1986 * gsm_free_mux - free up a mux
1987 * @mux: mux to free
1988 *
1989 * Dispose of allocated resources for a dead mux. No refcounting
1990 * at present so the mux must be truely dead.
1991 */
1992void gsm_free_mux(struct gsm_mux *gsm)
1993{
1994 kfree(gsm->txframe);
1995 kfree(gsm->buf);
1996 kfree(gsm);
1997}
1998EXPORT_SYMBOL_GPL(gsm_free_mux);
1999
2000/**
2001 * gsm_alloc_mux - allocate a mux
2002 *
2003 * Creates a new mux ready for activation.
2004 */
2005
2006struct gsm_mux *gsm_alloc_mux(void)
2007{
2008 struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
2009 if (gsm == NULL)
2010 return NULL;
2011 gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
2012 if (gsm->buf == NULL) {
2013 kfree(gsm);
2014 return NULL;
2015 }
2016 gsm->txframe = kmalloc(2 * MAX_MRU + 2, GFP_KERNEL);
2017 if (gsm->txframe == NULL) {
2018 kfree(gsm->buf);
2019 kfree(gsm);
2020 return NULL;
2021 }
2022 spin_lock_init(&gsm->lock);
2023
2024 gsm->t1 = T1;
2025 gsm->t2 = T2;
2026 gsm->n2 = N2;
2027 gsm->ftype = UIH;
2028 gsm->initiator = 0;
2029 gsm->adaption = 1;
2030 gsm->encoding = 1;
2031 gsm->mru = 64; /* Default to encoding 1 so these should be 64 */
2032 gsm->mtu = 64;
2033 gsm->dead = 1; /* Avoid early tty opens */
2034
2035 return gsm;
2036}
2037EXPORT_SYMBOL_GPL(gsm_alloc_mux);
2038
2039
2040
2041
2042/**
2043 * gsmld_output - write to link
2044 * @gsm: our mux
2045 * @data: bytes to output
2046 * @len: size
2047 *
2048 * Write a block of data from the GSM mux to the data channel. This
2049 * will eventually be serialized from above but at the moment isn't.
2050 */
2051
2052static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
2053{
2054 if (tty_write_room(gsm->tty) < len) {
2055 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
2056 return -ENOSPC;
2057 }
2058 if (debug & 4) {
2059 printk("-->%d bytes out\n", len);
2060 hex_packet(data, len);
2061 }
2062 gsm->tty->ops->write(gsm->tty, data, len);
2063 return len;
2064}
2065
2066/**
2067 * gsmld_attach_gsm - mode set up
2068 * @tty: our tty structure
2069 * @gsm: our mux
2070 *
2071 * Set up the MUX for basic mode and commence connecting to the
2072 * modem. Currently called from the line discipline set up but
2073 * will need moving to an ioctl path.
2074 */
2075
2076static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2077{
2078 int ret;
2079
2080 gsm->tty = tty_kref_get(tty);
2081 gsm->output = gsmld_output;
2082 ret = gsm_activate_mux(gsm);
2083 if (ret != 0)
2084 tty_kref_put(gsm->tty);
2085 return ret;
2086}
2087
2088
2089/**
2090 * gsmld_detach_gsm - stop doing 0710 mux
2091 * @tty: tty atttached to the mux
2092 * @gsm: mux
2093 *
2094 * Shutdown and then clean up the resources used by the line discipline
2095 */
2096
2097static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2098{
2099 WARN_ON(tty != gsm->tty);
2100 gsm_cleanup_mux(gsm);
2101 tty_kref_put(gsm->tty);
2102 gsm->tty = NULL;
2103}
2104
2105static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
2106 char *fp, int count)
2107{
2108 struct gsm_mux *gsm = tty->disc_data;
2109 const unsigned char *dp;
2110 char *f;
2111 int i;
2112 char buf[64];
2113 char flags;
2114
2115 if (debug & 4) {
2116 printk("Inbytes %dd\n", count);
2117 hex_packet(cp, count);
2118 }
2119
2120 for (i = count, dp = cp, f = fp; i; i--, dp++) {
2121 flags = *f++;
2122 switch (flags) {
2123 case TTY_NORMAL:
2124 gsm->receive(gsm, *dp);
2125 break;
2126 case TTY_OVERRUN:
2127 case TTY_BREAK:
2128 case TTY_PARITY:
2129 case TTY_FRAME:
2130 gsm->error(gsm, *dp, flags);
2131 break;
2132 default:
2133 printk(KERN_ERR "%s: unknown flag %d\n",
2134 tty_name(tty, buf), flags);
2135 break;
2136 }
2137 }
2138 /* FASYNC if needed ? */
2139 /* If clogged call tty_throttle(tty); */
2140}
2141
2142/**
2143 * gsmld_chars_in_buffer - report available bytes
2144 * @tty: tty device
2145 *
2146 * Report the number of characters buffered to be delivered to user
2147 * at this instant in time.
2148 *
2149 * Locking: gsm lock
2150 */
2151
2152static ssize_t gsmld_chars_in_buffer(struct tty_struct *tty)
2153{
2154 return 0;
2155}
2156
2157/**
2158 * gsmld_flush_buffer - clean input queue
2159 * @tty: terminal device
2160 *
2161 * Flush the input buffer. Called when the line discipline is
2162 * being closed, when the tty layer wants the buffer flushed (eg
2163 * at hangup).
2164 */
2165
2166static void gsmld_flush_buffer(struct tty_struct *tty)
2167{
2168}
2169
2170/**
2171 * gsmld_close - close the ldisc for this tty
2172 * @tty: device
2173 *
2174 * Called from the terminal layer when this line discipline is
2175 * being shut down, either because of a close or becsuse of a
2176 * discipline change. The function will not be called while other
2177 * ldisc methods are in progress.
2178 */
2179
2180static void gsmld_close(struct tty_struct *tty)
2181{
2182 struct gsm_mux *gsm = tty->disc_data;
2183
2184 gsmld_detach_gsm(tty, gsm);
2185
2186 gsmld_flush_buffer(tty);
2187 /* Do other clean up here */
2188 gsm_free_mux(gsm);
2189}
2190
2191/**
2192 * gsmld_open - open an ldisc
2193 * @tty: terminal to open
2194 *
2195 * Called when this line discipline is being attached to the
2196 * terminal device. Can sleep. Called serialized so that no
2197 * other events will occur in parallel. No further open will occur
2198 * until a close.
2199 */
2200
2201static int gsmld_open(struct tty_struct *tty)
2202{
2203 struct gsm_mux *gsm;
2204
2205 if (tty->ops->write == NULL)
2206 return -EINVAL;
2207
2208 /* Attach our ldisc data */
2209 gsm = gsm_alloc_mux();
2210 if (gsm == NULL)
2211 return -ENOMEM;
2212
2213 tty->disc_data = gsm;
2214 tty->receive_room = 65536;
2215
2216 /* Attach the initial passive connection */
2217 gsm->encoding = 1;
2218 return gsmld_attach_gsm(tty, gsm);
2219}
2220
2221/**
2222 * gsmld_write_wakeup - asynchronous I/O notifier
2223 * @tty: tty device
2224 *
2225 * Required for the ptys, serial driver etc. since processes
2226 * that attach themselves to the master and rely on ASYNC
2227 * IO must be woken up
2228 */
2229
2230static void gsmld_write_wakeup(struct tty_struct *tty)
2231{
2232 struct gsm_mux *gsm = tty->disc_data;
2233
2234 /* Queue poll */
2235 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2236 gsm_data_kick(gsm);
2237 if (gsm->tx_bytes < TX_THRESH_LO)
2238 gsm_dlci_data_sweep(gsm);
2239}
2240
2241/**
2242 * gsmld_read - read function for tty
2243 * @tty: tty device
2244 * @file: file object
2245 * @buf: userspace buffer pointer
2246 * @nr: size of I/O
2247 *
2248 * Perform reads for the line discipline. We are guaranteed that the
2249 * line discipline will not be closed under us but we may get multiple
2250 * parallel readers and must handle this ourselves. We may also get
2251 * a hangup. Always called in user context, may sleep.
2252 *
2253 * This code must be sure never to sleep through a hangup.
2254 */
2255
2256static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
2257 unsigned char __user *buf, size_t nr)
2258{
2259 return -EOPNOTSUPP;
2260}
2261
2262/**
2263 * gsmld_write - write function for tty
2264 * @tty: tty device
2265 * @file: file object
2266 * @buf: userspace buffer pointer
2267 * @nr: size of I/O
2268 *
2269 * Called when the owner of the device wants to send a frame
2270 * itself (or some other control data). The data is transferred
2271 * as-is and must be properly framed and checksummed as appropriate
2272 * by userspace. Frames are either sent whole or not at all as this
2273 * avoids pain user side.
2274 */
2275
2276static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
2277 const unsigned char *buf, size_t nr)
2278{
2279 int space = tty_write_room(tty);
2280 if (space >= nr)
2281 return tty->ops->write(tty, buf, nr);
2282 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2283 return -ENOBUFS;
2284}
2285
2286/**
2287 * gsmld_poll - poll method for N_GSM0710
2288 * @tty: terminal device
2289 * @file: file accessing it
2290 * @wait: poll table
2291 *
2292 * Called when the line discipline is asked to poll() for data or
2293 * for special events. This code is not serialized with respect to
2294 * other events save open/close.
2295 *
2296 * This code must be sure never to sleep through a hangup.
2297 * Called without the kernel lock held - fine
2298 */
2299
2300static unsigned int gsmld_poll(struct tty_struct *tty, struct file *file,
2301 poll_table *wait)
2302{
2303 unsigned int mask = 0;
2304 struct gsm_mux *gsm = tty->disc_data;
2305
2306 poll_wait(file, &tty->read_wait, wait);
2307 poll_wait(file, &tty->write_wait, wait);
2308 if (tty_hung_up_p(file))
2309 mask |= POLLHUP;
2310 if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
2311 mask |= POLLOUT | POLLWRNORM;
2312 if (gsm->dead)
2313 mask |= POLLHUP;
2314 return mask;
2315}
2316
2317static int gsmld_config(struct tty_struct *tty, struct gsm_mux *gsm,
2318 struct gsm_config *c)
2319{
2320 int need_close = 0;
2321 int need_restart = 0;
2322
2323 /* Stuff we don't support yet - UI or I frame transport, windowing */
2324 if ((c->adaption !=1 && c->adaption != 2) || c->k)
2325 return -EOPNOTSUPP;
2326 /* Check the MRU/MTU range looks sane */
2327 if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
2328 return -EINVAL;
2329 if (c->n2 < 3)
2330 return -EINVAL;
2331 if (c->encapsulation > 1) /* Basic, advanced, no I */
2332 return -EINVAL;
2333 if (c->initiator > 1)
2334 return -EINVAL;
2335 if (c->i == 0 || c->i > 2) /* UIH and UI only */
2336 return -EINVAL;
2337 /*
2338 * See what is needed for reconfiguration
2339 */
2340
2341 /* Timing fields */
2342 if (c->t1 != 0 && c->t1 != gsm->t1)
2343 need_restart = 1;
2344 if (c->t2 != 0 && c->t2 != gsm->t2)
2345 need_restart = 1;
2346 if (c->encapsulation != gsm->encoding)
2347 need_restart = 1;
2348 if (c->adaption != gsm->adaption)
2349 need_restart = 1;
2350 /* Requires care */
2351 if (c->initiator != gsm->initiator)
2352 need_close = 1;
2353 if (c->mru != gsm->mru)
2354 need_restart = 1;
2355 if (c->mtu != gsm->mtu)
2356 need_restart = 1;
2357
2358 /*
2359 * Close down what is needed, restart and initiate the new
2360 * configuration
2361 */
2362
2363 if (need_close || need_restart) {
2364 gsm_dlci_begin_close(gsm->dlci[0]);
2365 /* This will timeout if the link is down due to N2 expiring */
2366 wait_event_interruptible(gsm->event,
2367 gsm->dlci[0]->state == DLCI_CLOSED);
2368 if (signal_pending(current))
2369 return -EINTR;
2370 }
2371 if (need_restart)
2372 gsm_cleanup_mux(gsm);
2373
2374 gsm->initiator = c->initiator;
2375 gsm->mru = c->mru;
2376 gsm->encoding = c->encapsulation;
2377 gsm->adaption = c->adaption;
2378
2379 if (c->i == 1)
2380 gsm->ftype = UIH;
2381 else if (c->i == 2)
2382 gsm->ftype = UI;
2383
2384 if (c->t1)
2385 gsm->t1 = c->t1;
2386 if (c->t2)
2387 gsm->t2 = c->t2;
2388
2389 /* FIXME: We need to separate activation/deactivation from adding
2390 and removing from the mux array */
2391 if (need_restart)
2392 gsm_activate_mux(gsm);
2393 if (gsm->initiator && need_close)
2394 gsm_dlci_begin_open(gsm->dlci[0]);
2395 return 0;
2396}
2397
2398static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
2399 unsigned int cmd, unsigned long arg)
2400{
2401 struct gsm_config c;
2402 struct gsm_mux *gsm = tty->disc_data;
2403
2404 switch (cmd) {
2405 case GSMIOC_GETCONF:
2406 memset(&c, 0, sizeof(c));
2407 c.adaption = gsm->adaption;
2408 c.encapsulation = gsm->encoding;
2409 c.initiator = gsm->initiator;
2410 c.t1 = gsm->t1;
2411 c.t2 = gsm->t2;
2412 c.t3 = 0; /* Not supported */
2413 c.n2 = gsm->n2;
2414 if (gsm->ftype == UIH)
2415 c.i = 1;
2416 else
2417 c.i = 2;
2418 printk("Ftype %d i %d\n", gsm->ftype, c.i);
2419 c.mru = gsm->mru;
2420 c.mtu = gsm->mtu;
2421 c.k = 0;
2422 if (copy_to_user((void *)arg, &c, sizeof(c)))
2423 return -EFAULT;
2424 return 0;
2425 case GSMIOC_SETCONF:
2426 if (copy_from_user(&c, (void *)arg, sizeof(c)))
2427 return -EFAULT;
2428 return gsmld_config(tty, gsm, &c);
2429 default:
2430 return n_tty_ioctl_helper(tty, file, cmd, arg);
2431 }
2432}
2433
2434
2435/* Line discipline for real tty */
2436struct tty_ldisc_ops tty_ldisc_packet = {
2437 .owner = THIS_MODULE,
2438 .magic = TTY_LDISC_MAGIC,
2439 .name = "n_gsm",
2440 .open = gsmld_open,
2441 .close = gsmld_close,
2442 .flush_buffer = gsmld_flush_buffer,
2443 .chars_in_buffer = gsmld_chars_in_buffer,
2444 .read = gsmld_read,
2445 .write = gsmld_write,
2446 .ioctl = gsmld_ioctl,
2447 .poll = gsmld_poll,
2448 .receive_buf = gsmld_receive_buf,
2449 .write_wakeup = gsmld_write_wakeup
2450};
2451
2452/*
2453 * Virtual tty side
2454 */
2455
2456#define TX_SIZE 512
2457
2458static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk)
2459{
2460 u8 modembits[5];
2461 struct gsm_control *ctrl;
2462 int len = 2;
2463
2464 if (brk)
2465 len++;
2466
2467 modembits[0] = len << 1 | EA; /* Data bytes */
2468 modembits[1] = dlci->addr << 2 | 3; /* DLCI, EA, 1 */
2469 modembits[2] = gsm_encode_modem(dlci) << 1 | EA;
2470 if (brk)
2471 modembits[3] = brk << 4 | 2 | EA; /* Valid, EA */
2472 ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len + 1);
2473 if (ctrl == NULL)
2474 return -ENOMEM;
2475 return gsm_control_wait(dlci->gsm, ctrl);
2476}
2477
2478static int gsm_carrier_raised(struct tty_port *port)
2479{
2480 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2481 /* Not yet open so no carrier info */
2482 if (dlci->state != DLCI_OPEN)
2483 return 0;
2484 if (debug & 2)
2485 return 1;
2486 return dlci->modem_rx & TIOCM_CD;
2487}
2488
2489static void gsm_dtr_rts(struct tty_port *port, int onoff)
2490{
2491 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2492 unsigned int modem_tx = dlci->modem_tx;
2493 if (onoff)
2494 modem_tx |= TIOCM_DTR | TIOCM_RTS;
2495 else
2496 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
2497 if (modem_tx != dlci->modem_tx) {
2498 dlci->modem_tx = modem_tx;
2499 gsmtty_modem_update(dlci, 0);
2500 }
2501}
2502
2503static const struct tty_port_operations gsm_port_ops = {
2504 .carrier_raised = gsm_carrier_raised,
2505 .dtr_rts = gsm_dtr_rts,
2506};
2507
2508
2509static int gsmtty_open(struct tty_struct *tty, struct file *filp)
2510{
2511 struct gsm_mux *gsm;
2512 struct gsm_dlci *dlci;
2513 struct tty_port *port;
2514 unsigned int line = tty->index;
2515 unsigned int mux = line >> 6;
2516
2517 line = line & 0x3F;
2518
2519 if (mux >= MAX_MUX)
2520 return -ENXIO;
2521 /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
2522 if (gsm_mux[mux] == NULL)
2523 return -EUNATCH;
2524 if (line == 0 || line > 61) /* 62/63 reserved */
2525 return -ECHRNG;
2526 gsm = gsm_mux[mux];
2527 if (gsm->dead)
2528 return -EL2HLT;
2529 dlci = gsm->dlci[line];
2530 if (dlci == NULL)
2531 dlci = gsm_dlci_alloc(gsm, line);
2532 if (dlci == NULL)
2533 return -ENOMEM;
2534 port = &dlci->port;
2535 port->count++;
2536 tty->driver_data = dlci;
2537 tty_port_tty_set(port, tty);
2538
2539 dlci->modem_rx = 0;
2540 /* We could in theory open and close before we wait - eg if we get
2541 a DM straight back. This is ok as that will have caused a hangup */
2542 set_bit(ASYNCB_INITIALIZED, &port->flags);
2543 /* Start sending off SABM messages */
2544 gsm_dlci_begin_open(dlci);
2545 /* And wait for virtual carrier */
2546 return tty_port_block_til_ready(port, tty, filp);
2547}
2548
2549static void gsmtty_close(struct tty_struct *tty, struct file *filp)
2550{
2551 struct gsm_dlci *dlci = tty->driver_data;
2552 if (dlci == NULL)
2553 return;
2554 if (tty_port_close_start(&dlci->port, tty, filp) == 0)
2555 return;
2556 gsm_dlci_begin_close(dlci);
2557 tty_port_close_end(&dlci->port, tty);
2558 tty_port_tty_set(&dlci->port, NULL);
2559}
2560
2561static void gsmtty_hangup(struct tty_struct *tty)
2562{
2563 struct gsm_dlci *dlci = tty->driver_data;
2564 tty_port_hangup(&dlci->port);
2565 gsm_dlci_begin_close(dlci);
2566}
2567
2568static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
2569 int len)
2570{
2571 struct gsm_dlci *dlci = tty->driver_data;
2572 /* Stuff the bytes into the fifo queue */
2573 int sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
2574 /* Need to kick the channel */
2575 gsm_dlci_data_kick(dlci);
2576 return sent;
2577}
2578
2579static int gsmtty_write_room(struct tty_struct *tty)
2580{
2581 struct gsm_dlci *dlci = tty->driver_data;
2582 return TX_SIZE - kfifo_len(dlci->fifo);
2583}
2584
2585static int gsmtty_chars_in_buffer(struct tty_struct *tty)
2586{
2587 struct gsm_dlci *dlci = tty->driver_data;
2588 return kfifo_len(dlci->fifo);
2589}
2590
2591static void gsmtty_flush_buffer(struct tty_struct *tty)
2592{
2593 struct gsm_dlci *dlci = tty->driver_data;
2594 /* Caution needed: If we implement reliable transport classes
2595 then the data being transmitted can't simply be junked once
2596 it has first hit the stack. Until then we can just blow it
2597 away */
2598 kfifo_reset(dlci->fifo);
2599 /* Need to unhook this DLCI from the transmit queue logic */
2600}
2601
2602static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
2603{
2604 /* The FIFO handles the queue so the kernel will do the right
2605 thing waiting on chars_in_buffer before calling us. No work
2606 to do here */
2607}
2608
2609static int gsmtty_tiocmget(struct tty_struct *tty, struct file *filp)
2610{
2611 struct gsm_dlci *dlci = tty->driver_data;
2612 return dlci->modem_rx;
2613}
2614
2615static int gsmtty_tiocmset(struct tty_struct *tty, struct file *filp,
2616 unsigned int set, unsigned int clear)
2617{
2618 struct gsm_dlci *dlci = tty->driver_data;
2619 unsigned int modem_tx = dlci->modem_tx;
2620
2621 modem_tx &= clear;
2622 modem_tx |= set;
2623
2624 if (modem_tx != dlci->modem_tx) {
2625 dlci->modem_tx = modem_tx;
2626 return gsmtty_modem_update(dlci, 0);
2627 }
2628 return 0;
2629}
2630
2631
2632static int gsmtty_ioctl(struct tty_struct *tty, struct file *filp,
2633 unsigned int cmd, unsigned long arg)
2634{
2635 return -ENOIOCTLCMD;
2636}
2637
2638static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
2639{
2640 /* For the moment its fixed. In actual fact the speed information
2641 for the virtual channel can be propogated in both directions by
2642 the RPN control message. This however rapidly gets nasty as we
2643 then have to remap modem signals each way according to whether
2644 our virtual cable is null modem etc .. */
2645 tty_termios_copy_hw(tty->termios, old);
2646}
2647
2648static void gsmtty_throttle(struct tty_struct *tty)
2649{
2650 struct gsm_dlci *dlci = tty->driver_data;
2651 if (tty->termios->c_cflag & CRTSCTS)
2652 dlci->modem_tx &= ~TIOCM_DTR;
2653 dlci->throttled = 1;
2654 /* Send an MSC with DTR cleared */
2655 gsmtty_modem_update(dlci, 0);
2656}
2657
2658static void gsmtty_unthrottle(struct tty_struct *tty)
2659{
2660 struct gsm_dlci *dlci = tty->driver_data;
2661 if (tty->termios->c_cflag & CRTSCTS)
2662 dlci->modem_tx |= TIOCM_DTR;
2663 dlci->throttled = 0;
2664 /* Send an MSC with DTR set */
2665 gsmtty_modem_update(dlci, 0);
2666}
2667
2668static int gsmtty_break_ctl(struct tty_struct *tty, int state)
2669{
2670 struct gsm_dlci *dlci = tty->driver_data;
2671 int encode = 0; /* Off */
2672
2673 if (state == -1) /* "On indefinitely" - we can't encode this
2674 properly */
2675 encode = 0x0F;
2676 else if (state > 0) {
2677 encode = state / 200; /* mS to encoding */
2678 if (encode > 0x0F)
2679 encode = 0x0F; /* Best effort */
2680 }
2681 return gsmtty_modem_update(dlci, encode);
2682}
2683
2684static struct tty_driver *gsm_tty_driver;
2685
2686/* Virtual ttys for the demux */
2687static const struct tty_operations gsmtty_ops = {
2688 .open = gsmtty_open,
2689 .close = gsmtty_close,
2690 .write = gsmtty_write,
2691 .write_room = gsmtty_write_room,
2692 .chars_in_buffer = gsmtty_chars_in_buffer,
2693 .flush_buffer = gsmtty_flush_buffer,
2694 .ioctl = gsmtty_ioctl,
2695 .throttle = gsmtty_throttle,
2696 .unthrottle = gsmtty_unthrottle,
2697 .set_termios = gsmtty_set_termios,
2698 .hangup = gsmtty_hangup,
2699 .wait_until_sent = gsmtty_wait_until_sent,
2700 .tiocmget = gsmtty_tiocmget,
2701 .tiocmset = gsmtty_tiocmset,
2702 .break_ctl = gsmtty_break_ctl,
2703};
2704
2705
2706
2707static int __init gsm_init(void)
2708{
2709 /* Fill in our line protocol discipline, and register it */
2710 int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet);
2711 if (status != 0) {
2712 printk(KERN_ERR "n_gsm: can't register line discipline (err = %d)\n", status);
2713 return status;
2714 }
2715
2716 gsm_tty_driver = alloc_tty_driver(256);
2717 if (!gsm_tty_driver) {
2718 tty_unregister_ldisc(N_GSM0710);
2719 printk(KERN_ERR "gsm_init: tty allocation failed.\n");
2720 return -EINVAL;
2721 }
2722 gsm_tty_driver->owner = THIS_MODULE;
2723 gsm_tty_driver->driver_name = "gsmtty";
2724 gsm_tty_driver->name = "gsmtty";
2725 gsm_tty_driver->major = 0; /* Dynamic */
2726 gsm_tty_driver->minor_start = 0;
2727 gsm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
2728 gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
2729 gsm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
2730 | TTY_DRIVER_HARDWARE_BREAK;
2731 gsm_tty_driver->init_termios = tty_std_termios;
2732 /* Fixme */
2733 gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
2734 tty_set_operations(gsm_tty_driver, &gsmtty_ops);
2735
2736 spin_lock_init(&gsm_mux_lock);
2737
2738 if (tty_register_driver(gsm_tty_driver)) {
2739 put_tty_driver(gsm_tty_driver);
2740 tty_unregister_ldisc(N_GSM0710);
2741 printk(KERN_ERR "gsm_init: tty registration failed.\n");
2742 return -EBUSY;
2743 }
2744 printk(KERN_INFO "gsm_init: loaded as %d,%d.\n", gsm_tty_driver->major, gsm_tty_driver->minor_start);
2745 return 0;
2746}
2747
2748static void __exit gsm_exit(void)
2749{
2750 int status = tty_unregister_ldisc(N_GSM0710);
2751 if (status != 0)
2752 printk(KERN_ERR "n_gsm: can't unregister line discipline (err = %d)\n", status);
2753 tty_unregister_driver(gsm_tty_driver);
2754 put_tty_driver(gsm_tty_driver);
2755 printk(KERN_INFO "gsm_init: unloaded.\n");
2756}
2757
2758module_init(gsm_init);
2759module_exit(gsm_exit);
2760
2761
2762MODULE_LICENSE("GPL");
2763MODULE_ALIAS_LDISC(N_GSM0710);
diff --git a/drivers/char/serial167.c b/drivers/char/serial167.c
index 78a62ebe75c7..ecbe479c7d68 100644
--- a/drivers/char/serial167.c
+++ b/drivers/char/serial167.c
@@ -176,23 +176,6 @@ static void config_setup(struct cyclades_port *);
176static void show_status(int); 176static void show_status(int);
177#endif 177#endif
178 178
179#ifdef CONFIG_REMOTE_DEBUG
180static void debug_setup(void);
181void queueDebugChar(int c);
182int getDebugChar(void);
183
184#define DEBUG_PORT 1
185#define DEBUG_LEN 256
186
187typedef struct {
188 int in;
189 int out;
190 unsigned char buf[DEBUG_LEN];
191} debugq;
192
193debugq debugiq;
194#endif
195
196/* 179/*
197 * I have my own version of udelay(), as it is needed when initialising 180 * I have my own version of udelay(), as it is needed when initialising
198 * the chip, before the delay loop has been calibrated. Should probably 181 * the chip, before the delay loop has been calibrated. Should probably
@@ -515,11 +498,6 @@ static irqreturn_t cd2401_tx_interrupt(int irq, void *dev_id)
515 /* determine the channel and change to that context */ 498 /* determine the channel and change to that context */
516 channel = (u_short) (base_addr[CyLICR] >> 2); 499 channel = (u_short) (base_addr[CyLICR] >> 2);
517 500
518#ifdef CONFIG_REMOTE_DEBUG
519 if (channel == DEBUG_PORT) {
520 panic("TxInt on debug port!!!");
521 }
522#endif
523 /* validate the port number (as configured and open) */ 501 /* validate the port number (as configured and open) */
524 if ((channel < 0) || (NR_PORTS <= channel)) { 502 if ((channel < 0) || (NR_PORTS <= channel)) {
525 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy); 503 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
@@ -634,14 +612,6 @@ static irqreturn_t cd2401_rx_interrupt(int irq, void *dev_id)
634 info->last_active = jiffies; 612 info->last_active = jiffies;
635 save_cnt = char_count = base_addr[CyRFOC]; 613 save_cnt = char_count = base_addr[CyRFOC];
636 614
637#ifdef CONFIG_REMOTE_DEBUG
638 if (channel == DEBUG_PORT) {
639 while (char_count--) {
640 data = base_addr[CyRDR];
641 queueDebugChar(data);
642 }
643 } else
644#endif
645 /* if there is nowhere to put the data, discard it */ 615 /* if there is nowhere to put the data, discard it */
646 if (info->tty == 0) { 616 if (info->tty == 0) {
647 while (char_count--) { 617 while (char_count--) {
@@ -2195,9 +2165,7 @@ static int __init serial167_init(void)
2195 port_num++; 2165 port_num++;
2196 info++; 2166 info++;
2197 } 2167 }
2198#ifdef CONFIG_REMOTE_DEBUG 2168
2199 debug_setup();
2200#endif
2201 ret = request_irq(MVME167_IRQ_SER_ERR, cd2401_rxerr_interrupt, 0, 2169 ret = request_irq(MVME167_IRQ_SER_ERR, cd2401_rxerr_interrupt, 0,
2202 "cd2401_errors", cd2401_rxerr_interrupt); 2170 "cd2401_errors", cd2401_rxerr_interrupt);
2203 if (ret) { 2171 if (ret) {
@@ -2518,193 +2486,4 @@ static int __init serial167_console_init(void)
2518 2486
2519console_initcall(serial167_console_init); 2487console_initcall(serial167_console_init);
2520 2488
2521#ifdef CONFIG_REMOTE_DEBUG
2522void putDebugChar(int c)
2523{
2524 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2525 unsigned long flags;
2526 volatile u_char sink;
2527 u_char ier;
2528 int port;
2529
2530 local_irq_save(flags);
2531
2532 /* Ensure transmitter is enabled! */
2533
2534 port = DEBUG_PORT;
2535 base_addr[CyCAR] = (u_char) port;
2536 while (base_addr[CyCCR])
2537 ;
2538 base_addr[CyCCR] = CyENB_XMTR;
2539
2540 ier = base_addr[CyIER];
2541 base_addr[CyIER] = CyTxMpty;
2542
2543 while (1) {
2544 if (pcc2chip[PccSCCTICR] & 0x20) {
2545 /* We have a Tx int. Acknowledge it */
2546 sink = pcc2chip[PccTPIACKR];
2547 if ((base_addr[CyLICR] >> 2) == port) {
2548 base_addr[CyTDR] = c;
2549 base_addr[CyTEOIR] = 0;
2550 break;
2551 } else
2552 base_addr[CyTEOIR] = CyNOTRANS;
2553 }
2554 }
2555
2556 base_addr[CyIER] = ier;
2557
2558 local_irq_restore(flags);
2559}
2560
2561int getDebugChar()
2562{
2563 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2564 unsigned long flags;
2565 volatile u_char sink;
2566 u_char ier;
2567 int port;
2568 int i, c;
2569
2570 i = debugiq.out;
2571 if (i != debugiq.in) {
2572 c = debugiq.buf[i];
2573 if (++i == DEBUG_LEN)
2574 i = 0;
2575 debugiq.out = i;
2576 return c;
2577 }
2578 /* OK, nothing in queue, wait in poll loop */
2579
2580 local_irq_save(flags);
2581
2582 /* Ensure receiver is enabled! */
2583
2584 port = DEBUG_PORT;
2585 base_addr[CyCAR] = (u_char) port;
2586#if 0
2587 while (base_addr[CyCCR])
2588 ;
2589 base_addr[CyCCR] = CyENB_RCVR;
2590#endif
2591 ier = base_addr[CyIER];
2592 base_addr[CyIER] = CyRxData;
2593
2594 while (1) {
2595 if (pcc2chip[PccSCCRICR] & 0x20) {
2596 /* We have a Rx int. Acknowledge it */
2597 sink = pcc2chip[PccRPIACKR];
2598 if ((base_addr[CyLICR] >> 2) == port) {
2599 int cnt = base_addr[CyRFOC];
2600 while (cnt-- > 0) {
2601 c = base_addr[CyRDR];
2602 if (c == 0)
2603 printk
2604 ("!! debug char is null (cnt=%d) !!",
2605 cnt);
2606 else
2607 queueDebugChar(c);
2608 }
2609 base_addr[CyREOIR] = 0;
2610 i = debugiq.out;
2611 if (i == debugiq.in)
2612 panic("Debug input queue empty!");
2613 c = debugiq.buf[i];
2614 if (++i == DEBUG_LEN)
2615 i = 0;
2616 debugiq.out = i;
2617 break;
2618 } else
2619 base_addr[CyREOIR] = CyNOTRANS;
2620 }
2621 }
2622
2623 base_addr[CyIER] = ier;
2624
2625 local_irq_restore(flags);
2626
2627 return (c);
2628}
2629
2630void queueDebugChar(int c)
2631{
2632 int i;
2633
2634 i = debugiq.in;
2635 debugiq.buf[i] = c;
2636 if (++i == DEBUG_LEN)
2637 i = 0;
2638 if (i != debugiq.out)
2639 debugiq.in = i;
2640}
2641
2642static void debug_setup()
2643{
2644 unsigned long flags;
2645 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2646 int i, cflag;
2647
2648 cflag = B19200;
2649
2650 local_irq_save(flags);
2651
2652 for (i = 0; i < 4; i++) {
2653 base_addr[CyCAR] = i;
2654 base_addr[CyLICR] = i << 2;
2655 }
2656
2657 debugiq.in = debugiq.out = 0;
2658
2659 base_addr[CyCAR] = DEBUG_PORT;
2660
2661 /* baud rate */
2662 i = cflag & CBAUD;
2663
2664 base_addr[CyIER] = 0;
2665
2666 base_addr[CyCMR] = CyASYNC;
2667 base_addr[CyLICR] = DEBUG_PORT << 2;
2668 base_addr[CyLIVR] = 0x5c;
2669
2670 /* tx and rx baud rate */
2671
2672 base_addr[CyTCOR] = baud_co[i];
2673 base_addr[CyTBPR] = baud_bpr[i];
2674 base_addr[CyRCOR] = baud_co[i] >> 5;
2675 base_addr[CyRBPR] = baud_bpr[i];
2676
2677 /* set line characteristics according configuration */
2678
2679 base_addr[CySCHR1] = 0;
2680 base_addr[CySCHR2] = 0;
2681 base_addr[CySCRL] = 0;
2682 base_addr[CySCRH] = 0;
2683 base_addr[CyCOR1] = Cy_8_BITS | CyPARITY_NONE;
2684 base_addr[CyCOR2] = 0;
2685 base_addr[CyCOR3] = Cy_1_STOP;
2686 base_addr[CyCOR4] = baud_cor4[i];
2687 base_addr[CyCOR5] = 0;
2688 base_addr[CyCOR6] = 0;
2689 base_addr[CyCOR7] = 0;
2690
2691 write_cy_cmd(base_addr, CyINIT_CHAN);
2692 write_cy_cmd(base_addr, CyENB_RCVR);
2693
2694 base_addr[CyCAR] = DEBUG_PORT; /* !!! Is this needed? */
2695
2696 base_addr[CyRTPRL] = 2;
2697 base_addr[CyRTPRH] = 0;
2698
2699 base_addr[CyMSVR1] = CyRTS;
2700 base_addr[CyMSVR2] = CyDTR;
2701
2702 base_addr[CyIER] = CyRxData;
2703
2704 local_irq_restore(flags);
2705
2706} /* debug_setup */
2707
2708#endif
2709
2710MODULE_LICENSE("GPL"); 2489MODULE_LICENSE("GPL");
diff --git a/drivers/char/tty_buffer.c b/drivers/char/tty_buffer.c
index 7ee52164d474..cc1e9850d655 100644
--- a/drivers/char/tty_buffer.c
+++ b/drivers/char/tty_buffer.c
@@ -238,7 +238,7 @@ EXPORT_SYMBOL_GPL(tty_buffer_request_room);
238 * @size: size 238 * @size: size
239 * 239 *
240 * Queue a series of bytes to the tty buffering. All the characters 240 * Queue a series of bytes to the tty buffering. All the characters
241 * passed are marked as without error. Returns the number added. 241 * passed are marked with the supplied flag. Returns the number added.
242 * 242 *
243 * Locking: Called functions may take tty->buf.lock 243 * Locking: Called functions may take tty->buf.lock
244 */ 244 */
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index 302836a80693..8b23165bc5dc 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -1423,8 +1423,8 @@ config SERIAL_SC26XX_CONSOLE
1423 Support for Console on SC2681/SC2692 serial ports. 1423 Support for Console on SC2681/SC2692 serial ports.
1424 1424
1425config SERIAL_BFIN_SPORT 1425config SERIAL_BFIN_SPORT
1426 tristate "Blackfin SPORT emulate UART (EXPERIMENTAL)" 1426 tristate "Blackfin SPORT emulate UART"
1427 depends on BLACKFIN && EXPERIMENTAL 1427 depends on BLACKFIN
1428 select SERIAL_CORE 1428 select SERIAL_CORE
1429 help 1429 help
1430 Enable SPORT emulate UART on Blackfin series. 1430 Enable SPORT emulate UART on Blackfin series.
@@ -1439,28 +1439,52 @@ config SERIAL_BFIN_SPORT_CONSOLE
1439 1439
1440config SERIAL_BFIN_SPORT0_UART 1440config SERIAL_BFIN_SPORT0_UART
1441 bool "Enable UART over SPORT0" 1441 bool "Enable UART over SPORT0"
1442 depends on SERIAL_BFIN_SPORT && !(BF542 || BF542M || BF544 || BF544M) 1442 depends on SERIAL_BFIN_SPORT && !(BF542 || BF544)
1443 help 1443 help
1444 Enable UART over SPORT0 1444 Enable UART over SPORT0
1445 1445
1446config SERIAL_BFIN_SPORT0_UART_CTSRTS
1447 bool "Enable UART over SPORT0 hardware flow control"
1448 depends on SERIAL_BFIN_SPORT0_UART
1449 help
1450 Enable hardware flow control in the driver.
1451
1446config SERIAL_BFIN_SPORT1_UART 1452config SERIAL_BFIN_SPORT1_UART
1447 bool "Enable UART over SPORT1" 1453 bool "Enable UART over SPORT1"
1448 depends on SERIAL_BFIN_SPORT 1454 depends on SERIAL_BFIN_SPORT
1449 help 1455 help
1450 Enable UART over SPORT1 1456 Enable UART over SPORT1
1451 1457
1458config SERIAL_BFIN_SPORT1_UART_CTSRTS
1459 bool "Enable UART over SPORT1 hardware flow control"
1460 depends on SERIAL_BFIN_SPORT1_UART
1461 help
1462 Enable hardware flow control in the driver.
1463
1452config SERIAL_BFIN_SPORT2_UART 1464config SERIAL_BFIN_SPORT2_UART
1453 bool "Enable UART over SPORT2" 1465 bool "Enable UART over SPORT2"
1454 depends on SERIAL_BFIN_SPORT && (BF54x || BF538 || BF539) 1466 depends on SERIAL_BFIN_SPORT && (BF54x || BF538 || BF539)
1455 help 1467 help
1456 Enable UART over SPORT2 1468 Enable UART over SPORT2
1457 1469
1470config SERIAL_BFIN_SPORT2_UART_CTSRTS
1471 bool "Enable UART over SPORT2 hardware flow control"
1472 depends on SERIAL_BFIN_SPORT2_UART
1473 help
1474 Enable hardware flow control in the driver.
1475
1458config SERIAL_BFIN_SPORT3_UART 1476config SERIAL_BFIN_SPORT3_UART
1459 bool "Enable UART over SPORT3" 1477 bool "Enable UART over SPORT3"
1460 depends on SERIAL_BFIN_SPORT && (BF54x || BF538 || BF539) 1478 depends on SERIAL_BFIN_SPORT && (BF54x || BF538 || BF539)
1461 help 1479 help
1462 Enable UART over SPORT3 1480 Enable UART over SPORT3
1463 1481
1482config SERIAL_BFIN_SPORT3_UART_CTSRTS
1483 bool "Enable UART over SPORT3 hardware flow control"
1484 depends on SERIAL_BFIN_SPORT3_UART
1485 help
1486 Enable hardware flow control in the driver.
1487
1464config SERIAL_TIMBERDALE 1488config SERIAL_TIMBERDALE
1465 tristate "Support for timberdale UART" 1489 tristate "Support for timberdale UART"
1466 select SERIAL_CORE 1490 select SERIAL_CORE
@@ -1499,4 +1523,56 @@ config SERIAL_GRLIB_GAISLER_APBUART_CONSOLE
1499 help 1523 help
1500 Support for running a console on the GRLIB APBUART 1524 Support for running a console on the GRLIB APBUART
1501 1525
1526config SERIAL_ALTERA_JTAGUART
1527 tristate "Altera JTAG UART support"
1528 select SERIAL_CORE
1529 help
1530 This driver supports the Altera JTAG UART port.
1531
1532config SERIAL_ALTERA_JTAGUART_CONSOLE
1533 bool "Altera JTAG UART console support"
1534 depends on SERIAL_ALTERA_JTAGUART=y
1535 select SERIAL_CORE_CONSOLE
1536 help
1537 Enable a Altera JTAG UART port to be the system console.
1538
1539config SERIAL_ALTERA_JTAGUART_CONSOLE_BYPASS
1540 bool "Bypass output when no connection"
1541 depends on SERIAL_ALTERA_JTAGUART_CONSOLE
1542 select SERIAL_CORE_CONSOLE
1543 help
1544 Bypass console output and keep going even if there is no
1545 JTAG terminal connection with the host.
1546
1547config SERIAL_ALTERA_UART
1548 tristate "Altera UART support"
1549 select SERIAL_CORE
1550 help
1551 This driver supports the Altera softcore UART port.
1552
1553config SERIAL_ALTERA_UART_MAXPORTS
1554 int "Maximum number of Altera UART ports"
1555 depends on SERIAL_ALTERA_UART
1556 default 4
1557 help
1558 This setting lets you define the maximum number of the Altera
1559 UART ports. The usual default varies from board to board, and
1560 this setting is a way of catering for that.
1561
1562config SERIAL_ALTERA_UART_BAUDRATE
1563 int "Default baudrate for Altera UART ports"
1564 depends on SERIAL_ALTERA_UART
1565 default 115200
1566 help
1567 This setting lets you define what the default baudrate is for the
1568 Altera UART ports. The usual default varies from board to board,
1569 and this setting is a way of catering for that.
1570
1571config SERIAL_ALTERA_UART_CONSOLE
1572 bool "Altera UART console support"
1573 depends on SERIAL_ALTERA_UART=y
1574 select SERIAL_CORE_CONSOLE
1575 help
1576 Enable a Altera UART port to be the system console.
1577
1502endmenu 1578endmenu
diff --git a/drivers/serial/Makefile b/drivers/serial/Makefile
index 328f107346c4..208a85572c32 100644
--- a/drivers/serial/Makefile
+++ b/drivers/serial/Makefile
@@ -82,3 +82,5 @@ obj-$(CONFIG_KGDB_SERIAL_CONSOLE) += kgdboc.o
82obj-$(CONFIG_SERIAL_QE) += ucc_uart.o 82obj-$(CONFIG_SERIAL_QE) += ucc_uart.o
83obj-$(CONFIG_SERIAL_TIMBERDALE) += timbuart.o 83obj-$(CONFIG_SERIAL_TIMBERDALE) += timbuart.o
84obj-$(CONFIG_SERIAL_GRLIB_GAISLER_APBUART) += apbuart.o 84obj-$(CONFIG_SERIAL_GRLIB_GAISLER_APBUART) += apbuart.o
85obj-$(CONFIG_SERIAL_ALTERA_JTAGUART) += altera_jtaguart.o
86obj-$(CONFIG_SERIAL_ALTERA_UART) += altera_uart.o
diff --git a/drivers/serial/altera_jtaguart.c b/drivers/serial/altera_jtaguart.c
new file mode 100644
index 000000000000..f9b49b5ff5e1
--- /dev/null
+++ b/drivers/serial/altera_jtaguart.c
@@ -0,0 +1,504 @@
1/*
2 * altera_jtaguart.c -- Altera JTAG UART driver
3 *
4 * Based on mcf.c -- Freescale ColdFire UART driver
5 *
6 * (C) Copyright 2003-2007, Greg Ungerer <gerg@snapgear.com>
7 * (C) Copyright 2008, Thomas Chou <thomas@wytron.com.tw>
8 * (C) Copyright 2010, Tobias Klauser <tklauser@distanz.ch>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 */
15
16#include <linux/kernel.h>
17#include <linux/init.h>
18#include <linux/interrupt.h>
19#include <linux/module.h>
20#include <linux/console.h>
21#include <linux/tty.h>
22#include <linux/tty_flip.h>
23#include <linux/serial.h>
24#include <linux/serial_core.h>
25#include <linux/platform_device.h>
26#include <linux/io.h>
27#include <linux/altera_jtaguart.h>
28
29#define DRV_NAME "altera_jtaguart"
30
31/*
32 * Altera JTAG UART register definitions according to the Altera JTAG UART
33 * datasheet: http://www.altera.com/literature/hb/nios2/n2cpu_nii51009.pdf
34 */
35
36#define ALTERA_JTAGUART_SIZE 8
37
38#define ALTERA_JTAGUART_DATA_REG 0
39
40#define ALTERA_JTAGUART_DATA_DATA_MSK 0x000000FF
41#define ALTERA_JTAGUART_DATA_RVALID_MSK 0x00008000
42#define ALTERA_JTAGUART_DATA_RAVAIL_MSK 0xFFFF0000
43#define ALTERA_JTAGUART_DATA_RAVAIL_OFF 16
44
45#define ALTERA_JTAGUART_CONTROL_REG 4
46
47#define ALTERA_JTAGUART_CONTROL_RE_MSK 0x00000001
48#define ALTERA_JTAGUART_CONTROL_WE_MSK 0x00000002
49#define ALTERA_JTAGUART_CONTROL_RI_MSK 0x00000100
50#define ALTERA_JTAGUART_CONTROL_RI_OFF 8
51#define ALTERA_JTAGUART_CONTROL_WI_MSK 0x00000200
52#define ALTERA_JTAGUART_CONTROL_AC_MSK 0x00000400
53#define ALTERA_JTAGUART_CONTROL_WSPACE_MSK 0xFFFF0000
54#define ALTERA_JTAGUART_CONTROL_WSPACE_OFF 16
55
56/*
57 * Local per-uart structure.
58 */
59struct altera_jtaguart {
60 struct uart_port port;
61 unsigned int sigs; /* Local copy of line sigs */
62 unsigned long imr; /* Local IMR mirror */
63};
64
65static unsigned int altera_jtaguart_tx_empty(struct uart_port *port)
66{
67 return (readl(port->membase + ALTERA_JTAGUART_CONTROL_REG) &
68 ALTERA_JTAGUART_CONTROL_WSPACE_MSK) ? TIOCSER_TEMT : 0;
69}
70
71static unsigned int altera_jtaguart_get_mctrl(struct uart_port *port)
72{
73 return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
74}
75
76static void altera_jtaguart_set_mctrl(struct uart_port *port, unsigned int sigs)
77{
78}
79
80static void altera_jtaguart_start_tx(struct uart_port *port)
81{
82 struct altera_jtaguart *pp =
83 container_of(port, struct altera_jtaguart, port);
84
85 pp->imr |= ALTERA_JTAGUART_CONTROL_WE_MSK;
86 writel(pp->imr, port->membase + ALTERA_JTAGUART_CONTROL_REG);
87}
88
89static void altera_jtaguart_stop_tx(struct uart_port *port)
90{
91 struct altera_jtaguart *pp =
92 container_of(port, struct altera_jtaguart, port);
93
94 pp->imr &= ~ALTERA_JTAGUART_CONTROL_WE_MSK;
95 writel(pp->imr, port->membase + ALTERA_JTAGUART_CONTROL_REG);
96}
97
98static void altera_jtaguart_stop_rx(struct uart_port *port)
99{
100 struct altera_jtaguart *pp =
101 container_of(port, struct altera_jtaguart, port);
102
103 pp->imr &= ~ALTERA_JTAGUART_CONTROL_RE_MSK;
104 writel(pp->imr, port->membase + ALTERA_JTAGUART_CONTROL_REG);
105}
106
107static void altera_jtaguart_break_ctl(struct uart_port *port, int break_state)
108{
109}
110
111static void altera_jtaguart_enable_ms(struct uart_port *port)
112{
113}
114
115static void altera_jtaguart_set_termios(struct uart_port *port,
116 struct ktermios *termios,
117 struct ktermios *old)
118{
119 /* Just copy the old termios settings back */
120 if (old)
121 tty_termios_copy_hw(termios, old);
122}
123
124static void altera_jtaguart_rx_chars(struct altera_jtaguart *pp)
125{
126 struct uart_port *port = &pp->port;
127 unsigned char ch, flag;
128 unsigned long status;
129
130 while ((status = readl(port->membase + ALTERA_JTAGUART_DATA_REG)) &
131 ALTERA_JTAGUART_DATA_RVALID_MSK) {
132 ch = status & ALTERA_JTAGUART_DATA_DATA_MSK;
133 flag = TTY_NORMAL;
134 port->icount.rx++;
135
136 if (uart_handle_sysrq_char(port, ch))
137 continue;
138 uart_insert_char(port, 0, 0, ch, flag);
139 }
140
141 tty_flip_buffer_push(port->state->port.tty);
142}
143
144static void altera_jtaguart_tx_chars(struct altera_jtaguart *pp)
145{
146 struct uart_port *port = &pp->port;
147 struct circ_buf *xmit = &port->state->xmit;
148 unsigned int pending, count;
149
150 if (port->x_char) {
151 /* Send special char - probably flow control */
152 writel(port->x_char, port->membase + ALTERA_JTAGUART_DATA_REG);
153 port->x_char = 0;
154 port->icount.tx++;
155 return;
156 }
157
158 pending = uart_circ_chars_pending(xmit);
159 if (pending > 0) {
160 count = (readl(port->membase + ALTERA_JTAGUART_CONTROL_REG) &
161 ALTERA_JTAGUART_CONTROL_WSPACE_MSK) >>
162 ALTERA_JTAGUART_CONTROL_WSPACE_OFF;
163 if (count > pending)
164 count = pending;
165 if (count > 0) {
166 pending -= count;
167 while (count--) {
168 writel(xmit->buf[xmit->tail],
169 port->membase + ALTERA_JTAGUART_DATA_REG);
170 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
171 port->icount.tx++;
172 }
173 if (pending < WAKEUP_CHARS)
174 uart_write_wakeup(port);
175 }
176 }
177
178 if (pending == 0) {
179 pp->imr &= ~ALTERA_JTAGUART_CONTROL_WE_MSK;
180 writel(pp->imr, port->membase + ALTERA_JTAGUART_CONTROL_REG);
181 }
182}
183
184static irqreturn_t altera_jtaguart_interrupt(int irq, void *data)
185{
186 struct uart_port *port = data;
187 struct altera_jtaguart *pp =
188 container_of(port, struct altera_jtaguart, port);
189 unsigned int isr;
190
191 isr = (readl(port->membase + ALTERA_JTAGUART_CONTROL_REG) >>
192 ALTERA_JTAGUART_CONTROL_RI_OFF) & pp->imr;
193
194 spin_lock(&port->lock);
195
196 if (isr & ALTERA_JTAGUART_CONTROL_RE_MSK)
197 altera_jtaguart_rx_chars(pp);
198 if (isr & ALTERA_JTAGUART_CONTROL_WE_MSK)
199 altera_jtaguart_tx_chars(pp);
200
201 spin_unlock(&port->lock);
202
203 return IRQ_RETVAL(isr);
204}
205
206static void altera_jtaguart_config_port(struct uart_port *port, int flags)
207{
208 port->type = PORT_ALTERA_JTAGUART;
209
210 /* Clear mask, so no surprise interrupts. */
211 writel(0, port->membase + ALTERA_JTAGUART_CONTROL_REG);
212}
213
214static int altera_jtaguart_startup(struct uart_port *port)
215{
216 struct altera_jtaguart *pp =
217 container_of(port, struct altera_jtaguart, port);
218 unsigned long flags;
219 int ret;
220
221 ret = request_irq(port->irq, altera_jtaguart_interrupt, IRQF_DISABLED,
222 DRV_NAME, port);
223 if (ret) {
224 pr_err(DRV_NAME ": unable to attach Altera JTAG UART %d "
225 "interrupt vector=%d\n", port->line, port->irq);
226 return ret;
227 }
228
229 spin_lock_irqsave(&port->lock, flags);
230
231 /* Enable RX interrupts now */
232 pp->imr = ALTERA_JTAGUART_CONTROL_RE_MSK;
233 writel(pp->imr, port->membase + ALTERA_JTAGUART_CONTROL_REG);
234
235 spin_unlock_irqrestore(&port->lock, flags);
236
237 return 0;
238}
239
240static void altera_jtaguart_shutdown(struct uart_port *port)
241{
242 struct altera_jtaguart *pp =
243 container_of(port, struct altera_jtaguart, port);
244 unsigned long flags;
245
246 spin_lock_irqsave(&port->lock, flags);
247
248 /* Disable all interrupts now */
249 pp->imr = 0;
250 writel(pp->imr, port->membase + ALTERA_JTAGUART_CONTROL_REG);
251
252 spin_unlock_irqrestore(&port->lock, flags);
253
254 free_irq(port->irq, port);
255}
256
257static const char *altera_jtaguart_type(struct uart_port *port)
258{
259 return (port->type == PORT_ALTERA_JTAGUART) ? "Altera JTAG UART" : NULL;
260}
261
262static int altera_jtaguart_request_port(struct uart_port *port)
263{
264 /* UARTs always present */
265 return 0;
266}
267
268static void altera_jtaguart_release_port(struct uart_port *port)
269{
270 /* Nothing to release... */
271}
272
273static int altera_jtaguart_verify_port(struct uart_port *port,
274 struct serial_struct *ser)
275{
276 if (ser->type != PORT_UNKNOWN && ser->type != PORT_ALTERA_JTAGUART)
277 return -EINVAL;
278 return 0;
279}
280
281/*
282 * Define the basic serial functions we support.
283 */
284static struct uart_ops altera_jtaguart_ops = {
285 .tx_empty = altera_jtaguart_tx_empty,
286 .get_mctrl = altera_jtaguart_get_mctrl,
287 .set_mctrl = altera_jtaguart_set_mctrl,
288 .start_tx = altera_jtaguart_start_tx,
289 .stop_tx = altera_jtaguart_stop_tx,
290 .stop_rx = altera_jtaguart_stop_rx,
291 .enable_ms = altera_jtaguart_enable_ms,
292 .break_ctl = altera_jtaguart_break_ctl,
293 .startup = altera_jtaguart_startup,
294 .shutdown = altera_jtaguart_shutdown,
295 .set_termios = altera_jtaguart_set_termios,
296 .type = altera_jtaguart_type,
297 .request_port = altera_jtaguart_request_port,
298 .release_port = altera_jtaguart_release_port,
299 .config_port = altera_jtaguart_config_port,
300 .verify_port = altera_jtaguart_verify_port,
301};
302
303#define ALTERA_JTAGUART_MAXPORTS 1
304static struct altera_jtaguart altera_jtaguart_ports[ALTERA_JTAGUART_MAXPORTS];
305
306#if defined(CONFIG_SERIAL_ALTERA_JTAGUART_CONSOLE)
307
308int __init early_altera_jtaguart_setup(struct altera_jtaguart_platform_uart
309 *platp)
310{
311 struct uart_port *port;
312 int i;
313
314 for (i = 0; i < ALTERA_JTAGUART_MAXPORTS && platp[i].mapbase; i++) {
315 port = &altera_jtaguart_ports[i].port;
316
317 port->line = i;
318 port->type = PORT_ALTERA_JTAGUART;
319 port->mapbase = platp[i].mapbase;
320 port->membase = ioremap(port->mapbase, ALTERA_JTAGUART_SIZE);
321 port->iotype = SERIAL_IO_MEM;
322 port->irq = platp[i].irq;
323 port->flags = ASYNC_BOOT_AUTOCONF;
324 port->ops = &altera_jtaguart_ops;
325 }
326
327 return 0;
328}
329
330#if defined(CONFIG_SERIAL_ALTERA_JTAGUART_CONSOLE_BYPASS)
331static void altera_jtaguart_console_putc(struct console *co, const char c)
332{
333 struct uart_port *port = &(altera_jtaguart_ports + co->index)->port;
334 unsigned long status;
335 unsigned long flags;
336
337 spin_lock_irqsave(&port->lock, flags);
338 while (((status = readl(port->membase + ALTERA_JTAGUART_CONTROL_REG)) &
339 ALTERA_JTAGUART_CONTROL_WSPACE_MSK) == 0) {
340 if ((status & ALTERA_JTAGUART_CONTROL_AC_MSK) == 0) {
341 spin_unlock_irqrestore(&port->lock, flags);
342 return; /* no connection activity */
343 }
344 spin_unlock_irqrestore(&port->lock, flags);
345 cpu_relax();
346 spin_lock_irqsave(&port->lock, flags);
347 }
348 writel(c, port->membase + ALTERA_JTAGUART_DATA_REG);
349 spin_unlock_irqrestore(&port->lock, flags);
350}
351#else
352static void altera_jtaguart_console_putc(struct console *co, const char c)
353{
354 struct uart_port *port = &(altera_jtaguart_ports + co->index)->port;
355 unsigned long flags;
356
357 spin_lock_irqsave(&port->lock, flags);
358 while ((readl(port->membase + ALTERA_JTAGUART_CONTROL_REG) &
359 ALTERA_JTAGUART_CONTROL_WSPACE_MSK) == 0) {
360 spin_unlock_irqrestore(&port->lock, flags);
361 cpu_relax();
362 spin_lock_irqsave(&port->lock, flags);
363 }
364 writel(c, port->membase + ALTERA_JTAGUART_DATA_REG);
365 spin_unlock_irqrestore(&port->lock, flags);
366}
367#endif
368
369static void altera_jtaguart_console_write(struct console *co, const char *s,
370 unsigned int count)
371{
372 for (; count; count--, s++) {
373 altera_jtaguart_console_putc(co, *s);
374 if (*s == '\n')
375 altera_jtaguart_console_putc(co, '\r');
376 }
377}
378
379static int __init altera_jtaguart_console_setup(struct console *co,
380 char *options)
381{
382 struct uart_port *port;
383
384 if (co->index < 0 || co->index >= ALTERA_JTAGUART_MAXPORTS)
385 return -EINVAL;
386 port = &altera_jtaguart_ports[co->index].port;
387 if (port->membase == 0)
388 return -ENODEV;
389 return 0;
390}
391
392static struct uart_driver altera_jtaguart_driver;
393
394static struct console altera_jtaguart_console = {
395 .name = "ttyJ",
396 .write = altera_jtaguart_console_write,
397 .device = uart_console_device,
398 .setup = altera_jtaguart_console_setup,
399 .flags = CON_PRINTBUFFER,
400 .index = -1,
401 .data = &altera_jtaguart_driver,
402};
403
404static int __init altera_jtaguart_console_init(void)
405{
406 register_console(&altera_jtaguart_console);
407 return 0;
408}
409
410console_initcall(altera_jtaguart_console_init);
411
412#define ALTERA_JTAGUART_CONSOLE (&altera_jtaguart_console)
413
414#else
415
416#define ALTERA_JTAGUART_CONSOLE NULL
417
418#endif /* CONFIG_ALTERA_JTAGUART_CONSOLE */
419
420static struct uart_driver altera_jtaguart_driver = {
421 .owner = THIS_MODULE,
422 .driver_name = "altera_jtaguart",
423 .dev_name = "ttyJ",
424 .major = ALTERA_JTAGUART_MAJOR,
425 .minor = ALTERA_JTAGUART_MINOR,
426 .nr = ALTERA_JTAGUART_MAXPORTS,
427 .cons = ALTERA_JTAGUART_CONSOLE,
428};
429
430static int __devinit altera_jtaguart_probe(struct platform_device *pdev)
431{
432 struct altera_jtaguart_platform_uart *platp = pdev->dev.platform_data;
433 struct uart_port *port;
434 int i;
435
436 for (i = 0; i < ALTERA_JTAGUART_MAXPORTS && platp[i].mapbase; i++) {
437 port = &altera_jtaguart_ports[i].port;
438
439 port->line = i;
440 port->type = PORT_ALTERA_JTAGUART;
441 port->mapbase = platp[i].mapbase;
442 port->membase = ioremap(port->mapbase, ALTERA_JTAGUART_SIZE);
443 port->iotype = SERIAL_IO_MEM;
444 port->irq = platp[i].irq;
445 port->ops = &altera_jtaguart_ops;
446 port->flags = ASYNC_BOOT_AUTOCONF;
447
448 uart_add_one_port(&altera_jtaguart_driver, port);
449 }
450
451 return 0;
452}
453
454static int __devexit altera_jtaguart_remove(struct platform_device *pdev)
455{
456 struct uart_port *port;
457 int i;
458
459 for (i = 0; i < ALTERA_JTAGUART_MAXPORTS; i++) {
460 port = &altera_jtaguart_ports[i].port;
461 if (port)
462 uart_remove_one_port(&altera_jtaguart_driver, port);
463 }
464
465 return 0;
466}
467
468static struct platform_driver altera_jtaguart_platform_driver = {
469 .probe = altera_jtaguart_probe,
470 .remove = __devexit_p(altera_jtaguart_remove),
471 .driver = {
472 .name = DRV_NAME,
473 .owner = THIS_MODULE,
474 },
475};
476
477static int __init altera_jtaguart_init(void)
478{
479 int rc;
480
481 rc = uart_register_driver(&altera_jtaguart_driver);
482 if (rc)
483 return rc;
484 rc = platform_driver_register(&altera_jtaguart_platform_driver);
485 if (rc) {
486 uart_unregister_driver(&altera_jtaguart_driver);
487 return rc;
488 }
489 return 0;
490}
491
492static void __exit altera_jtaguart_exit(void)
493{
494 platform_driver_unregister(&altera_jtaguart_platform_driver);
495 uart_unregister_driver(&altera_jtaguart_driver);
496}
497
498module_init(altera_jtaguart_init);
499module_exit(altera_jtaguart_exit);
500
501MODULE_DESCRIPTION("Altera JTAG UART driver");
502MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>");
503MODULE_LICENSE("GPL");
504MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/serial/altera_uart.c b/drivers/serial/altera_uart.c
new file mode 100644
index 000000000000..bcee156d2f2e
--- /dev/null
+++ b/drivers/serial/altera_uart.c
@@ -0,0 +1,570 @@
1/*
2 * altera_uart.c -- Altera UART driver
3 *
4 * Based on mcf.c -- Freescale ColdFire UART driver
5 *
6 * (C) Copyright 2003-2007, Greg Ungerer <gerg@snapgear.com>
7 * (C) Copyright 2008, Thomas Chou <thomas@wytron.com.tw>
8 * (C) Copyright 2010, Tobias Klauser <tklauser@distanz.ch>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 */
15
16#include <linux/kernel.h>
17#include <linux/init.h>
18#include <linux/interrupt.h>
19#include <linux/module.h>
20#include <linux/console.h>
21#include <linux/tty.h>
22#include <linux/tty_flip.h>
23#include <linux/serial.h>
24#include <linux/serial_core.h>
25#include <linux/platform_device.h>
26#include <linux/io.h>
27#include <linux/altera_uart.h>
28
29#define DRV_NAME "altera_uart"
30
31/*
32 * Altera UART register definitions according to the Nios UART datasheet:
33 * http://www.altera.com/literature/ds/ds_nios_uart.pdf
34 */
35
36#define ALTERA_UART_SIZE 32
37
38#define ALTERA_UART_RXDATA_REG 0
39#define ALTERA_UART_TXDATA_REG 4
40#define ALTERA_UART_STATUS_REG 8
41#define ALTERA_UART_CONTROL_REG 12
42#define ALTERA_UART_DIVISOR_REG 16
43#define ALTERA_UART_EOP_REG 20
44
45#define ALTERA_UART_STATUS_PE_MSK 0x0001 /* parity error */
46#define ALTERA_UART_STATUS_FE_MSK 0x0002 /* framing error */
47#define ALTERA_UART_STATUS_BRK_MSK 0x0004 /* break */
48#define ALTERA_UART_STATUS_ROE_MSK 0x0008 /* RX overrun error */
49#define ALTERA_UART_STATUS_TOE_MSK 0x0010 /* TX overrun error */
50#define ALTERA_UART_STATUS_TMT_MSK 0x0020 /* TX shift register state */
51#define ALTERA_UART_STATUS_TRDY_MSK 0x0040 /* TX ready */
52#define ALTERA_UART_STATUS_RRDY_MSK 0x0080 /* RX ready */
53#define ALTERA_UART_STATUS_E_MSK 0x0100 /* exception condition */
54#define ALTERA_UART_STATUS_DCTS_MSK 0x0400 /* CTS logic-level change */
55#define ALTERA_UART_STATUS_CTS_MSK 0x0800 /* CTS logic state */
56#define ALTERA_UART_STATUS_EOP_MSK 0x1000 /* EOP written/read */
57
58 /* Enable interrupt on... */
59#define ALTERA_UART_CONTROL_PE_MSK 0x0001 /* ...parity error */
60#define ALTERA_UART_CONTROL_FE_MSK 0x0002 /* ...framing error */
61#define ALTERA_UART_CONTROL_BRK_MSK 0x0004 /* ...break */
62#define ALTERA_UART_CONTROL_ROE_MSK 0x0008 /* ...RX overrun */
63#define ALTERA_UART_CONTROL_TOE_MSK 0x0010 /* ...TX overrun */
64#define ALTERA_UART_CONTROL_TMT_MSK 0x0020 /* ...TX shift register empty */
65#define ALTERA_UART_CONTROL_TRDY_MSK 0x0040 /* ...TX ready */
66#define ALTERA_UART_CONTROL_RRDY_MSK 0x0080 /* ...RX ready */
67#define ALTERA_UART_CONTROL_E_MSK 0x0100 /* ...exception*/
68
69#define ALTERA_UART_CONTROL_TRBK_MSK 0x0200 /* TX break */
70#define ALTERA_UART_CONTROL_DCTS_MSK 0x0400 /* Interrupt on CTS change */
71#define ALTERA_UART_CONTROL_RTS_MSK 0x0800 /* RTS signal */
72#define ALTERA_UART_CONTROL_EOP_MSK 0x1000 /* Interrupt on EOP */
73
74/*
75 * Local per-uart structure.
76 */
77struct altera_uart {
78 struct uart_port port;
79 unsigned int sigs; /* Local copy of line sigs */
80 unsigned short imr; /* Local IMR mirror */
81};
82
83static unsigned int altera_uart_tx_empty(struct uart_port *port)
84{
85 return (readl(port->membase + ALTERA_UART_STATUS_REG) &
86 ALTERA_UART_STATUS_TMT_MSK) ? TIOCSER_TEMT : 0;
87}
88
89static unsigned int altera_uart_get_mctrl(struct uart_port *port)
90{
91 struct altera_uart *pp = container_of(port, struct altera_uart, port);
92 unsigned long flags;
93 unsigned int sigs;
94
95 spin_lock_irqsave(&port->lock, flags);
96 sigs =
97 (readl(port->membase + ALTERA_UART_STATUS_REG) &
98 ALTERA_UART_STATUS_CTS_MSK) ? TIOCM_CTS : 0;
99 sigs |= (pp->sigs & TIOCM_RTS);
100 spin_unlock_irqrestore(&port->lock, flags);
101
102 return sigs;
103}
104
105static void altera_uart_set_mctrl(struct uart_port *port, unsigned int sigs)
106{
107 struct altera_uart *pp = container_of(port, struct altera_uart, port);
108 unsigned long flags;
109
110 spin_lock_irqsave(&port->lock, flags);
111 pp->sigs = sigs;
112 if (sigs & TIOCM_RTS)
113 pp->imr |= ALTERA_UART_CONTROL_RTS_MSK;
114 else
115 pp->imr &= ~ALTERA_UART_CONTROL_RTS_MSK;
116 writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
117 spin_unlock_irqrestore(&port->lock, flags);
118}
119
120static void altera_uart_start_tx(struct uart_port *port)
121{
122 struct altera_uart *pp = container_of(port, struct altera_uart, port);
123 unsigned long flags;
124
125 spin_lock_irqsave(&port->lock, flags);
126 pp->imr |= ALTERA_UART_CONTROL_TRDY_MSK;
127 writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
128 spin_unlock_irqrestore(&port->lock, flags);
129}
130
131static void altera_uart_stop_tx(struct uart_port *port)
132{
133 struct altera_uart *pp = container_of(port, struct altera_uart, port);
134 unsigned long flags;
135
136 spin_lock_irqsave(&port->lock, flags);
137 pp->imr &= ~ALTERA_UART_CONTROL_TRDY_MSK;
138 writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
139 spin_unlock_irqrestore(&port->lock, flags);
140}
141
142static void altera_uart_stop_rx(struct uart_port *port)
143{
144 struct altera_uart *pp = container_of(port, struct altera_uart, port);
145 unsigned long flags;
146
147 spin_lock_irqsave(&port->lock, flags);
148 pp->imr &= ~ALTERA_UART_CONTROL_RRDY_MSK;
149 writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
150 spin_unlock_irqrestore(&port->lock, flags);
151}
152
153static void altera_uart_break_ctl(struct uart_port *port, int break_state)
154{
155 struct altera_uart *pp = container_of(port, struct altera_uart, port);
156 unsigned long flags;
157
158 spin_lock_irqsave(&port->lock, flags);
159 if (break_state == -1)
160 pp->imr |= ALTERA_UART_CONTROL_TRBK_MSK;
161 else
162 pp->imr &= ~ALTERA_UART_CONTROL_TRBK_MSK;
163 writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
164 spin_unlock_irqrestore(&port->lock, flags);
165}
166
167static void altera_uart_enable_ms(struct uart_port *port)
168{
169}
170
171static void altera_uart_set_termios(struct uart_port *port,
172 struct ktermios *termios,
173 struct ktermios *old)
174{
175 unsigned long flags;
176 unsigned int baud, baudclk;
177
178 baud = uart_get_baud_rate(port, termios, old, 0, 4000000);
179 baudclk = port->uartclk / baud;
180
181 if (old)
182 tty_termios_copy_hw(termios, old);
183 tty_termios_encode_baud_rate(termios, baud, baud);
184
185 spin_lock_irqsave(&port->lock, flags);
186 writel(baudclk, port->membase + ALTERA_UART_DIVISOR_REG);
187 spin_unlock_irqrestore(&port->lock, flags);
188}
189
190static void altera_uart_rx_chars(struct altera_uart *pp)
191{
192 struct uart_port *port = &pp->port;
193 unsigned char ch, flag;
194 unsigned short status;
195
196 while ((status = readl(port->membase + ALTERA_UART_STATUS_REG)) &
197 ALTERA_UART_STATUS_RRDY_MSK) {
198 ch = readl(port->membase + ALTERA_UART_RXDATA_REG);
199 flag = TTY_NORMAL;
200 port->icount.rx++;
201
202 if (status & ALTERA_UART_STATUS_E_MSK) {
203 writel(status, port->membase + ALTERA_UART_STATUS_REG);
204
205 if (status & ALTERA_UART_STATUS_BRK_MSK) {
206 port->icount.brk++;
207 if (uart_handle_break(port))
208 continue;
209 } else if (status & ALTERA_UART_STATUS_PE_MSK) {
210 port->icount.parity++;
211 } else if (status & ALTERA_UART_STATUS_ROE_MSK) {
212 port->icount.overrun++;
213 } else if (status & ALTERA_UART_STATUS_FE_MSK) {
214 port->icount.frame++;
215 }
216
217 status &= port->read_status_mask;
218
219 if (status & ALTERA_UART_STATUS_BRK_MSK)
220 flag = TTY_BREAK;
221 else if (status & ALTERA_UART_STATUS_PE_MSK)
222 flag = TTY_PARITY;
223 else if (status & ALTERA_UART_STATUS_FE_MSK)
224 flag = TTY_FRAME;
225 }
226
227 if (uart_handle_sysrq_char(port, ch))
228 continue;
229 uart_insert_char(port, status, ALTERA_UART_STATUS_ROE_MSK, ch,
230 flag);
231 }
232
233 tty_flip_buffer_push(port->state->port.tty);
234}
235
236static void altera_uart_tx_chars(struct altera_uart *pp)
237{
238 struct uart_port *port = &pp->port;
239 struct circ_buf *xmit = &port->state->xmit;
240
241 if (port->x_char) {
242 /* Send special char - probably flow control */
243 writel(port->x_char, port->membase + ALTERA_UART_TXDATA_REG);
244 port->x_char = 0;
245 port->icount.tx++;
246 return;
247 }
248
249 while (readl(port->membase + ALTERA_UART_STATUS_REG) &
250 ALTERA_UART_STATUS_TRDY_MSK) {
251 if (xmit->head == xmit->tail)
252 break;
253 writel(xmit->buf[xmit->tail],
254 port->membase + ALTERA_UART_TXDATA_REG);
255 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
256 port->icount.tx++;
257 }
258
259 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
260 uart_write_wakeup(port);
261
262 if (xmit->head == xmit->tail) {
263 pp->imr &= ~ALTERA_UART_CONTROL_TRDY_MSK;
264 writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
265 }
266}
267
268static irqreturn_t altera_uart_interrupt(int irq, void *data)
269{
270 struct uart_port *port = data;
271 struct altera_uart *pp = container_of(port, struct altera_uart, port);
272 unsigned int isr;
273
274 isr = readl(port->membase + ALTERA_UART_STATUS_REG) & pp->imr;
275 if (isr & ALTERA_UART_STATUS_RRDY_MSK)
276 altera_uart_rx_chars(pp);
277 if (isr & ALTERA_UART_STATUS_TRDY_MSK)
278 altera_uart_tx_chars(pp);
279 return IRQ_RETVAL(isr);
280}
281
282static void altera_uart_config_port(struct uart_port *port, int flags)
283{
284 port->type = PORT_ALTERA_UART;
285
286 /* Clear mask, so no surprise interrupts. */
287 writel(0, port->membase + ALTERA_UART_CONTROL_REG);
288 /* Clear status register */
289 writel(0, port->membase + ALTERA_UART_STATUS_REG);
290}
291
292static int altera_uart_startup(struct uart_port *port)
293{
294 struct altera_uart *pp = container_of(port, struct altera_uart, port);
295 unsigned long flags;
296 int ret;
297
298 ret = request_irq(port->irq, altera_uart_interrupt, IRQF_DISABLED,
299 DRV_NAME, port);
300 if (ret) {
301 pr_err(DRV_NAME ": unable to attach Altera UART %d "
302 "interrupt vector=%d\n", port->line, port->irq);
303 return ret;
304 }
305
306 spin_lock_irqsave(&port->lock, flags);
307
308 /* Enable RX interrupts now */
309 pp->imr = ALTERA_UART_CONTROL_RRDY_MSK;
310 writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
311
312 spin_unlock_irqrestore(&port->lock, flags);
313
314 return 0;
315}
316
317static void altera_uart_shutdown(struct uart_port *port)
318{
319 struct altera_uart *pp = container_of(port, struct altera_uart, port);
320 unsigned long flags;
321
322 spin_lock_irqsave(&port->lock, flags);
323
324 /* Disable all interrupts now */
325 pp->imr = 0;
326 writel(pp->imr, port->membase + ALTERA_UART_CONTROL_REG);
327
328 spin_unlock_irqrestore(&port->lock, flags);
329
330 free_irq(port->irq, port);
331}
332
333static const char *altera_uart_type(struct uart_port *port)
334{
335 return (port->type == PORT_ALTERA_UART) ? "Altera UART" : NULL;
336}
337
338static int altera_uart_request_port(struct uart_port *port)
339{
340 /* UARTs always present */
341 return 0;
342}
343
344static void altera_uart_release_port(struct uart_port *port)
345{
346 /* Nothing to release... */
347}
348
349static int altera_uart_verify_port(struct uart_port *port,
350 struct serial_struct *ser)
351{
352 if ((ser->type != PORT_UNKNOWN) && (ser->type != PORT_ALTERA_UART))
353 return -EINVAL;
354 return 0;
355}
356
357/*
358 * Define the basic serial functions we support.
359 */
360static struct uart_ops altera_uart_ops = {
361 .tx_empty = altera_uart_tx_empty,
362 .get_mctrl = altera_uart_get_mctrl,
363 .set_mctrl = altera_uart_set_mctrl,
364 .start_tx = altera_uart_start_tx,
365 .stop_tx = altera_uart_stop_tx,
366 .stop_rx = altera_uart_stop_rx,
367 .enable_ms = altera_uart_enable_ms,
368 .break_ctl = altera_uart_break_ctl,
369 .startup = altera_uart_startup,
370 .shutdown = altera_uart_shutdown,
371 .set_termios = altera_uart_set_termios,
372 .type = altera_uart_type,
373 .request_port = altera_uart_request_port,
374 .release_port = altera_uart_release_port,
375 .config_port = altera_uart_config_port,
376 .verify_port = altera_uart_verify_port,
377};
378
379static struct altera_uart altera_uart_ports[CONFIG_SERIAL_ALTERA_UART_MAXPORTS];
380
381#if defined(CONFIG_SERIAL_ALTERA_UART_CONSOLE)
382
383int __init early_altera_uart_setup(struct altera_uart_platform_uart *platp)
384{
385 struct uart_port *port;
386 int i;
387
388 for (i = 0; i < CONFIG_SERIAL_ALTERA_UART_MAXPORTS && platp[i].mapbase; i++) {
389 port = &altera_uart_ports[i].port;
390
391 port->line = i;
392 port->type = PORT_ALTERA_UART;
393 port->mapbase = platp[i].mapbase;
394 port->membase = ioremap(port->mapbase, ALTERA_UART_SIZE);
395 port->iotype = SERIAL_IO_MEM;
396 port->irq = platp[i].irq;
397 port->uartclk = platp[i].uartclk;
398 port->flags = ASYNC_BOOT_AUTOCONF;
399 port->ops = &altera_uart_ops;
400 }
401
402 return 0;
403}
404
405static void altera_uart_console_putc(struct console *co, const char c)
406{
407 struct uart_port *port = &(altera_uart_ports + co->index)->port;
408 int i;
409
410 for (i = 0; i < 0x10000; i++) {
411 if (readl(port->membase + ALTERA_UART_STATUS_REG) &
412 ALTERA_UART_STATUS_TRDY_MSK)
413 break;
414 }
415 writel(c, port->membase + ALTERA_UART_TXDATA_REG);
416 for (i = 0; i < 0x10000; i++) {
417 if (readl(port->membase + ALTERA_UART_STATUS_REG) &
418 ALTERA_UART_STATUS_TRDY_MSK)
419 break;
420 }
421}
422
423static void altera_uart_console_write(struct console *co, const char *s,
424 unsigned int count)
425{
426 for (; count; count--, s++) {
427 altera_uart_console_putc(co, *s);
428 if (*s == '\n')
429 altera_uart_console_putc(co, '\r');
430 }
431}
432
433static int __init altera_uart_console_setup(struct console *co, char *options)
434{
435 struct uart_port *port;
436 int baud = CONFIG_SERIAL_ALTERA_UART_BAUDRATE;
437 int bits = 8;
438 int parity = 'n';
439 int flow = 'n';
440
441 if (co->index < 0 || co->index >= CONFIG_SERIAL_ALTERA_UART_MAXPORTS)
442 return -EINVAL;
443 port = &altera_uart_ports[co->index].port;
444 if (port->membase == 0)
445 return -ENODEV;
446
447 if (options)
448 uart_parse_options(options, &baud, &parity, &bits, &flow);
449
450 return uart_set_options(port, co, baud, parity, bits, flow);
451}
452
453static struct uart_driver altera_uart_driver;
454
455static struct console altera_uart_console = {
456 .name = "ttyS",
457 .write = altera_uart_console_write,
458 .device = uart_console_device,
459 .setup = altera_uart_console_setup,
460 .flags = CON_PRINTBUFFER,
461 .index = -1,
462 .data = &altera_uart_driver,
463};
464
465static int __init altera_uart_console_init(void)
466{
467 register_console(&altera_uart_console);
468 return 0;
469}
470
471console_initcall(altera_uart_console_init);
472
473#define ALTERA_UART_CONSOLE (&altera_uart_console)
474
475#else
476
477#define ALTERA_UART_CONSOLE NULL
478
479#endif /* CONFIG_ALTERA_UART_CONSOLE */
480
481/*
482 * Define the altera_uart UART driver structure.
483 */
484static struct uart_driver altera_uart_driver = {
485 .owner = THIS_MODULE,
486 .driver_name = DRV_NAME,
487 .dev_name = "ttyS",
488 .major = TTY_MAJOR,
489 .minor = 64,
490 .nr = CONFIG_SERIAL_ALTERA_UART_MAXPORTS,
491 .cons = ALTERA_UART_CONSOLE,
492};
493
494static int __devinit altera_uart_probe(struct platform_device *pdev)
495{
496 struct altera_uart_platform_uart *platp = pdev->dev.platform_data;
497 struct uart_port *port;
498 int i;
499
500 for (i = 0; i < CONFIG_SERIAL_ALTERA_UART_MAXPORTS && platp[i].mapbase; i++) {
501 port = &altera_uart_ports[i].port;
502
503 port->line = i;
504 port->type = PORT_ALTERA_UART;
505 port->mapbase = platp[i].mapbase;
506 port->membase = ioremap(port->mapbase, ALTERA_UART_SIZE);
507 port->iotype = SERIAL_IO_MEM;
508 port->irq = platp[i].irq;
509 port->uartclk = platp[i].uartclk;
510 port->ops = &altera_uart_ops;
511 port->flags = ASYNC_BOOT_AUTOCONF;
512
513 uart_add_one_port(&altera_uart_driver, port);
514 }
515
516 return 0;
517}
518
519static int altera_uart_remove(struct platform_device *pdev)
520{
521 struct uart_port *port;
522 int i;
523
524 for (i = 0; i < CONFIG_SERIAL_ALTERA_UART_MAXPORTS; i++) {
525 port = &altera_uart_ports[i].port;
526 if (port)
527 uart_remove_one_port(&altera_uart_driver, port);
528 }
529
530 return 0;
531}
532
533static struct platform_driver altera_uart_platform_driver = {
534 .probe = altera_uart_probe,
535 .remove = __devexit_p(altera_uart_remove),
536 .driver = {
537 .name = DRV_NAME,
538 .owner = THIS_MODULE,
539 .pm = NULL,
540 },
541};
542
543static int __init altera_uart_init(void)
544{
545 int rc;
546
547 rc = uart_register_driver(&altera_uart_driver);
548 if (rc)
549 return rc;
550 rc = platform_driver_register(&altera_uart_platform_driver);
551 if (rc) {
552 uart_unregister_driver(&altera_uart_driver);
553 return rc;
554 }
555 return 0;
556}
557
558static void __exit altera_uart_exit(void)
559{
560 platform_driver_unregister(&altera_uart_platform_driver);
561 uart_unregister_driver(&altera_uart_driver);
562}
563
564module_init(altera_uart_init);
565module_exit(altera_uart_exit);
566
567MODULE_DESCRIPTION("Altera UART driver");
568MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>");
569MODULE_LICENSE("GPL");
570MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/serial/bfin_sport_uart.c b/drivers/serial/bfin_sport_uart.c
index c88f8ad3ff82..e57fb3d228e2 100644
--- a/drivers/serial/bfin_sport_uart.c
+++ b/drivers/serial/bfin_sport_uart.c
@@ -34,32 +34,12 @@
34#include <linux/tty_flip.h> 34#include <linux/tty_flip.h>
35#include <linux/serial_core.h> 35#include <linux/serial_core.h>
36 36
37#include <asm/bfin_sport.h>
37#include <asm/delay.h> 38#include <asm/delay.h>
38#include <asm/portmux.h> 39#include <asm/portmux.h>
39 40
40#include "bfin_sport_uart.h" 41#include "bfin_sport_uart.h"
41 42
42#ifdef CONFIG_SERIAL_BFIN_SPORT0_UART
43unsigned short bfin_uart_pin_req_sport0[] =
44 {P_SPORT0_TFS, P_SPORT0_DTPRI, P_SPORT0_TSCLK, P_SPORT0_RFS, \
45 P_SPORT0_DRPRI, P_SPORT0_RSCLK, P_SPORT0_DRSEC, P_SPORT0_DTSEC, 0};
46#endif
47#ifdef CONFIG_SERIAL_BFIN_SPORT1_UART
48unsigned short bfin_uart_pin_req_sport1[] =
49 {P_SPORT1_TFS, P_SPORT1_DTPRI, P_SPORT1_TSCLK, P_SPORT1_RFS, \
50 P_SPORT1_DRPRI, P_SPORT1_RSCLK, P_SPORT1_DRSEC, P_SPORT1_DTSEC, 0};
51#endif
52#ifdef CONFIG_SERIAL_BFIN_SPORT2_UART
53unsigned short bfin_uart_pin_req_sport2[] =
54 {P_SPORT2_TFS, P_SPORT2_DTPRI, P_SPORT2_TSCLK, P_SPORT2_RFS, \
55 P_SPORT2_DRPRI, P_SPORT2_RSCLK, P_SPORT2_DRSEC, P_SPORT2_DTSEC, 0};
56#endif
57#ifdef CONFIG_SERIAL_BFIN_SPORT3_UART
58unsigned short bfin_uart_pin_req_sport3[] =
59 {P_SPORT3_TFS, P_SPORT3_DTPRI, P_SPORT3_TSCLK, P_SPORT3_RFS, \
60 P_SPORT3_DRPRI, P_SPORT3_RSCLK, P_SPORT3_DRSEC, P_SPORT3_DTSEC, 0};
61#endif
62
63struct sport_uart_port { 43struct sport_uart_port {
64 struct uart_port port; 44 struct uart_port port;
65 int err_irq; 45 int err_irq;
@@ -69,9 +49,13 @@ struct sport_uart_port {
69 unsigned short txmask2; 49 unsigned short txmask2;
70 unsigned char stopb; 50 unsigned char stopb;
71/* unsigned char parib; */ 51/* unsigned char parib; */
52#ifdef CONFIG_SERIAL_BFIN_SPORT_CTSRTS
53 int cts_pin;
54 int rts_pin;
55#endif
72}; 56};
73 57
74static void sport_uart_tx_chars(struct sport_uart_port *up); 58static int sport_uart_tx_chars(struct sport_uart_port *up);
75static void sport_stop_tx(struct uart_port *port); 59static void sport_stop_tx(struct uart_port *port);
76 60
77static inline void tx_one_byte(struct sport_uart_port *up, unsigned int value) 61static inline void tx_one_byte(struct sport_uart_port *up, unsigned int value)
@@ -219,6 +203,59 @@ static irqreturn_t sport_uart_err_irq(int irq, void *dev_id)
219 return IRQ_HANDLED; 203 return IRQ_HANDLED;
220} 204}
221 205
206#ifdef CONFIG_SERIAL_BFIN_SPORT_CTSRTS
207static unsigned int sport_get_mctrl(struct uart_port *port)
208{
209 struct sport_uart_port *up = (struct sport_uart_port *)port;
210 if (up->cts_pin < 0)
211 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
212
213 /* CTS PIN is negative assertive. */
214 if (SPORT_UART_GET_CTS(up))
215 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
216 else
217 return TIOCM_DSR | TIOCM_CAR;
218}
219
220static void sport_set_mctrl(struct uart_port *port, unsigned int mctrl)
221{
222 struct sport_uart_port *up = (struct sport_uart_port *)port;
223 if (up->rts_pin < 0)
224 return;
225
226 /* RTS PIN is negative assertive. */
227 if (mctrl & TIOCM_RTS)
228 SPORT_UART_ENABLE_RTS(up);
229 else
230 SPORT_UART_DISABLE_RTS(up);
231}
232
233/*
234 * Handle any change of modem status signal.
235 */
236static irqreturn_t sport_mctrl_cts_int(int irq, void *dev_id)
237{
238 struct sport_uart_port *up = (struct sport_uart_port *)dev_id;
239 unsigned int status;
240
241 status = sport_get_mctrl(&up->port);
242 uart_handle_cts_change(&up->port, status & TIOCM_CTS);
243
244 return IRQ_HANDLED;
245}
246#else
247static unsigned int sport_get_mctrl(struct uart_port *port)
248{
249 pr_debug("%s enter\n", __func__);
250 return TIOCM_CTS | TIOCM_CD | TIOCM_DSR;
251}
252
253static void sport_set_mctrl(struct uart_port *port, unsigned int mctrl)
254{
255 pr_debug("%s enter\n", __func__);
256}
257#endif
258
222/* Reqeust IRQ, Setup clock */ 259/* Reqeust IRQ, Setup clock */
223static int sport_startup(struct uart_port *port) 260static int sport_startup(struct uart_port *port)
224{ 261{
@@ -247,6 +284,21 @@ static int sport_startup(struct uart_port *port)
247 goto fail2; 284 goto fail2;
248 } 285 }
249 286
287#ifdef CONFIG_SERIAL_BFIN_SPORT_CTSRTS
288 if (up->cts_pin >= 0) {
289 if (request_irq(gpio_to_irq(up->cts_pin),
290 sport_mctrl_cts_int,
291 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
292 IRQF_DISABLED, "BFIN_SPORT_UART_CTS", up)) {
293 up->cts_pin = -1;
294 dev_info(port->dev, "Unable to attach BlackFin UART \
295 over SPORT CTS interrupt. So, disable it.\n");
296 }
297 }
298 if (up->rts_pin >= 0)
299 gpio_direction_output(up->rts_pin, 0);
300#endif
301
250 return 0; 302 return 0;
251 fail2: 303 fail2:
252 free_irq(up->port.irq+1, up); 304 free_irq(up->port.irq+1, up);
@@ -256,23 +308,35 @@ static int sport_startup(struct uart_port *port)
256 return ret; 308 return ret;
257} 309}
258 310
259static void sport_uart_tx_chars(struct sport_uart_port *up) 311/*
312 * sport_uart_tx_chars
313 *
314 * ret 1 means need to enable sport.
315 * ret 0 means do nothing.
316 */
317static int sport_uart_tx_chars(struct sport_uart_port *up)
260{ 318{
261 struct circ_buf *xmit = &up->port.state->xmit; 319 struct circ_buf *xmit = &up->port.state->xmit;
262 320
263 if (SPORT_GET_STAT(up) & TXF) 321 if (SPORT_GET_STAT(up) & TXF)
264 return; 322 return 0;
265 323
266 if (up->port.x_char) { 324 if (up->port.x_char) {
267 tx_one_byte(up, up->port.x_char); 325 tx_one_byte(up, up->port.x_char);
268 up->port.icount.tx++; 326 up->port.icount.tx++;
269 up->port.x_char = 0; 327 up->port.x_char = 0;
270 return; 328 return 1;
271 } 329 }
272 330
273 if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) { 331 if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) {
274 sport_stop_tx(&up->port); 332 /* The waiting loop to stop SPORT TX from TX interrupt is
275 return; 333 * too long. This may block SPORT RX interrupts and cause
334 * RX FIFO overflow. So, do stop sport TX only after the last
335 * char in TX FIFO is moved into the shift register.
336 */
337 if (SPORT_GET_STAT(up) & TXHRE)
338 sport_stop_tx(&up->port);
339 return 0;
276 } 340 }
277 341
278 while(!(SPORT_GET_STAT(up) & TXF) && !uart_circ_empty(xmit)) { 342 while(!(SPORT_GET_STAT(up) & TXF) && !uart_circ_empty(xmit)) {
@@ -283,6 +347,8 @@ static void sport_uart_tx_chars(struct sport_uart_port *up)
283 347
284 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) 348 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
285 uart_write_wakeup(&up->port); 349 uart_write_wakeup(&up->port);
350
351 return 1;
286} 352}
287 353
288static unsigned int sport_tx_empty(struct uart_port *port) 354static unsigned int sport_tx_empty(struct uart_port *port)
@@ -298,23 +364,15 @@ static unsigned int sport_tx_empty(struct uart_port *port)
298 return 0; 364 return 0;
299} 365}
300 366
301static unsigned int sport_get_mctrl(struct uart_port *port)
302{
303 pr_debug("%s enter\n", __func__);
304 return (TIOCM_CTS | TIOCM_CD | TIOCM_DSR);
305}
306
307static void sport_set_mctrl(struct uart_port *port, unsigned int mctrl)
308{
309 pr_debug("%s enter\n", __func__);
310}
311
312static void sport_stop_tx(struct uart_port *port) 367static void sport_stop_tx(struct uart_port *port)
313{ 368{
314 struct sport_uart_port *up = (struct sport_uart_port *)port; 369 struct sport_uart_port *up = (struct sport_uart_port *)port;
315 370
316 pr_debug("%s enter\n", __func__); 371 pr_debug("%s enter\n", __func__);
317 372
373 if (!(SPORT_GET_TCR1(up) & TSPEN))
374 return;
375
318 /* Although the hold register is empty, last byte is still in shift 376 /* Although the hold register is empty, last byte is still in shift
319 * register and not sent out yet. So, put a dummy data into TX FIFO. 377 * register and not sent out yet. So, put a dummy data into TX FIFO.
320 * Then, sport tx stops when last byte is shift out and the dummy 378 * Then, sport tx stops when last byte is shift out and the dummy
@@ -337,11 +395,12 @@ static void sport_start_tx(struct uart_port *port)
337 pr_debug("%s enter\n", __func__); 395 pr_debug("%s enter\n", __func__);
338 396
339 /* Write data into SPORT FIFO before enable SPROT to transmit */ 397 /* Write data into SPORT FIFO before enable SPROT to transmit */
340 sport_uart_tx_chars(up); 398 if (sport_uart_tx_chars(up)) {
399 /* Enable transmit, then an interrupt will generated */
400 SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) | TSPEN));
401 SSYNC();
402 }
341 403
342 /* Enable transmit, then an interrupt will generated */
343 SPORT_PUT_TCR1(up, (SPORT_GET_TCR1(up) | TSPEN));
344 SSYNC();
345 pr_debug("%s exit\n", __func__); 404 pr_debug("%s exit\n", __func__);
346} 405}
347 406
@@ -379,6 +438,10 @@ static void sport_shutdown(struct uart_port *port)
379 free_irq(up->port.irq, up); 438 free_irq(up->port.irq, up);
380 free_irq(up->port.irq+1, up); 439 free_irq(up->port.irq+1, up);
381 free_irq(up->err_irq, up); 440 free_irq(up->err_irq, up);
441#ifdef CONFIG_SERIAL_BFIN_SPORT_CTSRTS
442 if (up->cts_pin >= 0)
443 free_irq(gpio_to_irq(up->cts_pin), up);
444#endif
382} 445}
383 446
384static const char *sport_type(struct uart_port *port) 447static const char *sport_type(struct uart_port *port)
@@ -448,27 +511,14 @@ static void sport_set_termios(struct uart_port *port,
448 /* up->parib = 1; */ 511 /* up->parib = 1; */
449 } 512 }
450 513
451 port->read_status_mask = OE; 514 spin_lock_irqsave(&up->port.lock, flags);
452 if (termios->c_iflag & INPCK) 515
453 port->read_status_mask |= (FE | PE); 516 port->read_status_mask = 0;
454 if (termios->c_iflag & (BRKINT | PARMRK))
455 port->read_status_mask |= BI;
456 517
457 /* 518 /*
458 * Characters to ignore 519 * Characters to ignore
459 */ 520 */
460 port->ignore_status_mask = 0; 521 port->ignore_status_mask = 0;
461 if (termios->c_iflag & IGNPAR)
462 port->ignore_status_mask |= FE | PE;
463 if (termios->c_iflag & IGNBRK) {
464 port->ignore_status_mask |= BI;
465 /*
466 * If we're ignoring parity and break indicators,
467 * ignore overruns too (for real raw support).
468 */
469 if (termios->c_iflag & IGNPAR)
470 port->ignore_status_mask |= OE;
471 }
472 522
473 /* RX extract mask */ 523 /* RX extract mask */
474 up->rxmask = 0x01 | (((up->csize + up->stopb) * 2 - 1) << 0x8); 524 up->rxmask = 0x01 | (((up->csize + up->stopb) * 2 - 1) << 0x8);
@@ -488,8 +538,6 @@ static void sport_set_termios(struct uart_port *port,
488 /* uart baud rate */ 538 /* uart baud rate */
489 port->uartclk = uart_get_baud_rate(port, termios, old, 0, get_sclk()/16); 539 port->uartclk = uart_get_baud_rate(port, termios, old, 0, get_sclk()/16);
490 540
491 spin_lock_irqsave(&up->port.lock, flags);
492
493 /* Disable UART */ 541 /* Disable UART */
494 SPORT_PUT_TCR1(up, SPORT_GET_TCR1(up) & ~TSPEN); 542 SPORT_PUT_TCR1(up, SPORT_GET_TCR1(up) & ~TSPEN);
495 SPORT_PUT_RCR1(up, SPORT_GET_RCR1(up) & ~RSPEN); 543 SPORT_PUT_RCR1(up, SPORT_GET_RCR1(up) & ~RSPEN);
@@ -542,6 +590,8 @@ struct uart_ops sport_uart_ops = {
542static struct sport_uart_port *bfin_sport_uart_ports[BFIN_SPORT_UART_MAX_PORTS]; 590static struct sport_uart_port *bfin_sport_uart_ports[BFIN_SPORT_UART_MAX_PORTS];
543 591
544#ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE 592#ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE
593#define CLASS_BFIN_SPORT_CONSOLE "bfin-sport-console"
594
545static int __init 595static int __init
546sport_uart_console_setup(struct console *co, char *options) 596sport_uart_console_setup(struct console *co, char *options)
547{ 597{
@@ -549,7 +599,11 @@ sport_uart_console_setup(struct console *co, char *options)
549 int baud = 57600; 599 int baud = 57600;
550 int bits = 8; 600 int bits = 8;
551 int parity = 'n'; 601 int parity = 'n';
602# ifdef CONFIG_SERIAL_BFIN_SPORT_CTSRTS
603 int flow = 'r';
604# else
552 int flow = 'n'; 605 int flow = 'n';
606# endif
553 607
554 /* Check whether an invalid uart number has been specified */ 608 /* Check whether an invalid uart number has been specified */
555 if (co->index < 0 || co->index >= BFIN_SPORT_UART_MAX_PORTS) 609 if (co->index < 0 || co->index >= BFIN_SPORT_UART_MAX_PORTS)
@@ -690,11 +744,11 @@ static int __devinit sport_uart_probe(struct platform_device *pdev)
690 744
691 if (bfin_sport_uart_ports[pdev->id] == NULL) { 745 if (bfin_sport_uart_ports[pdev->id] == NULL) {
692 bfin_sport_uart_ports[pdev->id] = 746 bfin_sport_uart_ports[pdev->id] =
693 kmalloc(sizeof(struct sport_uart_port), GFP_KERNEL); 747 kzalloc(sizeof(struct sport_uart_port), GFP_KERNEL);
694 sport = bfin_sport_uart_ports[pdev->id]; 748 sport = bfin_sport_uart_ports[pdev->id];
695 if (!sport) { 749 if (!sport) {
696 dev_err(&pdev->dev, 750 dev_err(&pdev->dev,
697 "Fail to kmalloc sport_uart_port\n"); 751 "Fail to malloc sport_uart_port\n");
698 return -ENOMEM; 752 return -ENOMEM;
699 } 753 }
700 754
@@ -720,13 +774,13 @@ static int __devinit sport_uart_probe(struct platform_device *pdev)
720 goto out_error_free_peripherals; 774 goto out_error_free_peripherals;
721 } 775 }
722 776
723 sport->port.membase = ioremap(res->start, 777 sport->port.membase = ioremap(res->start, resource_size(res));
724 res->end - res->start);
725 if (!sport->port.membase) { 778 if (!sport->port.membase) {
726 dev_err(&pdev->dev, "Cannot map sport IO\n"); 779 dev_err(&pdev->dev, "Cannot map sport IO\n");
727 ret = -ENXIO; 780 ret = -ENXIO;
728 goto out_error_free_peripherals; 781 goto out_error_free_peripherals;
729 } 782 }
783 sport->port.mapbase = res->start;
730 784
731 sport->port.irq = platform_get_irq(pdev, 0); 785 sport->port.irq = platform_get_irq(pdev, 0);
732 if (sport->port.irq < 0) { 786 if (sport->port.irq < 0) {
@@ -741,6 +795,22 @@ static int __devinit sport_uart_probe(struct platform_device *pdev)
741 ret = -ENOENT; 795 ret = -ENOENT;
742 goto out_error_unmap; 796 goto out_error_unmap;
743 } 797 }
798#ifdef CONFIG_SERIAL_BFIN_SPORT_CTSRTS
799 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
800 if (res == NULL)
801 sport->cts_pin = -1;
802 else
803 sport->cts_pin = res->start;
804
805 res = platform_get_resource(pdev, IORESOURCE_IO, 1);
806 if (res == NULL)
807 sport->rts_pin = -1;
808 else
809 sport->rts_pin = res->start;
810
811 if (sport->rts_pin >= 0)
812 gpio_request(sport->rts_pin, DRV_NAME);
813#endif
744 } 814 }
745 815
746#ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE 816#ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE
@@ -779,6 +849,10 @@ static int __devexit sport_uart_remove(struct platform_device *pdev)
779 849
780 if (sport) { 850 if (sport) {
781 uart_remove_one_port(&sport_uart_reg, &sport->port); 851 uart_remove_one_port(&sport_uart_reg, &sport->port);
852#ifdef CONFIG_SERIAL_BFIN_CTSRTS
853 if (sport->rts_pin >= 0)
854 gpio_free(sport->rts_pin);
855#endif
782 iounmap(sport->port.membase); 856 iounmap(sport->port.membase);
783 peripheral_free_list( 857 peripheral_free_list(
784 (unsigned short *)pdev->dev.platform_data); 858 (unsigned short *)pdev->dev.platform_data);
@@ -802,7 +876,7 @@ static struct platform_driver sport_uart_driver = {
802 876
803#ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE 877#ifdef CONFIG_SERIAL_BFIN_SPORT_CONSOLE
804static __initdata struct early_platform_driver early_sport_uart_driver = { 878static __initdata struct early_platform_driver early_sport_uart_driver = {
805 .class_str = DRV_NAME, 879 .class_str = CLASS_BFIN_SPORT_CONSOLE,
806 .pdrv = &sport_uart_driver, 880 .pdrv = &sport_uart_driver,
807 .requested_id = EARLY_PLATFORM_ID_UNSET, 881 .requested_id = EARLY_PLATFORM_ID_UNSET,
808}; 882};
@@ -811,7 +885,8 @@ static int __init sport_uart_rs_console_init(void)
811{ 885{
812 early_platform_driver_register(&early_sport_uart_driver, DRV_NAME); 886 early_platform_driver_register(&early_sport_uart_driver, DRV_NAME);
813 887
814 early_platform_driver_probe(DRV_NAME, BFIN_SPORT_UART_MAX_PORTS, 0); 888 early_platform_driver_probe(CLASS_BFIN_SPORT_CONSOLE,
889 BFIN_SPORT_UART_MAX_PORTS, 0);
815 890
816 register_console(&sport_uart_console); 891 register_console(&sport_uart_console);
817 892
@@ -824,7 +899,7 @@ static int __init sport_uart_init(void)
824{ 899{
825 int ret; 900 int ret;
826 901
827 pr_info("Serial: Blackfin uart over sport driver\n"); 902 pr_info("Blackfin uart over sport driver\n");
828 903
829 ret = uart_register_driver(&sport_uart_reg); 904 ret = uart_register_driver(&sport_uart_reg);
830 if (ret) { 905 if (ret) {
diff --git a/drivers/serial/bfin_sport_uart.h b/drivers/serial/bfin_sport_uart.h
index abe03614e4df..9ce253e381d2 100644
--- a/drivers/serial/bfin_sport_uart.h
+++ b/drivers/serial/bfin_sport_uart.h
@@ -37,7 +37,21 @@
37#define SPORT_GET_TFSDIV(sport) bfin_read16(((sport)->port.membase + OFFSET_TFSDIV)) 37#define SPORT_GET_TFSDIV(sport) bfin_read16(((sport)->port.membase + OFFSET_TFSDIV))
38#define SPORT_GET_TX(sport) bfin_read16(((sport)->port.membase + OFFSET_TX)) 38#define SPORT_GET_TX(sport) bfin_read16(((sport)->port.membase + OFFSET_TX))
39#define SPORT_GET_RX(sport) bfin_read16(((sport)->port.membase + OFFSET_RX)) 39#define SPORT_GET_RX(sport) bfin_read16(((sport)->port.membase + OFFSET_RX))
40#define SPORT_GET_RX32(sport) bfin_read32(((sport)->port.membase + OFFSET_RX)) 40/*
41 * If another interrupt fires while doing a 32-bit read from RX FIFO,
42 * a fake RX underflow error will be generated. So disable interrupts
43 * to prevent interruption while reading the FIFO.
44 */
45#define SPORT_GET_RX32(sport) \
46({ \
47 unsigned int __ret; \
48 if (ANOMALY_05000473) \
49 local_irq_disable(); \
50 __ret = bfin_read32((sport)->port.membase + OFFSET_RX); \
51 if (ANOMALY_05000473) \
52 local_irq_enable(); \
53 __ret; \
54})
41#define SPORT_GET_RCR1(sport) bfin_read16(((sport)->port.membase + OFFSET_RCR1)) 55#define SPORT_GET_RCR1(sport) bfin_read16(((sport)->port.membase + OFFSET_RCR1))
42#define SPORT_GET_RCR2(sport) bfin_read16(((sport)->port.membase + OFFSET_RCR2)) 56#define SPORT_GET_RCR2(sport) bfin_read16(((sport)->port.membase + OFFSET_RCR2))
43#define SPORT_GET_RCLKDIV(sport) bfin_read16(((sport)->port.membase + OFFSET_RCLKDIV)) 57#define SPORT_GET_RCLKDIV(sport) bfin_read16(((sport)->port.membase + OFFSET_RCLKDIV))
@@ -58,4 +72,15 @@
58 72
59#define SPORT_TX_FIFO_SIZE 8 73#define SPORT_TX_FIFO_SIZE 8
60 74
75#define SPORT_UART_GET_CTS(x) gpio_get_value(x->cts_pin)
76#define SPORT_UART_DISABLE_RTS(x) gpio_set_value(x->rts_pin, 1)
77#define SPORT_UART_ENABLE_RTS(x) gpio_set_value(x->rts_pin, 0)
78
79#if defined(CONFIG_SERIAL_BFIN_SPORT0_UART_CTSRTS) \
80 || defined(CONFIG_SERIAL_BFIN_SPORT1_UART_CTSRTS) \
81 || defined(CONFIG_SERIAL_BFIN_SPORT2_UART_CTSRTS) \
82 || defined(CONFIG_SERIAL_BFIN_SPORT3_UART_CTSRTS)
83# define CONFIG_SERIAL_BFIN_SPORT_CTSRTS
84#endif
85
61#endif /* _BFIN_SPORT_UART_H */ 86#endif /* _BFIN_SPORT_UART_H */
diff --git a/drivers/serial/timbuart.c b/drivers/serial/timbuart.c
index 786ba85c170b..67ca642713b8 100644
--- a/drivers/serial/timbuart.c
+++ b/drivers/serial/timbuart.c
@@ -68,12 +68,22 @@ static void timbuart_start_tx(struct uart_port *port)
68 tasklet_schedule(&uart->tasklet); 68 tasklet_schedule(&uart->tasklet);
69} 69}
70 70
71static unsigned int timbuart_tx_empty(struct uart_port *port)
72{
73 u32 isr = ioread32(port->membase + TIMBUART_ISR);
74
75 return (isr & TXBE) ? TIOCSER_TEMT : 0;
76}
77
71static void timbuart_flush_buffer(struct uart_port *port) 78static void timbuart_flush_buffer(struct uart_port *port)
72{ 79{
73 u8 ctl = ioread8(port->membase + TIMBUART_CTRL) | TIMBUART_CTRL_FLSHTX; 80 if (!timbuart_tx_empty(port)) {
81 u8 ctl = ioread8(port->membase + TIMBUART_CTRL) |
82 TIMBUART_CTRL_FLSHTX;
74 83
75 iowrite8(ctl, port->membase + TIMBUART_CTRL); 84 iowrite8(ctl, port->membase + TIMBUART_CTRL);
76 iowrite32(TXBF, port->membase + TIMBUART_ISR); 85 iowrite32(TXBF, port->membase + TIMBUART_ISR);
86 }
77} 87}
78 88
79static void timbuart_rx_chars(struct uart_port *port) 89static void timbuart_rx_chars(struct uart_port *port)
@@ -195,13 +205,6 @@ void timbuart_tasklet(unsigned long arg)
195 dev_dbg(uart->port.dev, "%s leaving\n", __func__); 205 dev_dbg(uart->port.dev, "%s leaving\n", __func__);
196} 206}
197 207
198static unsigned int timbuart_tx_empty(struct uart_port *port)
199{
200 u32 isr = ioread32(port->membase + TIMBUART_ISR);
201
202 return (isr & TXBE) ? TIOCSER_TEMT : 0;
203}
204
205static unsigned int timbuart_get_mctrl(struct uart_port *port) 208static unsigned int timbuart_get_mctrl(struct uart_port *port)
206{ 209{
207 u8 cts = ioread8(port->membase + TIMBUART_CTRL); 210 u8 cts = ioread8(port->membase + TIMBUART_CTRL);
@@ -220,7 +223,7 @@ static void timbuart_set_mctrl(struct uart_port *port, unsigned int mctrl)
220 if (mctrl & TIOCM_RTS) 223 if (mctrl & TIOCM_RTS)
221 iowrite8(TIMBUART_CTRL_RTS, port->membase + TIMBUART_CTRL); 224 iowrite8(TIMBUART_CTRL_RTS, port->membase + TIMBUART_CTRL);
222 else 225 else
223 iowrite8(TIMBUART_CTRL_RTS, port->membase + TIMBUART_CTRL); 226 iowrite8(0, port->membase + TIMBUART_CTRL);
224} 227}
225 228
226static void timbuart_mctrl_check(struct uart_port *port, u32 isr, u32 *ier) 229static void timbuart_mctrl_check(struct uart_port *port, u32 isr, u32 *ier)
diff --git a/drivers/serial/uartlite.c b/drivers/serial/uartlite.c
index f0a6c61b17f7..e6639a95d276 100644
--- a/drivers/serial/uartlite.c
+++ b/drivers/serial/uartlite.c
@@ -86,7 +86,7 @@ static int ulite_receive(struct uart_port *port, int stat)
86 /* stats */ 86 /* stats */
87 if (stat & ULITE_STATUS_RXVALID) { 87 if (stat & ULITE_STATUS_RXVALID) {
88 port->icount.rx++; 88 port->icount.rx++;
89 ch = readb(port->membase + ULITE_RX); 89 ch = ioread32be(port->membase + ULITE_RX);
90 90
91 if (stat & ULITE_STATUS_PARITY) 91 if (stat & ULITE_STATUS_PARITY)
92 port->icount.parity++; 92 port->icount.parity++;
@@ -131,7 +131,7 @@ static int ulite_transmit(struct uart_port *port, int stat)
131 return 0; 131 return 0;
132 132
133 if (port->x_char) { 133 if (port->x_char) {
134 writeb(port->x_char, port->membase + ULITE_TX); 134 iowrite32be(port->x_char, port->membase + ULITE_TX);
135 port->x_char = 0; 135 port->x_char = 0;
136 port->icount.tx++; 136 port->icount.tx++;
137 return 1; 137 return 1;
@@ -140,7 +140,7 @@ static int ulite_transmit(struct uart_port *port, int stat)
140 if (uart_circ_empty(xmit) || uart_tx_stopped(port)) 140 if (uart_circ_empty(xmit) || uart_tx_stopped(port))
141 return 0; 141 return 0;
142 142
143 writeb(xmit->buf[xmit->tail], port->membase + ULITE_TX); 143 iowrite32be(xmit->buf[xmit->tail], port->membase + ULITE_TX);
144 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE-1); 144 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE-1);
145 port->icount.tx++; 145 port->icount.tx++;
146 146
@@ -157,7 +157,7 @@ static irqreturn_t ulite_isr(int irq, void *dev_id)
157 int busy, n = 0; 157 int busy, n = 0;
158 158
159 do { 159 do {
160 int stat = readb(port->membase + ULITE_STATUS); 160 int stat = ioread32be(port->membase + ULITE_STATUS);
161 busy = ulite_receive(port, stat); 161 busy = ulite_receive(port, stat);
162 busy |= ulite_transmit(port, stat); 162 busy |= ulite_transmit(port, stat);
163 n++; 163 n++;
@@ -178,7 +178,7 @@ static unsigned int ulite_tx_empty(struct uart_port *port)
178 unsigned int ret; 178 unsigned int ret;
179 179
180 spin_lock_irqsave(&port->lock, flags); 180 spin_lock_irqsave(&port->lock, flags);
181 ret = readb(port->membase + ULITE_STATUS); 181 ret = ioread32be(port->membase + ULITE_STATUS);
182 spin_unlock_irqrestore(&port->lock, flags); 182 spin_unlock_irqrestore(&port->lock, flags);
183 183
184 return ret & ULITE_STATUS_TXEMPTY ? TIOCSER_TEMT : 0; 184 return ret & ULITE_STATUS_TXEMPTY ? TIOCSER_TEMT : 0;
@@ -201,7 +201,7 @@ static void ulite_stop_tx(struct uart_port *port)
201 201
202static void ulite_start_tx(struct uart_port *port) 202static void ulite_start_tx(struct uart_port *port)
203{ 203{
204 ulite_transmit(port, readb(port->membase + ULITE_STATUS)); 204 ulite_transmit(port, ioread32be(port->membase + ULITE_STATUS));
205} 205}
206 206
207static void ulite_stop_rx(struct uart_port *port) 207static void ulite_stop_rx(struct uart_port *port)
@@ -230,17 +230,17 @@ static int ulite_startup(struct uart_port *port)
230 if (ret) 230 if (ret)
231 return ret; 231 return ret;
232 232
233 writeb(ULITE_CONTROL_RST_RX | ULITE_CONTROL_RST_TX, 233 iowrite32be(ULITE_CONTROL_RST_RX | ULITE_CONTROL_RST_TX,
234 port->membase + ULITE_CONTROL); 234 port->membase + ULITE_CONTROL);
235 writeb(ULITE_CONTROL_IE, port->membase + ULITE_CONTROL); 235 iowrite32be(ULITE_CONTROL_IE, port->membase + ULITE_CONTROL);
236 236
237 return 0; 237 return 0;
238} 238}
239 239
240static void ulite_shutdown(struct uart_port *port) 240static void ulite_shutdown(struct uart_port *port)
241{ 241{
242 writeb(0, port->membase + ULITE_CONTROL); 242 iowrite32be(0, port->membase + ULITE_CONTROL);
243 readb(port->membase + ULITE_CONTROL); /* dummy */ 243 ioread32be(port->membase + ULITE_CONTROL); /* dummy */
244 free_irq(port->irq, port); 244 free_irq(port->irq, port);
245} 245}
246 246
@@ -352,7 +352,7 @@ static void ulite_console_wait_tx(struct uart_port *port)
352 352
353 /* Spin waiting for TX fifo to have space available */ 353 /* Spin waiting for TX fifo to have space available */
354 for (i = 0; i < 100000; i++) { 354 for (i = 0; i < 100000; i++) {
355 val = readb(port->membase + ULITE_STATUS); 355 val = ioread32be(port->membase + ULITE_STATUS);
356 if ((val & ULITE_STATUS_TXFULL) == 0) 356 if ((val & ULITE_STATUS_TXFULL) == 0)
357 break; 357 break;
358 cpu_relax(); 358 cpu_relax();
@@ -362,7 +362,7 @@ static void ulite_console_wait_tx(struct uart_port *port)
362static void ulite_console_putchar(struct uart_port *port, int ch) 362static void ulite_console_putchar(struct uart_port *port, int ch)
363{ 363{
364 ulite_console_wait_tx(port); 364 ulite_console_wait_tx(port);
365 writeb(ch, port->membase + ULITE_TX); 365 iowrite32be(ch, port->membase + ULITE_TX);
366} 366}
367 367
368static void ulite_console_write(struct console *co, const char *s, 368static void ulite_console_write(struct console *co, const char *s,
@@ -379,8 +379,8 @@ static void ulite_console_write(struct console *co, const char *s,
379 spin_lock_irqsave(&port->lock, flags); 379 spin_lock_irqsave(&port->lock, flags);
380 380
381 /* save and disable interrupt */ 381 /* save and disable interrupt */
382 ier = readb(port->membase + ULITE_STATUS) & ULITE_STATUS_IE; 382 ier = ioread32be(port->membase + ULITE_STATUS) & ULITE_STATUS_IE;
383 writeb(0, port->membase + ULITE_CONTROL); 383 iowrite32be(0, port->membase + ULITE_CONTROL);
384 384
385 uart_console_write(port, s, count, ulite_console_putchar); 385 uart_console_write(port, s, count, ulite_console_putchar);
386 386
@@ -388,7 +388,7 @@ static void ulite_console_write(struct console *co, const char *s,
388 388
389 /* restore interrupt state */ 389 /* restore interrupt state */
390 if (ier) 390 if (ier)
391 writeb(ULITE_CONTROL_IE, port->membase + ULITE_CONTROL); 391 iowrite32be(ULITE_CONTROL_IE, port->membase + ULITE_CONTROL);
392 392
393 if (locked) 393 if (locked)
394 spin_unlock_irqrestore(&port->lock, flags); 394 spin_unlock_irqrestore(&port->lock, flags);
@@ -601,7 +601,7 @@ ulite_of_probe(struct of_device *op, const struct of_device_id *match)
601 601
602 id = of_get_property(op->node, "port-number", NULL); 602 id = of_get_property(op->node, "port-number", NULL);
603 603
604 return ulite_assign(&op->dev, id ? *id : -1, res.start+3, irq); 604 return ulite_assign(&op->dev, id ? *id : -1, res.start, irq);
605} 605}
606 606
607static int __devexit ulite_of_remove(struct of_device *op) 607static int __devexit ulite_of_remove(struct of_device *op)
diff --git a/include/linux/altera_jtaguart.h b/include/linux/altera_jtaguart.h
new file mode 100644
index 000000000000..953b178a1650
--- /dev/null
+++ b/include/linux/altera_jtaguart.h
@@ -0,0 +1,16 @@
1/*
2 * altera_jtaguart.h -- Altera JTAG UART driver defines.
3 */
4
5#ifndef __ALTJUART_H
6#define __ALTJUART_H
7
8#define ALTERA_JTAGUART_MAJOR 204
9#define ALTERA_JTAGUART_MINOR 186
10
11struct altera_jtaguart_platform_uart {
12 unsigned long mapbase; /* Physical address base */
13 unsigned int irq; /* Interrupt vector */
14};
15
16#endif /* __ALTJUART_H */
diff --git a/include/linux/altera_uart.h b/include/linux/altera_uart.h
new file mode 100644
index 000000000000..8d441064a30d
--- /dev/null
+++ b/include/linux/altera_uart.h
@@ -0,0 +1,14 @@
1/*
2 * altera_uart.h -- Altera UART driver defines.
3 */
4
5#ifndef __ALTUART_H
6#define __ALTUART_H
7
8struct altera_uart_platform_uart {
9 unsigned long mapbase; /* Physical address base */
10 unsigned int irq; /* Interrupt vector */
11 unsigned int uartclk; /* UART clock rate */
12};
13
14#endif /* __ALTUART_H */
diff --git a/include/linux/gsmmux.h b/include/linux/gsmmux.h
new file mode 100644
index 000000000000..378de4195caf
--- /dev/null
+++ b/include/linux/gsmmux.h
@@ -0,0 +1,25 @@
1#ifndef _LINUX_GSMMUX_H
2#define _LINUX_GSMMUX_H
3
4struct gsm_config
5{
6 unsigned int adaption;
7 unsigned int encapsulation;
8 unsigned int initiator;
9 unsigned int t1;
10 unsigned int t2;
11 unsigned int t3;
12 unsigned int n2;
13 unsigned int mru;
14 unsigned int mtu;
15 unsigned int k;
16 unsigned int i;
17 unsigned int unused[8]; /* Padding for expansion without
18 breaking stuff */
19};
20
21#define GSMIOC_GETCONF _IOR('G', 0, struct gsm_config)
22#define GSMIOC_SETCONF _IOW('G', 1, struct gsm_config)
23
24
25#endif
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 78dd1e7120a9..09d0d2d5a08b 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -182,6 +182,10 @@
182/* Aeroflex Gaisler GRLIB APBUART */ 182/* Aeroflex Gaisler GRLIB APBUART */
183#define PORT_APBUART 90 183#define PORT_APBUART 90
184 184
185/* Altera UARTs */
186#define PORT_ALTERA_JTAGUART 91
187#define PORT_ALTERA_UART 92
188
185#ifdef __KERNEL__ 189#ifdef __KERNEL__
186 190
187#include <linux/compiler.h> 191#include <linux/compiler.h>
diff --git a/include/linux/tty.h b/include/linux/tty.h
index bb44fa9ae135..931078b73226 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -23,7 +23,7 @@
23 */ 23 */
24#define NR_UNIX98_PTY_DEFAULT 4096 /* Default maximum for Unix98 ptys */ 24#define NR_UNIX98_PTY_DEFAULT 4096 /* Default maximum for Unix98 ptys */
25#define NR_UNIX98_PTY_MAX (1 << MINORBITS) /* Absolute limit */ 25#define NR_UNIX98_PTY_MAX (1 << MINORBITS) /* Absolute limit */
26#define NR_LDISCS 21 26#define NR_LDISCS 30
27 27
28/* line disciplines */ 28/* line disciplines */
29#define N_TTY 0 29#define N_TTY 0
@@ -48,6 +48,7 @@
48#define N_PPS 18 /* Pulse per Second */ 48#define N_PPS 18 /* Pulse per Second */
49#define N_V253 19 /* Codec control over voice modem */ 49#define N_V253 19 /* Codec control over voice modem */
50#define N_CAIF 20 /* CAIF protocol for talking to modems */ 50#define N_CAIF 20 /* CAIF protocol for talking to modems */
51#define N_GSM0710 21 /* GSM 0710 Mux */
51 52
52/* 53/*
53 * This character is the same as _POSIX_VDISABLE: it cannot be used as 54 * This character is the same as _POSIX_VDISABLE: it cannot be used as
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-08 05:13:05 -0500