Root/target/linux/ubicom32/files/drivers/video/ubicom32fb.c

1/*
2 * drivers/video/ubicom32fb.c
3 * Ubicom32 frame buffer driver
4 *
5 * (C) Copyright 2009, Ubicom, Inc.
6 *
7 * This file is part of the Ubicom32 Linux Kernel Port.
8 *
9 * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10 * it and/or modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation, either version 2 of the
12 * License, or (at your option) any later version.
13 *
14 * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
16 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with the Ubicom32 Linux Kernel Port. If not,
21 * see <http://www.gnu.org/licenses/>.
22 *
23 * Ubicom32 implementation derived from (with many thanks):
24 * arch/m68knommu
25 * arch/blackfin
26 * arch/parisc
27 */
28
29/*
30 * This driver was based on skeletonfb.c, Skeleton for a frame buffer device by
31 * Geert Uytterhoeven.
32 */
33
34#include <linux/device.h>
35#include <linux/module.h>
36#include <linux/kernel.h>
37#include <linux/version.h>
38#include <linux/errno.h>
39#include <linux/string.h>
40#include <linux/mm.h>
41#include <linux/fb.h>
42#include <linux/init.h>
43#include <linux/dma-mapping.h>
44#include <linux/platform_device.h>
45#include <linux/device.h>
46#include <linux/uaccess.h>
47#include <linux/interrupt.h>
48
49#include <asm/io.h>
50#include <asm/ip5000.h>
51#include <asm/vdc_tio.h>
52#include <asm/ubicom32fb.h>
53
54#define DRIVER_NAME "ubicom32fb"
55#define DRIVER_DESCRIPTION "Ubicom32 frame buffer driver"
56
57#define PALETTE_ENTRIES_NO 16
58
59/*
60 * Option variables
61 *
62 * vram_size: VRAM size in kilobytes, subject to alignment
63 */
64static int vram_size = 0;
65module_param(vram_size, int, 0);
66MODULE_PARM_DESC(vram, "VRAM size, in kilobytes to allocate, should be at least the size of one screen, subject to alignment");
67static int init_value = 0;
68module_param(init_value, int, 0);
69MODULE_PARM_DESC(init, "Initial value of the framebuffer (16-bit number).");
70
71/*
72 * fb_fix_screeninfo defines the non-changeable properties of the VDC, depending on what mode it is in.
73 */
74static struct fb_fix_screeninfo ubicom32fb_fix = {
75    .id = "Ubicom32",
76    .type = FB_TYPE_PACKED_PIXELS,
77    .visual = FB_VISUAL_TRUECOLOR,
78    .accel = FB_ACCEL_UBICOM32,
79};
80
81/*
82 * Filled in at probe time when we find out what the hardware supports
83 */
84static struct fb_var_screeninfo ubicom32fb_var;
85
86/*
87 * Private data structure
88 */
89struct ubicom32fb_drvdata {
90    struct fb_info *fbinfo;
91    bool cmap_alloc;
92
93    /*
94     * The address of the framebuffer in memory
95     */
96    void *fb;
97    void *fb_aligned;
98
99    /*
100     * Total size of vram including alignment allowance
101     */
102    u32 total_vram_size;
103
104    /*
105     * Interrupt to set when changing registers
106     */
107    u32 vp_int;
108
109    /*
110     * Optional: Interrupt used by TIO to signal us
111     */
112    u32 rx_int;
113
114    /*
115     * Base address of the regs for VDC_TIO
116     */
117    volatile struct vdc_tio_vp_regs *regs;
118
119    /*
120     * non-zero if we are in yuv mode
121     */
122    u8_t is_yuv;
123
124    /*
125     * Fake palette of 16 colors
126     */
127    u32 pseudo_palette[PALETTE_ENTRIES_NO];
128
129    /*
130     * Wait queue and lock used to block when we need to wait
131     * for something to happen.
132     */
133    wait_queue_head_t waitq;
134    struct mutex lock;
135
136};
137
138/*
139 * ubicom32fb_set_next_frame
140 * Sets the next frame buffer to display
141 *
142 * if sync is TRUE then this function will block until the hardware
143 * acknowledges the change
144 */
145static inline void ubicom32fb_set_next_frame(struct ubicom32fb_drvdata *ud, void *fb, u8_t sync)
146{
147    ud->regs->next_frame_flags = ud->is_yuv ? VDCTIO_NEXT_FRAME_FLAG_YUV : 0;
148    ud->regs->next_frame = (void *)((u32_t)fb | 1);
149
150    /*
151     * If we have interrupts, then we can wait on it
152     */
153    if (ud->rx_int != -1) {
154        DEFINE_WAIT(wait);
155        unsigned long flags;
156
157        spin_lock_irqsave(&ud->lock, flags);
158        prepare_to_wait(&ud->waitq, &wait, TASK_INTERRUPTIBLE);
159        spin_unlock_irqrestore(&ud->lock, flags);
160        schedule();
161        finish_wait(&ud->waitq, &wait);
162        return;
163    }
164
165    /*
166     * No interrupt, we will just spin here
167     */
168    while (sync && ((u32_t)ud->regs->next_frame & 1));
169}
170
171/*
172 * ubicom32fb_send_command
173 * Sends a command/data pair to the VDC
174 */
175static inline void ubicom32fb_send_command(struct ubicom32fb_drvdata *ud, u16 command, u8_t block)
176{
177    ud->regs->command = command;
178    ubicom32_set_interrupt(ud->vp_int);
179    while (block && ud->regs->command);
180}
181
182/*
183 * ubicom32fb_ioctl
184 * Handles any ioctls sent to us
185 */
186static int ubicom32fb_ioctl(struct fb_info *fbi, unsigned int cmd,
187               unsigned long arg)
188{
189    struct ubicom32fb_drvdata *ud = (struct ubicom32fb_drvdata *)fbi->par;
190    void __user *argp = (void __user *)arg;
191    int retval = -EFAULT;
192
193    switch (cmd) {
194    case UBICOM32FB_IOCTL_SET_NEXT_FRAME_SYNC:
195        // check alignment, return -EINVAL if necessary
196        ubicom32fb_set_next_frame(ud, argp, 1);
197        retval = 0;
198        break;
199
200    case UBICOM32FB_IOCTL_SET_NEXT_FRAME:
201        // check alignment, return -EINVAL if necessary
202        ubicom32fb_set_next_frame(ud, argp, 0);
203        retval = 0;
204        break;
205
206    case UBICOM32FB_IOCTL_SET_MODE:
207        if (!(ud->regs->caps & VDCTIO_CAPS_SUPPORTS_SCALING)) {
208            break;
209        } else {
210            struct ubicom32fb_mode mode;
211            volatile struct vdc_tio_vp_regs *regs = ud->regs;
212            u32_t flags = 0;
213
214            if (copy_from_user(&mode, argp, sizeof(mode))) {
215                break;
216            }
217
218            regs->x_in = mode.width;
219            regs->y_in = mode.height;
220            regs->x_out = regs->xres;
221            regs->y_out = regs->yres;
222            if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_YUV_SCAN_ORDER) {
223                flags |= VDCTIO_SCALE_FLAG_YUV_SCAN_ORDER;
224            }
225            if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_YUV_BLOCK_ORDER) {
226                flags |= VDCTIO_SCALE_FLAG_YUV_BLOCK_ORDER;
227            }
228            ud->is_yuv = mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_YUV;
229            if (ud->is_yuv) {
230                flags |= VDCTIO_SCALE_FLAG_YUV;
231            }
232            if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_VRANGE_16_255) {
233                flags |= VDCTIO_SCALE_FLAG_VRANGE_16_255;
234            }
235            if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_VRANGE_0_255) {
236                flags |= VDCTIO_SCALE_FLAG_VRANGE_0_255;
237            }
238            if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_VSUB) {
239                flags |= VDCTIO_SCALE_FLAG_VSUB;
240            }
241            if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_HSUB_2_1) {
242                flags |= VDCTIO_SCALE_FLAG_HSUB_2_1;
243            }
244            if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_HSUB_1_1) {
245                flags |= VDCTIO_SCALE_FLAG_HSUB_1_1;
246            }
247            if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_SCALE_ENABLE) {
248                flags |= VDCTIO_SCALE_FLAG_ENABLE;
249            }
250            if (mode.next_frame) {
251                flags |= VDCTIO_SCALE_FLAG_SET_FRAME_BUFFER;
252                regs->next_frame = mode.next_frame;
253            }
254
255            regs->scale_flags = flags;
256            ubicom32fb_send_command(ud, VDCTIO_COMMAND_SET_SCALE_MODE, 1);
257            retval = 0;
258            break;
259        }
260
261    default:
262        retval = -ENOIOCTLCMD;
263        break;
264    }
265
266    return retval;
267}
268
269/*
270 * ubicom32fb_interrupt
271 * Called by the OS when the TIO has set the rx_int
272 */
273static irqreturn_t ubicom32fb_interrupt(int vec, void *appdata)
274{
275    struct ubicom32fb_drvdata *ud = (struct ubicom32fb_drvdata *)appdata;
276
277    spin_lock(&ud->lock);
278    if (waitqueue_active(&ud->waitq)) {
279        wake_up(&ud->waitq);
280    }
281    spin_unlock(&ud->lock);
282
283    return IRQ_HANDLED;
284}
285
286/*
287 * ubicom32fb_pan_display
288 * Pans the display to a given location. Supports only y direction panning.
289 */
290static int ubicom32fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *fbi)
291{
292    struct ubicom32fb_drvdata *ud = (struct ubicom32fb_drvdata *)fbi->par;
293    void *new_addr;
294
295    /*
296     * Get the last y line that would be displayed. Since we don't support YWRAP,
297     * it must be less than our virtual y size.
298     */
299    u32 lasty = var->yoffset + var->yres;
300    if (lasty > fbi->var.yres_virtual) {
301        /*
302         * We would fall off the end of our frame buffer if we panned here.
303         */
304        return -EINVAL;
305    }
306
307    if (var->xoffset) {
308        /*
309         * We don't support panning in the x direction
310         */
311        return -EINVAL;
312    }
313
314    /*
315     * Everything looks sane, go ahead and pan
316     *
317     * We have to calculate a new address for the VDC to look at
318     */
319    new_addr = ud->fb_aligned + (var->yoffset * fbi->fix.line_length);
320
321    /*
322     * Send down the command. The buffer will switch at the next vertical blank
323     */
324    ubicom32fb_set_next_frame(ud, (void *)new_addr, 0);
325
326    return 0;
327}
328
329/*
330 * ubicom32fb_setcolreg
331 * Sets a color in our virtual palette
332 */
333static int ubicom32fb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue, unsigned transp, struct fb_info *fbi)
334{
335    u32 *palette = fbi->pseudo_palette;
336
337    if (regno >= PALETTE_ENTRIES_NO) {
338        return -EINVAL;
339    }
340
341    /*
342     * We only use 8 bits from each color
343     */
344    red >>= 8;
345    green >>= 8;
346    blue >>= 8;
347
348    /*
349     * Convert any grayscale values
350     */
351    if (fbi->var.grayscale) {
352        u16 gray = red + green + blue;
353        gray += (gray >> 2) + (gray >> 3) - (gray >> 7);
354        gray >>= 2;
355        if (gray > 255) {
356            gray = 255;
357        }
358        red = gray;
359        blue = gray;
360        green = gray;
361    }
362
363    palette[regno] = (red << fbi->var.red.offset) | (green << fbi->var.green.offset) |
364             (blue << fbi->var.blue.offset);
365
366    return 0;
367}
368
369/*
370 * ubicom32fb_mmap
371 */
372static int ubicom32fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
373{
374    struct ubicom32fb_drvdata *drvdata = (struct ubicom32fb_drvdata *)info->par;
375
376    vma->vm_start = (unsigned long)(drvdata->fb_aligned);
377
378    vma->vm_end = vma->vm_start + info->fix.smem_len;
379
380    /* For those who don't understand how mmap works, go read
381     * Documentation/nommu-mmap.txt.
382     * For those that do, you will know that the VM_MAYSHARE flag
383     * must be set in the vma->vm_flags structure on noMMU
384     * Other flags can be set, and are documented in
385     * include/linux/mm.h
386     */
387
388    vma->vm_flags |= VM_MAYSHARE | VM_SHARED;
389
390    return 0;
391}
392
393/*
394 * ubicom32fb_blank
395 */
396static int ubicom32fb_blank(int blank_mode, struct fb_info *fbi)
397{
398    return 0;
399#if 0
400    struct ubicom32fb_drvdata *drvdata = to_ubicom32fb_drvdata(fbi);
401
402    switch (blank_mode) {
403    case FB_BLANK_UNBLANK:
404        /* turn on panel */
405        ubicom32fb_out_be32(drvdata, REG_CTRL, drvdata->reg_ctrl_default);
406        break;
407
408    case FB_BLANK_NORMAL:
409    case FB_BLANK_VSYNC_SUSPEND:
410    case FB_BLANK_HSYNC_SUSPEND:
411    case FB_BLANK_POWERDOWN:
412        /* turn off panel */
413        ubicom32fb_out_be32(drvdata, REG_CTRL, 0);
414    default:
415        break;
416
417    }
418    return 0; /* success */
419#endif
420}
421
422static struct fb_ops ubicom32fb_ops =
423{
424    .owner = THIS_MODULE,
425    .fb_pan_display = ubicom32fb_pan_display,
426    .fb_setcolreg = ubicom32fb_setcolreg,
427    .fb_blank = ubicom32fb_blank,
428    .fb_mmap = ubicom32fb_mmap,
429    .fb_ioctl = ubicom32fb_ioctl,
430    .fb_fillrect = cfb_fillrect,
431    .fb_copyarea = cfb_copyarea,
432    .fb_imageblit = cfb_imageblit,
433};
434
435/*
436 * ubicom32fb_release
437 */
438static int ubicom32fb_release(struct device *dev)
439{
440    struct ubicom32fb_drvdata *ud = dev_get_drvdata(dev);
441
442#if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
443    //ubicom32fb_blank(VESA_POWERDOWN, &drvdata->info);
444#endif
445
446    unregister_framebuffer(ud->fbinfo);
447
448    if (ud->cmap_alloc) {
449        fb_dealloc_cmap(&ud->fbinfo->cmap);
450    }
451
452    if (ud->fb) {
453        kfree(ud->fb);
454    }
455
456    if (ud->rx_int != -1) {
457        free_irq(ud->rx_int, ud);
458    }
459
460    /*
461     * Turn off the display
462     */
463    //ubicom32fb_out_be32(drvdata, REG_CTRL, 0);
464    //iounmap(drvdata->regs);
465
466    framebuffer_release(ud->fbinfo);
467    dev_set_drvdata(dev, NULL);
468
469    return 0;
470}
471
472/*
473 * ubicom32fb_platform_probe
474 */
475static int __init ubicom32fb_platform_probe(struct platform_device *pdev)
476{
477    struct ubicom32fb_drvdata *ud;
478    struct resource *irq_resource_rx;
479    struct resource *irq_resource_tx;
480    struct resource *mem_resource;
481    struct fb_info *fbinfo;
482    int rc;
483    size_t fbsize;
484    struct device *dev = &pdev->dev;
485    int offset;
486    struct vdc_tio_vp_regs *regs;
487
488    /*
489     * Get our resources
490     */
491    irq_resource_tx = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
492    if (!irq_resource_tx) {
493        dev_err(dev, "No tx IRQ resource assigned\n");
494        return -ENODEV;
495    }
496
497    irq_resource_rx = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
498    if (!irq_resource_rx) {
499        dev_err(dev, "No rx IRQ resource assigned\n");
500        return -ENODEV;
501    }
502
503    mem_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
504    if (!mem_resource || !mem_resource->start) {
505        dev_err(dev, "No mem resource assigned\n");
506        return -ENODEV;
507    }
508    regs = (struct vdc_tio_vp_regs *)mem_resource->start;
509    if (regs->version != VDCTIO_VP_VERSION) {
510        dev_err(dev, "VDCTIO is not compatible with this driver tio:%x drv:%x\n",
511            regs->version, VDCTIO_VP_VERSION);
512        return -ENODEV;
513    }
514
515    /*
516     * This is the minimum VRAM size
517     */
518    fbsize = regs->xres * regs->yres * (regs->bpp / 8);
519    if (!vram_size) {
520        vram_size = (fbsize + 1023) / 1024;
521    } else {
522        if (fbsize > (vram_size * 1024)) {
523            dev_err(dev, "Not enough VRAM for display, need >= %u bytes\n", fbsize);
524            return -ENOMEM; // should be ebadparam?
525        }
526    }
527
528    /*
529     * Allocate the framebuffer instance + our private data
530     */
531    fbinfo = framebuffer_alloc(sizeof(struct ubicom32fb_drvdata), &pdev->dev);
532    if (!fbinfo) {
533        dev_err(dev, "Not enough memory to allocate instance.\n");
534        return -ENOMEM;
535    }
536
537    /*
538     * Fill in our private data.
539     */
540    ud = (struct ubicom32fb_drvdata *)fbinfo->par;
541    ud->fbinfo = fbinfo;
542    ud->regs = (struct vdc_tio_vp_regs *)(mem_resource->start);
543    dev_set_drvdata(dev, ud);
544
545    ud->vp_int = irq_resource_tx->start;
546
547    /*
548     * If we were provided an rx_irq then we need to init the appropriate
549     * queues, locks, and functions.
550     */
551    ud->rx_int = -1;
552    if (irq_resource_rx->start != DEVTREE_IRQ_NONE) {
553        init_waitqueue_head(&ud->waitq);
554        mutex_init(&ud->lock);
555        if (request_irq(ud->rx_int, ubicom32fb_interrupt, IRQF_SHARED, "ubicom32fb_rx", ud)) {
556            dev_err(dev, "Couldn't request rx IRQ\n");
557            rc = -ENOMEM;
558            goto fail;
559        }
560        ud->rx_int = irq_resource_rx->start;
561    }
562
563    /*
564     * Allocate and align the requested amount of VRAM
565     */
566    ud->total_vram_size = (vram_size * 1024) + regs->fb_align;
567    ud->fb = kmalloc(ud->total_vram_size, GFP_KERNEL);
568    if (ud->fb == NULL) {
569        dev_err(dev, "Couldn't allocate VRAM\n");
570        rc = -ENOMEM;
571        goto fail;
572    }
573
574    offset = (u32_t)ud->fb & (regs->fb_align - 1);
575    if (!offset) {
576        ud->fb_aligned = ud->fb;
577    } else {
578        offset = regs->fb_align - offset;
579        ud->fb_aligned = ud->fb + offset;
580    }
581
582    /*
583     * Clear the entire frame buffer
584     */
585    if (!init_value) {
586        memset(ud->fb_aligned, 0, vram_size * 1024);
587    } else {
588        unsigned short *p = ud->fb_aligned;
589        int i;
590        for (i = 0; i < ((vram_size * 1024) / sizeof(u16_t)); i++) {
591            *p++ = init_value;
592        }
593    }
594
595    /*
596     * Fill in the fb_var_screeninfo structure
597     */
598    memset(&ubicom32fb_var, 0, sizeof(ubicom32fb_var));
599    ubicom32fb_var.bits_per_pixel = regs->bpp;
600    ubicom32fb_var.red.offset = regs->rshift;
601    ubicom32fb_var.green.offset = regs->gshift;
602    ubicom32fb_var.blue.offset = regs->bshift;
603    ubicom32fb_var.red.length = regs->rbits;
604    ubicom32fb_var.green.length = regs->gbits;
605    ubicom32fb_var.blue.length = regs->bbits;
606    ubicom32fb_var.activate = FB_ACTIVATE_NOW;
607
608#if 0
609    /*
610     * Turn on the display
611     */
612    ud->reg_ctrl_default = REG_CTRL_ENABLE;
613    if (regs->rotate_screen)
614        ud->reg_ctrl_default |= REG_CTRL_ROTATE;
615    ubicom32fb_out_be32(ud, REG_CTRL, ud->reg_ctrl_default);
616#endif
617
618    /*
619     * Fill in the fb_info structure
620     */
621    ud->fbinfo->device = dev;
622    ud->fbinfo->screen_base = (void *)ud->fb_aligned;
623    ud->fbinfo->fbops = &ubicom32fb_ops;
624    ud->fbinfo->fix = ubicom32fb_fix;
625    ud->fbinfo->fix.smem_start = (u32)ud->fb_aligned;
626    ud->fbinfo->fix.smem_len = vram_size * 1024;
627    ud->fbinfo->fix.line_length = regs->xres * (regs->bpp / 8);
628    ud->fbinfo->fix.mmio_start = (u32)regs;
629    ud->fbinfo->fix.mmio_len = sizeof(struct vdc_tio_vp_regs);
630
631    /*
632     * We support panning in the y direction only
633     */
634    ud->fbinfo->fix.xpanstep = 0;
635    ud->fbinfo->fix.ypanstep = 1;
636
637    ud->fbinfo->pseudo_palette = ud->pseudo_palette;
638    ud->fbinfo->flags = FBINFO_DEFAULT;
639    ud->fbinfo->var = ubicom32fb_var;
640    ud->fbinfo->var.xres = regs->xres;
641    ud->fbinfo->var.yres = regs->yres;
642
643    /*
644     * We cannot pan in the X direction, so xres_virtual is regs->xres
645     * We can pan in the Y direction, so yres_virtual is vram_size / ud->fbinfo->fix.line_length
646     */
647    ud->fbinfo->var.xres_virtual = regs->xres;
648    ud->fbinfo->var.yres_virtual = (vram_size * 1024) / ud->fbinfo->fix.line_length;
649
650    //ud->fbinfo->var.height = regs->height_mm;
651    //ud->fbinfo->var.width = regs->width_mm;
652
653    /*
654     * Allocate a color map
655     */
656    rc = fb_alloc_cmap(&ud->fbinfo->cmap, PALETTE_ENTRIES_NO, 0);
657    if (rc) {
658        dev_err(dev, "Fail to allocate colormap (%d entries)\n",
659            PALETTE_ENTRIES_NO);
660        goto fail;
661    }
662    ud->cmap_alloc = true;
663
664    /*
665     * Register new frame buffer
666     */
667    rc = register_framebuffer(ud->fbinfo);
668    if (rc) {
669        dev_err(dev, "Could not register frame buffer\n");
670        goto fail;
671    }
672
673    /*
674     * Start up the VDC
675     */
676    ud->regs->next_frame = ud->fb;
677    ubicom32fb_send_command(ud, VDCTIO_COMMAND_START, 0);
678
679    /*
680     * Tell the log we are here
681     */
682    dev_info(dev, "fbaddr=%p align=%p, size=%uKB screen(%ux%u) virt(%ux%u), regs=%p irqtx=%u irqrx=%u\n",
683        ud->fb, ud->fb_aligned, vram_size, ud->fbinfo->var.xres, ud->fbinfo->var.yres,
684        ud->fbinfo->var.xres_virtual, ud->fbinfo->var.yres_virtual, ud->regs,
685        irq_resource_tx->start, irq_resource_rx->start);
686
687    /*
688     * Success
689     */
690    return 0;
691
692fail:
693    ubicom32fb_release(dev);
694    return rc;
695}
696
697/*
698 * ubicom32fb_platform_remove
699 */
700static int ubicom32fb_platform_remove(struct platform_device *pdev)
701{
702    dev_info(&(pdev->dev), "Ubicom32 FB Driver Remove\n");
703    return ubicom32fb_release(&pdev->dev);
704}
705
706static struct platform_driver ubicom32fb_platform_driver = {
707    .probe = ubicom32fb_platform_probe,
708    .remove = ubicom32fb_platform_remove,
709    .driver = {
710        .name = DRIVER_NAME,
711        .owner = THIS_MODULE,
712    },
713};
714
715#ifndef MODULE
716/*
717 * ubicom32fb_setup
718 * Process kernel boot options
719 */
720static int __init ubicom32fb_setup(char *options)
721{
722    char *this_opt;
723
724    if (!options || !*options) {
725        return 0;
726    }
727
728    while ((this_opt = strsep(&options, ",")) != NULL) {
729        if (!*this_opt) {
730            continue;
731        }
732
733        if (!strncmp(this_opt, "init_value=", 10)) {
734            init_value = simple_strtoul(this_opt + 11, NULL, 0);
735            continue;
736        }
737
738        if (!strncmp(this_opt, "vram_size=", 10)) {
739            vram_size = simple_strtoul(this_opt + 10, NULL, 0);
740            continue;
741        }
742    }
743    return 0;
744}
745#endif /* MODULE */
746
747/*
748 * ubicom32fb_init
749 */
750static int __devinit ubicom32fb_init(void)
751{
752#ifndef MODULE
753    /*
754     * Get kernel boot options (in 'video=ubicom32fb:<options>')
755     */
756    char *option = NULL;
757
758    if (fb_get_options(DRIVER_NAME, &option)) {
759        return -ENODEV;
760    }
761    ubicom32fb_setup(option);
762#endif /* MODULE */
763
764    return platform_driver_register(&ubicom32fb_platform_driver);
765}
766module_init(ubicom32fb_init);
767
768/*
769 * ubicom32fb_exit
770 */
771static void __exit ubicom32fb_exit(void)
772{
773    platform_driver_unregister(&ubicom32fb_platform_driver);
774}
775module_exit(ubicom32fb_exit);
776
777MODULE_LICENSE("GPL");
778MODULE_AUTHOR("Patrick Tjin <@ubicom.com>");
779MODULE_DESCRIPTION(DRIVER_DESCRIPTION);
780

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive