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