av7110_hw.c

linux环境下的dvb驱动程序

/****************************************************************************
 * Firmware commands
 ****************************************************************************/

/* get version of the firmware ROM, RTSL, video ucode and ARM application  */
int av7110_firmversion(struct av7110 *av7110)
{
	u16 buf[20];
	u16 tag = ((COMTYPE_REQUEST << 8) + ReqVersion);

	DEB_EE(("av7110: %p\n", av7110));

	if (av7110_fw_query(av7110, tag, buf, 16)) {
		printk("DVB: AV7110-%d: ERROR: Failed to boot firmware\n",
		       av7110->dvb_adapter->num);
		return -EIO;
	}

	av7110->arm_fw = (buf[0] << 16) + buf[1];
	av7110->arm_rtsl = (buf[2] << 16) + buf[3];
	av7110->arm_vid = (buf[4] << 16) + buf[5];
	av7110->arm_app = (buf[6] << 16) + buf[7];
	av7110->avtype = (buf[8] << 16) + buf[9];

	printk("DVB: AV711%d(%d) - firm %08x, rtsl %08x, vid %08x, app %08x\n",
	       av7110->avtype, av7110->dvb_adapter->num, av7110->arm_fw,
	       av7110->arm_rtsl, av7110->arm_vid, av7110->arm_app);

	/* print firmware capabilities */
	if (FW_CI_LL_SUPPORT(av7110->arm_app))
		printk("DVB: AV711%d(%d) - firmware supports CI link layer interface\n",
		       av7110->avtype, av7110->dvb_adapter->num);
	else
		printk("DVB: AV711%d(%d) - no firmware support for CI link layer interface\n",
		       av7110->avtype, av7110->dvb_adapter->num);

	return 0;
}


