1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/fb.h>
24#include <linux/sysfs.h>
25#include <linux/device.h>
26#include <linux/uaccess.h>
27#include <linux/platform_device.h>
28#include <linux/kernel.h>
29#include <linux/mm.h>
30#include <linux/omapfb.h>
31
32#include <video/omapdss.h>
33#include <plat/vrfb.h>
34
35#include "omapfb.h"
36
37static ssize_t show_rotate_type(struct device *dev,
38 struct device_attribute *attr, char *buf)
39{
40 struct fb_info *fbi = dev_get_drvdata(dev);
41 struct omapfb_info *ofbi = FB2OFB(fbi);
42
43 return snprintf(buf, PAGE_SIZE, "%d\n", ofbi->rotation_type);
44}
45
46static ssize_t store_rotate_type(struct device *dev,
47 struct device_attribute *attr,
48 const char *buf, size_t count)
49{
50 struct fb_info *fbi = dev_get_drvdata(dev);
51 struct omapfb_info *ofbi = FB2OFB(fbi);
52 struct omapfb2_mem_region *rg;
53 int rot_type;
54 int r;
55
56 r = kstrtoint(buf, 0, &rot_type);
57 if (r)
58 return r;
59
60 if (rot_type != OMAP_DSS_ROT_DMA && rot_type != OMAP_DSS_ROT_VRFB)
61 return -EINVAL;
62
63 if (!lock_fb_info(fbi))
64 return -ENODEV;
65
66 r = 0;
67 if (rot_type == ofbi->rotation_type)
68 goto out;
69
70 rg = omapfb_get_mem_region(ofbi->region);
71
72 if (rg->size) {
73 r = -EBUSY;
74 goto put_region;
75 }
76
77 ofbi->rotation_type = rot_type;
78
79
80
81
82
83put_region:
84 omapfb_put_mem_region(rg);
85out:
86 unlock_fb_info(fbi);
87
88 return r ? r : count;
89}
90
91
92static ssize_t show_mirror(struct device *dev,
93 struct device_attribute *attr, char *buf)
94{
95 struct fb_info *fbi = dev_get_drvdata(dev);
96 struct omapfb_info *ofbi = FB2OFB(fbi);
97
98 return snprintf(buf, PAGE_SIZE, "%d\n", ofbi->mirror);
99}
100
101static ssize_t store_mirror(struct device *dev,
102 struct device_attribute *attr,
103 const char *buf, size_t count)
104{
105 struct fb_info *fbi = dev_get_drvdata(dev);
106 struct omapfb_info *ofbi = FB2OFB(fbi);
107 bool mirror;
108 int r;
109 struct fb_var_screeninfo new_var;
110
111 r = strtobool(buf, &mirror);
112 if (r)
113 return r;
114
115 if (!lock_fb_info(fbi))
116 return -ENODEV;
117
118 ofbi->mirror = mirror;
119
120 omapfb_get_mem_region(ofbi->region);
121
122 memcpy(&new_var, &fbi->var, sizeof(new_var));
123 r = check_fb_var(fbi, &new_var);
124 if (r)
125 goto out;
126 memcpy(&fbi->var, &new_var, sizeof(fbi->var));
127
128 set_fb_fix(fbi);
129
130 r = omapfb_apply_changes(fbi, 0);
131 if (r)
132 goto out;
133
134 r = count;
135out:
136 omapfb_put_mem_region(ofbi->region);
137
138 unlock_fb_info(fbi);
139
140 return r;
141}
142
143static ssize_t show_overlays(struct device *dev,
144 struct device_attribute *attr, char *buf)
145{
146 struct fb_info *fbi = dev_get_drvdata(dev);
147 struct omapfb_info *ofbi = FB2OFB(fbi);
148 struct omapfb2_device *fbdev = ofbi->fbdev;
149 ssize_t l = 0;
150 int t;
151
152 if (!lock_fb_info(fbi))
153 return -ENODEV;
154 omapfb_lock(fbdev);
155
156 for (t = 0; t < ofbi->num_overlays; t++) {
157 struct omap_overlay *ovl = ofbi->overlays[t];
158 int ovlnum;
159
160 for (ovlnum = 0; ovlnum < fbdev->num_overlays; ++ovlnum)
161 if (ovl == fbdev->overlays[ovlnum])
162 break;
163
164 l += snprintf(buf + l, PAGE_SIZE - l, "%s%d",
165 t == 0 ? "" : ",", ovlnum);
166 }
167
168 l += snprintf(buf + l, PAGE_SIZE - l, "\n");
169
170 omapfb_unlock(fbdev);
171 unlock_fb_info(fbi);
172
173 return l;
174}
175
176static struct omapfb_info *get_overlay_fb(struct omapfb2_device *fbdev,
177 struct omap_overlay *ovl)
178{
179 int i, t;
180
181 for (i = 0; i < fbdev->num_fbs; i++) {
182 struct omapfb_info *ofbi = FB2OFB(fbdev->fbs[i]);
183
184 for (t = 0; t < ofbi->num_overlays; t++) {
185 if (ofbi->overlays[t] == ovl)
186 return ofbi;
187 }
188 }
189
190 return NULL;
191}
192
193static ssize_t store_overlays(struct device *dev, struct device_attribute *attr,
194 const char *buf, size_t count)
195{
196 struct fb_info *fbi = dev_get_drvdata(dev);
197 struct omapfb_info *ofbi = FB2OFB(fbi);
198 struct omapfb2_device *fbdev = ofbi->fbdev;
199 struct omap_overlay *ovls[OMAPFB_MAX_OVL_PER_FB];
200 struct omap_overlay *ovl;
201 int num_ovls, r, i;
202 int len;
203 bool added = false;
204
205 num_ovls = 0;
206
207 len = strlen(buf);
208 if (buf[len - 1] == '\n')
209 len = len - 1;
210
211 if (!lock_fb_info(fbi))
212 return -ENODEV;
213 omapfb_lock(fbdev);
214
215 if (len > 0) {
216 char *p = (char *)buf;
217 int ovlnum;
218
219 while (p < buf + len) {
220 int found;
221 if (num_ovls == OMAPFB_MAX_OVL_PER_FB) {
222 r = -EINVAL;
223 goto out;
224 }
225
226 ovlnum = simple_strtoul(p, &p, 0);
227 if (ovlnum > fbdev->num_overlays) {
228 r = -EINVAL;
229 goto out;
230 }
231
232 found = 0;
233 for (i = 0; i < num_ovls; ++i) {
234 if (ovls[i] == fbdev->overlays[ovlnum]) {
235 found = 1;
236 break;
237 }
238 }
239
240 if (!found)
241 ovls[num_ovls++] = fbdev->overlays[ovlnum];
242
243 p++;
244 }
245 }
246
247 for (i = 0; i < num_ovls; ++i) {
248 struct omapfb_info *ofbi2 = get_overlay_fb(fbdev, ovls[i]);
249 if (ofbi2 && ofbi2 != ofbi) {
250 dev_err(fbdev->dev, "overlay already in use\n");
251 r = -EINVAL;
252 goto out;
253 }
254 }
255
256
257 for (i = 0; i < ofbi->num_overlays; ++i) {
258 int t, found;
259
260 ovl = ofbi->overlays[i];
261
262 found = 0;
263
264 for (t = 0; t < num_ovls; ++t) {
265 if (ovl == ovls[t]) {
266 found = 1;
267 break;
268 }
269 }
270
271 if (found)
272 continue;
273
274 DBG("detaching %d\n", ofbi->overlays[i]->id);
275
276 omapfb_get_mem_region(ofbi->region);
277
278 omapfb_overlay_enable(ovl, 0);
279
280 if (ovl->manager)
281 ovl->manager->apply(ovl->manager);
282
283 omapfb_put_mem_region(ofbi->region);
284
285 for (t = i + 1; t < ofbi->num_overlays; t++) {
286 ofbi->rotation[t-1] = ofbi->rotation[t];
287 ofbi->overlays[t-1] = ofbi->overlays[t];
288 }
289
290 ofbi->num_overlays--;
291 i--;
292 }
293
294 for (i = 0; i < num_ovls; ++i) {
295 int t, found;
296
297 ovl = ovls[i];
298
299 found = 0;
300
301 for (t = 0; t < ofbi->num_overlays; ++t) {
302 if (ovl == ofbi->overlays[t]) {
303 found = 1;
304 break;
305 }
306 }
307
308 if (found)
309 continue;
310 ofbi->rotation[ofbi->num_overlays] = 0;
311 ofbi->overlays[ofbi->num_overlays++] = ovl;
312
313 added = true;
314 }
315
316 if (added) {
317 omapfb_get_mem_region(ofbi->region);
318
319 r = omapfb_apply_changes(fbi, 0);
320
321 omapfb_put_mem_region(ofbi->region);
322
323 if (r)
324 goto out;
325 }
326
327 r = count;
328out:
329 omapfb_unlock(fbdev);
330 unlock_fb_info(fbi);
331
332 return r;
333}
334
335static ssize_t show_overlays_rotate(struct device *dev,
336 struct device_attribute *attr, char *buf)
337{
338 struct fb_info *fbi = dev_get_drvdata(dev);
339 struct omapfb_info *ofbi = FB2OFB(fbi);
340 ssize_t l = 0;
341 int t;
342
343 if (!lock_fb_info(fbi))
344 return -ENODEV;
345
346 for (t = 0; t < ofbi->num_overlays; t++) {
347 l += snprintf(buf + l, PAGE_SIZE - l, "%s%d",
348 t == 0 ? "" : ",", ofbi->rotation[t]);
349 }
350
351 l += snprintf(buf + l, PAGE_SIZE - l, "\n");
352
353 unlock_fb_info(fbi);
354
355 return l;
356}
357
358static ssize_t store_overlays_rotate(struct device *dev,
359 struct device_attribute *attr, const char *buf, size_t count)
360{
361 struct fb_info *fbi = dev_get_drvdata(dev);
362 struct omapfb_info *ofbi = FB2OFB(fbi);
363 int num_ovls = 0, r, i;
364 int len;
365 bool changed = false;
366 u8 rotation[OMAPFB_MAX_OVL_PER_FB];
367
368 len = strlen(buf);
369 if (buf[len - 1] == '\n')
370 len = len - 1;
371
372 if (!lock_fb_info(fbi))
373 return -ENODEV;
374
375 if (len > 0) {
376 char *p = (char *)buf;
377
378 while (p < buf + len) {
379 int rot;
380
381 if (num_ovls == ofbi->num_overlays) {
382 r = -EINVAL;
383 goto out;
384 }
385
386 rot = simple_strtoul(p, &p, 0);
387 if (rot < 0 || rot > 3) {
388 r = -EINVAL;
389 goto out;
390 }
391
392 if (ofbi->rotation[num_ovls] != rot)
393 changed = true;
394
395 rotation[num_ovls++] = rot;
396
397 p++;
398 }
399 }
400
401 if (num_ovls != ofbi->num_overlays) {
402 r = -EINVAL;
403 goto out;
404 }
405
406 if (changed) {
407 for (i = 0; i < num_ovls; ++i)
408 ofbi->rotation[i] = rotation[i];
409
410 omapfb_get_mem_region(ofbi->region);
411
412 r = omapfb_apply_changes(fbi, 0);
413
414 omapfb_put_mem_region(ofbi->region);
415
416 if (r)
417 goto out;
418
419
420 }
421
422 r = count;
423out:
424 unlock_fb_info(fbi);
425
426 return r;
427}
428
429static ssize_t show_size(struct device *dev,
430 struct device_attribute *attr, char *buf)
431{
432 struct fb_info *fbi = dev_get_drvdata(dev);
433 struct omapfb_info *ofbi = FB2OFB(fbi);
434
435 return snprintf(buf, PAGE_SIZE, "%lu\n", ofbi->region->size);
436}
437
438static ssize_t store_size(struct device *dev, struct device_attribute *attr,
439 const char *buf, size_t count)
440{
441 struct fb_info *fbi = dev_get_drvdata(dev);
442 struct omapfb_info *ofbi = FB2OFB(fbi);
443 struct omapfb2_device *fbdev = ofbi->fbdev;
444 struct omapfb2_mem_region *rg;
445 unsigned long size;
446 int r;
447 int i;
448
449 r = kstrtoul(buf, 0, &size);
450 if (r)
451 return r;
452
453 size = PAGE_ALIGN(size);
454
455 if (!lock_fb_info(fbi))
456 return -ENODEV;
457
458 rg = ofbi->region;
459
460 down_write_nested(&rg->lock, rg->id);
461 atomic_inc(&rg->lock_count);
462
463 if (atomic_read(&rg->map_count)) {
464 r = -EBUSY;
465 goto out;
466 }
467
468 for (i = 0; i < fbdev->num_fbs; i++) {
469 struct omapfb_info *ofbi2 = FB2OFB(fbdev->fbs[i]);
470 int j;
471
472 if (ofbi2->region != rg)
473 continue;
474
475 for (j = 0; j < ofbi2->num_overlays; j++) {
476 struct omap_overlay *ovl;
477 ovl = ofbi2->overlays[j];
478 if (ovl->is_enabled(ovl)) {
479 r = -EBUSY;
480 goto out;
481 }
482 }
483 }
484
485 if (size != ofbi->region->size) {
486 r = omapfb_realloc_fbmem(fbi, size, ofbi->region->type);
487 if (r) {
488 dev_err(dev, "realloc fbmem failed\n");
489 goto out;
490 }
491 }
492
493 r = count;
494out:
495 atomic_dec(&rg->lock_count);
496 up_write(&rg->lock);
497
498 unlock_fb_info(fbi);
499
500 return r;
501}
502
503static ssize_t show_phys(struct device *dev,
504 struct device_attribute *attr, char *buf)
505{
506 struct fb_info *fbi = dev_get_drvdata(dev);
507 struct omapfb_info *ofbi = FB2OFB(fbi);
508
509 return snprintf(buf, PAGE_SIZE, "%0x\n", ofbi->region->paddr);
510}
511
512static ssize_t show_virt(struct device *dev,
513 struct device_attribute *attr, char *buf)
514{
515 struct fb_info *fbi = dev_get_drvdata(dev);
516 struct omapfb_info *ofbi = FB2OFB(fbi);
517
518 return snprintf(buf, PAGE_SIZE, "%p\n", ofbi->region->vaddr);
519}
520
521static ssize_t show_upd_mode(struct device *dev,
522 struct device_attribute *attr, char *buf)
523{
524 struct fb_info *fbi = dev_get_drvdata(dev);
525 enum omapfb_update_mode mode;
526 int r;
527
528 r = omapfb_get_update_mode(fbi, &mode);
529
530 if (r)
531 return r;
532
533 return snprintf(buf, PAGE_SIZE, "%u\n", (unsigned)mode);
534}
535
536static ssize_t store_upd_mode(struct device *dev, struct device_attribute *attr,
537 const char *buf, size_t count)
538{
539 struct fb_info *fbi = dev_get_drvdata(dev);
540 unsigned mode;
541 int r;
542
543 r = kstrtouint(buf, 0, &mode);
544 if (r)
545 return r;
546
547 r = omapfb_set_update_mode(fbi, mode);
548 if (r)
549 return r;
550
551 return count;
552}
553
554static struct device_attribute omapfb_attrs[] = {
555 __ATTR(rotate_type, S_IRUGO | S_IWUSR, show_rotate_type,
556 store_rotate_type),
557 __ATTR(mirror, S_IRUGO | S_IWUSR, show_mirror, store_mirror),
558 __ATTR(size, S_IRUGO | S_IWUSR, show_size, store_size),
559 __ATTR(overlays, S_IRUGO | S_IWUSR, show_overlays, store_overlays),
560 __ATTR(overlays_rotate, S_IRUGO | S_IWUSR, show_overlays_rotate,
561 store_overlays_rotate),
562 __ATTR(phys_addr, S_IRUGO, show_phys, NULL),
563 __ATTR(virt_addr, S_IRUGO, show_virt, NULL),
564 __ATTR(update_mode, S_IRUGO | S_IWUSR, show_upd_mode, store_upd_mode),
565};
566
567int omapfb_create_sysfs(struct omapfb2_device *fbdev)
568{
569 int i;
570 int r;
571
572 DBG("create sysfs for fbs\n");
573 for (i = 0; i < fbdev->num_fbs; i++) {
574 int t;
575 for (t = 0; t < ARRAY_SIZE(omapfb_attrs); t++) {
576 r = device_create_file(fbdev->fbs[i]->dev,
577 &omapfb_attrs[t]);
578
579 if (r) {
580 dev_err(fbdev->dev, "failed to create sysfs "
581 "file\n");
582 return r;
583 }
584 }
585 }
586
587 return 0;
588}
589
590void omapfb_remove_sysfs(struct omapfb2_device *fbdev)
591{
592 int i, t;
593
594 DBG("remove sysfs for fbs\n");
595 for (i = 0; i < fbdev->num_fbs; i++) {
596 for (t = 0; t < ARRAY_SIZE(omapfb_attrs); t++)
597 device_remove_file(fbdev->fbs[i]->dev,
598 &omapfb_attrs[t]);
599 }
600}
601
602
