OpenCores
URL https://opencores.org/ocsvn/or1k_old/or1k_old/trunk

Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [uclinux/] [uClinux-2.0.x/] [drivers/] [char/] [fbmem.c] - Blame information for rev 1782

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 199 simons
/*
2
 *  linux/drivers/char/fbmem.c
3
 *
4
 *  Copyright (C) 1994 Martin Schaller
5
 *
6
 * This file is subject to the terms and conditions of the GNU General Public
7
 * License.  See the file COPYING in the main directory of this archive
8
 * for more details.
9
 *
10
 */
11
 
12
/*
13
 * uClinux revisions for NO_MM
14
 * Copyright (C) 1998  Kenneth Albanowski <kjahds@kjahds.com>,
15
 *                     The Silver Hammer Group, Ltd.
16
 */
17
 
18
#include <linux/types.h>
19
#include <linux/errno.h>
20
#include <linux/sched.h>
21
#include <linux/kernel.h>
22
#include <linux/major.h>
23
#include <linux/malloc.h>
24
#include <linux/mman.h>
25
#include <linux/tty.h>
26
 
27
#include <asm/segment.h>
28
#include <asm/bootinfo.h>
29
#include <asm/page.h>
30
#include <asm/pgtable.h>
31
 
32
#include <linux/fb.h>
33
 
34
#define FB_MAJOR        29
35
 
36
#define FB_MODES_SHIFT    5     /* 32 modes per framebuffer */
37
#define FB_NUM_MINORS   256     /* 256 Minors               */
38
#define FB_MAX          (FB_NUM_MINORS / (1 << FB_MODES_SHIFT))
39
 
40
#define GET_INODE(i) MKDEV(FB_MAJOR, (i) << FB_MODES_SHIFT)
41
#define GET_FB_IDX(node) (MINOR(node) >> FB_MODES_SHIFT)
42
#define GET_FB_VAR_IDX(node) (MINOR(node) & ((1 << FB_MODES_SHIFT)-1)) 
43
 
44
struct fb_ops *registered_fb[FB_MAX];
45
struct fb_var_screeninfo *registered_fb_var[FB_MAX];
46
int registered_fb_var_num[FB_MAX];
47
int fb_curr_open[FB_MAX];
48
int fb_open_count[FB_MAX];
49
 
50
static inline int PROC_CONSOLE(void)
51
{
52
        if (!current->tty)
53
                return fg_console;
54
 
55
        if (current->tty->driver.type != TTY_DRIVER_TYPE_CONSOLE)
56
                /* XXX Should report error here? */
57
                return fg_console;
58
 
59
        if (MINOR(current->tty->device) < 1)
60
                return fg_console;
61
 
62
        return MINOR(current->tty->device) - 1;
63
}
64
 
65
static int
66
fb_read(struct inode *inode, struct file *file, char *buf, int count)
67
{
68
        unsigned long p = file->f_pos;
69
        struct fb_ops *fb = registered_fb[GET_FB_IDX(inode->i_rdev)];
70
        struct fb_fix_screeninfo fix;
71
        char *base_addr;
72
        int copy_size;
73
 
74
        if (! fb)
75
                return -ENODEV;
76
        if (count < 0)
77
                return -EINVAL;
78
 
79
        fb->fb_get_fix(&fix,PROC_CONSOLE());
80
        base_addr=(char *) fix.smem_start;
81
        copy_size=(count + p <= fix.smem_len ? count : fix.smem_len - p);
82
        memcpy_tofs(buf, base_addr+p, copy_size);
83
        file->f_pos += copy_size;
84
        return copy_size;
85
}
86
 
87
static int
88
fb_write(struct inode *inode, struct file *file, const char *buf, int count)
89
{
90
        unsigned long p = file->f_pos;
91
        struct fb_ops *fb = registered_fb[GET_FB_IDX(inode->i_rdev)];
92
        struct fb_fix_screeninfo fix;
93
        char *base_addr;
94
        int copy_size;
95
 
96
        if (! fb)
97
                return -ENODEV;
98
        if (count < 0)
99
                return -EINVAL;
100
        fb->fb_get_fix(&fix, PROC_CONSOLE());
101
        base_addr=(char *) fix.smem_start;
102
        copy_size=(count + p <= fix.smem_len ? count : fix.smem_len - p);
103
        memcpy_fromfs(base_addr+p, buf, copy_size);
104
        file->f_pos += copy_size;
105
        return copy_size;
106
}
107
 
108
 
109
static int
110
fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
111
         unsigned long arg)
