linux/drivers/tty/bfin_jtag_comm.c
<<
>>
Prefs
   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
  38static inline uint32_t bfin_write_emudat(uint32_t emudat)
  39{
  40        __asm__ __volatile__("emudat = %0;" : : "d"(emudat));
  41        return emudat;
  42}
  43
  44static inline uint32_t bfin_read_emudat(void)
  45{
  46        uint32_t emudat;
  47        __asm__ __volatile__("%0 = emudat;" : "=d"(emudat));
  48        return emudat;
  49}
  50
  51static 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
  63static struct tty_driver *bfin_jc_driver;
  64static struct task_struct *bfin_jc_kthread;
  65static struct tty_port port;
  66static volatile struct circ_buf bfin_jc_write_buf;
  67
  68static int
  69bfin_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
 143static int
 144bfin_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
 156static void
 157bfin_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 */
 171static int
 172bfin_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
 187static int
 188bfin_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
 198static void
 199bfin_jc_flush_chars(struct tty_struct *tty)
 200{
 201        wake_up_process(bfin_jc_kthread);
 202}
 203
 204static int
 205bfin_jc_write_room(struct tty_struct *tty)
 206{
 207        return circ_free(&bfin_jc_write_buf);
 208}
 209
 210static int
 211bfin_jc_chars_in_buffer(struct tty_struct *tty)
 212{
 213        return circ_cnt(&bfin_jc_write_buf);
 214}
 215
 216static void
 217bfin_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
 228static 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
 239static 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}
 285module_init(bfin_jc_init);
 286
 287static 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}
 295module_exit(bfin_jc_exit);
 296
 297#if defined(CONFIG_BFIN_JTAG_COMM_CONSOLE) || defined(CONFIG_EARLY_PRINTK)
 298static void
 299bfin_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
 315static void
 316bfin_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
 324static struct tty_driver *
 325bfin_jc_console_device(struct console *co, int *index)
 326{
 327        *index = co->index;
 328        return bfin_jc_driver;
 329}
 330
 331static 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
 339static int __init bfin_jc_console_init(void)
 340{
 341        register_console(&bfin_jc_console);
 342        return 0;
 343}
 344console_initcall(bfin_jc_console_init);
 345#endif
 346
 347#ifdef CONFIG_EARLY_PRINTK
 348static void __init
 349bfin_jc_early_write(struct console *co, const char *buf, unsigned int count)
 350{
 351        bfin_jc_straight_buffer_write(buf, count);
 352}
 353
 354static 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
 361struct console * __init
 362bfin_jc_early_init(unsigned int port, unsigned int cflag)
 363{
 364        return &bfin_jc_early_console;
 365}
 366#endif
 367
 368MODULE_AUTHOR("Mike Frysinger <vapier@gentoo.org>");
 369MODULE_DESCRIPTION("TTY over Blackfin JTAG Communication");
 370MODULE_LICENSE("GPL");
 371
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.