picvue_proc.c 4.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
  1. /*
  2. * Picvue PVC160206 display driver
  3. *
  4. * Brian Murphy <brian.murphy@eicon.com>
  5. *
  6. */
  7. #include <linux/bug.h>
  8. #include <linux/kernel.h>
  9. #include <linux/module.h>
  10. #include <linux/init.h>
  11. #include <linux/errno.h>
  12. #include <linux/proc_fs.h>
  13. #include <linux/seq_file.h>
  14. #include <linux/interrupt.h>
  15. #include <linux/timer.h>
  16. #include <linux/mutex.h>
  17. #include "picvue.h"
  18. static DEFINE_MUTEX(pvc_mutex);
  19. static char pvc_lines[PVC_NLINES][PVC_LINELEN+1];
  20. static int pvc_linedata[PVC_NLINES];
  21. static char *pvc_linename[PVC_NLINES] = {"line1", "line2"};
  22. #define DISPLAY_DIR_NAME "display"
  23. static int scroll_dir, scroll_interval;
  24. static struct timer_list timer;
  25. static void pvc_display(unsigned long data)
  26. {
  27. int i;
  28. pvc_clear();
  29. for (i = 0; i < PVC_NLINES; i++)
  30. pvc_write_string(pvc_lines[i], 0, i);
  31. }
  32. static DECLARE_TASKLET(pvc_display_tasklet, &pvc_display, 0);
  33. static int pvc_line_proc_show(struct seq_file *m, void *v)
  34. {
  35. int lineno = *(int *)m->private;
  36. if (lineno < 0 || lineno >= PVC_NLINES) {
  37. printk(KERN_WARNING "proc_read_line: invalid lineno %d\n", lineno);
  38. return 0;
  39. }
  40. mutex_lock(&pvc_mutex);
  41. seq_printf(m, "%s\n", pvc_lines[lineno]);
  42. mutex_unlock(&pvc_mutex);
  43. return 0;
  44. }
  45. static int pvc_line_proc_open(struct inode *inode, struct file *file)
  46. {
  47. return single_open(file, pvc_line_proc_show, PDE_DATA(inode));
  48. }
  49. static ssize_t pvc_line_proc_write(struct file *file, const char __user *buf,
  50. size_t count, loff_t *pos)
  51. {
  52. int lineno = *(int *)PDE_DATA(file_inode(file));
  53. char kbuf[PVC_LINELEN];
  54. size_t len;
  55. BUG_ON(lineno < 0 || lineno >= PVC_NLINES);
  56. len = min(count, sizeof(kbuf) - 1);
  57. if (copy_from_user(kbuf, buf, len))
  58. return -EFAULT;
  59. kbuf[len] = '\0';
  60. if (len > 0 && kbuf[len - 1] == '\n')
  61. len--;
  62. mutex_lock(&pvc_mutex);
  63. strncpy(pvc_lines[lineno], kbuf, len);
  64. pvc_lines[lineno][len] = '\0';
  65. mutex_unlock(&pvc_mutex);
  66. tasklet_schedule(&pvc_display_tasklet);
  67. return count;
  68. }
  69. static const struct file_operations pvc_line_proc_fops = {
  70. .owner = THIS_MODULE,
  71. .open = pvc_line_proc_open,
  72. .read = seq_read,
  73. .llseek = seq_lseek,
  74. .release = single_release,
  75. .write = pvc_line_proc_write,
  76. };
  77. static ssize_t pvc_scroll_proc_write(struct file *file, const char __user *buf,
  78. size_t count, loff_t *pos)
  79. {
  80. char kbuf[42];
  81. size_t len;
  82. int cmd;
  83. len = min(count, sizeof(kbuf) - 1);
  84. if (copy_from_user(kbuf, buf, len))
  85. return -EFAULT;
  86. kbuf[len] = '\0';
  87. cmd = simple_strtol(kbuf, NULL, 10);
  88. mutex_lock(&pvc_mutex);
  89. if (scroll_interval != 0)
  90. del_timer(&timer);
  91. if (cmd == 0) {
  92. scroll_dir = 0;
  93. scroll_interval = 0;
  94. } else {
  95. if (cmd < 0) {
  96. scroll_dir = -1;
  97. scroll_interval = -cmd;
  98. } else {
  99. scroll_dir = 1;
  100. scroll_interval = cmd;
  101. }
  102. add_timer(&timer);
  103. }
  104. mutex_unlock(&pvc_mutex);
  105. return count;
  106. }
  107. static int pvc_scroll_proc_show(struct seq_file *m, void *v)
  108. {
  109. mutex_lock(&pvc_mutex);
  110. seq_printf(m, "%d\n", scroll_dir * scroll_interval);
  111. mutex_unlock(&pvc_mutex);
  112. return 0;
  113. }
  114. static int pvc_scroll_proc_open(struct inode *inode, struct file *file)
  115. {
  116. return single_open(file, pvc_scroll_proc_show, NULL);
  117. }
  118. static const struct file_operations pvc_scroll_proc_fops = {
  119. .owner = THIS_MODULE,
  120. .open = pvc_scroll_proc_open,
  121. .read = seq_read,
  122. .llseek = seq_lseek,
  123. .release = single_release,
  124. .write = pvc_scroll_proc_write,
  125. };
  126. void pvc_proc_timerfunc(unsigned long data)
  127. {
  128. if (scroll_dir < 0)
  129. pvc_move(DISPLAY|RIGHT);
  130. else if (scroll_dir > 0)
  131. pvc_move(DISPLAY|LEFT);
  132. timer.expires = jiffies + scroll_interval;
  133. add_timer(&timer);
  134. }
  135. static void pvc_proc_cleanup(void)
  136. {
  137. remove_proc_subtree(DISPLAY_DIR_NAME, NULL);
  138. del_timer_sync(&timer);
  139. }
  140. static int __init pvc_proc_init(void)
  141. {
  142. struct proc_dir_entry *dir, *proc_entry;
  143. int i;
  144. dir = proc_mkdir(DISPLAY_DIR_NAME, NULL);
  145. if (dir == NULL)
  146. goto error;
  147. for (i = 0; i < PVC_NLINES; i++) {
  148. strcpy(pvc_lines[i], "");
  149. pvc_linedata[i] = i;
  150. }
  151. for (i = 0; i < PVC_NLINES; i++) {
  152. proc_entry = proc_create_data(pvc_linename[i], 0644, dir,
  153. &pvc_line_proc_fops, &pvc_linedata[i]);
  154. if (proc_entry == NULL)
  155. goto error;
  156. }
  157. proc_entry = proc_create("scroll", 0644, dir,
  158. &pvc_scroll_proc_fops);
  159. if (proc_entry == NULL)
  160. goto error;
  161. init_timer(&timer);
  162. timer.function = pvc_proc_timerfunc;
  163. return 0;
  164. error:
  165. pvc_proc_cleanup();
  166. return -ENOMEM;
  167. }
  168. module_init(pvc_proc_init);
  169. module_exit(pvc_proc_cleanup);
  170. MODULE_LICENSE("GPL");