112
{
113
        struct fb_ops *fb = registered_fb[GET_FB_IDX(inode->i_rdev)];
114
        struct fb_cmap cmap;
115
        struct fb_var_screeninfo var;
116
        struct fb_fix_screeninfo fix;
117
 
118
        int i,fbidx,vidx;
119
 
120
        if (! fb)
121
                return -ENODEV;
122
        switch (cmd) {
123
        case FBIOGET_VSCREENINFO:
124
                i = verify_area(VERIFY_WRITE, (void *) arg,
125
                                sizeof(struct fb_var_screeninfo));
126
                if (i) return i;
127
                fbidx=GET_FB_IDX(inode->i_rdev);
128
                vidx=GET_FB_VAR_IDX(inode->i_rdev);
129
                if (! vidx) /* ask device driver for current */
130
                        i=fb->fb_get_var(&var, PROC_CONSOLE());
131
                else
132
                        var=registered_fb_var[fbidx][vidx-1];
133
                memcpy_tofs((void *) arg, &var, sizeof(var));
134
                return i;
135
        case FBIOPUT_VSCREENINFO:
136
                i = verify_area(VERIFY_WRITE, (void *) arg,
137
                                sizeof(struct fb_var_screeninfo));
138
                if (i) return i;
139
                memcpy_fromfs(&var, (void *) arg, sizeof(var));
140
                i=fb->fb_set_var(&var, PROC_CONSOLE());
141
                memcpy_tofs((void *) arg, &var, sizeof(var));
142
                fbidx=GET_FB_IDX(inode->i_rdev);
143
                vidx=GET_FB_VAR_IDX(inode->i_rdev);
144
                if (! i && vidx)
145
                        registered_fb_var[fbidx][vidx-1]=var;
146
                return i;
147
        case FBIOGET_FSCREENINFO:
148
                i = verify_area(VERIFY_WRITE, (void *) arg,
149
                                sizeof(struct fb_fix_screeninfo));
150
                if (i)  return i;
151
                i=fb->fb_get_fix(&fix, PROC_CONSOLE());
152
                memcpy_tofs((void *) arg, &fix, sizeof(fix));
153
                return i;
154
        case FBIOPUTCMAP:
155
                i = verify_area(VERIFY_READ, (void *) arg,
156
                                sizeof(struct fb_cmap));
157
                if (i) return i;
158
                memcpy_fromfs(&cmap, (void *) arg, sizeof(cmap));
159
                i = verify_area(VERIFY_READ, (void *) cmap.red,
160
                                cmap.len * sizeof(unsigned short));
161
                if (i) return i;
162
                i = verify_area(VERIFY_READ, (void *) cmap.green,
163
                                cmap.len * sizeof(unsigned short));
164
                if (i) return i;
165
                i = verify_area(VERIFY_READ, (void *) cmap.blue,
166
                                cmap.len * sizeof(unsigned short));
167
                if (i) return i;
168
                if (cmap.transp) {
169
                        i = verify_area(VERIFY_READ, (void *) cmap.transp,
170
                                        cmap.len * sizeof(unsigned short));
171
                        if (i) return i;
172
                }
173
                return (fb->fb_set_cmap(&cmap, 0, PROC_CONSOLE()));
174
        case FBIOGETCMAP:
175
                i = verify_area(VERIFY_READ, (void *) arg,
176
                                sizeof(struct fb_cmap));
177
                if (i)  return i;
178
                memcpy_fromfs(&cmap, (void *) arg, sizeof(cmap));
179
                i = verify_area(VERIFY_WRITE, (void *) cmap.red,
180
                                cmap.len * sizeof(unsigned short));
181
                if (i) return i;
182
                i = verify_area(VERIFY_WRITE, (void *) cmap.green,
183
                                cmap.len * sizeof(unsigned short));
184
                if (i) return i;
185
                i = verify_area(VERIFY_WRITE, (void *) cmap.blue,
186
                                cmap.len * sizeof(unsigned short));
187
                if (i) return i;
188
                if (cmap.transp) {
189
                        i = verify_area(VERIFY_WRITE, (void *) cmap.transp,
190
                                        cmap.len * sizeof(unsigned short));
191
                        if (i) return i;
192
                }
193
                return (fb->fb_get_cmap(&cmap, 0, PROC_CONSOLE()));
194
        case FBIOPAN_DISPLAY:
195
                i = verify_area(VERIFY_WRITE, (void *) arg,
196
                                sizeof(struct fb_var_screeninfo));
197
                if (i) return i;
198
                memcpy_fromfs(&var, (void *) arg, sizeof(var));
199
                i=fb->fb_pan_display(&var, PROC_CONSOLE());
200
                memcpy_tofs((void *) arg, &var, sizeof(var));
201
                fbidx=GET_FB_IDX(inode->i_rdev);
202
                vidx=GET_FB_VAR_IDX(inode->i_rdev);
203
                if (! i && vidx)
204
                        registered_fb_var[fbidx][vidx-1]=var;
205
                return i;
206
        default:
207
                return (fb->fb_ioctl(inode, file, cmd, arg, PROC_CONSOLE()));
208
        }
209
}
210
 
