Ticket #1234: glamo-fb-dma.patch

File glamo-fb-dma.patch, 42.0 KB (added by dodji@…, 11 years ago)

DMA+blitter queued to perform the pixmap copy

  • arch/arm/mach-s3c2440/mach-gta02.c

    old new  
    638638        }, 
    639639        [2] = { 
    640640                .flags = IORESOURCE_DMA, 
    641                 .start = 0, /* Channel 0 for SDI */ 
    642                 .end = 0, 
     641                .start = 2, /* Channel 0 for SDI */ 
     642                .end = 2, 
    643643        }, 
    644644}; 
    645645 
  • arch/arm/plat-s3c24xx/dma.c

    old new  
    377377        tmp = dma_rdreg(chan, S3C2410_DMA_DMASKTRIG); 
    378378        tmp &= ~S3C2410_DMASKTRIG_STOP; 
    379379        tmp |= S3C2410_DMASKTRIG_ON; 
     380        tmp |= S3C2410_DMASKTRIG_SWTRIG; 
    380381        dma_wrreg(chan, S3C2410_DMA_DMASKTRIG, tmp); 
    381382 
    382383        pr_debug("dma%d: %08lx to DMASKTRIG\n", chan->number, tmp); 
     
    10781079                return -EINVAL; 
    10791080        } 
    10801081 
    1081         dcon |= S3C2410_DCON_HWTRIG; 
     1082        /*dcon |= S3C2410_DCON_HWTRIG;*/ 
    10821083        dcon |= S3C2410_DCON_INTREQ; 
    10831084 
    10841085        pr_debug("%s: dcon now %08x\n", __FUNCTION__, dcon); 
  • drivers/mfd/glamo/glamo-core.c

    old new  
    185185}; 
    186186 
    187187static struct resource glamo_2d_resources[] = { 
     188        /* 
    188189        { 
     190                .name = "glamo-2d-regs", 
    189191                .start  = GLAMO_REGOFS_2D, 
    190192                .end    = GLAMO_REGOFS_3D - 1, 
    191193                .flags  = IORESOURCE_MEM, 
    192194        }, { 
     195                .name = "glamo-2d-irqs", 
    193196                .start  = IRQ_GLAMO_2D, 
    194197                .end    = IRQ_GLAMO_2D, 
    195198                .flags  = IORESOURCE_IRQ, 
    196199        }, 
     200        */ 
     201        {0}, 
    197202}; 
    198203 
    199204static struct platform_device glamo_2d_dev = { 
     
    204209 
    205210static struct resource glamo_3d_resources[] = { 
    206211        { 
     212                .name = "glamo-3d-regs", 
    207213                .start  = GLAMO_REGOFS_3D, 
    208214                .end    = GLAMO_REGOFS_END - 1, 
    209215                .flags  = IORESOURCE_MEM, 
     
    233239                .end    = GLAMO_OFFSET_FB + GLAMO_FB_SIZE - 1, 
    234240                .flags  = IORESOURCE_MEM, 
    235241        }, 
     242        { 
     243                .name = "glamo-dma", 
     244                .start = 0, /* Channel 0 for XDREQ */ 
     245                .end   = 0, 
     246                .flags = IORESOURCE_DMA 
     247        }, 
     248        { 
     249                .name = "glamo-2d-regs", 
     250                .start  = GLAMO_REGOFS_2D, 
     251                .end    = GLAMO_REGOFS_3D - 1, 
     252                .flags  = IORESOURCE_MEM, 
     253        }, 
     254        { 
     255                .name = "glamo-2d-irqs", 
     256                .start  = IRQ_GLAMO_2D, 
     257                .end    = IRQ_GLAMO_2D, 
     258                .flags  = IORESOURCE_IRQ, 
     259        }, 
     260        { 
     261                .name = "glamo-cmdq-regs", 
     262                .start  = GLAMO_REGOFS_CMDQUEUE, 
     263                .end    = GLAMO_REGOFS_RISC - 1, 
     264                .flags  = IORESOURCE_MEM, 
     265        }, 
    236266}; 
    237267 
    238268static struct platform_device glamo_fb_dev = { 
    239269        .name           = "glamo-fb", 
     270        .dev            = { 
     271                .coherent_dma_mask      = 0xffffffff, 
     272        }, 
    240273        .resource       = glamo_fb_resources, 
    241274        .num_resources  = ARRAY_SIZE(glamo_fb_resources), 
    242275}; 
     
    417450                                   GLAMO_CLOCK_2D_DG_GCLK, 0xffff); 
    418451                __reg_set_bit_mask(glamo, GLAMO_REG_HOSTBUS(2), 
    419452                                   GLAMO_HOSTBUS2_MMIO_EN_2D, 
    420                                    GLAMO_HOSTBUS2_MMIO_EN_2D); 
     453                                   0xffff); 
     454                __reg_set_bit_mask(glamo, GLAMO_REG_CLOCK_GEN5_1, 
     455                                   GLAMO_CLOCK_GEN51_EN_DIV_GCLK, 
     456                                   0xffff); 
    421457                break; 
    422458        case GLAMO_ENGINE_CMDQ: 
    423459                __reg_set_bit_mask(glamo, GLAMO_REG_CLOCK_2D, 
    424                                    GLAMO_CLOCK_2D_EN_M6CLK, 0xffff); 
     460                                   GLAMO_CLOCK_2D_EN_M6CLK, 
     461                                   0xffff); 
    425462                __reg_set_bit_mask(glamo, GLAMO_REG_HOSTBUS(2), 
    426463                                   GLAMO_HOSTBUS2_MMIO_EN_CQ, 
    427                                    GLAMO_HOSTBUS2_MMIO_EN_CQ); 
     464                                   0xffff); 
     465                __reg_set_bit_mask(glamo, GLAMO_REG_CLOCK_GEN5_1, 
     466                                   GLAMO_CLOCK_GEN51_EN_DIV_MCLK, 
     467                                   0xffff); 
    428468                break; 
    429469        /* FIXME: Implementation */ 
    430470        default: 
     
    486526        [GLAMO_ENGINE_JPEG] = { 
    487527                GLAMO_REG_CLOCK_JPEG, GLAMO_CLOCK_JPEG_RESET 
    488528        }, 
     529        [GLAMO_ENGINE_CMDQ] = { 
     530                GLAMO_REG_CLOCK_2D, GLAMO_CLOCK_2D_CQ_RESET 
     531        }, 
    489532}; 
    490533 
    491534void glamo_engine_reset(struct glamo_core *glamo, enum glamo_engine engine) 
  • drivers/mfd/glamo/glamo-fb.c

    old new  
    2727#include <linux/mm.h> 
    2828#include <linux/slab.h> 
    2929#include <linux/delay.h> 
     30#include <linux/console.h> 
    3031#include <linux/fb.h> 
    3132#include <linux/init.h> 
    3233#include <linux/vmalloc.h> 
     
    3637#include <linux/wait.h> 
    3738#include <linux/platform_device.h> 
    3839#include <linux/clk.h> 
     40#include <linux/spinlock.h> 
    3941 
    4042#include <asm/io.h> 
    4143#include <asm/uaccess.h> 
    4244#include <asm/div64.h> 
     45#include <asm/dma.h> 
    4346 
    4447#ifdef CONFIG_PM 
    4548#include <linux/pm.h> 
     
    5053#include "glamo-regs.h" 
    5154#include "glamo-core.h" 
    5255 
    53 #ifdef DEBUG 
     56/*#define DEBUG 1*/ 
     57 
     58#ifndef DEBUG 
    5459#define GLAMO_LOG(...) 
    5560#else 
    5661#define GLAMO_LOG(...) \ 
     
    6368 
    6469#define RESSIZE(ressource) (((ressource)->end - (ressource)->start)+1) 
    6570 
     71struct pixmap_dma_context { 
     72        u_int32_t channel; 
     73        u_int32_t en; 
     74        u_int32_t datum_size; 
     75        char do_dma_write; /*write to glamo ?*/ 
     76        uint32_t vram_addr; 
     77        void *io_dma_buf; 
     78        dma_addr_t io_dma_buf_ba; /*bus address of io_dma_buf*/ 
     79        int io_dma_buf_size; /*buf size in bytes*/ 
     80        int io_dma_len; 
     81        dma_addr_t dma_bounce_buf_ba; 
     82        dma_addr_t dma_bounce_buf_len; 
     83        dma_addr_t dma_bounce_buf_size; 
     84        uint32_t pixmap_vram_addr; 
     85        struct glamofb_pixmap *pixmap; 
     86        uint32_t vram_pitch; 
     87        uint32_t cur_line; 
     88        struct work_struct pixmap_blit_work; 
     89        wait_queue_head_t pixmap_xfer_wait; 
     90        char pixmap_xfer_on; 
     91}; 
     92 
     93struct glamo_cmdq { 
     94        uint32_t ring_offset;/*offset in offscreen video ram*/ 
     95        uint32_t ring_size;/*size in words of 16 bits*/ 
     96        uint32_t write; 
     97        uint32_t read; 
     98        /* 
     99         * command cache in system ram. Same size as ring_size. 
     100         * flushed to ring_addr when we are happy with it. 
     101         */ 
     102        uint16_t *cache; 
     103        uint32_t cache_start; 
     104        uint32_t last_cmd_in_cache; 
     105 
     106        /* 
     107         * these are used to control the 
     108         * command submission to the cache. 
     109         */ 
     110        uint16_t cmd_count; 
     111        uint16_t cached_cmds; 
     112}; 
     113 
    66114struct glamofb_handle { 
    67115        struct fb_info *fb; 
    68116        struct device *dev; 
    69117        struct resource *reg; 
    70118        struct resource *fb_res; 
    71         char __iomem *base; 
     119        struct resource *dma_res; 
     120        struct resource *twod_res; 
     121        struct resource *cmdq_res; 
     122        char __iomem *lcd_reg_base; 
     123        char __iomem *twod_reg_base; 
     124        char __iomem *cmdq_reg_base; 
    72125        struct glamofb_platform_data *mach_info; 
    73126        char __iomem *cursor_addr; 
    74127        u_int32_t pseudo_pal[16]; 
     128        struct glamofb_upload_pixmap_info p_info; 
     129        struct pixmap_dma_context dma_ctxt; 
     130        struct glamo_cmdq *cmdq; 
    75131}; 
    76132 
    77133/* 'sibling' spi device for lcm init */ 
     
    80136}; 
    81137 
    82138 
    83 static int reg_read(struct glamofb_handle *glamo, 
    84                            u_int16_t reg) 
     139static int reg_read(char __iomem *reg_base, 
     140                    u_int16_t reg) 
    85141{ 
    86142        glamo_reg_access_delay(); 
    87         return readw(glamo->base + reg); 
     143        return readw(reg_base + reg); 
    88144} 
    89145 
    90 static void reg_write(struct glamofb_handle *glamo, 
    91                              u_int16_t reg, u_int16_t val) 
     146static void reg_write(char __iomem *reg_base, 
     147                      u_int16_t reg, u_int16_t val) 
    92148{ 
    93149        glamo_reg_access_delay(); 
    94         writew(val, glamo->base + reg); 
     150        writew(val, reg_base + reg); 
    95151} 
    96152 
    97153static struct glamo_script glamo_regs[] = { 
     
    117173        { GLAMO_REG_LCD_A_BASE2, 0x0000 }, /* display A base address 22:16 */ 
    118174}; 
    119175 
     176static struct s3c2410_dma_client glamofb_dma_client = { 
     177       .name           = "glamo-fb", 
     178}; 
     179 
     180static int glamo_cmdq_set_init_params(struct glamofb_handle *glamofb, 
     181                                      struct glamo_cmdq *cmdq) 
     182{ 
     183        int err = -1; 
     184        uint16_t *ring_start = NULL, cmdq_len = 0; 
     185 
     186        GLAMO_LOG("enter, glamofb:%p, cmdq:%p, " 
     187                  "ring_offset:%#x, ring_size:%d\n", 
     188                  glamofb, 
     189                  cmdq, 
     190                  cmdq->ring_offset, 
     191                  cmdq->ring_size); 
     192        if (!glamofb || !cmdq) { 
     193                goto out; 
     194        } 
     195 
     196        glamo_engine_enable(glamofb->mach_info->glamo, GLAMO_ENGINE_CMDQ); 
     197        glamo_engine_reset(glamofb->mach_info->glamo, GLAMO_ENGINE_CMDQ); 
     198 
     199        cmdq_len = (cmdq->ring_size*2)/1024 - 1; 
     200 
     201        GLAMO_LOG("cmdq_len:%d, reg_base:%p\n", 
     202                   cmdq_len, glamofb->cmdq_reg_base); 
     203        ring_start = 
     204                (uint16_t*)(glamofb->fb->screen_base + cmdq->ring_offset); 
     205 
     206        fb_memset(ring_start, 0, cmdq->ring_size*2+1); 
     207 
     208        reg_write(glamofb->cmdq_reg_base, 
     209                  GLAMO_REG_CMDQ_BASE_ADDRL, 
     210                  cmdq->ring_offset & 0xffff); 
     211        reg_write(glamofb->cmdq_reg_base, 
     212                  GLAMO_REG_CMDQ_BASE_ADDRH, 
     213                  (cmdq->ring_offset >> 16) & 0x7f); 
     214        reg_write(glamofb->cmdq_reg_base, GLAMO_REG_CMDQ_LEN, cmdq_len); 
     215 
     216        reg_write(glamofb->cmdq_reg_base, GLAMO_REG_CMDQ_WRITE_ADDRH, 0); 
     217        reg_write(glamofb->cmdq_reg_base, GLAMO_REG_CMDQ_WRITE_ADDRL, 0); 
     218        reg_write(glamofb->cmdq_reg_base, GLAMO_REG_CMDQ_READ_ADDRH, 0); 
     219        reg_write(glamofb->cmdq_reg_base, GLAMO_REG_CMDQ_READ_ADDRL, 0); 
     220        reg_write(glamofb->cmdq_reg_base, 
     221                  GLAMO_REG_CMDQ_CONTROL, 
     222                  1 << 12 | /*no turbo flip*/ 
     223                  5 << 8  | /*generate an irq when cmdq empty*/ 
     224                  8 << 4) /*cmdq threshold ? wtf*/; 
     225        err = 0; 
     226out: 
     227        GLAMO_LOG("leave, err:%d\n", err); 
     228        return err; 
     229 
     230} 
     231 
     232static int glamo_cmdq_init(struct glamofb_handle *glamofb, 
     233                           struct glamo_cmdq *cmdq, 
     234                           uint32_t ring_offset/*offset in vram.*/, 
     235                           uint32_t ring_size/*size in bytes*/) 
     236{ 
     237        int err=-1; 
     238 
     239        GLAMO_LOG("enter, glamofb:%p, cmdq:%p, " 
     240                  "ring_offset:%#x, ring_size:%#x\n", 
     241                  glamofb, cmdq, ring_offset, ring_size); 
     242 
     243        cmdq->ring_offset = ring_offset; 
     244        cmdq->ring_size = ring_size/2; /*size in words of 16 bits*/ 
     245        if (cmdq->cache) 
     246                kfree(cmdq->cache); 
     247        cmdq->cache = kzalloc(ring_size, GFP_KERNEL); 
     248        if (!cmdq->cache) { 
     249                GLAMO_LOG("failed to allocated cmdq->cache\n"); 
     250                goto out; 
     251        } 
     252        memset(cmdq->cache, 0, ring_size); 
     253        err = glamo_cmdq_set_init_params(glamofb, cmdq); 
     254        if (err) { 
     255                GLAMO_LOG("glamo_cmdq_set_init() failed\n"); 
     256                goto out; 
     257        } 
     258        err = 0; 
     259out: 
     260        GLAMO_LOG("leave\n"); 
     261        return err; 
     262} 
     263 
     264static struct glamo_cmdq* glamo_cmdq_new(struct glamofb_handle *glamofb, 
     265                                         uint32_t ring_offset, 
     266                                         uint32_t ring_size) 
     267{ 
     268        struct glamo_cmdq *result; 
     269 
     270        result = kzalloc(sizeof(struct glamo_cmdq), GFP_KERNEL); 
     271        if (!result) 
     272                return NULL; 
     273        memset(result, 0, sizeof(struct glamo_cmdq)); 
     274        if (glamo_cmdq_init(glamofb, result, ring_offset, ring_size)) { 
     275                kfree(result); 
     276                return NULL; 
     277        } 
     278        return result; 
     279} 
     280 
     281static void glamo_cmdq_delete(struct glamo_cmdq *cmdq) 
     282{ 
     283        if (!cmdq) 
     284                return; 
     285        if (cmdq->cache) { 
     286                kfree(cmdq->cache); 
     287                cmdq->cache = NULL; 
     288        } 
     289        kfree(cmdq); 
     290} 
     291 
     292static int glamo_cmdq_flush_cache(struct glamofb_handle *glamofb) 
     293{ 
     294        int err=-1, nb_commands=0, i=0; 
     295        uint16_t *cur=NULL, *ring_start=NULL, *initial_ring_start=NULL; 
     296        struct glamo_cmdq *cmdq = NULL; 
     297 
     298        /* 
     299         GLAMO_LOG("enter, glamofb:%p, cmdq:%p\n", glamofb, glamofb->cmdq); 
     300         */ 
     301 
     302        if (!glamofb || !glamofb->cmdq) { 
     303                goto out; 
     304        } 
     305        cmdq = glamofb->cmdq; 
     306 
     307        nb_commands = cmdq->last_cmd_in_cache - cmdq->cache_start; 
     308        /*GLAMO_LOG("nb_commands to flush:%d\n", nb_commands);*/ 
     309 
     310        cmdq->write = reg_read(glamofb->cmdq_reg_base, 
     311                               GLAMO_REG_CMDQ_WRITE_ADDRL); 
     312        cmdq->write |= 
     313                (reg_read(glamofb->cmdq_reg_base, 
     314                         GLAMO_REG_CMDQ_WRITE_ADDRH) & 0x7) << 15; 
     315        cmdq->write >>= 1; 
     316 
     317        /*GLAMO_LOG("cmdq->write:%d\n", cmdq->write);*/ 
     318 
     319        cur = cmdq->cache + cmdq->cache_start; 
     320        initial_ring_start = 
     321                (uint16_t*)(glamofb->fb->screen_base + cmdq->ring_offset); 
     322        ring_start = initial_ring_start + cmdq->write; 
     323        /*GLAMO_LOG("ring_offset:%p\n", cmdq->ring_offset);*/ 
     324 
     325        for (i=0; i < nb_commands; i++) { 
     326                /* 
     327                 GLAMO_LOG("writing %#x to %#x\n", 
     328                           *cur, 
     329                           cmdq->ring_offset+cmdq->write); 
     330                 */ 
     331                fb_writew(*cur++, ring_start++); 
     332                cmdq->write++; 
     333                if (cmdq->write >= cmdq->ring_size) { 
     334                        GLAMO_LOG("cmdq wrapped up!\n"); 
     335                        cmdq->write = 0; 
     336                        ring_start = initial_ring_start + cmdq->write; 
     337                } 
     338                /* 
     339                 * when the cmdq is full, wait for the 
     340                 * command processor until 
     341                 * it reads the command queue. 
     342                 */ 
     343                while (cmdq->write == cmdq->read) { 
     344                        GLAMO_LOG("waiting for CP to read " 
     345                                  "cmdq. cmdq->read:%#x\n", 
     346                                  cmdq->read); 
     347                        cmdq->read = reg_read(glamofb->cmdq_reg_base, 
     348                                              GLAMO_REG_CMDQ_READ_ADDRL); 
     349                        cmdq->read |= 
     350                        (reg_read(glamofb->cmdq_reg_base, 
     351                                  GLAMO_REG_CMDQ_READ_ADDRH) & 0x7) << 16; 
     352                        GLAMO_LOG("cmdq->read:%x\n", cmdq->read); 
     353                } 
     354                /*GLAMO_LOG("command processor read the cmdq okay\n");*/ 
     355        } 
     356        GLAMO_LOG("cmq->write:%#x\n", cmdq->write); 
     357        reg_write(glamofb->cmdq_reg_base, 
     358                  GLAMO_REG_CMDQ_WRITE_ADDRH, 
     359                  (cmdq->write >> 15) & 0x7); 
     360        reg_write(glamofb->cmdq_reg_base, 
     361                  GLAMO_REG_CMDQ_WRITE_ADDRL, 
     362                  (cmdq->write << 1) & 0xffff); 
     363        err = 0; 
     364 
     365out: 
     366        /*GLAMO_LOG("leave, err:%d\n", err);*/ 
     367        return err; 
     368} 
     369 
     370static int glamo_cmdq_begin_commands(struct glamofb_handle *glamofb, 
     371                                     uint32_t nb_commands_to_submit) 
     372{ 
     373        int err = -1, nb_commands = 0; 
     374        struct glamo_cmdq *cmdq = NULL; 
     375 
     376        /*GLAMO_LOG("enter, glamofb:%p, glamofb->cmdq:%p\n", 
     377                  glamofb, glamofb->cmdq); 
     378        */ 
     379        if (!glamofb->cmdq) { 
     380                printk(KERN_ERR "glamo command processor queue has not " 
     381                                "been initialized!\n"); 
     382                goto out; 
     383        } 
     384        cmdq = glamofb->cmdq; 
     385        nb_commands = cmdq->last_cmd_in_cache - cmdq->cache_start; 
     386        if (nb_commands + nb_commands_to_submit > cmdq->ring_size) { 
     387                err = glamo_cmdq_flush_cache(glamofb); 
     388                if (err) { 
     389                        /*GLAMO_LOG("failed to dispatch\n");*/ 
     390                        goto out; 
     391                } 
     392        } 
     393        cmdq->cached_cmds = nb_commands_to_submit; 
     394        err = 0; 
     395out: 
     396        /*GLAMO_LOG("leave, err:%d\n", err);*/ 
     397        return err; 
     398} 
     399 
     400static int glamo_cmdq_end_commands(struct glamofb_handle *glamofb) 
     401{ 
     402        int err=-1; 
     403        struct glamo_cmdq *cmdq=NULL; 
     404 
     405        /*GLAMO_LOG("enter, glamofb:%p, glamofb->cmdq:%p\n", 
     406                  glamofb, glamofb->cmdq); 
     407        */ 
     408        if (!glamofb || !glamofb->cmdq) { 
     409                goto out; 
     410        } 
     411        cmdq = glamofb->cmdq; 
     412        if (cmdq->cmd_count != cmdq->cached_cmds*2) { 
     413                printk(KERN_ERR "issued wrong number " 
     414                                "of commands to glamo cmdq!" 
     415                                "cmdq->cmd_counto:%d," 
     416                                "cmdq->cached_cmds:%d\n", 
     417                       cmdq->cmd_count, cmdq->cached_cmds); 
     418        } 
     419        cmdq->last_cmd_in_cache += cmdq->cmd_count; 
     420        cmdq->cmd_count = 0; 
     421        cmdq->cached_cmds = 0; 
     422        err = 0; 
     423out: 
     424        /*GLAMO_LOG("leave, err:%d\n", err);*/ 
     425        return err; 
     426} 
     427 
     428static void glamo_cmdq_out_reg(struct glamofb_handle *glamofb, 
     429                               uint16_t reg_base, 
     430                               uint16_t reg, 
     431                               uint16_t val) 
     432{ 
     433        uint16_t *head; 
     434        struct glamo_cmdq *cmdq; 
     435 
     436        if (!glamofb || !glamofb->cmdq) 
     437                return; 
     438 
     439        cmdq = glamofb->cmdq; 
     440        head = cmdq->cache + cmdq->cache_start; 
     441        head[cmdq->cmd_count++] = reg_base + reg; 
     442        head[cmdq->cmd_count++] = val; 
     443} 
     444 
    120445static int glamofb_run_script(struct glamofb_handle *glamo, 
    121446                                struct glamo_script *script, int len) 
    122447{ 
     
    130455                else if (line->reg == 0xfffe) 
    131456                        msleep(line->val); 
    132457                else 
    133                         reg_write(glamo, script[i].reg, script[i].val); 
     458                        reg_write(glamo->lcd_reg_base, script[i].reg, script[i].val); 
    134459        } 
    135460 
    136461        return 0; 
     
    159484        /* FIXME: set rgb positions */ 
    160485        switch (var->bits_per_pixel) { 
    161486        case 16: 
    162                 switch (reg_read(glamo, GLAMO_REG_LCD_MODE3) & 0xc000) { 
     487                switch (reg_read(glamo->lcd_reg_base, 
     488                        GLAMO_REG_LCD_MODE3) & 0xc000) { 
    163489                case GLAMO_LCD_SRC_RGB565: 
    164490                        var->red.offset         = 11; 
    165491                        var->green.offset       = 5; 
     
    204530        return 0; 
    205531} 
    206532 
    207 static void reg_set_bit_mask(struct glamofb_handle *glamo, 
     533static void reg_set_bit_mask(char __iomem *reg_base, 
    208534                             u_int16_t reg, u_int16_t mask, 
    209535                             u_int16_t val) 
    210536{ 
     
    212538 
    213539        val &= mask; 
    214540 
    215         tmp = reg_read(glamo, reg); 
     541        tmp = reg_read(reg_base, reg); 
    216542        tmp &= ~mask; 
    217543        tmp |= val; 
    218         reg_write(glamo, reg, tmp); 
     544        reg_write(reg_base, reg, tmp); 
    219545} 
    220546 
    221547#define GLAMO_LCD_WIDTH_MASK 0x03FF 
     
    256582                        break; 
    257583        } 
    258584        glamofb_cmd_mode(glamo, 1); 
    259         reg_set_bit_mask(glamo, 
     585        reg_set_bit_mask(glamo->lcd_reg_base, 
    260586                         GLAMO_REG_LCD_WIDTH, 
    261587                         GLAMO_LCD_ROT_MODE_MASK, 
    262588                         glamo_rot); 
    263         reg_set_bit_mask(glamo, 
     589        reg_set_bit_mask(glamo->lcd_reg_base, 
    264590                         GLAMO_REG_LCD_MODE1, 
    265591                         GLAMO_LCD_MODE1_ROTATE_EN, 
    266592                         (glamo_rot != GLAMO_LCD_ROT_MODE_0)? 
     
    334660        /* 
    335661         * set the awaiten LCD geometry 
    336662         */ 
    337         reg_set_bit_mask(glamo, 
     663        reg_set_bit_mask(glamo->lcd_reg_base, 
    338664                         GLAMO_REG_LCD_WIDTH, 
    339665                         GLAMO_LCD_WIDTH_MASK, 
    340666                         xres); 
    341         reg_set_bit_mask(glamo, 
     667        reg_set_bit_mask(glamo->lcd_reg_base, 
    342668                         GLAMO_REG_LCD_HEIGHT, 
    343669                         GLAMO_LCD_HEIGHT_MASK, 
    344670                         yres); 
    345         reg_set_bit_mask(glamo, 
     671        reg_set_bit_mask(glamo->lcd_reg_base, 
    346672                         GLAMO_REG_LCD_PITCH, 
    347673                         GLAMO_LCD_PITCH_MASK, 
    348674                         pitch); 
     
    375701        fp = disp + xres; 
    376702        total = fp + var->right_margin; 
    377703 
    378         reg_set_bit_mask(glamo, GLAMO_REG_LCD_HORIZ_TOTAL, 
     704        reg_set_bit_mask(glamo->lcd_reg_base, 
     705                         GLAMO_REG_LCD_HORIZ_TOTAL, 
    379706                         GLAMO_LCD_HV_TOTAL_MASK, total); 
    380         reg_set_bit_mask(glamo, GLAMO_REG_LCD_HORIZ_RETR_START, 
     707        reg_set_bit_mask(glamo->lcd_reg_base, 
     708                         GLAMO_REG_LCD_HORIZ_RETR_START, 
    381709                         GLAMO_LCD_HV_RETR_START_MASK, sync); 
    382         reg_set_bit_mask(glamo, GLAMO_REG_LCD_HORIZ_RETR_END, 
     710        reg_set_bit_mask(glamo->lcd_reg_base, 
     711                         GLAMO_REG_LCD_HORIZ_RETR_END, 
    383712                         GLAMO_LCD_HV_RETR_END_MASK, bp); 
    384         reg_set_bit_mask(glamo, GLAMO_REG_LCD_HORIZ_DISP_START, 
     713        reg_set_bit_mask(glamo->lcd_reg_base, 
     714                         GLAMO_REG_LCD_HORIZ_DISP_START, 
    385715                          GLAMO_LCD_HV_RETR_DISP_START_MASK, disp); 
    386         reg_set_bit_mask(glamo, GLAMO_REG_LCD_HORIZ_DISP_END, 
     716        reg_set_bit_mask(glamo->lcd_reg_base, 
     717                         GLAMO_REG_LCD_HORIZ_DISP_END, 
    387718                         GLAMO_LCD_HV_RETR_DISP_END_MASK, fp); 
    388719 
    389720        GLAMO_LOG("mark:\n"); 
     
    394725        fp = disp + yres; 
    395726        total = fp + var->lower_margin; 
    396727 
    397         reg_set_bit_mask(glamo, GLAMO_REG_LCD_VERT_TOTAL, 
     728        reg_set_bit_mask(glamo->lcd_reg_base, 
     729                         GLAMO_REG_LCD_VERT_TOTAL, 
    398730                         GLAMO_LCD_HV_TOTAL_MASK, total); 
    399         reg_set_bit_mask(glamo, GLAMO_REG_LCD_VERT_RETR_START, 
    400                           GLAMO_LCD_HV_RETR_START_MASK, sync); 
    401         reg_set_bit_mask(glamo, GLAMO_REG_LCD_VERT_RETR_END, 
     731        reg_set_bit_mask(glamo->lcd_reg_base, 
     732                         GLAMO_REG_LCD_VERT_RETR_START, 
     733                         GLAMO_LCD_HV_RETR_START_MASK, sync); 
     734        reg_set_bit_mask(glamo->lcd_reg_base, 
     735                         GLAMO_REG_LCD_VERT_RETR_END, 
    402736                         GLAMO_LCD_HV_RETR_END_MASK, bp); 
    403         reg_set_bit_mask(glamo, GLAMO_REG_LCD_VERT_DISP_START, 
     737        reg_set_bit_mask(glamo->lcd_reg_base, 
     738                         GLAMO_REG_LCD_VERT_DISP_START, 
    404739                         GLAMO_LCD_HV_RETR_DISP_START_MASK, disp); 
    405         reg_set_bit_mask(glamo, GLAMO_REG_LCD_VERT_DISP_END, 
     740        reg_set_bit_mask(glamo->lcd_reg_base, 
     741                         GLAMO_REG_LCD_VERT_DISP_END, 
    406742                         GLAMO_LCD_HV_RETR_DISP_END_MASK, fp); 
    407743 
    408744        GLAMO_LOG("mark:\n"); 
     
    416752        struct glamofb_handle *glamo = info->par; 
    417753        struct fb_var_screeninfo *var = &info->var; 
    418754 
     755        GLAMO_LOG("enter\n"); 
     756 
    419757        switch (var->bits_per_pixel) { 
    420758        case 16: 
    421759                info->fix.visual = FB_VISUAL_TRUECOLOR; 
     
    429767 
    430768        glamofb_update_lcd_controller(glamo, var); 
    431769 
     770        GLAMO_LOG("leave\n"); 
     771 
    432772        return 0; 
    433773} 
    434774 
     
    474814        return 0; 
    475815} 
    476816 
     817#if 0 
    477818static int glamofb_cursor(struct fb_info *info, struct fb_cursor *cursor) 
    478819{ 
    479820        struct glamofb_handle *glamo = info->par; 
     
    545886                } 
    546887        } 
    547888} 
     889#endif 
    548890 
    549891static inline int glamofb_cmdq_empty(struct glamofb_handle *gfb) 
    550892{ 
    551         return reg_read(gfb, GLAMO_REG_LCD_STATUS1) & (1 << 15); 
     893        return reg_read(gfb->lcd_reg_base, 
     894                        GLAMO_REG_LCD_STATUS1) & (1 << 15); 
    552895} 
    553896 
    554897void glamofb_cmd_mode(struct glamofb_handle *gfb, int on) 
     
    562905                dev_dbg(gfb->dev, "empty!\n"); 
    563906 
    564907                /* display the entire frame then switch to command */ 
    565                 reg_write(gfb, GLAMO_REG_LCD_COMMAND1, 
     908                reg_write(gfb->lcd_reg_base, 
     909                          GLAMO_REG_LCD_COMMAND1, 
    566910                          GLAMO_LCD_CMD_TYPE_DISP | 
    567911                          GLAMO_LCD_CMD_DATA_FIRE_VSYNC); 
    568912 
    569913                /* wait until LCD is idle */ 
    570914                dev_dbg(gfb->dev, "waiting for LCD idle: "); 
    571                 while (!reg_read(gfb, GLAMO_REG_LCD_STATUS2) & (1 << 12)) 
     915                while (!reg_read(gfb->lcd_reg_base, 
     916                        GLAMO_REG_LCD_STATUS2) & (1 << 12)) 
    572917                        yield(); 
    573918                dev_dbg(gfb->dev, "idle!\n"); 
    574919 
    575920                msleep(90); 
    576921        } else { 
    577922                /* RGB interface needs vsync/hsync */ 
    578                 if (reg_read(gfb, GLAMO_REG_LCD_MODE3) & GLAMO_LCD_MODE3_RGB) 
    579                         reg_write(gfb, GLAMO_REG_LCD_COMMAND1, 
     923                if (reg_read(gfb->lcd_reg_base, 
     924                             GLAMO_REG_LCD_MODE3) & GLAMO_LCD_MODE3_RGB) 
     925                        reg_write(gfb->lcd_reg_base, 
     926                                  GLAMO_REG_LCD_COMMAND1, 
    580927                                  GLAMO_LCD_CMD_TYPE_DISP | 
    581928                                  GLAMO_LCD_CMD_DATA_DISP_SYNC); 
    582929 
    583                 reg_write(gfb, GLAMO_REG_LCD_COMMAND1, 
     930                reg_write(gfb->lcd_reg_base, GLAMO_REG_LCD_COMMAND1, 
    584931                          GLAMO_LCD_CMD_TYPE_DISP | 
    585932                          GLAMO_LCD_CMD_DATA_DISP_FIRE); 
    586933        } 
     
    595942                yield(); 
    596943        dev_dbg(gfb->dev, "idle, writing 0x%04x\n", val); 
    597944 
    598         reg_write(gfb, GLAMO_REG_LCD_COMMAND1, val); 
     945        reg_write(gfb->lcd_reg_base, GLAMO_REG_LCD_COMMAND1, val); 
    599946 
    600947        return 0; 
    601948} 
    602949EXPORT_SYMBOL_GPL(glamofb_cmd_write); 
    603950 
     951static int trigger_dma(struct glamofb_handle *glamofb, 
     952                       char do_dma_write/*write to/read from glamo*/, 
     953                       u_int32_t dma_datum_size, 
     954                       unsigned vram_addr, 
     955                       dma_addr_t io_dma_buf, 
     956                       int io_dma_len); 
     957 
     958static void glamofb_do_copy_rect(struct glamofb_handle *glamo, 
     959                                 uint32_t dst_origin_offset, 
     960                                 uint32_t dst_x, 
     961                                 uint32_t dst_y, 
     962                                 uint32_t dst_pitch, 
     963                                 uint32_t src_origin_offset, 
     964                                 uint32_t src_x, 
     965                                 uint32_t src_y, 
     966                                 uint32_t src_pitch, 
     967                                 uint32_t width, 
     968                                 uint32_t height); 
     969 
     970 
     971static void dma_done_before_2d_blit(struct s3c2410_dma_chan *channel, 
     972                                    void *glamofb_handle, 
     973                                    int size, 
     974                                    enum s3c2410_dma_buffresult result) 
     975{ 
     976        struct glamofb_handle *glamofb = glamofb_handle; 
     977        if (!channel || !glamofb) { 
     978                printk(KERN_ERR "got null channel of glamofb\n"); 
     979                return; 
     980        } 
     981        if (result != S3C2410_RES_OK) { 
     982                printk(KERN_ERR "DMA xfer failed:%d\n", result); 
     983                glamofb->dma_ctxt.pixmap_xfer_on = 0; 
     984                wake_up(&glamofb->dma_ctxt.pixmap_xfer_wait); 
     985                return; 
     986        } 
     987        schedule_work(&glamofb->dma_ctxt.pixmap_blit_work); 
     988} 
     989 
     990static void do_pixmap_blit_work(struct work_struct *work) 
     991{ 
     992        struct pixmap_dma_context *dma_ctxt = 
     993                        container_of(work, 
     994                                     struct pixmap_dma_context, 
     995                                     pixmap_blit_work); 
     996        struct glamofb_handle *glamofb = 
     997                        container_of(dma_ctxt, 
     998                                     struct glamofb_handle, 
     999                                     dma_ctxt); 
     1000 
     1001        GLAMO_LOG("enter:glamofb:%p, glamofb->vram_pitch:%d\n", 
     1002                  glamofb, glamofb->dma_ctxt.vram_pitch); 
     1003 
     1004        glamofb_do_copy_rect(glamofb, 
     1005                             glamofb->dma_ctxt.vram_addr, 
     1006                             0,0, 
     1007                             glamofb->dma_ctxt.vram_pitch, 
     1008                             glamofb->dma_ctxt.dma_bounce_buf_ba - 
     1009                              glamofb->fb_res->start, 
     1010                             0, 0, 
     1011                             glamofb->dma_ctxt.pixmap->pitch, 
     1012                             glamofb->dma_ctxt.pixmap->width, 
     1013                             glamofb->dma_ctxt.pixmap->height); 
     1014 
     1015        /*wake up the process because the DMA transer is done now*/ 
     1016        glamofb->dma_ctxt.pixmap_xfer_on = 0; 
     1017        wake_up(&glamofb->dma_ctxt.pixmap_xfer_wait); 
     1018        GLAMO_LOG("leave\n"); 
     1019} 
     1020 
     1021static const char glamo_blit_rop[16] = { 
     1022    /* GXclear      */      0x00,         /* 0 */ 
     1023    /* GXand        */      0x88,         /* src AND dst */ 
     1024    /* GXandReverse */      0x44,         /* src AND NOT dst */ 
     1025    /* GXcopy       */      0xcc,         /* src */ 
     1026    /* GXandInverted*/      0x22,         /* NOT src AND dst */ 
     1027    /* GXnoop       */      0xaa,         /* dst */ 
     1028    /* GXxor        */      0x66,         /* src XOR dst */ 
     1029    /* GXor         */      0xee,         /* src OR dst */ 
     1030    /* GXnor        */      0x11,         /* NOT src AND NOT dst */ 
     1031    /* GXequiv      */      0x99,         /* NOT src XOR dst */ 
     1032    /* GXinvert     */      0x55,         /* NOT dst */ 
     1033    /* GXorReverse  */      0xdd,         /* src OR NOT dst */ 
     1034    /* GXcopyInverted*/     0x33,         /* NOT src */ 
     1035    /* GXorInverted */      0xbb,         /* NOT src OR dst */ 
     1036    /* GXnand       */      0x77,         /* NOT src OR NOT dst */ 
     1037    /* GXset        */      0xff,         /* 1 */ 
     1038}; 
     1039 
     1040static void glamofb_do_copy_rect(struct glamofb_handle *glamo, 
     1041                                 uint32_t dst_origin_offset, 
     1042                                 uint32_t dst_x, 
     1043                                 uint32_t dst_y, 
     1044                                 uint32_t dst_pitch, 
     1045                                 uint32_t src_origin_offset, 
     1046                                 uint32_t src_x, 
     1047                                 uint32_t src_y, 
     1048                                 uint32_t src_pitch, 
     1049                                 uint32_t width, 
     1050                                 uint32_t height) 
     1051{ 
     1052        uint16_t settings = glamo_blit_rop[3] << 8; /*GXCopy*/ 
     1053 
     1054        GLAMO_LOG("enter, glamo:%p, glamo->2d_reg_base:%p\n" 
     1055                  "dst_org_offset:%#x, dstx:%#x, dsty:%#x," 
     1056                  "dst_pitch:%#x\n" 
     1057                  "src_org_offset:%#x, srcx:%#x, srcy:%#x, src_pitch:%#x\n" 
     1058                  "w:%d, h:%d\n", 
     1059                  glamo, 
     1060                  glamo->twod_reg_base, 
     1061                  dst_origin_offset, dst_x, dst_y, dst_pitch, 
     1062                  src_origin_offset, src_x, src_y, src_pitch, 
     1063                  width, height); 
     1064 
     1065        if (glamo_cmdq_begin_commands(glamo, 17)) { 
     1066                printk(KERN_ERR "Can not use glamo command processor, " 
     1067                                "so the 2D engine cannot be used\n"); 
     1068                return; 
     1069        } 
     1070 
     1071        glamo_cmdq_out_reg(glamo, 
     1072                           GLAMO_REGOFS_2D, 
     1073                           GLAMO_REG_2D_SRC_ADDRL, 
     1074                           src_origin_offset & 0xffff); 
     1075        glamo_cmdq_out_reg(glamo, 
     1076                           GLAMO_REGOFS_2D, 
     1077                           GLAMO_REG_2D_SRC_ADDRH, 
     1078                           (src_origin_offset >> 16) & 0x7f); 
     1079        glamo_cmdq_out_reg(glamo, 
     1080                           GLAMO_REGOFS_2D, 
     1081                           GLAMO_REG_2D_SRC_PITCH, 
     1082                           src_pitch & 0x7ff); 
     1083        glamo_cmdq_out_reg(glamo, 
     1084                           GLAMO_REGOFS_2D, 
     1085                           GLAMO_REG_2D_SRC_X, 
     1086                           src_x & 0x7ff); 
     1087        glamo_cmdq_out_reg(glamo, 
     1088                           GLAMO_REGOFS_2D, 
     1089                           GLAMO_REG_2D_SRC_Y, 
     1090                           src_y & 0x7ff); 
     1091        glamo_cmdq_out_reg(glamo, 
     1092                           GLAMO_REGOFS_2D, 
     1093                           GLAMO_REG_2D_RECT_WIDTH, 
     1094                           width & 0x3ff); 
     1095        glamo_cmdq_out_reg(glamo, 
     1096                           GLAMO_REGOFS_2D, 
     1097                           GLAMO_REG_2D_RECT_HEIGHT, 
     1098                           height & 0x3ff); 
     1099 
     1100        glamo_cmdq_out_reg(glamo, 
     1101                           GLAMO_REGOFS_2D, 
     1102                           GLAMO_REG_2D_DST_ADDRL, 
     1103                           dst_origin_offset & 0xffff); 
     1104        glamo_cmdq_out_reg(glamo, 
     1105                           GLAMO_REGOFS_2D, 
     1106                           GLAMO_REG_2D_DST_ADDRH, 
     1107                           (dst_origin_offset >> 16) & 0x7f); 
     1108        glamo_cmdq_out_reg(glamo, 
     1109                           GLAMO_REGOFS_2D, 
     1110                           GLAMO_REG_2D_DST_PITCH, 
     1111                           dst_pitch & 0x7ff); 
     1112        glamo_cmdq_out_reg(glamo, 
     1113                           GLAMO_REGOFS_2D, 
     1114                           GLAMO_REG_2D_DST_X, 
     1115                           dst_x & 0x7ff); 
     1116        glamo_cmdq_out_reg(glamo, 
     1117                           GLAMO_REGOFS_2D, 
     1118                           GLAMO_REG_2D_DST_Y, 
     1119                           dst_y & 0x7ff); 
     1120        glamo_cmdq_out_reg(glamo, 
     1121                           GLAMO_REGOFS_2D, 
     1122                           GLAMO_REG_2D_DST_HEIGHT, 
     1123                           height & 0x3ff); 
     1124        glamo_cmdq_out_reg(glamo, 
     1125                           GLAMO_REGOFS_2D, 
     1126                           GLAMO_REG_2D_COMMAND2, 
     1127                           settings); 
     1128        glamo_cmdq_out_reg(glamo, 
     1129                           GLAMO_REGOFS_2D, 
     1130                           GLAMO_REG_2D_COMMAND3, 
     1131                           0); 
     1132        glamo_cmdq_out_reg(glamo, 
     1133                           GLAMO_REGOFS_2D, 
     1134                           GLAMO_REG_2D_ID1, 
     1135                           0); 
     1136        glamo_cmdq_out_reg(glamo, 
     1137                           GLAMO_REGOFS_2D, 
     1138                           GLAMO_REG_2D_ID2, 
     1139                           0); 
     1140 
     1141        glamo_cmdq_end_commands(glamo); 
     1142        glamo_cmdq_flush_cache(glamo); 
     1143 
     1144        GLAMO_LOG("leave\n"); 
     1145        return ; 
     1146} 
     1147 
     1148static int trigger_dma(struct glamofb_handle *glamofb, 
     1149                       char do_dma_write/*write to/read from glamo*/, 
     1150                       u_int32_t dma_datum_size, 
     1151                       unsigned vram_addr, 
     1152                       dma_addr_t io_dma_buf, 
     1153                       int io_dma_len) 
     1154{ 
     1155        int err=-1; 
     1156        int dcon=0; 
     1157        unsigned vram_dma_addr=0; 
     1158 
     1159        GLAMO_LOG("enter, dma channel:%d, dma_datum_size:%d,\n" 
     1160                  "vram_addr:%#x, io_dma_buf:%#lx, io_dma_len:%d\n", 
     1161                  glamofb->dma_ctxt.channel, 
     1162                  dma_datum_size, 
     1163                  vram_addr, 
     1164                  (long unsigned int)io_dma_buf, 
     1165                  io_dma_len); 
     1166        if (!glamofb) { 
     1167                printk(KERN_ERR "got NULL glamofb"); 
     1168                goto out; 
     1169        } 
     1170        glamofb->dma_ctxt.do_dma_write = do_dma_write; 
     1171        glamofb->dma_ctxt.datum_size = dma_datum_size; 
     1172        glamofb->dma_ctxt.vram_addr = vram_addr; 
     1173        glamofb->dma_ctxt.io_dma_buf_ba = io_dma_buf; 
     1174        glamofb->dma_ctxt.io_dma_len = io_dma_len; 
     1175        glamofb->dma_ctxt.en = 1; 
     1176 
     1177        vram_dma_addr = glamofb->dma_ctxt.dma_bounce_buf_ba; 
     1178 
     1179        if (glamofb->dma_ctxt.do_dma_write) { 
     1180                err = s3c2410_dma_devconfig(glamofb->dma_ctxt.channel, 
     1181                                            S3C2410_DMASRC_MEM, 
     1182                                            0, 
     1183                                            vram_dma_addr); 
     1184                if (err) { 
     1185                        printk(KERN_ERR "failed to setup dma source:%d\n", 
     1186                                        err); 
     1187                        goto out; 
     1188                } 
     1189        } else { 
     1190                err = s3c2410_dma_devconfig(glamofb->dma_ctxt.channel, 
     1191                                            S3C2410_DMASRC_HW, 
     1192                                            0, 
     1193                                            vram_dma_addr); 
     1194                if (err) { 
     1195                        printk(KERN_ERR "failed to setup dma source:%d\n", 
     1196                               err); 
     1197                        goto out; 
     1198                } 
     1199        } 
     1200        dcon = glamofb->dma_ctxt.io_dma_len; 
     1201        dcon |= S3C2410_DCON_INTREQ; 
     1202        dcon |= S3C2410_DCON_SERVMOD_WHOLE; 
     1203        err = s3c2410_dma_config(glamofb->dma_ctxt.channel, 
     1204                                 glamofb->dma_ctxt.datum_size, 
     1205                                 dcon); 
     1206        if (err) { 
     1207                printk(KERN_ERR "failed to setup dma size and channel\n"); 
     1208                goto out; 
     1209        } 
     1210        err = s3c2410_dma_set_buffdone_fn(glamofb->dma_ctxt.channel, 
     1211                                          dma_done_before_2d_blit); 
     1212        if (err) { 
     1213                printk(KERN_ERR "failed to setup dma buffdone\n"); 
     1214                goto out; 
     1215        } 
     1216        err = s3c2410_dma_setflags(glamofb->dma_ctxt.channel, 
     1217                                   S3C2410_DMAF_AUTOSTART); 
     1218        if (err) { 
     1219                printk(KERN_ERR "failed to setup dma operation\n"); 
     1220                goto out; 
     1221        } 
     1222        glamofb->dma_ctxt.pixmap_xfer_on = 1; 
     1223        err = s3c2410_dma_enqueue(glamofb->dma_ctxt.channel, 
     1224                                  glamofb, 
     1225                                  glamofb->dma_ctxt.io_dma_buf_ba, 
     1226                                  glamofb->dma_ctxt.io_dma_len); 
     1227        if (err) { 
     1228                printk(KERN_ERR "failed to enqueue dma buffer\n"); 
     1229                glamofb->dma_ctxt.pixmap_xfer_on = 0; 
     1230                goto out; 
     1231        } 
     1232        GLAMO_LOG("block the process\n"); 
     1233        wait_event(glamofb->dma_ctxt.pixmap_xfer_wait, 
     1234                   !glamofb->dma_ctxt.pixmap_xfer_on); 
     1235        GLAMO_LOG("process got unbocked\n"); 
     1236        err = 0; 
     1237out: 
     1238        GLAMO_LOG("leave\n"); 
     1239        return err; 
     1240} 
     1241 
     1242static int trigger_pixmap_dma_to_vram(struct glamofb_handle *glamofb, 
     1243                                     struct glamofb_pixmap *pixmap, 
     1244                                     unsigned vram_addr, 
     1245                                     unsigned vram_pitch, 
     1246                                     dma_addr_t pixmap_buf, 
     1247                                     int pixmap_buf_len) 
     1248{ 
     1249        int err = -1, line_len; 
     1250 
     1251        GLAMO_LOG("enter, glamofb:%p, pixmap:%p\n", glamofb, pixmap); 
     1252 
     1253        if (!pixmap || ! glamofb) { 
     1254                printk(KERN_ERR "got NULL pixmap or glamofb." 
     1255                                " glamofb:%p, pixmap:%p\n", 
     1256                                glamofb, pixmap); 
     1257                goto out; 
     1258        } 
     1259        glamofb->dma_ctxt.pixmap = pixmap; 
     1260        glamofb->dma_ctxt.vram_pitch = vram_pitch; 
     1261        glamofb->dma_ctxt.cur_line = 0; 
     1262        line_len = pixmap->width * pixmap->bits_per_pixel / 8; 
     1263        err = trigger_dma(glamofb, 1, 1, vram_addr, 
     1264                          pixmap_buf, pixmap_buf_len); 
     1265out: 
     1266        GLAMO_LOG("leave. err:%d\n", err); 
     1267        return err; 
     1268} 
     1269 
     1270static int dma_upload_to_vram(struct glamofb_handle *glamofb, 
     1271                              struct glamofb_pixmap  *pixmap/*pxm in vram*/, 
     1272                              unsigned to /*offset in glamo vram*/, 
     1273                              unsigned vram_pitch) 
     1274{ 
     1275        void __user *pixmap_addr; 
     1276        int err = -1; 
     1277        /* 
     1278         * size of the rectangular region containing 
     1279         * which width equals the pixmap pitch, and that 
     1280         * contains the pixmap 
     1281         */ 
     1282        int pixmap_region_size; 
     1283 
     1284        if (!pixmap || !glamofb) { 
     1285                printk(KERN_ERR "(glamofb_dma_upload_to_vram) " 
     1286                                "failed sanity\n"); 
     1287                goto out; 
     1288        } 
     1289 
     1290        GLAMO_LOG("enter. glamofb:%p, " 
     1291                        "pixmap(pitch,w,h,bpp,@):(%d,%d,%d,%d,%#x)," 
     1292                        "to:%#x, vram_pitch:%d\n", 
     1293                        glamofb, 
     1294                        pixmap->pitch, pixmap->width, 
     1295                        pixmap->height, 
     1296                        pixmap->bits_per_pixel, 
     1297                        (unsigned int)pixmap->address, 
     1298                        to, vram_pitch); 
     1299        /* 
     1300         * now copy the pixmap into the in kernel buffer, 
     1301         * and start the DMA transfers for each DMA buffer lines. 
     1302         */ 
     1303        pixmap_addr = (void __user*)pixmap->address; 
     1304        pixmap_region_size = 
     1305                pixmap->pitch*pixmap->height; 
     1306        GLAMO_LOG("going to copy %d bytes of wide pixmap region " 
     1307                  "from user space, starting at %#x, into %#x\n", 
     1308                  pixmap_region_size, (unsigned)pixmap_addr, 
     1309                  (unsigned)glamofb->dma_ctxt.io_dma_buf); 
     1310        err = copy_from_user(glamofb->dma_ctxt.io_dma_buf, 
     1311                             pixmap_addr, 
     1312                             pixmap_region_size); 
     1313        if (err) { 
     1314                printk(KERN_ERR "failed to copy pixmap to kernel\n"); 
     1315                goto out; 
     1316        } 
     1317        GLAMO_LOG("did copy okay, to:%#x\n", to); 
     1318        err = trigger_pixmap_dma_to_vram(glamofb, 
     1319                                         pixmap, 
     1320                                         to, 
     1321                                         vram_pitch, 
     1322                                         glamofb->dma_ctxt.io_dma_buf_ba, 
     1323                                         pixmap_region_size); 
     1324        if (err) { 
     1325                printk(KERN_ERR "dma xfer failed\n"); 
     1326                goto out; 
     1327        } else { 
     1328                GLAMO_LOG("dma xfer triggered okay\n"); 
     1329        } 
     1330 
     1331out: 
     1332        GLAMO_LOG("leave. err:%d\n", err); 
     1333        return err; 
     1334} 
     1335 
     1336void glamofb_log_pixmap(struct glamofb_pixmap *pixmap) 
     1337{ 
     1338        printk(KERN_INFO "(WxH,p,bpp,address):(%dx%d,%d,%d,%#x)\n", 
     1339                        pixmap->width, pixmap->height, 
     1340                        pixmap->pitch, pixmap->bits_per_pixel, 
     1341                        (unsigned int)pixmap->address); 
     1342} 
     1343 
     1344void glamofb_log_upload_pixmap_info(struct glamofb_upload_pixmap_info *info) 
     1345{ 
     1346        printk(KERN_INFO "pixmap: "); 
     1347        glamofb_log_pixmap(&info->pixmap); 
     1348        printk(KERN_INFO "(dest_offset, dest_pitch):(%d,%d)\n", 
     1349                        info->dest_offset, 
     1350                        info->dest_pitch); 
     1351} 
     1352 
     1353static int glamofb_ioctl (struct fb_info *info, 
     1354                         unsigned int cmd, 
     1355                         unsigned long arg) 
     1356{ 
     1357        int err = -1; 
     1358        void __user *argp = (void __user*)arg; 
     1359        struct glamofb_handle *glamofb = info->par; 
     1360 
     1361        GLAMO_LOG("enter, cmd:%#x, glamofb:%p\n", cmd, glamofb); 
     1362 
     1363        if (!glamofb) 
     1364                goto out; 
     1365 
     1366        acquire_console_sem(); 
     1367 
     1368        switch (cmd) { 
     1369                case FBIO_GLAMO_UPLOAD_PIXMAP_TO_VRAM: 
     1370                        err = copy_from_user(&glamofb->p_info, 
     1371                                             argp, 
     1372                                             sizeof(glamofb->p_info)); 
     1373                        if (err) { 
     1374                                printk(KERN_ERR "failed to copy " 
     1375                                                "ioctl parameters\n"); 
     1376                                goto out; 
     1377                        } 
     1378                        glamofb_log_upload_pixmap_info(&glamofb->p_info); 
     1379                        err = dma_upload_to_vram(glamofb, 
     1380                                                 &glamofb->p_info.pixmap, 
     1381                                                 glamofb->p_info.dest_offset, 
     1382                                                 glamofb->p_info.dest_pitch); 
     1383                        if (err) { 
     1384                                printk(KERN_ERR "upload to vram failed\n"); 
     1385                                goto out; 
     1386                        } 
     1387                        break; 
     1388                case FBIO_GLAMO_INIT_CMDQ: { 
     1389                        struct glamofb_init_cmdq_info info; 
     1390                        err = copy_from_user(&info, argp, sizeof(info)); 
     1391                        if (err) { 
     1392                                printk(KERN_ERR "failed to copy " 
     1393                                                "ioctl parameters\n"); 
     1394                                goto out; 
     1395                        } 
     1396                        GLAMO_LOG("info.ring_offset:%#x, " 
     1397                                  "info.ring_len:%d\n", 
     1398                                  info.ring_offset, info.ring_len); 
     1399                        if (glamofb->cmdq) { 
     1400                                glamo_cmdq_delete(glamofb->cmdq); 
     1401                        } 
     1402                        glamofb->cmdq = glamo_cmdq_new(glamofb, 
     1403                                                       info.ring_offset, 
     1404                                                       info.ring_len); 
     1405                } 
     1406                        break; 
     1407 
     1408                default: 
     1409                        printk(KERN_ERR "unknown ioctl received in " 
     1410                                        "glamo-fb:%d\n", 
     1411                                        cmd); 
     1412                        err = -EINVAL; 
     1413                        goto out; 
     1414        } 
     1415        err = 0; 
     1416 
     1417out: 
     1418        release_console_sem(); 
     1419        GLAMO_LOG("leave. err:%d\n", err); 
     1420        return err; 
     1421} 
     1422 
     1423 
    6041424static struct fb_ops glamofb_ops = { 
    6051425        .owner          = THIS_MODULE, 
    6061426        .fb_check_var   = glamofb_check_var, 
    6071427        .fb_set_par     = glamofb_set_par, 
    6081428        .fb_blank       = glamofb_blank, 
    6091429        .fb_setcolreg   = glamofb_setcolreg, 
    610         //.fb_cursor    = glamofb_cursor, 
     1430        .fb_ioctl =       glamofb_ioctl, 
     1431        .fb_compat_ioctl = glamofb_ioctl, 
    6111432        .fb_fillrect    = cfb_fillrect, 
    6121433        .fb_copyarea    = cfb_copyarea, 
    6131434        .fb_imageblit   = cfb_imageblit, 
     
    6171438{ 
    6181439        struct fb_info *info = glamo->fb; 
    6191440 
     1441        GLAMO_LOG("enter\n"); 
     1442 
    6201443        glamofb_check_var(&info->var, info); 
    6211444        glamofb_run_script(glamo, glamo_regs, ARRAY_SIZE(glamo_regs)); 
    6221445        glamofb_set_par(info); 
     1446        GLAMO_LOG("leave\n"); 
    6231447 
    6241448        return 0; 
    6251449} 
     
    6321456        struct glamofb_platform_data *mach_info = pdev->dev.platform_data; 
    6331457 
    6341458        printk(KERN_INFO "SMEDIA Glamo frame buffer driver (C) 2007 " 
    635                 "OpenMoko, Inc.\n"); 
     1459                        "OpenMoko, Inc.\n"); 
    6361460 
    6371461        fbinfo = framebuffer_alloc(sizeof(struct glamofb_handle), &pdev->dev); 
    6381462        if (!fbinfo) 
     
    6451469        strcpy(fbinfo->fix.id, "SMedia Glamo"); 
    6461470 
    6471471        glamofb->reg = platform_get_resource_byname(pdev, IORESOURCE_MEM, 
    648                                                     "glamo-fb-regs"); 
     1472                        "glamo-fb-regs"); 
    6491473        if (!glamofb->reg) { 
    6501474                dev_err(&pdev->dev, "platform device with no registers?\n"); 
    6511475                rc = -ENOENT; 
     
    6531477        } 
    6541478 
    6551479        glamofb->fb_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, 
    656                                                         "glamo-fb-mem"); 
     1480                                                       "glamo-fb-mem"); 
    6571481        if (!glamofb->fb_res) { 
    6581482                dev_err(&pdev->dev, "platform device with no memory ?\n"); 
    6591483                rc = -ENOENT; 
     
    6611485        } 
    6621486 
    6631487        glamofb->reg = request_mem_region(glamofb->reg->start, 
    664                                           RESSIZE(glamofb->reg), pdev->name); 
     1488                                          RESSIZE(glamofb->reg), 
     1489                                          pdev->name); 
    6651490        if (!glamofb->reg) { 
    666                 dev_err(&pdev->dev, "failed to request mmio region\n"); 
     1491                dev_err(&pdev->dev, "failed to request LCD mmio region\n"); 
    6671492                goto out_free; 
    6681493        } 
    6691494 
     
    6751500                goto out_release_reg; 
    6761501        } 
    6771502 
     1503        glamofb->twod_res = 
     1504                platform_get_resource_byname(pdev, IORESOURCE_MEM, 
     1505                                             "glamo-2d-regs"); 
     1506        if (!glamofb->twod_res) { 
     1507                dev_err(&pdev->dev, "failed to get 2D resources\n"); 
     1508                rc = -ENOENT; 
     1509                goto out_free; 
     1510        } 
     1511        printk("got glamo 2D resource okay\n"); 
     1512        glamofb->twod_res = request_mem_region(glamofb->twod_res->start, 
     1513                                               RESSIZE(glamofb->twod_res), 
     1514                                               pdev->name); 
     1515        if (!glamofb->twod_res) { 
     1516                dev_err(&pdev->dev, "failed to request 2D MMIO region\n"); 
     1517                goto out_release_reg; 
     1518        } 
     1519        printk("requested glamo 2D mmio region okay\n"); 
     1520 
     1521        glamofb->cmdq_res = platform_get_resource_byname(pdev, 
     1522                                                         IORESOURCE_MEM, 
     1523                                                         "glamo-cmdq-regs"); 
     1524        if (!glamofb->cmdq_res) { 
     1525                dev_err(&pdev->dev, "failed to get glamo-cmdq resources\n"); 
     1526                rc = -ENOENT; 
     1527                goto out_free; 
     1528        } 
     1529        GLAMO_LOG("cmdq_res->start:%#x\n", glamofb->cmdq_res->start); 
     1530        glamofb->cmdq_res = request_mem_region(glamofb->cmdq_res->start, 
     1531                                               RESSIZE(glamofb->cmdq_res), 
     1532                                               pdev->name); 
     1533        if (!glamofb->cmdq_res) { 
     1534                dev_err(&pdev->dev, "failed to request glamo cmdq " 
     1535                                    "MMIO region\n"); 
     1536                goto out_release_reg; 
     1537        } 
     1538 
    6781539        /* we want to remap only the registers required for this core 
    6791540         * driver. */ 
    680         glamofb->base = ioremap(glamofb->reg->start, RESSIZE(glamofb->reg)); 
    681         if (!glamofb->base) { 
    682                 dev_err(&pdev->dev, "failed to ioremap() mmio memory\n"); 
     1541        glamofb->lcd_reg_base = 
     1542                ioremap(glamofb->reg->start, RESSIZE(glamofb->reg)); 
     1543        if (!glamofb->lcd_reg_base) { 
     1544                dev_err(&pdev->dev, "failed to ioremap() LCD mmio memory\n"); 
     1545                goto out_release_fb; 
     1546        } 
     1547        glamofb->twod_reg_base = ioremap(glamofb->twod_res->start, 
     1548                                         RESSIZE(glamofb->twod_res)); 
     1549        if (!glamofb->twod_reg_base) { 
     1550                dev_err(&pdev->dev, "failed to ioremap() 2D mmio memory\n"); 
     1551                goto out_release_fb; 
     1552        } 
     1553        GLAMO_LOG("glamofb->twod_reg_base:%p\n", glamofb->twod_reg_base); 
     1554        glamofb->cmdq_reg_base = ioremap(glamofb->cmdq_res->start, 
     1555                                         RESSIZE(glamofb->cmdq_res)); 
     1556        if (!glamofb->cmdq_reg_base) { 
     1557                dev_err(&pdev->dev, "failed to ioremap() glamo cmdq " 
     1558                                    "mmio memory\n"); 
    6831559                goto out_release_fb; 
    6841560        } 
     1561        GLAMO_LOG("glamofb->cmdq_reg_base:%p\n", glamofb->cmdq_reg_base); 
     1562 
    6851563        fbinfo->fix.smem_start = (unsigned long) glamofb->fb_res->start; 
    6861564        fbinfo->fix.smem_len = mach_info->fb_mem_size; 
    6871565 
    6881566        fbinfo->screen_base = ioremap(glamofb->fb_res->start, 
    689                                        RESSIZE(glamofb->fb_res)); 
     1567                                      RESSIZE(glamofb->fb_res)); 
    6901568        if (!fbinfo->screen_base) { 
    6911569                dev_err(&pdev->dev, "failed to ioremap() vram memory\n"); 
    6921570                goto out_release_fb; 
     
    7331611 
    7341612        glamo_engine_enable(mach_info->glamo, GLAMO_ENGINE_LCD); 
    7351613        glamo_engine_reset(mach_info->glamo, GLAMO_ENGINE_LCD); 
     1614        glamo_engine_enable(mach_info->glamo, GLAMO_ENGINE_2D); 
     1615        glamo_engine_reset(mach_info->glamo, GLAMO_ENGINE_2D); 
     1616        GLAMO_LOG("mark\n"); 
    7361617        glamofb_init_regs(glamofb); 
     1618        GLAMO_LOG("mark\n"); 
    7371619 
    7381620        rc = register_framebuffer(fbinfo); 
    7391621        if (rc < 0) { 
    7401622                dev_err(&pdev->dev, "failed to register framebuffer\n"); 
    7411623                goto out_unmap_fb; 
    7421624        } 
     1625        GLAMO_LOG("mark\n"); 
    7431626 
    7441627        if (mach_info->spi_info) { 
    7451628                /* register the sibling spi device */ 
     
    7501633        } 
    7511634 
    7521635        printk(KERN_INFO "fb%d: %s frame buffer device\n", 
    753                 fbinfo->node, fbinfo->fix.id); 
     1636                        fbinfo->node, fbinfo->fix.id); 
     1637 
     1638        /*DMA setup*/ 
     1639        glamofb->dma_res = 
     1640                platform_get_resource_byname(pdev, IORESOURCE_DMA, 
     1641                                             "glamo-dma"); 
     1642        if (!glamofb->dma_res) { 
     1643                printk(KERN_ERR "failed to get DMA resource\n"); 
     1644                goto out; 
     1645        } 
     1646        printk(KERN_INFO "got glamo DMA resource OK\n"); 
     1647        glamofb->dma_ctxt.channel = glamofb->dma_res->start; 
     1648        GLAMO_LOG("dma channel:%d\n", glamofb->dma_ctxt.channel); 
     1649        glamofb->dma_ctxt.en = 0; 
     1650        glamofb->dma_ctxt.io_dma_buf_size = 480*640*2; 
     1651        glamofb->dma_ctxt.io_dma_buf = 
     1652                dma_alloc_writecombine(&pdev->dev, 
     1653                                glamofb->dma_ctxt.io_dma_buf_size, 
     1654                                &glamofb->dma_ctxt.io_dma_buf_ba, 
     1655                                GFP_KERNEL|GFP_DMA); 
     1656        if (!glamofb->dma_ctxt.io_dma_buf) { 
     1657                printk(KERN_ERR "failed to alloc dma buf of size %d\n", 
     1658                                glamofb->dma_ctxt.io_dma_buf_size); 
     1659                goto out; 
     1660        } else { 
     1661                printk(KERN_INFO "allocated dma io buffer at %#x\n", 
     1662                                (unsigned)glamofb->dma_ctxt.io_dma_buf); 
     1663        } 
     1664        glamofb->dma_ctxt.dma_bounce_buf_size = 0x100000; 
     1665        glamofb->dma_ctxt.dma_bounce_buf_ba = glamofb->fb_res->start 
     1666                                                + 0x300000; 
     1667        GLAMO_LOG("bounce buf ba:%#x\n", 
     1668                  glamofb->dma_ctxt.dma_bounce_buf_ba); 
     1669 
     1670        if (s3c2410_dma_request(glamofb->dma_ctxt.channel, 
     1671                                &glamofb_dma_client, 
     1672                                NULL)) { 
     1673                printk("unable to get DMA channel for channel num %d", 
     1674                                glamofb->dma_ctxt.channel); 
     1675                goto out; 
     1676        } 
     1677        INIT_WORK(&glamofb->dma_ctxt.pixmap_blit_work, 
     1678                  do_pixmap_blit_work); 
     1679 
     1680        init_waitqueue_head(&glamofb->dma_ctxt.pixmap_xfer_wait); 
     1681 
     1682out: 
    7541683 
    7551684        return 0; 
    7561685 
    7571686out_unmap_fb: 
    7581687        iounmap(fbinfo->screen_base); 
    759         iounmap(glamofb->base); 
     1688        iounmap(glamofb->lcd_reg_base); 
    7601689out_release_fb: 
    7611690        release_mem_region(glamofb->fb_res->start, RESSIZE(glamofb->fb_res)); 
    7621691out_release_reg: 
     
    7711700        struct glamofb_handle *glamofb = platform_get_drvdata(pdev); 
    7721701 
    7731702        platform_set_drvdata(pdev, NULL); 
    774         iounmap(glamofb->base); 
     1703        iounmap(glamofb->lcd_reg_base); 
    7751704        release_mem_region(glamofb->reg->start, RESSIZE(glamofb->reg)); 
    7761705        kfree(glamofb); 
    7771706 
  • include/asm-arm/arch-s3c2410/dma.h

    old new  
    342342#define S3C2410_DCON_SYNC_HCLK  (1<<30) 
    343343 
    344344#define S3C2410_DCON_INTREQ     (1<<29) 
     345#define S3C2410_DCON_SERVMOD_WHOLE   (1<<27) 
     346#define S3C2410_DCON_SERVMOD_SINGLE   (0<<27) 
    345347 
    346348#define S3C2410_DCON_CH0_XDREQ0 (0<<24) 
    347349#define S3C2410_DCON_CH0_UART0  (1<<24) 
  • include/linux/glamofb.h

    old new  
    3333        int             (*glamo_irq_is_wired)(void); 
    3434}; 
    3535 
     36struct glamofb_pixmap { 
     37       unsigned int pitch; 
     38       unsigned int width; 
     39       unsigned int height; 
     40       unsigned int bits_per_pixel; 
     41       char *address; 
     42}; 
     43 
     44struct glamofb_upload_pixmap_info { 
     45       struct glamofb_pixmap pixmap; 
     46       unsigned int dest_offset;/*offset in glamo vram*/ 
     47       unsigned int  dest_pitch; 
     48}; 
     49 
     50struct glamofb_init_cmdq_info { 
     51        uint32_t ring_offset;/*offset of cmdq ring in glamo vram*/ 
     52        uint32_t ring_len; /*in bytes*/ 
     53}; 
     54 
     55#define FBIO_GLAMO_UPLOAD_PIXMAP_TO_VRAM \ 
     56       _IOW('F', 0x19, struct glamofb_upload_pixmap_info) 
     57 
     58#define FBIO_GLAMO_INIT_CMDQ \ 
     59       _IOW('F', 0x20, struct glamofb_init_cmdq_info) 
     60 
    3661void glamofb_cmd_mode(struct glamofb_handle *gfb, int on); 
    3762int glamofb_cmd_write(struct glamofb_handle *gfb, u_int16_t val); 
    3863