TTY: call tty_port_destroy in the rest of drivers
[linux-3.10.git] / drivers / tty / bfin_jtag_comm.c
1 /*
2  * TTY over Blackfin JTAG Communication
3  *
4  * Copyright 2008-2009 Analog Devices Inc.
5  *
6  * Enter bugs at http://blackfin.uclinux.org/
7  *
8  * Licensed under the GPL-2 or later.
9  */
10
11 #define DRV_NAME "bfin-jtag-comm"
12 #define DEV_NAME "ttyBFJC"
13 #define pr_fmt(fmt) DRV_NAME ": " fmt
14
15 #include <linux/circ_buf.h>
16 #include <linux/console.h>
17 #include <linux/delay.h>
18 #include <linux/err.h>
19 #include <linux/kernel.h>
20 #include <linux/kthread.h>
21 #include <linux/module.h>
22 #include <linux/mutex.h>
23 #include <linux/sched.h>
24 #include <linux/slab.h>
25 #include <linux/tty.h>
26 #include <linux/tty_driver.h>
27 #include <linux/tty_flip.h>
28 #include <linux/atomic.h>
29
30 #define pr_init(fmt, args...) ({ static const __initconst char __fmt[] = fmt; printk(__fmt, ## args); })
31
32 /* See the Debug/Emulation chapter in the HRM */
33 #define EMUDOF   0x00000001     /* EMUDAT_OUT full & valid */
34 #define EMUDIF   0x00000002     /* EMUDAT_IN full & valid */
35 #define EMUDOOVF 0x00000004     /* EMUDAT_OUT overflow */
36 #define EMUDIOVF 0x00000008     /* EMUDAT_IN overflow */
37
38 static inline uint32_t bfin_write_emudat(uint32_t emudat)
39 {
40         __asm__ __volatile__("emudat = %0;" : : "d"(emudat));
41         return emudat;
42 }
43
44 static inline uint32_t bfin_read_emudat(void)
45 {
46         uint32_t emudat;
47         __asm__ __volatile__("%0 = emudat;" : "=d"(emudat));
48         return emudat;
49 }
50
51 static inline uint32_t bfin_write_emudat_chars(char a, char b, char c, char d)
52 {
53         return bfin_write_emudat((a << 0) | (b << 8) | (c << 16) | (d << 24));
54 }
55
56 #define CIRC_SIZE 2048  /* see comment in tty_io.c:do_tty_write() */
57 #define CIRC_MASK (CIRC_SIZE - 1)
58 #define circ_empty(circ)     ((circ)->head == (circ)->tail)
59 #define circ_free(circ)      CIRC_SPACE((circ)->head, (circ)->tail, CIRC_SIZE)
60 #define circ_cnt(circ)       CIRC_CNT((circ)->head, (circ)->tail, CIRC_SIZE)
61 #define circ_byte(circ, idx) ((circ)->buf[(idx) & CIRC_MASK])
62
63 static struct tty_driver *bfin_jc_driver;
64 static struct task_struct *bfin_jc_kthread;
65 static struct tty_port port;
66 static volatile struct circ_buf bfin_jc_write_buf;
67
68 static int
69 bfin_jc_emudat_manager(void *arg)
70 {
71         uint32_t inbound_len = 0, outbound_len = 0;
72
73         while (!kthread_should_stop()) {
74                 struct tty_struct *tty = tty_port_tty_get(&port);
75                 /* no one left to give data to, so sleep */
76                 if (tty == NULL && circ_empty(&bfin_jc_write_buf)) {
77                         pr_debug("waiting for readers\n");
78                         __set_current_state(TASK_UNINTERRUPTIBLE);
79                         schedule();
80                         __set_current_state(TASK_RUNNING);
81                         continue;
82                 }
83
84                 /* no data available, so just chill */
85                 if (!(bfin_read_DBGSTAT() & EMUDIF) && circ_empty(&bfin_jc_write_buf)) {
86                         pr_debug("waiting for data (in_len = %i) (circ: %i %i)\n",
87                                 inbound_len, bfin_jc_write_buf.tail, bfin_jc_write_buf.head);
88                         tty_kref_put(tty);
89                         if (inbound_len)
90                                 schedule();
91                         else
92                                 schedule_timeout_interruptible(HZ);
93                         continue;
94                 }
95
96                 /* if incoming data is ready, eat it */
97                 if (bfin_read_DBGSTAT() & EMUDIF) {
98                         if (tty != NULL) {
99                                 uint32_t emudat = bfin_read_emudat();
100                                 if (inbound_len == 0) {
101                                         pr_debug("incoming length: 0x%08x\n", emudat);
102                                         inbound_len = emudat;
103                                 } else {
104                                         size_t num_chars = (4 <= inbound_len ? 4 : inbound_len);
105                                         pr_debug("  incoming data: 0x%08x (pushing %zu)\n", emudat, num_chars);
106                                         inbound_len -= num_chars;
107                                         tty_insert_flip_string(tty, (unsigned char *)&emudat, num_chars);
108                                         tty_flip_buffer_push(tty);
109                                 }
110                         }
111                 }
112
113                 /* if outgoing data is ready, post it */
114                 if (!(bfin_read_DBGSTAT() & EMUDOF) && !circ_empty(&bfin_jc_write_buf)) {
115                         if (outbound_len == 0) {
116                                 outbound_len = circ_cnt(&bfin_jc_write_buf);
117                                 bfin_write_emudat(outbound_len);
118                                 pr_debug("outgoing length: 0x%08x\n", outbound_len);
119                         } else {
120                                 int tail = bfin_jc_write_buf.tail;
121                                 size_t ate = (4 <= outbound_len ? 4 : outbound_len);
122                                 uint32_t emudat =
123                                 bfin_write_emudat_chars(
124                                         circ_byte(&bfin_jc_write_buf, tail + 0),
125                                         circ_byte(&bfin_jc_write_buf, tail + 1),
126                                         circ_byte(&bfin_jc_write_buf, tail + 2),
127                                         circ_byte(&bfin_jc_write_buf, tail + 3)
128                                 );
129                                 bfin_jc_write_buf.tail += ate;
130                                 outbound_len -= ate;
131                                 if (tty)
132                                         tty_wakeup(tty);
133                                 pr_debug("  outgoing data: 0x%08x (pushing %zu)\n", emudat, ate);
134                         }
135                 }
136                 tty_kref_put(tty);
137         }
138
139         __set_current_state(TASK_RUNNING);
140         return 0;
141 }
142
143 static int
144 bfin_jc_open(struct tty_struct *tty, struct file *filp)
145 {
146         unsigned long flags;
147
148         spin_lock_irqsave(&port.lock, flags);
149         port.count++;
150         spin_unlock_irqrestore(&port.lock, flags);
151         tty_port_tty_set(&port, tty);
152         wake_up_process(bfin_jc_kthread);
153         return 0;
154 }
155
156 static void
157 bfin_jc_close(struct tty_struct *tty, struct file *filp)
158 {
159         unsigned long flags;
160         bool last;
161
162         spin_lock_irqsave(&port.lock, flags);
163         last = --port.count == 0;
164         spin_unlock_irqrestore(&port.lock, flags);
165         if (last)
166                 tty_port_tty_set(&port, NULL);
167         wake_up_process(bfin_jc_kthread);
168 }
169
170 /* XXX: we dont handle the put_char() case where we must handle count = 1 */
171 static int
172 bfin_jc_circ_write(const unsigned char *buf, int count)
173 {
174         int i;
175         count = min(count, circ_free(&bfin_jc_write_buf));
176         pr_debug("going to write chunk of %i bytes\n", count);
177         for (i = 0; i < count; ++i)
178                 circ_byte(&bfin_jc_write_buf, bfin_jc_write_buf.head + i) = buf[i];
179         bfin_jc_write_buf.head += i;
180         return i;
181 }
182
183 #ifndef CONFIG_BFIN_JTAG_COMM_CONSOLE
184 # define console_lock()
185 # define console_unlock()
186 #endif
187 static int
188 bfin_jc_write(struct tty_struct *tty, const unsigned char *buf, int count)
189 {
190         int i;
191         console_lock();
192         i = bfin_jc_circ_write(buf, count);
193         console_unlock();
194         wake_up_process(bfin_jc_kthread);
195         return i;
196 }
197
198 static void
199 bfin_jc_flush_chars(struct tty_struct *tty)
200 {
201         wake_up_process(bfin_jc_kthread);
202 }
203
204 static int
205 bfin_jc_write_room(struct tty_struct *tty)
206 {
207         return circ_free(&bfin_jc_write_buf);
208 }
209
210 static int
211 bfin_jc_chars_in_buffer(struct tty_struct *tty)
212 {
213         return circ_cnt(&bfin_jc_write_buf);
214 }
215
216 static void
217 bfin_jc_wait_until_sent(struct tty_struct *tty, int timeout)
218 {
219         unsigned long expire = jiffies + timeout;
220         while (!circ_empty(&bfin_jc_write_buf)) {
221                 if (signal_pending(current))
222                         break;
223                 if (time_after(jiffies, expire))
224                         break;
225         }
226 }
227
228 static const struct tty_operations bfin_jc_ops = {
229         .open            = bfin_jc_open,
230         .close           = bfin_jc_close,
231         .write           = bfin_jc_write,
232         /*.put_char        = bfin_jc_put_char,*/
233         .flush_chars     = bfin_jc_flush_chars,
234         .write_room      = bfin_jc_write_room,
235         .chars_in_buffer = bfin_jc_chars_in_buffer,
236         .wait_until_sent = bfin_jc_wait_until_sent,
237 };
238
239 static int __init bfin_jc_init(void)
240 {
241         int ret;
242
243         bfin_jc_kthread = kthread_create(bfin_jc_emudat_manager, NULL, DRV_NAME);
244         if (IS_ERR(bfin_jc_kthread))
245                 return PTR_ERR(bfin_jc_kthread);
246
247         ret = -ENOMEM;
248
249         bfin_jc_write_buf.head = bfin_jc_write_buf.tail = 0;
250         bfin_jc_write_buf.buf = kmalloc(CIRC_SIZE, GFP_KERNEL);
251         if (!bfin_jc_write_buf.buf)
252                 goto err_buf;
253
254         bfin_jc_driver = alloc_tty_driver(1);
255         if (!bfin_jc_driver)
256                 goto err_driver;
257
258         tty_port_init(&port);
259
260         bfin_jc_driver->driver_name  = DRV_NAME;
261         bfin_jc_driver->name         = DEV_NAME;
262         bfin_jc_driver->type         = TTY_DRIVER_TYPE_SERIAL;
263         bfin_jc_driver->subtype      = SERIAL_TYPE_NORMAL;
264         bfin_jc_driver->init_termios = tty_std_termios;
265         tty_set_operations(bfin_jc_driver, &bfin_jc_ops);
266         tty_port_link_device(&port, bfin_jc_driver, 0);
267
268         ret = tty_register_driver(bfin_jc_driver);
269         if (ret)
270                 goto err;
271
272         pr_init(KERN_INFO DRV_NAME ": initialized\n");
273
274         return 0;
275
276  err:
277         tty_port_destroy(&port);
278         put_tty_driver(bfin_jc_driver);
279  err_driver:
280         kfree(bfin_jc_write_buf.buf);
281  err_buf:
282         kthread_stop(bfin_jc_kthread);
283         return ret;
284 }
285 module_init(bfin_jc_init);
286
287 static void __exit bfin_jc_exit(void)
288 {
289         kthread_stop(bfin_jc_kthread);
290         kfree(bfin_jc_write_buf.buf);
291         tty_unregister_driver(bfin_jc_driver);
292         put_tty_driver(bfin_jc_driver);
293         tty_port_destroy(&port);
294 }
295 module_exit(bfin_jc_exit);
296
297 #if defined(CONFIG_BFIN_JTAG_COMM_CONSOLE) || defined(CONFIG_EARLY_PRINTK)
298 static void
299 bfin_jc_straight_buffer_write(const char *buf, unsigned count)
300 {
301         unsigned ate = 0;
302         while (bfin_read_DBGSTAT() & EMUDOF)
303                 continue;
304         bfin_write_emudat(count);
305         while (ate < count) {
306                 while (bfin_read_DBGSTAT() & EMUDOF)
307                         continue;
308                 bfin_write_emudat_chars(buf[ate], buf[ate+1], buf[ate+2], buf[ate+3]);
309                 ate += 4;
310         }
311 }
312 #endif
313
314 #ifdef CONFIG_BFIN_JTAG_COMM_CONSOLE
315 static void
316 bfin_jc_console_write(struct console *co, const char *buf, unsigned count)
317 {
318         if (bfin_jc_kthread == NULL)
319                 bfin_jc_straight_buffer_write(buf, count);
320         else
321                 bfin_jc_circ_write(buf, count);
322 }
323
324 static struct tty_driver *
325 bfin_jc_console_device(struct console *co, int *index)
326 {
327         *index = co->index;
328         return bfin_jc_driver;
329 }
330
331 static struct console bfin_jc_console = {
332         .name    = DEV_NAME,
333         .write   = bfin_jc_console_write,
334         .device  = bfin_jc_console_device,
335         .flags   = CON_ANYTIME | CON_PRINTBUFFER,
336         .index   = -1,
337 };
338
339 static int __init bfin_jc_console_init(void)
340 {
341         register_console(&bfin_jc_console);
342         return 0;
343 }
344 console_initcall(bfin_jc_console_init);
345 #endif
346
347 #ifdef CONFIG_EARLY_PRINTK
348 static void __init
349 bfin_jc_early_write(struct console *co, const char *buf, unsigned int count)
350 {
351         bfin_jc_straight_buffer_write(buf, count);
352 }
353
354 static struct __initdata console bfin_jc_early_console = {
355         .name   = "early_BFJC",
356         .write   = bfin_jc_early_write,
357         .flags   = CON_ANYTIME | CON_PRINTBUFFER,
358         .index   = -1,
359 };
360
361 struct console * __init
362 bfin_jc_early_init(unsigned int port, unsigned int cflag)
363 {
364         return &bfin_jc_early_console;
365 }
366 #endif
367
368 MODULE_AUTHOR("Mike Frysinger <vapier@gentoo.org>");
369 MODULE_DESCRIPTION("TTY over Blackfin JTAG Communication");
370 MODULE_LICENSE("GPL");