int av7110_diseqc_send(struct av7110 *av7110, int len, u8 *msg, unsigned long burst)
{
	int i;
	u16 buf[18] = { ((COMTYPE_AUDIODAC << 8) + SendDiSEqC),
			16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

	DEB_EE(("av7110: %p\n", av7110));

	if (len > 10)
		len = 10;

	buf[1] = len + 2;
	buf[2] = len;

	if (burst != -1)
		buf[3] = burst ? 0x01 : 0x00;
	else
		buf[3] = 0xffff;

	for (i = 0; i < len; i++)
		buf[i + 4] = msg[i];

	if (av7110_send_fw_cmd(av7110, buf, 18))
		printk("av7110_diseqc_send error\n");

	return 0;
}


#ifdef CONFIG_DVB_AV7110_OSD

static inline int ResetBlend(struct av7110 *av7110, u8 windownr)
{
	return av7110_fw_cmd(av7110, COMTYPE_OSD, SetNonBlend, 1, windownr);
}

static inline int SetColorBlend(struct av7110 *av7110, u8 windownr)
{
	return av7110_fw_cmd(av7110, COMTYPE_OSD, SetCBlend, 1, windownr);
}

static inline int SetWindowBlend(struct av7110 *av7110, u8 windownr, u8 blending)
{
	return av7110_fw_cmd(av7110, COMTYPE_OSD, SetWBlend, 2, windownr, blending);
}

static inline int SetBlend_(struct av7110 *av7110, u8 windownr,
		     enum av7110_osd_palette_type colordepth, u16 index, u8 blending)
{
	return av7110_fw_cmd(av7110, COMTYPE_OSD, SetBlend, 4,
			     windownr, colordepth, index, blending);
}

static inline int SetColor_(struct av7110 *av7110, u8 windownr,
		     enum av7110_osd_palette_type colordepth, u16 index, u16 colorhi, u16 colorlo)
{
	return av7110_fw_cmd(av7110, COMTYPE_OSD, SetColor, 5,
			     windownr, colordepth, index, colorhi, colorlo);
}

static inline int BringToTop(struct av7110 *av7110, u8 windownr)
{
	return av7110_fw_cmd(av7110, COMTYPE_OSD, WTop, 1, windownr);
}

static inline int SetFont(struct av7110 *av7110, u8 windownr, u8 fontsize,
			  u16 colorfg, u16 colorbg)
{
	return av7110_fw_cmd(av7110, COMTYPE_OSD, Set_Font, 4,
			     windownr, fontsize, colorfg, colorbg);
}

static int FlushText(struct av7110 *av7110)
{
	unsigned long start;

	if (down_interruptible(&av7110->dcomlock))
		return -ERESTARTSYS;
	start = jiffies;
	while (rdebi(av7110, DEBINOSWAP, BUFF1_BASE, 0, 2)) {
		dvb_delay(1);
		if (time_after(jiffies, start + ARM_WAIT_OSD)) {
			printk(KERN_ERR "%s: timeout waiting for BUFF1_BASE == 0\n",
			       __FUNCTION__);
			up(&av7110->dcomlock);
			return -1;
		}
	}
	up(&av7110->dcomlock);
	return 0;
}

static int WriteText(struct av7110 *av7110, u8 win, u16 x, u16 y, u8* buf)
{
	int i, ret;
	unsigned long start;
	int length = strlen(buf) + 1;
	u16 cbuf[5] = { (COMTYPE_OSD << 8) + DText, 3, win, x, y };

	if (down_interruptible(&av7110->dcomlock))
		return -ERESTARTSYS;

	start = jiffies;
	while (rdebi(av7110, DEBINOSWAP, BUFF1_BASE, 0, 2)) {
		dvb_delay(1);
		if (time_after(jiffies, start + ARM_WAIT_OSD)) {
			printk(KERN_ERR "%s: timeout waiting for BUFF1_BASE == 0\n",
			       __FUNCTION__);
			up(&av7110->dcomlock);
			return -1;
		}
	}
#ifndef _NOHANDSHAKE
	start = jiffies;
	while (rdebi(av7110, DEBINOSWAP, HANDSHAKE_REG, 0, 2)) {
		dvb_delay(1);
		if (time_after(jiffies, start + ARM_WAIT_SHAKE)) {
			printk(KERN_ERR "%s: timeout waiting for HANDSHAKE_REG\n",
			       __FUNCTION__);
			up(&av7110->dcomlock);
			return -1;
		}
	}
#endif
	for (i = 0; i < length / 2; i++)
		wdebi(av7110, DEBINOSWAP, BUFF1_BASE + i * 2,
		      swab16(*(u16 *)(buf + 2 * i)), 2);
	if (length & 1)
		wdebi(av7110, DEBINOSWAP, BUFF1_BASE + i * 2, 0, 2);
	ret = __av7110_send_fw_cmd(av7110, cbuf, 5);
	up(&av7110->dcomlock);
	if (ret)
		printk("WriteText error\n");
	return ret;
}

static inline int DrawLine(struct av7110 *av7110, u8 windownr,
			   u16 x, u16 y, u16 dx, u16 dy, u16 color)
{
	return av7110_fw_cmd(av7110, COMTYPE_OSD, DLine, 6,
			     windownr, x, y, dx, dy, color);
}

static inline int DrawBlock(struct av7110 *av7110, u8 windownr,
			    u16 x, u16 y, u16 dx, u16 dy, u16 color)
{
	return av7110_fw_cmd(av7110, COMTYPE_OSD, DBox, 6,
			     windownr, x, y, dx, dy, color);
}

static inline int HideWindow(struct av7110 *av7110, u8 windownr)
{
	return av7110_fw_cmd(av7110, COMTYPE_OSD, WHide, 1, windownr);
}

static inline int MoveWindowRel(struct av7110 *av7110, u8 windownr, u16 x, u16 y)
{
	return av7110_fw_cmd(av7110, COMTYPE_OSD, WMoveD, 3, windownr, x, y);
}

static inline int MoveWindowAbs(struct av7110 *av7110, u8 windownr, u16 x, u16 y)
{
	return av7110_fw_cmd(av7110, COMTYPE_OSD, WMoveA, 3, windownr, x, y);
}

static inline int DestroyOSDWindow(struct av7110 *av7110, u8 windownr)
{
	return av7110_fw_cmd(av7110, COMTYPE_OSD, WDestroy, 1, windownr);
}

static inline int CreateOSDWindow(struct av7110 *av7110, u8 windownr,
				  enum av7110_window_display_type disptype,
				  u16 width, u16 height)
{
	return av7110_fw_cmd(av7110, COMTYPE_OSD, WCreate, 4,
			     windownr, disptype, width, height);
}


static enum av7110_osd_palette_type bpp2pal[8] = {
	Pal1Bit, Pal2Bit, 0, Pal4Bit, 0, 0, 0, Pal8Bit
};
static enum av7110_window_display_type bpp2bit[8] = {
	BITMAP1, BITMAP2, 0, BITMAP4, 0, 0, 0, BITMAP8
};

static inline int LoadBitmap(struct av7110 *av7110, u16 format,
			     u16 dx, u16 dy, int inc, u8* data)
{
	int bpp;
	int i;
	int d, delta;
	u8 c;
	DECLARE_WAITQUEUE(wait, current);

	DEB_EE(("av7110: %p\n", av7110));

	if (av7110->bmp_state == BMP_LOADING) {
		add_wait_queue(&av7110->bmpq, &wait);
		while (1) {
			set_current_state(TASK_INTERRUPTIBLE);
			if (av7110->bmp_state != BMP_LOADING
			    || signal_pending(current))
				break;
			schedule();
		}
		set_current_state(TASK_RUNNING);
		remove_wait_queue(&av7110->bmpq, &wait);
	}
	if (av7110->bmp_state == BMP_LOADING)
		return -1;
	av7110->bmp_state = BMP_LOADING;
	if	(format == BITMAP8) {
		bpp=8; delta = 1;
	} else if (format == BITMAP4) {
		bpp=4; delta = 2;
	} else if (format == BITMAP2) {
		bpp=2; delta = 4;
	} else if (format == BITMAP1) {
		bpp=1; delta = 8;
	} else {
		av7110->bmp_state = BMP_NONE;
		return -1;
	}
	av7110->bmplen = ((dx * dy * bpp + 7) & ~7) / 8;
	av7110->bmpp = 0;
	if (av7110->bmplen > 32768) {
		av7110->bmp_state = BMP_NONE;
		return -1;
	}
	for (i = 0; i < dy; i++) {
		if (copy_from_user(av7110->bmpbuf + 1024 + i * dx, data + i * inc, dx)) {
			av7110->bmp_state = BMP_NONE;
			return -1;
		}
	}
	if (format != BITMAP8) {
		for (i = 0; i < dx * dy / delta; i++) {
			c = ((u8 *)av7110->bmpbuf)[1024 + i * delta + delta - 1];
			for (d = delta - 2; d >= 0; d--) {
				c |= (((u8 *)av7110->bmpbuf)[1024 + i * delta + d]
				      << ((delta - d - 1) * bpp));
				((u8 *)av7110->bmpbuf)[1024 + i] = c;
			}
		}
	}
	av7110->bmplen += 1024;
	return av7110_fw_cmd(av7110, COMTYPE_OSD, LoadBmp, 3, format, dx, dy);
}

static int BlitBitmap(struct av7110 *av7110, u16 win, u16 x, u16 y, u16 trans)
{
	DECLARE_WAITQUEUE(wait, current);

	DEB_EE(("av7110: %p\n", av7110));

       if (av7110->bmp_state == BMP_NONE)
		return -1;
	if (av7110->bmp_state == BMP_LOADING) {
		add_wait_queue(&av7110->bmpq, &wait);
		while (1) {
			set_current_state(TASK_INTERRUPTIBLE);
			if (av7110->bmp_state != BMP_LOADING
			    || signal_pending(current))
				break;
			schedule();
		}
		set_current_state(TASK_RUNNING);
		remove_wait_queue(&av7110->bmpq, &wait);
	}
	if (av7110->bmp_state == BMP_LOADED)
		return av7110_fw_cmd(av7110, COMTYPE_OSD, BlitBmp, 4, win, x, y, trans);
	return -1;
}

static inline int ReleaseBitmap(struct av7110 *av7110)
{
	DEB_EE(("av7110: %p\n",av7110));

	if (av7110->bmp_state != BMP_LOADED)
		return -1;
	av7110->bmp_state = BMP_NONE;
	return av7110_fw_cmd(av7110, COMTYPE_OSD, ReleaseBmp, 0);
}

static u32 RGB2YUV(u16 R, u16 G, u16 B)
{
	u16 y, u, v;
	u16 Y, Cr, Cb;

	y = R * 77 + G * 150 + B * 29;	/* Luma=0.299R+0.587G+0.114B 0..65535 */
	u = 2048 + B * 8 -(y >> 5);	/* Cr 0..4095 */
	v = 2048 + R * 8 -(y >> 5);	/* Cb 0..4095 */

	Y = y / 256;
	Cb = u / 16;
	Cr = v / 16;

	return Cr | (Cb << 16) | (Y << 8);
}

static void OSDSetColor(struct av7110 *av7110, u8 color, u8 r, u8 g, u8 b, u8 blend)
{
	u16 ch, cl;
	u32 yuv;

	yuv = blend ? RGB2YUV(r,g,b) : 0;
	cl = (yuv & 0xffff);
	ch = ((yuv >> 16) & 0xffff);
	SetColor_(av7110, av7110->osdwin, bpp2pal[av7110->osdbpp[av7110->osdwin]],
		  color, ch, cl);
	SetBlend_(av7110, av7110->osdwin, bpp2pal[av7110->osdbpp[av7110->osdwin]],
		  color, ((blend >> 4) & 0x0f));
}

static int OSDSetPalette(struct av7110 *av7110, u32 *colors, u8 first, u8 last)
{
       int i;
       int length = last - first + 1;

       if (length * 4 > DATA_BUFF3_SIZE)
	       return -1;

       for (i = 0; i < length; i++) {
	       u32 blend = (colors[i] & 0xF0000000) >> 4;
	       u32 yuv = blend ? RGB2YUV(colors[i] & 0xFF, (colors[i] >> 8) & 0xFF,
					 (colors[i] >> 16) & 0xFF) | blend : 0;
	       yuv = ((yuv & 0xFFFF0000) >> 16) | ((yuv & 0x0000FFFF) << 16);
	       wdebi(av7110, DEBINOSWAP, DATA_BUFF3_BASE + i * 4, yuv, 4);
       }
       return av7110_fw_cmd(av7110, COMTYPE_OSD, Set_Palette, 4,
			    av7110->osdwin,
			    bpp2pal[av7110->osdbpp[av7110->osdwin]],
			    first, last);
}

static int OSDSetBlock(struct av7110 *av7110, int x0, int y0,
		       int x1, int y1, int inc, u8 *data)
{
	uint w, h, bpp, bpl, size, lpb, bnum, brest;
	int i;

	w = x1 - x0 + 1;
	h = y1 - y0 + 1;
	if (inc <= 0)
		inc = w;
	if (w <= 0 || w > 720 || h <= 0 || h > 576)
		return -1;
	bpp = av7110->osdbpp[av7110->osdwin] + 1;
	bpl = ((w * bpp + 7) & ~7) / 8;
	size = h * bpl;
	lpb = (32 * 1024) / bpl;
	bnum = size / (lpb * bpl);
	brest = size - bnum * lpb * bpl;

	for (i = 0; i < bnum; i++) {
		LoadBitmap(av7110, bpp2bit[av7110->osdbpp[av7110->osdwin]],
			   w, lpb, inc, data);
		BlitBitmap(av7110, av7110->osdwin, x0, y0 + i * lpb, 0);
		data += lpb * inc;
	}
	if (brest) {
		LoadBitmap(av7110, bpp2bit[av7110->osdbpp[av7110->osdwin]],
			   w, brest / bpl, inc, data);
		BlitBitmap(av7110, av7110->osdwin, x0, y0 + bnum * lpb, 0);
	}
	ReleaseBitmap(av7110);
	return 0;
}

int av7110_osd_cmd(struct av7110 *av7110, osd_cmd_t *dc)
{
	switch (dc->cmd) {
	case OSD_Close:
		DestroyOSDWindow(av7110, av7110->osdwin);
		return 0;
	case OSD_Open:
		av7110->osdbpp[av7110->osdwin] = (dc->color - 1) & 7;
		CreateOSDWindow(av7110, av7110->osdwin,
				bpp2bit[av7110->osdbpp[av7110->osdwin]],
				dc->x1 - dc->x0 + 1, dc->y1 - dc->y0 + 1);
		if (!dc->data) {
			MoveWindowAbs(av7110, av7110->osdwin, dc->x0, dc->y0);
			SetColorBlend(av7110, av7110->osdwin);
		}
		return 0;
	case OSD_Show:
		MoveWindowRel(av7110, av7110->osdwin, 0, 0);
		return 0;
	case OSD_Hide:
		HideWindow(av7110, av7110->osdwin);
		return 0;
	case OSD_Clear:
		DrawBlock(av7110, av7110->osdwin, 0, 0, 720, 576, 0);
		return 0;
	case OSD_Fill:
		DrawBlock(av7110, av7110->osdwin, 0, 0, 720, 576, dc->color);
		return 0;
	case OSD_SetColor:
		OSDSetColor(av7110, dc->color, dc->x0, dc->y0, dc->x1, dc->y1);
		return 0;
	case OSD_SetPalette:
	{
		if (FW_VERSION(av7110->arm_app) >= 0x2618)
			OSDSetPalette(av7110, (u32 *)dc->data, dc->color, dc->x0);
		else {
			int i, len = dc->x0-dc->color+1;
			u8 *colors = (u8 *)dc->data;

			for (i = 0; i<len; i++)
				OSDSetColor(av7110, dc->color + i,
					colors[i * 4], colors[i * 4 + 1],
					colors[i * 4 + 2], colors[i * 4 + 3]);
		}
		return 0;
	}
	case OSD_SetTrans:
		return 0;
	case OSD_SetPixel:
		DrawLine(av7110, av7110->osdwin,
			 dc->x0, dc->y0, 0, 0, dc->color);
		return 0;
	case OSD_GetPixel:
		return 0;

	case OSD_SetRow:
		dc->y1 = dc->y0;
		/* fall through */
	case OSD_SetBlock:
		OSDSetBlock(av7110, dc->x0, dc->y0, dc->x1, dc->y1, dc->color, dc->data);
		return 0;

	case OSD_FillRow:
		DrawBlock(av7110, av7110->osdwin, dc->x0, dc->y0,
			  dc->x1-dc->x0+1, dc->y1, dc->color);
		return 0;
	case OSD_FillBlock:
		DrawBlock(av7110, av7110->osdwin, dc->x0, dc->y0,
			  dc->x1 - dc->x0 + 1, dc->y1 - dc->y0 + 1, dc->color);
		return 0;
	case OSD_Line:
		DrawLine(av7110, av7110->osdwin,
			 dc->x0, dc->y0, dc->x1 - dc->x0, dc->y1 - dc->y0, dc->color);
		return 0;
	case OSD_Query:
		return 0;
	case OSD_Test:
		return 0;
	case OSD_Text:
	{
		char textbuf[240];

		if (strncpy_from_user(textbuf, dc->data, 240) < 0)
			return -EFAULT;
		textbuf[239] = 0;
		if (dc->x1 > 3)
			dc->x1 = 3;
		SetFont(av7110, av7110->osdwin, dc->x1,
			(u16) (dc->color & 0xffff), (u16) (dc->color >> 16));
		FlushText(av7110);
		WriteText(av7110, av7110->osdwin, dc->x0, dc->y0, textbuf);
		return 0;
	}
	case OSD_SetWindow:
		if (dc->x0 < 1 || dc->x0 > 7)
			return -EINVAL;
		av7110->osdwin = dc->x0;
		return 0;
	case OSD_MoveWindow:
		MoveWindowAbs(av7110, av7110->osdwin, dc->x0, dc->y0);
		SetColorBlend(av7110, av7110->osdwin);
		return 0;
	default:
		return -EINVAL;
	}
}
#endif /* CONFIG_DVB_AV7110_OSD */