211
static int
212
fb_mmap(struct inode *inode, struct file *file, struct vm_area_struct * vma)
213
{
214
        struct fb_ops *fb = registered_fb[GET_FB_IDX(inode->i_rdev)];
215
        struct fb_fix_screeninfo fix;
216
 
217
        if (! fb)
218
                return -ENODEV;
219
        fb->fb_get_fix(&fix, PROC_CONSOLE());
220
#ifndef NO_MM
221
        if ((vma->vm_end - vma->vm_start + vma->vm_offset) > fix.smem_len)
222
                return -EINVAL;
223
        vma->vm_offset += fix.smem_start;
224
        if (vma->vm_offset & ~PAGE_MASK)
225
                return -ENXIO;
226
        if (m68k_is040or060) {
227
                pgprot_val(vma->vm_page_prot) &= _CACHEMASK040;
228
                /* Use write-through cache mode */
229
                pgprot_val(vma->vm_page_prot) |= _PAGE_CACHE040W;
230
        }
231
        if (remap_page_range(vma->vm_start, vma->vm_offset,
232
                             vma->vm_end - vma->vm_start, vma->vm_page_prot))
233
                return -EAGAIN;
234
        vma->vm_inode = inode;
235
        inode->i_count++;
236
#else /* !NO_MM */
237
        vma->vm_start = fix.smem_start+vma->vm_offset;
238
#endif /* !NO_MM */
239
        return 0;
240
}
241
 
242
static int
243
fb_open(struct inode *inode, struct file *file)
244
{
245
        int fbidx=GET_FB_IDX(inode->i_rdev);
246
        int vidx=GET_FB_VAR_IDX(inode->i_rdev);
247
        struct fb_ops *fb = registered_fb[fbidx];
248
        int err;
249
 
250
        if (! vidx)             /* fb?current always succeeds */
251
                return 0;
252
        if (vidx > registered_fb_var_num[fbidx])
253
                return -EINVAL;
254
        if (fb_curr_open[fbidx] && fb_curr_open[fbidx] != vidx)
255
                return -EBUSY;
256
        if (file->f_mode & 2) /* only set parameters if opened writeable */
257
                if ((err=fb->fb_set_var(registered_fb_var[fbidx] + vidx-1, PROC_CONSOLE())))
258
                        return err;
259
        fb_curr_open[fbidx] = vidx;
260
        fb_open_count[fbidx]++;
261
        return 0;
262
}
263
 
264
static void
265
fb_release(struct inode *inode, struct file *file)
266
{
267
        int fbidx=GET_FB_IDX(inode->i_rdev);
268
        int vidx=GET_FB_VAR_IDX(inode->i_rdev);
269
        if (! vidx)
270
                return;
271
        if (! (--fb_open_count[fbidx]))
272
                fb_curr_open[fbidx]=0;
273
}
274
 
275
static struct file_operations fb_fops = {
276
        NULL,           /* lseek        */
277
        fb_read,        /* read         */
278
        fb_write,       /* write        */
279
        NULL,           /* readdir      */
280
        NULL,           /* select       */
281
        fb_ioctl,       /* ioctl        */
282
        fb_mmap,        /* mmap         */
283
        fb_open,        /* open         */
284
        fb_release,     /* release      */
285
        NULL            /* fsync        */
286
};
287
 
288
int
289
register_framebuffer(char *id, int *node, struct fb_ops *fbops, int fbvar_num,
290
                     struct fb_var_screeninfo *fbvar)
291
{
292
        int i;
293
        for (i = 0 ; i < FB_MAX; i++)
294
                if (! registered_fb[i])
295
                        break;
296
        if (i == FB_MAX)
297
                return -ENXIO;
298
        registered_fb[i]=fbops;
299
        registered_fb_var[i]=fbvar;
300
        registered_fb_var_num[i]=fbvar_num;
301
        *node=GET_INODE(i);
302
        return 0;
303
}
304
 
305
int
306
unregister_framebuffer(int node)
307
{
308
        int i=GET_FB_IDX(node);
309
        if (! registered_fb[i])
310
                return -EINVAL;
311
        registered_fb[i]=NULL;
312
        registered_fb_var[i]=NULL;
313
        return 0;
314
}
315
 
316
int
317
fbmem_init(void)
318
{
319
        if (register_chrdev(FB_MAJOR,"fb",&fb_fops))
320
                printk("unable to get major %d for fb devs\n", FB_MAJOR);
321
        return 0;
322
}
323
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.