Subversion Repositories test_project

/*

    btcx-risc.c

    bt848/bt878/cx2388x risc code generator.

    (c) 2000-03 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#include <linux/module.h>

#include <linux/init.h>

#include <linux/pci.h>

#include <linux/interrupt.h>

#include <linux/videodev2.h>

#include <asm/page.h>

#include <asm/pgtable.h>

#include "btcx-risc.h"

MODULE_DESCRIPTION("some code shared by bttv and cx88xx drivers");

MODULE_AUTHOR("Gerd Knorr");

MODULE_LICENSE("GPL");

static unsigned int debug;

module_param(debug, int, 0644);

MODULE_PARM_DESC(debug,"debug messages, default is 0 (no)");

/* ---------------------------------------------------------- */

/* allocate/free risc memory                                  */

static int memcnt;

void btcx_riscmem_free(struct pci_dev *pci,

                       struct btcx_riscmem *risc)

{

        if (NULL == risc->cpu)

                return;

        if (debug) {

                memcnt--;

                printk("btcx: riscmem free [%d] dma=%lx\n",

                       memcnt, (unsigned long)risc->dma);

        }

        pci_free_consistent(pci, risc->size, risc->cpu, risc->dma);

        memset(risc,0,sizeof(*risc));

}

int btcx_riscmem_alloc(struct pci_dev *pci,

                       struct btcx_riscmem *risc,

                       unsigned int size)

{

        u32 *cpu;

        dma_addr_t dma;

        if (NULL != risc->cpu && risc->size < size)

                btcx_riscmem_free(pci,risc);

        if (NULL == risc->cpu) {

                cpu = pci_alloc_consistent(pci, size, &dma);

                if (NULL == cpu)

                        return -ENOMEM;

                risc->cpu  = cpu;

                risc->dma  = dma;

                risc->size = size;

                if (debug) {

                        memcnt++;

                        printk("btcx: riscmem alloc [%d] dma=%lx cpu=%p size=%d\n",

                               memcnt, (unsigned long)dma, cpu, size);

                }

        }

        memset(risc->cpu,0,risc->size);

        return 0;

}

/* ---------------------------------------------------------- */

/* screen overlay helpers                                     */

int

btcx_screen_clips(int swidth, int sheight, struct v4l2_rect *win,

                  struct v4l2_clip *clips, unsigned int n)

{

        if (win->left < 0) {

                /* left */

                clips[n].c.left = 0;

                clips[n].c.top = 0;

                clips[n].c.width  = -win->left;

                clips[n].c.height = win->height;

                n++;

        }

        if (win->left + win->width > swidth) {

                /* right */

                clips[n].c.left   = swidth - win->left;

                clips[n].c.top    = 0;

                clips[n].c.width  = win->width - clips[n].c.left;

                clips[n].c.height = win->height;

                n++;

        }

        if (win->top < 0) {

                /* top */

                clips[n].c.left = 0;

                clips[n].c.top = 0;

                clips[n].c.width  = win->width;

                clips[n].c.height = -win->top;

                n++;

        }

        if (win->top + win->height > sheight) {

                /* bottom */

                clips[n].c.left = 0;

                clips[n].c.top = sheight - win->top;

                clips[n].c.width  = win->width;

                clips[n].c.height = win->height - clips[n].c.top;

                n++;

        }

        return n;

}

int

btcx_align(struct v4l2_rect *win, struct v4l2_clip *clips, unsigned int n, int mask)

{

        s32 nx,nw,dx;

        unsigned int i;

        /* fixup window */

        nx = (win->left + mask) & ~mask;

        nw = (win->width) & ~mask;

        if (nx + nw > win->left + win->width)

                nw -= mask+1;

        dx = nx - win->left;

        win->left  = nx;

        win->width = nw;

        if (debug)

                printk(KERN_DEBUG "btcx: window align %dx%d+%d+%d [dx=%d]\n",

                       win->width, win->height, win->left, win->top, dx);

        /* fixup clips */

        for (i = 0; i < n; i++) {

                nx = (clips[i].c.left-dx) & ~mask;

                nw = (clips[i].c.width) & ~mask;

                if (nx + nw < clips[i].c.left-dx + clips[i].c.width)

                        nw += mask+1;

                clips[i].c.left  = nx;

                clips[i].c.width = nw;

                if (debug)

                        printk(KERN_DEBUG "btcx:   clip align %dx%d+%d+%d\n",

                               clips[i].c.width, clips[i].c.height,

                               clips[i].c.left, clips[i].c.top);

        }

        return 0;

}

void

btcx_sort_clips(struct v4l2_clip *clips, unsigned int nclips)

{

        struct v4l2_clip swap;

        int i,j,n;

        if (nclips < 2)

                return;

        for (i = nclips-2; i >= 0; i--) {

                for (n = 0, j = 0; j <= i; j++) {

                        if (clips[j].c.left > clips[j+1].c.left) {

                                swap = clips[j];

                                clips[j] = clips[j+1];

                                clips[j+1] = swap;

                                n++;

                        }

                }

                if (0 == n)

                        break;

        }

}

void

btcx_calc_skips(int line, int width, unsigned int *maxy,

                struct btcx_skiplist *skips, unsigned int *nskips,

                const struct v4l2_clip *clips, unsigned int nclips)

{

        unsigned int clip,skip;

        int end,maxline;

        skip=0;

        maxline = 9999;

        for (clip = 0; clip < nclips; clip++) {

                /* sanity checks */

                if (clips[clip].c.left + clips[clip].c.width <= 0)

                        continue;

                if (clips[clip].c.left > (signed)width)

                        break;

                /* vertical range */

                if (line > clips[clip].c.top+clips[clip].c.height-1)

                        continue;

                if (line < clips[clip].c.top) {

                        if (maxline > clips[clip].c.top-1)

                                maxline = clips[clip].c.top-1;

                        continue;

                }

                if (maxline > clips[clip].c.top+clips[clip].c.height-1)

                        maxline = clips[clip].c.top+clips[clip].c.height-1;

                /* horizontal range */

                if (0 == skip || clips[clip].c.left > skips[skip-1].end) {

                        /* new one */

                        skips[skip].start = clips[clip].c.left;

                        if (skips[skip].start < 0)

                                skips[skip].start = 0;

                        skips[skip].end = clips[clip].c.left + clips[clip].c.width;

                        if (skips[skip].end > width)

                                skips[skip].end = width;

                        skip++;

                } else {

                        /* overlaps -- expand last one */

                        end = clips[clip].c.left + clips[clip].c.width;

                        if (skips[skip-1].end < end)

                                skips[skip-1].end = end;

                        if (skips[skip-1].end > width)

                                skips[skip-1].end = width;

                }

        }

        *nskips = skip;

        *maxy = maxline;

        if (debug) {

                printk(KERN_DEBUG "btcx: skips line %d-%d:",line,maxline);

                for (skip = 0; skip < *nskips; skip++) {

                        printk(" %d-%d",skips[skip].start,skips[skip].end);

                }

                printk("\n");

        }

}

/* ---------------------------------------------------------- */

EXPORT_SYMBOL(btcx_riscmem_alloc);

EXPORT_SYMBOL(btcx_riscmem_free);

EXPORT_SYMBOL(btcx_screen_clips);

EXPORT_SYMBOL(btcx_align);

EXPORT_SYMBOL(btcx_sort_clips);

EXPORT_SYMBOL(btcx_calc_skips);

/*

 * Local variables:

 * c-basic-offset: 8

 * End:

 */