sbuslib.c 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291
  1. /* sbuslib.c: Helper library for SBUS framebuffer drivers.
  2. *
  3. * Copyright (C) 2003 David S. Miller (davem@redhat.com)
  4. */
  5. #include <linux/compat.h>
  6. #include <linux/kernel.h>
  7. #include <linux/module.h>
  8. #include <linux/string.h>
  9. #include <linux/fb.h>
  10. #include <linux/mm.h>
  11. #include <asm/oplib.h>
  12. #include <asm/fbio.h>
  13. #include "sbuslib.h"
  14. void sbusfb_fill_var(struct fb_var_screeninfo *var, int prom_node, int bpp)
  15. {
  16. memset(var, 0, sizeof(*var));
  17. var->xres = prom_getintdefault(prom_node, "width", 1152);
  18. var->yres = prom_getintdefault(prom_node, "height", 900);
  19. var->xres_virtual = var->xres;
  20. var->yres_virtual = var->yres;
  21. var->bits_per_pixel = bpp;
  22. }
  23. EXPORT_SYMBOL(sbusfb_fill_var);
  24. static unsigned long sbusfb_mmapsize(long size, unsigned long fbsize)
  25. {
  26. if (size == SBUS_MMAP_EMPTY) return 0;
  27. if (size >= 0) return size;
  28. return fbsize * (-size);
  29. }
  30. int sbusfb_mmap_helper(struct sbus_mmap_map *map,
  31. unsigned long physbase,
  32. unsigned long fbsize,
  33. unsigned long iospace,
  34. struct vm_area_struct *vma)
  35. {
  36. unsigned int size, page, r, map_size;
  37. unsigned long map_offset = 0;
  38. unsigned long off;
  39. int i;
  40. if (!(vma->vm_flags & (VM_SHARED | VM_MAYSHARE)))
  41. return -EINVAL;
  42. size = vma->vm_end - vma->vm_start;
  43. if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
  44. return -EINVAL;
  45. off = vma->vm_pgoff << PAGE_SHIFT;
  46. /* To stop the swapper from even considering these pages */
  47. vma->vm_flags |= (VM_IO | VM_RESERVED);
  48. vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
  49. /* Each page, see which map applies */
  50. for (page = 0; page < size; ){
  51. map_size = 0;
  52. for (i = 0; map[i].size; i++)
  53. if (map[i].voff == off+page) {
  54. map_size = sbusfb_mmapsize(map[i].size, fbsize);
  55. #ifdef __sparc_v9__
  56. #define POFF_MASK (PAGE_MASK|0x1UL)
  57. #else
  58. #define POFF_MASK (PAGE_MASK)
  59. #endif
  60. map_offset = (physbase + map[i].poff) & POFF_MASK;
  61. break;
  62. }
  63. if (!map_size){
  64. page += PAGE_SIZE;
  65. continue;
  66. }
  67. if (page + map_size > size)
  68. map_size = size - page;
  69. r = io_remap_pfn_range(vma,
  70. vma->vm_start + page,
  71. MK_IOSPACE_PFN(iospace,
  72. map_offset >> PAGE_SHIFT),
  73. map_size,
  74. vma->vm_page_prot);
  75. if (r)
  76. return -EAGAIN;
  77. page += map_size;
  78. }
  79. return 0;
  80. }
  81. EXPORT_SYMBOL(sbusfb_mmap_helper);
  82. int sbusfb_ioctl_helper(unsigned long cmd, unsigned long arg,
  83. struct fb_info *info,
  84. int type, int fb_depth, unsigned long fb_size)
  85. {
  86. switch(cmd) {
  87. case FBIOGTYPE: {
  88. struct fbtype __user *f = (struct fbtype __user *) arg;
  89. if (put_user(type, &f->fb_type) ||
  90. __put_user(info->var.yres, &f->fb_height) ||
  91. __put_user(info->var.xres, &f->fb_width) ||
  92. __put_user(fb_depth, &f->fb_depth) ||
  93. __put_user(0, &f->fb_cmsize) ||
  94. __put_user(fb_size, &f->fb_cmsize))
  95. return -EFAULT;
  96. return 0;
  97. }
  98. case FBIOPUTCMAP_SPARC: {
  99. struct fbcmap __user *c = (struct fbcmap __user *) arg;
  100. struct fb_cmap cmap;
  101. u16 red, green, blue;
  102. u8 red8, green8, blue8;
  103. unsigned char __user *ured;
  104. unsigned char __user *ugreen;
  105. unsigned char __user *ublue;
  106. int index, count, i;
  107. if (get_user(index, &c->index) ||
  108. __get_user(count, &c->count) ||
  109. __get_user(ured, &c->red) ||
  110. __get_user(ugreen, &c->green) ||
  111. __get_user(ublue, &c->blue))
  112. return -EFAULT;
  113. cmap.len = 1;
  114. cmap.red = &red;
  115. cmap.green = &green;
  116. cmap.blue = &blue;
  117. cmap.transp = NULL;
  118. for (i = 0; i < count; i++) {
  119. int err;
  120. if (get_user(red8, &ured[i]) ||
  121. get_user(green8, &ugreen[i]) ||
  122. get_user(blue8, &ublue[i]))
  123. return -EFAULT;
  124. red = red8 << 8;
  125. green = green8 << 8;
  126. blue = blue8 << 8;
  127. cmap.start = index + i;
  128. err = fb_set_cmap(&cmap, info);
  129. if (err)
  130. return err;
  131. }
  132. return 0;
  133. }
  134. case FBIOGETCMAP_SPARC: {
  135. struct fbcmap __user *c = (struct fbcmap __user *) arg;
  136. unsigned char __user *ured;
  137. unsigned char __user *ugreen;
  138. unsigned char __user *ublue;
  139. struct fb_cmap *cmap = &info->cmap;
  140. int index, count, i;
  141. u8 red, green, blue;
  142. if (get_user(index, &c->index) ||
  143. __get_user(count, &c->count) ||
  144. __get_user(ured, &c->red) ||
  145. __get_user(ugreen, &c->green) ||
  146. __get_user(ublue, &c->blue))
  147. return -EFAULT;
  148. if (index + count > cmap->len)
  149. return -EINVAL;
  150. for (i = 0; i < count; i++) {
  151. red = cmap->red[index + i] >> 8;
  152. green = cmap->green[index + i] >> 8;
  153. blue = cmap->blue[index + i] >> 8;
  154. if (put_user(red, &ured[i]) ||
  155. put_user(green, &ugreen[i]) ||
  156. put_user(blue, &ublue[i]))
  157. return -EFAULT;
  158. }
  159. return 0;
  160. }
  161. default:
  162. return -EINVAL;
  163. };
  164. }
  165. EXPORT_SYMBOL(sbusfb_ioctl_helper);
  166. #ifdef CONFIG_COMPAT
  167. struct fbcmap32 {
  168. int index; /* first element (0 origin) */
  169. int count;
  170. u32 red;
  171. u32 green;
  172. u32 blue;
  173. };
  174. #define FBIOPUTCMAP32 _IOW('F', 3, struct fbcmap32)
  175. #define FBIOGETCMAP32 _IOW('F', 4, struct fbcmap32)
  176. static int fbiogetputcmap(struct fb_info *info, unsigned int cmd, unsigned long arg)
  177. {
  178. struct fbcmap32 __user *argp = (void __user *)arg;
  179. struct fbcmap __user *p = compat_alloc_user_space(sizeof(*p));
  180. u32 addr;
  181. int ret;
  182. ret = copy_in_user(p, argp, 2 * sizeof(int));
  183. ret |= get_user(addr, &argp->red);
  184. ret |= put_user(compat_ptr(addr), &p->red);
  185. ret |= get_user(addr, &argp->green);
  186. ret |= put_user(compat_ptr(addr), &p->green);
  187. ret |= get_user(addr, &argp->blue);
  188. ret |= put_user(compat_ptr(addr), &p->blue);
  189. if (ret)
  190. return -EFAULT;
  191. return info->fbops->fb_ioctl(info,
  192. (cmd == FBIOPUTCMAP32) ?
  193. FBIOPUTCMAP_SPARC : FBIOGETCMAP_SPARC,
  194. (unsigned long)p);
  195. }
  196. struct fbcursor32 {
  197. short set; /* what to set, choose from the list above */
  198. short enable; /* cursor on/off */
  199. struct fbcurpos pos; /* cursor position */
  200. struct fbcurpos hot; /* cursor hot spot */
  201. struct fbcmap32 cmap; /* color map info */
  202. struct fbcurpos size; /* cursor bit map size */
  203. u32 image; /* cursor image bits */
  204. u32 mask; /* cursor mask bits */
  205. };
  206. #define FBIOSCURSOR32 _IOW('F', 24, struct fbcursor32)
  207. #define FBIOGCURSOR32 _IOW('F', 25, struct fbcursor32)
  208. static int fbiogscursor(struct fb_info *info, unsigned long arg)
  209. {
  210. struct fbcursor __user *p = compat_alloc_user_space(sizeof(*p));
  211. struct fbcursor32 __user *argp = (void __user *)arg;
  212. compat_uptr_t addr;
  213. int ret;
  214. ret = copy_in_user(p, argp,
  215. 2 * sizeof (short) + 2 * sizeof(struct fbcurpos));
  216. ret |= copy_in_user(&p->size, &argp->size, sizeof(struct fbcurpos));
  217. ret |= copy_in_user(&p->cmap, &argp->cmap, 2 * sizeof(int));
  218. ret |= get_user(addr, &argp->cmap.red);
  219. ret |= put_user(compat_ptr(addr), &p->cmap.red);
  220. ret |= get_user(addr, &argp->cmap.green);
  221. ret |= put_user(compat_ptr(addr), &p->cmap.green);
  222. ret |= get_user(addr, &argp->cmap.blue);
  223. ret |= put_user(compat_ptr(addr), &p->cmap.blue);
  224. ret |= get_user(addr, &argp->mask);
  225. ret |= put_user(compat_ptr(addr), &p->mask);
  226. ret |= get_user(addr, &argp->image);
  227. ret |= put_user(compat_ptr(addr), &p->image);
  228. if (ret)
  229. return -EFAULT;
  230. return info->fbops->fb_ioctl(info, FBIOSCURSOR, (unsigned long)p);
  231. }
  232. int sbusfb_compat_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
  233. {
  234. switch (cmd) {
  235. case FBIOGTYPE:
  236. case FBIOSATTR:
  237. case FBIOGATTR:
  238. case FBIOSVIDEO:
  239. case FBIOGVIDEO:
  240. case FBIOGCURSOR32: /* This is not implemented yet.
  241. Later it should be converted... */
  242. case FBIOSCURPOS:
  243. case FBIOGCURPOS:
  244. case FBIOGCURMAX:
  245. return info->fbops->fb_ioctl(info, cmd, arg);
  246. case FBIOPUTCMAP32:
  247. return fbiogetputcmap(info, cmd, arg);
  248. case FBIOGETCMAP32:
  249. return fbiogetputcmap(info, cmd, arg);
  250. case FBIOSCURSOR32:
  251. return fbiogscursor(info, arg);
  252. default:
  253. return -ENOIOCTLCMD;
  254. }
  255. }
  256. EXPORT_SYMBOL(sbusfb_compat_ioctl);
  257. #endif