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

1/*
2 * drivers/video/ubicom32plio80.c
3 * Ubicom32 80 bus PLIO 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
24/*
25 * This driver was based on skeletonfb.c, Skeleton for a frame buffer device by
26 * Geert Uytterhoeven.
27 */
28
29#include <linux/device.h>
30#include <linux/module.h>
31#include <linux/kernel.h>
32#include <linux/version.h>
33#include <linux/errno.h>
34#include <linux/string.h>
35#include <linux/mm.h>
36#include <linux/fb.h>
37#include <linux/init.h>
38#include <linux/interrupt.h>
39#include <linux/dma-mapping.h>
40#include <linux/platform_device.h>
41#include <linux/device.h>
42#include <linux/uaccess.h>
43#include <asm/plio.h>
44
45#define DRIVER_NAME "ubicom32plio80"
46#define DRIVER_DESCRIPTION "Ubicom32 80 bus PLIO frame buffer driver"
47
48#define PALETTE_ENTRIES_NO 16
49
50/*
51 * Option variables
52 *
53 * vram_size: VRAM size in kilobytes, subject to alignment
54 */
55static int vram_size = 0;
56module_param(vram_size, int, 0);
57MODULE_PARM_DESC(vram_size, "VRAM size, in kilobytes to allocate, should be at least the size of one screen, subject to alignment");
58
59static int xres = 240;
60module_param(xres, int, 0);
61MODULE_PARM_DESC(xres, "x (horizontal) resolution");
62
63static int yres = 320;
64module_param(yres, int, 0);
65MODULE_PARM_DESC(yres, "y (vertical) resolution");
66
67static int bgr = 0;
68module_param(bgr, int, 0);
69MODULE_PARM_DESC(bgr, "display is BGR (Blue is MSB)");
70
71#define BITS_PER_PIXEL 16
72
73/*
74 * Buffer alignment, must not be 0
75 */
76#define UBICOM32PLIO80_ALIGNMENT 4
77
78/*
79 * PLIO FSM
80 * 16-bit data bus on port I
81 * CS on EXTCTL[6]
82 * WR on EXTCTL[4]
83 */
84static const plio_fctl_t plio_fctl = {
85    .fctl0 = {
86        .ptif_port_mode = PLIO_PORT_MODE_DI,
87        .ptif_portd_cfg = 0,
88        .ptif_porti_cfg = 3,
89        .edif_ds = 6,
90        .edif_cmp_mode = 1,
91        .ecif_extclk_ena = 0, // enable clock output on PD7 table 2.65/p111 says extctl[0]?
92        .icif_clk_src_sel = PLIO_CLK_IO,
93    },
94    .fctl2 = {
95        .icif_eclk_div = 10,
96        .icif_iclk_div = 10,
97    },
98
99    };
100
101    static const plio_config_t plio_config = {
102    .pfsm = {
103        /*
104         * Table 12.63
105         */
106        .grpsel[0] = {1,1,1,1,1,1,1,1,1,1},
107
108        /*
109        * Table 12.66 Counter load value
110        */
111        .cs_lut[0] = {0,0,0,0,0,0,0,0},
112
113        /*
114         * Table 2.75 PLIO PFSM Configuration Registers
115         */
116        // 3 2 1 0
117        .extctl_o_lut[0] = {0x3f, 0x2f, 0x3f, 0x3f},
118        // 7 6 5 4
119        .extctl_o_lut[1] = {0x3f, 0x3f, 0x3f, 0x2f},
120    },
121    .edif = {
122        .odr_oe = 0xffff,
123    },
124    .ecif = {
125        .output_ena = (1 << 6) | (1 << 4),
126    },
127};
128
129static const u32_t ubicom32plio80_plio_fsm[] = {
130    // 0-F
131    0x00070007, 0x00070007,
132    0x00070007, 0x00070007,
133    0x00070007, 0x00070007,
134    0x00070007, 0x00070007,
135
136    0x16260806, 0x16260806,
137    0x16260806, 0x16260806,
138    0x16260806, 0x16260806,
139    0x16260806, 0x16260806,
140
141    // 10 - 1f
142    0x22061806, 0x22061806,
143    0x22061806, 0x22061806,
144    0x22061806, 0x22061806,
145    0x22061806, 0x22061806,
146
147    0x22061806, 0x22061806,
148    0x22061806, 0x22061806,
149    0x22061806, 0x22061806,
150    0x22061806, 0x22061806,
151
152    // 20 - 2f
153    0x00070806, 0x00070806,
154    0x00070806, 0x00070806,
155    0x00070806, 0x00070806,
156    0x00070806, 0x00070806,
157
158    0x00070806, 0x00070806,
159    0x00070806, 0x00070806,
160    0x00070806, 0x00070806,
161    0x00070806, 0x00070806,
162};
163
164/*
165 * fb_fix_screeninfo defines the non-changeable properties of the VDC, depending on what mode it is in.
166 */
167static struct fb_fix_screeninfo ubicom32plio80_fix = {
168    .id = "Ubicom32",
169    .type = FB_TYPE_PACKED_PIXELS,
170    .visual = FB_VISUAL_TRUECOLOR,
171    .accel = FB_ACCEL_UBICOM32_PLIO80,
172};
173
174/*
175 * Filled in at probe time when we find out what the hardware supports
176 */
177static struct fb_var_screeninfo ubicom32plio80_var;
178
179/*
180 * Private data structure
181 */
182struct ubicom32plio80_drvdata {
183    struct fb_info *fbinfo;
184    bool cmap_alloc;
185
186    /*
187     * The address of the framebuffer in memory
188     */
189    void *fb;
190    void *fb_aligned;
191
192    /*
193     * Total size of vram including alignment allowance
194     */
195    u32 total_vram_size;
196
197    /*
198     * Fake palette of 16 colors
199     */
200    u32 pseudo_palette[PALETTE_ENTRIES_NO];
201
202    int irq_req;
203
204    /*
205     * Current pointer and bytes left to transfer with the PLIO
206     */
207    void *xfer_ptr;
208    u32 bytes_to_xfer;
209    u32 busy;
210};
211
212static struct platform_device *ubicom32plio80_platform_device;
213
214/*
215 * ubicom32plio80_isr
216 */
217static int ubicom32plio80_isr(int irq, void *appdata)
218{
219    struct ubicom32plio80_drvdata *ud = (struct ubicom32plio80_drvdata *)appdata;
220
221    if (!ud->bytes_to_xfer) {
222        ubicom32_disable_interrupt(TX_FIFO_INT(PLIO_PORT));
223        PLIO_NBR->intmask.txfifo_wm = 0;
224        ud->busy = 0;
225        return IRQ_HANDLED;
226    }
227
228    asm volatile (
229        ".rept 8 \n\t"
230        "move.4 (%[fifo]), (%[data])4++ \n\t"
231        ".endr \n\t"
232        : [data] "+a" (ud->xfer_ptr)
233        : [fifo] "a" (&PLIO_NBR->tx_lo)
234    );
235
236    ud->bytes_to_xfer -= 32;
237
238    return IRQ_HANDLED;
239}
240
241/*
242 * ubicom32plio80_update
243 */
244static void ubicom32plio80_update(struct ubicom32plio80_drvdata *ud, u32 *fb)
245{
246    struct ubicom32_io_port *ri = (struct ubicom32_io_port *)RI;
247    struct ubicom32_io_port *rd = (struct ubicom32_io_port *)RD;
248
249    ud->xfer_ptr = fb;
250    ud->bytes_to_xfer = (xres * yres * 2) - 64;
251    ud->busy = 1;
252
253    ri->gpio_mask = 0;
254    rd->gpio_mask &= ~((1 << 4) | (1 << 2));
255
256    *(u32 *)(&PLIO_NBR->intclr) = ~0;
257    PLIO_NBR->intmask.txfifo_wm = 1;
258    PLIO_NBR->fifo_wm.tx = 8;
259    ubicom32_enable_interrupt(TX_FIFO_INT(PLIO_PORT));
260
261    asm volatile (
262        ".rept 16 \n\t"
263        "move.4 (%[fifo]), (%[data])4++ \n\t"
264        ".endr \n\t"
265        : [data] "+a" (ud->xfer_ptr)
266        : [fifo] "a" (&PLIO_NBR->tx_lo)
267    );
268}
269
270/*
271 * ubicom32plio80_pan_display
272 * Pans the display to a given location. Supports only y direction panning.
273 */
274static int ubicom32plio80_pan_display(struct fb_var_screeninfo *var, struct fb_info *fbi)
275{
276    struct ubicom32plio80_drvdata *ud = (struct ubicom32plio80_drvdata *)fbi->par;
277    void *new_addr;
278
279    /*
280     * Get the last y line that would be displayed. Since we don't support YWRAP,
281     * it must be less than our virtual y size.
282     */
283    u32 lasty = var->yoffset + var->yres;
284    if (lasty > fbi->var.yres_virtual) {
285        /*
286         * We would fall off the end of our frame buffer if we panned here.
287         */
288        return -EINVAL;
289    }
290
291    if (var->xoffset) {
292        /*
293         * We don't support panning in the x direction
294         */
295        return -EINVAL;
296    }
297
298    /*
299     * Everything looks sane, go ahead and pan
300     *
301     * We have to calculate a new address for the VDC to look at
302     */
303    new_addr = ud->fb_aligned + (var->yoffset * fbi->fix.line_length);
304
305    return 0;
306}
307
308/*
309 * ubicom32plio80_setcolreg
310 * Sets a color in our virtual palette
311 */
312static int ubicom32plio80_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue, unsigned transp, struct fb_info *fbi)
313{
314    u32 *palette = fbi->pseudo_palette;
315
316    if (regno >= PALETTE_ENTRIES_NO) {
317        return -EINVAL;
318    }
319
320    /*
321     * We only use 8 bits from each color
322     */
323    red >>= 8;
324    green >>= 8;
325    blue >>= 8;
326
327    /*
328     * Convert any grayscale values
329     */
330    if (fbi->var.grayscale) {
331        u16 gray = red + green + blue;
332        gray += (gray >> 2) + (gray >> 3) - (gray >> 7);
333        gray >>= 2;
334        if (gray > 255) {
335            gray = 255;
336        }
337        red = gray;
338        blue = gray;
339        green = gray;
340    }
341
342    palette[regno] = (red << fbi->var.red.offset) | (green << fbi->var.green.offset) |
343             (blue << fbi->var.blue.offset);
344
345    return 0;
346}
347
348/*
349 * ubicom32plio80_mmap
350 */
351static int ubicom32plio80_mmap(struct fb_info *info, struct vm_area_struct *vma)
352{
353    struct ubicom32plio80_drvdata *ud = (struct ubicom32plio80_drvdata *)info->par;
354
355    vma->vm_start = (unsigned long)(ud->fb_aligned);
356
357    vma->vm_end = vma->vm_start + info->fix.smem_len;
358
359    /* For those who don't understand how mmap works, go read
360     * Documentation/nommu-mmap.txt.
361     * For those that do, you will know that the VM_MAYSHARE flag
362     * must be set in the vma->vm_flags structure on noMMU
363     * Other flags can be set, and are documented in
364     * include/linux/mm.h
365     */
366
367    vma->vm_flags |= VM_MAYSHARE | VM_SHARED;
368
369    return 0;
370}
371
372/*
373 * ubicom32plio80_check_var
374 * Check the var, tweak it but don't change operational parameters.
375 */
376static int ubicom32plio80_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
377{
378    struct ubicom32plio80_drvdata *ud = (struct ubicom32plio80_drvdata *)info->par;
379    u32 line_size = var->xres * (BITS_PER_PIXEL / 8);
380
381    /*
382     * See if we can handle this bpp
383     */
384    if (var->bits_per_pixel > BITS_PER_PIXEL) {
385        return -EINVAL;
386    }
387    var->bits_per_pixel = BITS_PER_PIXEL;
388
389    /*
390     * See if we have enough memory to handle this resolution
391     */
392    if ((line_size * var->yres * BITS_PER_PIXEL / 8) > ud->total_vram_size) {
393        return -EINVAL;
394    }
395
396    var->xres_virtual = var->xres;
397    var->yres_virtual = ud->total_vram_size / line_size;
398
399    var->red.length = 5;
400    var->green.length = 6;
401    var->green.offset = 5;
402    var->blue.length = 5;
403    var->transp.offset = var->transp.length = 0;
404
405    if (bgr) {
406        var->red.offset = 0;
407        var->blue.offset = 11;
408    } else {
409        var->red.offset = 11;
410        var->blue.offset = 0;
411    }
412
413    var->nonstd = 0;
414    var->height = -1;
415    var->width = -1;
416    var->vmode = FB_VMODE_NONINTERLACED;
417    var->sync = 0;
418
419    return 0;
420}
421
422/*
423 * ubicom32plio80_set_par
424 * Set the video mode according to info->var
425 */
426static int ubicom32plio80_set_par(struct fb_info *info)
427{
428    /*
429     * Anything changed?
430     */
431    if ((xres == info->var.xres) && (yres == info->var.yres)) {
432        return 0;
433    }
434
435    /*
436     * Implement changes
437     */
438    xres = info->var.xres;
439    yres = info->var.yres;
440    info->fix.visual = FB_VISUAL_TRUECOLOR;
441    info->fix.xpanstep = 0;
442    info->fix.ypanstep = 1;
443    info->fix.line_length = xres * (BITS_PER_PIXEL / 8);
444
445    return 0;
446}
447
448/*
449 * ubicom32plio80_ops
450 * List of supported operations
451 */
452static struct fb_ops ubicom32plio80_ops =
453{
454    .owner = THIS_MODULE,
455    .fb_pan_display = ubicom32plio80_pan_display,
456    .fb_setcolreg = ubicom32plio80_setcolreg,
457    .fb_mmap = ubicom32plio80_mmap,
458    .fb_check_var = ubicom32plio80_check_var,
459    .fb_set_par = ubicom32plio80_set_par,
460    .fb_fillrect = cfb_fillrect,
461    .fb_copyarea = cfb_copyarea,
462    .fb_imageblit = cfb_imageblit,
463};
464
465/*
466 * ubicom32plio80_release
467 */
468static int ubicom32plio80_release(struct device *dev)
469{
470    struct ubicom32plio80_drvdata *ud = dev_get_drvdata(dev);
471
472    unregister_framebuffer(ud->fbinfo);
473
474    if (ud->irq_req) {
475        free_irq(TX_FIFO_INT(PLIO_PORT), ud);
476    }
477    if (ud->cmap_alloc) {
478        fb_dealloc_cmap(&ud->fbinfo->cmap);
479    }
480
481    if (ud->fb) {
482        kfree(ud->fb);
483    }
484
485    framebuffer_release(ud->fbinfo);
486    dev_set_drvdata(dev, NULL);
487
488    return 0;
489}
490
491/*
492 * ubicom32plio80_platform_probe
493 */
494static int __init ubicom32plio80_platform_probe(struct platform_device *pdev)
495{
496    struct ubicom32plio80_drvdata *ud;
497    struct fb_info *fbinfo;
498    int rc;
499    size_t fbsize;
500    struct device *dev = &pdev->dev;
501    int offset;
502
503    /*
504     * This is the minimum VRAM size
505     */
506    fbsize = xres * yres * 2;
507    if (!vram_size) {
508        vram_size = (fbsize + 1023) / 1024;
509    } else {
510        if (fbsize > (vram_size * 1024)) {
511            dev_err(dev, "Not enough VRAM for display, need >= %u bytes\n", fbsize);
512            return -ENOMEM; // should be ebadparam?
513        }
514    }
515
516    /*
517     * Allocate the framebuffer instance + our private data
518     */
519    fbinfo = framebuffer_alloc(sizeof(struct ubicom32plio80_drvdata), &pdev->dev);
520    if (!fbinfo) {
521        dev_err(dev, "Not enough memory to allocate instance.\n");
522        return -ENOMEM;
523    }
524
525    /*
526     * Fill in our private data.
527     */
528    ud = (struct ubicom32plio80_drvdata *)fbinfo->par;
529    ud->fbinfo = fbinfo;
530    dev_set_drvdata(dev, ud);
531
532    /*
533     * Allocate and align the requested amount of VRAM
534     */
535    ud->total_vram_size = (vram_size * 1024) + UBICOM32PLIO80_ALIGNMENT;
536    ud->fb = kmalloc(ud->total_vram_size, GFP_KERNEL);
537    if (ud->fb == NULL) {
538        dev_err(dev, "Couldn't allocate VRAM\n");
539        rc = -ENOMEM;
540        goto fail;
541    }
542
543    offset = (u32_t)ud->fb & (UBICOM32PLIO80_ALIGNMENT - 1);
544    if (!offset) {
545        ud->fb_aligned = ud->fb;
546    } else {
547        offset = UBICOM32PLIO80_ALIGNMENT - offset;
548        ud->fb_aligned = ud->fb + offset;
549    }
550
551    /*
552     * Clear the entire frame buffer
553     */
554    memset(ud->fb_aligned, 0, vram_size * 1024);
555
556    /*
557     * Fill in the fb_var_screeninfo structure
558     */
559    memset(&ubicom32plio80_var, 0, sizeof(ubicom32plio80_var));
560    ubicom32plio80_var.bits_per_pixel = BITS_PER_PIXEL;
561    ubicom32plio80_var.red.length = 5;
562    ubicom32plio80_var.green.length = 6;
563    ubicom32plio80_var.green.offset = 5;
564    ubicom32plio80_var.blue.length = 5;
565    ubicom32plio80_var.activate = FB_ACTIVATE_NOW;
566
567    if (bgr) {
568        ubicom32plio80_var.red.offset = 0;
569        ubicom32plio80_var.blue.offset = 11;
570    } else {
571        ubicom32plio80_var.red.offset = 11;
572        ubicom32plio80_var.blue.offset = 0;
573    }
574
575    /*
576     * Fill in the fb_info structure
577     */
578    ud->fbinfo->device = dev;
579    ud->fbinfo->screen_base = (void *)ud->fb_aligned;
580    ud->fbinfo->fbops = &ubicom32plio80_ops;
581    ud->fbinfo->fix = ubicom32plio80_fix;
582    ud->fbinfo->fix.smem_start = (u32)ud->fb_aligned;
583    ud->fbinfo->fix.smem_len = vram_size * 1024;
584    ud->fbinfo->fix.line_length = xres * 2;
585    ud->fbinfo->fix.mmio_start = (u32)ud;
586    ud->fbinfo->fix.mmio_len = sizeof(struct ubicom32plio80_drvdata);
587
588    /*
589     * We support panning in the y direction only
590     */
591    ud->fbinfo->fix.xpanstep = 0;
592    ud->fbinfo->fix.ypanstep = 1;
593
594    ud->fbinfo->pseudo_palette = ud->pseudo_palette;
595    ud->fbinfo->flags = FBINFO_DEFAULT;
596    ud->fbinfo->var = ubicom32plio80_var;
597    ud->fbinfo->var.xres = xres;
598    ud->fbinfo->var.yres = yres;
599
600    /*
601     * We cannot pan in the X direction, so xres_virtual is xres
602     * We can pan in the Y direction, so yres_virtual is vram_size / ud->fbinfo->fix.line_length
603     */
604    ud->fbinfo->var.xres_virtual = xres;
605    ud->fbinfo->var.yres_virtual = (vram_size * 1024) / ud->fbinfo->fix.line_length;
606
607    /*
608     * Allocate a color map
609     */
610    rc = fb_alloc_cmap(&ud->fbinfo->cmap, PALETTE_ENTRIES_NO, 0);
611    if (rc) {
612        dev_err(dev, "Fail to allocate colormap (%d entries)\n",
613            PALETTE_ENTRIES_NO);
614        goto fail;
615    }
616    ud->cmap_alloc = true;
617
618    /*
619     * Register new frame buffer
620     */
621    rc = register_framebuffer(ud->fbinfo);
622    if (rc) {
623        dev_err(dev, "Could not register frame buffer\n");
624        goto fail;
625    }
626
627    /*
628     * request the PLIO IRQ
629     */
630    rc = request_irq(TX_FIFO_INT(PLIO_PORT), ubicom32plio80_isr, IRQF_DISABLED, "ubicom32plio80", ud);
631    if (rc) {
632        dev_err(dev, "Could not request IRQ\n");
633        goto fail;
634    }
635    ud->irq_req = 1;
636
637    /*
638     * Clear any garbage out of the TX FIFOs (idif_txfifo_flush)
639     *
640     * cast through ubicom32_io_port to make sure the compiler does a word write
641     */
642    ((struct ubicom32_io_port *)PLIO_NBR)->int_set = (1 << 18);
643
644    /*
645     * Start up the state machine
646     */
647    plio_init(&plio_fctl, &plio_config, (plio_sram_t *)ubicom32plio80_plio_fsm, sizeof(ubicom32plio80_plio_fsm));
648    PLIO_NBR->fctl0.pfsm_cmd = 0;
649
650    ubicom32plio80_update(ud, ud->fb_aligned);
651
652    /*
653     * Tell the log we are here
654     */
655    dev_info(dev, "fbaddr=%p align=%p, size=%uKB screen(%ux%u) virt(%ux%u)\n",
656        ud->fb, ud->fb_aligned, vram_size, ud->fbinfo->var.xres, ud->fbinfo->var.yres,
657        ud->fbinfo->var.xres_virtual, ud->fbinfo->var.yres_virtual);
658
659    /*
660     * Success
661     */
662    return 0;
663
664fail:
665    ubicom32plio80_release(dev);
666    return rc;
667}
668
669/*
670 * ubicom32plio80_platform_remove
671 */
672static int ubicom32plio80_platform_remove(struct platform_device *pdev)
673{
674    dev_info(&(pdev->dev), "Ubicom32 FB Driver Remove\n");
675    return ubicom32plio80_release(&pdev->dev);
676}
677
678static struct platform_driver ubicom32plio80_platform_driver = {
679    .probe = ubicom32plio80_platform_probe,
680    .remove = ubicom32plio80_platform_remove,
681    .driver = {
682        .name = DRIVER_NAME,
683        .owner = THIS_MODULE,
684    },
685};
686
687#ifndef MODULE
688/*
689 * ubicom32plio80_setup
690 * Process kernel boot options
691 */
692static int __init ubicom32plio80_setup(char *options)
693{
694    char *this_opt;
695
696    if (!options || !*options) {
697        return 0;
698    }
699
700    while ((this_opt = strsep(&options, ",")) != NULL) {
701        if (!*this_opt) {
702            continue;
703        }
704
705        if (!strncmp(this_opt, "vram_size=", 10)) {
706            vram_size = simple_strtoul(this_opt + 10, NULL, 0);
707            continue;
708        }
709
710        if (!strncmp(this_opt, "bgr=", 4)) {
711            bgr = simple_strtoul(this_opt + 4, NULL, 0);
712            continue;
713        }
714
715        if (!strncmp(this_opt, "xres=", 5)) {
716            xres = simple_strtoul(this_opt + 5, NULL, 0);
717            continue;
718        }
719
720        if (!strncmp(this_opt, "yres=", 5)) {
721            yres = simple_strtoul(this_opt + 5, NULL, 0);
722            continue;
723        }
724    }
725    return 0;
726}
727#endif /* MODULE */
728
729/*
730 * ubicom32plio80_init
731 */
732static int __devinit ubicom32plio80_init(void)
733{
734    int ret;
735
736#ifndef MODULE
737    /*
738     * Get kernel boot options (in 'video=ubicom32plio80:<options>')
739     */
740    char *option = NULL;
741
742    if (fb_get_options(DRIVER_NAME, &option)) {
743        return -ENODEV;
744    }
745    ubicom32plio80_setup(option);
746#endif /* MODULE */
747
748    ret = platform_driver_register(&ubicom32plio80_platform_driver);
749
750    if (!ret) {
751        ubicom32plio80_platform_device = platform_device_alloc(DRIVER_NAME, 0);
752
753        if (ubicom32plio80_platform_device)
754            ret = platform_device_add(ubicom32plio80_platform_device);
755        else
756            ret = -ENOMEM;
757
758        if (ret) {
759            platform_device_put(ubicom32plio80_platform_device);
760            platform_driver_unregister(&ubicom32plio80_platform_driver);
761        }
762    }
763
764    return ret;
765}
766module_init(ubicom32plio80_init);
767
768/*
769 * ubicom32plio80_exit
770 */
771static void __exit ubicom32plio80_exit(void)
772{
773    platform_device_unregister(ubicom32plio80_platform_device);
774    platform_driver_unregister(&ubicom32plio80_platform_driver);
775}
776module_exit(ubicom32plio80_exit);
777
778MODULE_LICENSE("GPL");
779MODULE_AUTHOR("Patrick Tjin <@ubicom.com>");
780MODULE_DESCRIPTION(DRIVER_DESCRIPTION);
781

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