--- skystar2.c_01STYLE	2003-11-26 15:38:54.000000000 +0100
+++ skystar2.c_02FILTER	2003-11-26 19:55:47.000000000 +0100
@@ -45,12 +45,14 @@
 
 #include "dvb_functions.h"
 
-static int debug = 0;
+static int debug = 1;
 #define dprintk(x...) do { if (debug) printk(x); } while (0)
 
 #define SIZE_OF_BUF_DMA1	0x3AC00
 #define SIZE_OF_BUF_DMA2	0x758
 
+#define MAX_FILTERED_PIDS	60
+
 struct dmaq {
 	u32 bus_addr;
 	u32 head;
@@ -60,6 +62,94 @@
 };
 
 
+struct hw_filter_single {
+	char *name;
+	u32 enable_reg;
+	u32 enable_mask;
+	u32 pid_reg;
+	u32 pid_shift;
+};
+
+#if 0
+struct hw_filter_group {
+	char *name;
+	u32 enable_reg;
+	u32 enable_mask;
+	u32 pid_reg;
+	u32 pid_shift;
+	u32 mask_reg;
+	u32 mask_shift;
+};
+#endif
+
+static struct hw_filter_single hw_filter_single[] = {
+	{
+		.name           = "stream1",
+		.enable_reg     = 0x208,
+		.enable_mask    = 0x00000001,
+		.pid_reg        = 0x300,
+		.pid_shift = 0,
+	},
+	{
+		.name           = "stream2",
+		.enable_reg     = 0x208,
+		.enable_mask    = 0x00000002,
+		.pid_reg        = 0x300,
+		.pid_shift = 16,
+	},
+	{
+		.name           = "pcr",
+		.enable_reg     = 0x208,
+		.enable_mask    = 0x00000004,
+		.pid_reg        = 0x304,
+		.pid_shift = 0,
+	},
+	{
+		.name           = "pmt",
+		.enable_reg     = 0x208,
+		.enable_mask    = 0x00000008,
+		.pid_reg        = 0x304,
+		.pid_shift = 16,
+	},
+	{
+		.name           = "emm",
+		.enable_reg     = 0x208,
+		.enable_mask    = 0x00000010,
+		.pid_reg        = 0x308,
+		.pid_shift = 0,
+	},
+	{
+		.name           = "ecm",
+		.enable_reg     = 0x208,
+		.enable_mask    = 0x00000020,
+		.pid_reg        = 0x308,
+		.pid_shift = 16,
+	},
+/*
+	{
+		name           = "null / used as mask of the group filter",
+		enable_reg     = 0x208,
+		enable_mask    = 0x00000040,
+		pid_reg        = 0x30c,
+		pid_shift = 0,
+	}
+*/
+};
+
+#define NUM_OF_HW_FILT_SINGLE sizeof(hw_filter_single)/sizeof(struct hw_filter_single)
+
+#if 0
+static struct hw_filter_group hw_filter_group = {
+	.name            = "group",
+	.enable_reg      = 0x208,
+	.enable_mask     = 0x00000080,
+	.pid_reg         = 0x30c,
+	.pid_shift  = 0,
+	.mask_reg        = 0x30c,
+	.mask_shift = 16,
+};
+#endif
+
 struct adapter {
 	struct pci_dev *pdev;
 
@@ -93,7 +183,7 @@
 
 	spinlock_t lock;
 
-	u16 pids[0x27];
+	u16 pids[MAX_FILTERED_PIDS];
 	u32 mac_filter;
 };
 
@@ -926,98 +1016,23 @@
 */
 
 /* PID filter */
-static void filter_enable_stream1_filter(struct adapter *adapter, u32 op)
-{
-	dprintk("%s: op=%x\n", __FUNCTION__, op);
-
-	if (op == 0) {
-		write_reg_op(adapter, 0x208, 2, ~0x00000001, 0);
-
-	} else {
-
-		write_reg_op(adapter, 0x208, 1, 0, 0x00000001);
-	}
-}
-
-static void filter_enable_stream2_filter(struct adapter *adapter, u32 op)
-{
-	dprintk("%s: op=%x\n", __FUNCTION__, op);
-
-	if (op == 0) {
-		write_reg_op(adapter, 0x208, 2, ~0x00000002, 0);
-
-	} else {
-
-		write_reg_op(adapter, 0x208, 1, 0, 0x00000002);
-	}
-}
-
-static void filter_enable_pcr_filter(struct adapter *adapter, u32 op)
-{
-	dprintk("%s: op=%x\n", __FUNCTION__, op);
-
-	if (op == 0) {
-		write_reg_op(adapter, 0x208, 2, ~0x00000004, 0);
-
-	} else {
-
-		write_reg_op(adapter, 0x208, 1, 0, 0x00000004);
-	}
-}
-
-static void filter_enable_pmt_filter(struct adapter *adapter, u32 op)
-{
-	dprintk("%s: op=%x\n", __FUNCTION__, op);
-
-	if (op == 0) {
-		write_reg_op(adapter, 0x208, 2, ~0x00000008, 0);
-
-	} else {
-
-		write_reg_op(adapter, 0x208, 1, 0, 0x00000008);
-	}
-}
-
-static void filter_enable_emm_fFilter(struct adapter *adapter, u32 op)
+static void filter_enable_single_filter(struct adapter *adapter, u32 single_filter_num, u32 op)
 {
-	dprintk("%s: op=%x\n", __FUNCTION__, op);
-
-	if (op == 0) {
-		write_reg_op(adapter, 0x208, 2, ~0x00000010, 0);
-
-	} else {
+	struct hw_filter_single *hfs;
 
-		write_reg_op(adapter, 0x208, 1, 0, 0x00000010);
-	}
-}
+	dprintk("%s: op=%x filt=%x\n", __FUNCTION__, op, single_filter_num);
 
-static void filter_enable_ecm_filter(struct adapter *adapter, u32 op)
-{
-	dprintk("%s: op=%x\n", __FUNCTION__, op);
+	hfs = &hw_filter_single[single_filter_num];
 
 	if (op == 0) {
-		write_reg_op(adapter, 0x208, 2, ~0x00000020, 0);
+		write_reg_op(adapter, hfs->enable_reg, 2, ~hfs->enable_mask, 0);
 
 	} else {
 
-		write_reg_op(adapter, 0x208, 1, 0, 0x00000020);
+		write_reg_op(adapter, hfs->enable_reg, 1, 0, hfs->enable_mask);
 	}
 }
 
-/*
-static void filter_enable_null_filter(struct adapter *adapter, u32 op)
-{
-	dprintk("%s: op=%x\n", __FUNCTION__, op);
-
-	if (op == 0) {
-		write_reg_op(adapter, 0x208, 2, ~0x00000040, 0);
-
-	} else {
-
-		write_reg_op(adapter, 0x208, 1, 0, 0x00000040);
-	}
-}
-*/
 
 static void filter_enable_mask_filter(struct adapter *adapter, u32 op)
 {
@@ -1088,7 +1103,7 @@
 {
 	int i;
 
-	for (i = 0; i < 0x27; i++)
+	for (i = 0; i < MAX_FILTERED_PIDS; i++)
 		adapter->pids[i] = 0x1FFF;
 }
 
@@ -1099,7 +1114,7 @@
 	if (pid == 0x1FFF)
 		return 0;
         
-	for (i = 0; i < 0x27; i++) {
+	for (i = 0; i < MAX_FILTERED_PIDS; i++) {
 		if (adapter->pids[i] == pid || adapter->pids[i] == 0x2000)
 			return 1;
 	}
@@ -1107,146 +1122,63 @@
 	return 0;
 }
 
-static void pid_set_group_pid(struct adapter * adapter, u32 pid)
-{
-	u32 value;
-
-	dprintk("%s: pid=%x\n", __FUNCTION__, pid);
-
-	value = (pid & 0x3FFF) | (read_reg_dw(adapter, 0x30C) & 0xFFFF0000);
-
-	write_reg_dw(adapter, 0x30C, value);
-
-	/* return value is never used? */
-/*	return value; */
-}
-
-static void pid_set_group_mask(struct adapter * adapter, u32 pid)
-{
-	u32 value;
-
-	dprintk("%s: pid=%x\n", __FUNCTION__, pid);
-
-	value = ((pid & 0x3FFF) << 0x10) | (read_reg_dw(adapter, 0x30C) & 0xFFFF);
-
-	write_reg_dw(adapter, 0x30C, value);
-
-	/* return value is never used? */
-/*	return value; */
-}
-
-static void pid_set_stream1_pid(struct adapter * adapter, u32 pid)
-{
-	u32 value;
-
-	dprintk("%s: pid=%x\n", __FUNCTION__, pid);
-
-	value = (pid & 0x3FFF) | (read_reg_dw(adapter, 0x300) & 0xFFFFC000);
-
-	write_reg_dw(adapter, 0x300, value);
-
-	/* return value is never used? */
-/*	return value; */
-}
-
-static void pid_set_stream2_pid(struct adapter * adapter, u32 pid)
-{
-	u32 value;
-
-	dprintk("%s: pid=%x\n", __FUNCTION__, pid);
-
-	value = ((pid & 0x3FFF) << 0x10) | (read_reg_dw(adapter, 0x300) & 0xFFFF);
-
-	write_reg_dw(adapter, 0x300, value);
-
-	/* return value is never used? */
-/*	return value; */
-}
-
-static void pid_set_pcr_pid(struct adapter * adapter, u32 pid)
+static void pid_set_single_filter(struct adapter * adapter, u32 single_filter_num, u32 pid)
 {
+	struct hw_filter_single *hfs;
 	u32 value;
 
-	dprintk("%s: pid=%x\n", __FUNCTION__, pid);
-
-	value = (pid & 0x3FFF) | (read_reg_dw(adapter, 0x304) & 0xFFFFC000);
-
-	write_reg_dw(adapter, 0x304, value);
-
-	/* return value is never used? */
-/*	return value; */
-}
+	dprintk("%s: filt=%x pid=%x \n", __FUNCTION__, single_filter_num, pid);
 
-static void pid_set_pmt_pid(struct adapter * adapter, u32 pid)
-{
-	u32 value;
+	hfs = &hw_filter_single[single_filter_num];
 
-	dprintk("%s: pid=%x\n", __FUNCTION__, pid);
+	value = (read_reg_dw(adapter, hfs->pid_reg) & ~(0xFFFF << hfs->pid_shift))
+	      | ((pid & 0x1FFF) << hfs->pid_shift);
 
-	value = ((pid & 0x3FFF) << 0x10) | (read_reg_dw(adapter, 0x304) & 0x3FFF);
+	dprintk("%s: reg=%x value=%x\n", __FUNCTION__, hfs->pid_reg, value);
 
-	write_reg_dw(adapter, 0x304, value);
+	write_reg_dw(adapter, hfs->pid_reg, value);
 
 	/* return value is never used? */
 /*	return value; */
 }
 
-static void pid_set_emm_pid(struct adapter * adapter, u32 pid)
+static void pid_set_group_pid(struct adapter * adapter, u32 pid)
 {
 	u32 value;
 
 	dprintk("%s: pid=%x\n", __FUNCTION__, pid);
 
-	value = (pid & 0xFFFF) | (read_reg_dw(adapter, 0x308) & 0xFFFF0000);
+	value = (pid & 0x1FFF) | (read_reg_dw(adapter, 0x30C) & 0xFFFF0000);
 
-	write_reg_dw(adapter, 0x308, value);
+	write_reg_dw(adapter, 0x30C, value);
 
 	/* return value is never used? */
 /*	return value; */
 }
 
-static void pid_set_ecm_pid(struct adapter * adapter, u32 pid)
+static void pid_set_group_mask(struct adapter * adapter, u32 pid)
 {
 	u32 value;
 
 	dprintk("%s: pid=%x\n", __FUNCTION__, pid);
 
-	value = (pid << 0x10) | (read_reg_dw(adapter, 0x308) & 0xFFFF);
+	value = ((pid & 0x1FFF) << 0x10) | (read_reg_dw(adapter, 0x30C) & 0xFFFF);
 
-	write_reg_dw(adapter, 0x308, value);
+	write_reg_dw(adapter, 0x30C, value);
 
 	/* return value is never used? */
 /*	return value; */
 }
 
-static int pid_get_stream1_pid(struct adapter * adapter)
-{
-	return read_reg_dw(adapter, 0x300) & 0x00001FFF;
-}
-
-static int pid_get_stream2_pid(struct adapter * adapter)
-{
-	return (read_reg_dw(adapter, 0x300) >> 0x10)& 0x00001FFF;
-}
-
-static int pid_get_pcr_pid(struct adapter * adapter)
+static int pid_get_single_filter(struct adapter * adapter, u32 single_filter_num)
 {
-	return read_reg_dw(adapter, 0x304) & 0x00001FFF;
-}
+	struct hw_filter_single *hfs;
 
-static int pid_get_pmt_pid(struct adapter * adapter)
-{
-	return (read_reg_dw(adapter, 0x304) >> 0x10)& 0x00001FFF;
-}
+	dprintk("%s: filt=%x\n", __FUNCTION__, single_filter_num);
 
-static int pid_get_emm_pid(struct adapter * adapter)
-{
-	return read_reg_dw(adapter, 0x308) & 0x00001FFF;
-}
+	hfs = &hw_filter_single[single_filter_num];
 
-static int pid_get_ecm_pid(struct adapter * adapter)
-{
-	return (read_reg_dw(adapter, 0x308) >> 0x10)& 0x00001FFF;
+	return (read_reg_dw(adapter, hfs->pid_reg) >> hfs->pid_shift) & 0x00001FFF;
 }
 
 static int pid_get_group_pid(struct adapter * adapter)
@@ -1295,6 +1227,8 @@
 
 static int add_hw_pid(struct adapter *adapter, u32 pid)
 {
+	int i;
+
 	dprintk("%s: pid=%d\n", __FUNCTION__, pid);
 
 	if (pid <= 0x1F)
@@ -1303,52 +1237,14 @@
 	if ((pid_get_group_mask(adapter) == 0) && (pid_get_group_pid(adapter) == 0))
 		return 0;
 
-	if (pid_get_stream1_pid(adapter) == 0x1FFF) {
-		pid_set_stream1_pid(adapter, pid & 0xFFFF);
-
-		filter_enable_stream1_filter(adapter, 1);
-
-		return 1;
-	}
-
-	if (pid_get_stream2_pid(adapter) == 0x1FFF) {
-		pid_set_stream2_pid(adapter, (pid & 0xFFFF));
-
-		filter_enable_stream2_filter(adapter, 1);
-
-		return 1;
-	}
-
-	if (pid_get_pcr_pid(adapter) == 0x1FFF) {
-		pid_set_pcr_pid(adapter, (pid & 0xFFFF));
-
-		filter_enable_pcr_filter(adapter, 1);
-
-		return 1;
-	}
-
-	if ((pid_get_pmt_pid(adapter) & 0x1FFF) == 0x1FFF) {
-		pid_set_pmt_pid(adapter, (pid & 0xFFFF));
-
-		filter_enable_pmt_filter(adapter, 1);
-
-		return 1;
-	}
-
-	if ((pid_get_emm_pid(adapter) & 0x1FFF) == 0x1FFF) {
-		pid_set_emm_pid(adapter, (pid & 0xFFFF));
-
-		filter_enable_emm_fFilter(adapter, 1);
-
-		return 1;
-	}
-
-	if ((pid_get_ecm_pid(adapter) & 0x1FFF) == 0x1FFF) {
-		pid_set_ecm_pid(adapter, (pid & 0xFFFF));
+	for (i = 0; i < NUM_OF_HW_FILT_SINGLE; i++) {
+		if (pid_get_single_filter(adapter, i) == 0x1FFF) {
+			pid_set_single_filter(adapter, i, pid & 0x1FFF);
 
-		filter_enable_ecm_filter(adapter, 1);
+			filter_enable_single_filter(adapter, i, 1);
 
-		return 1;
+			return 1;
+		}
 	}
 
 	return -1;
@@ -1356,56 +1252,21 @@
 
 static int remove_hw_pid(struct adapter *adapter, u32 pid)
 {
+	int i;
+
 	dprintk("%s: pid=%d\n", __FUNCTION__, pid);
 
 	if (pid <= 0x1F)
 		return 1;
 
-	if (pid_get_stream1_pid(adapter) == pid) {
-		pid_set_stream1_pid(adapter, 0x1FFF);
-
-		return 1;
-	}
-
-	if (pid_get_stream2_pid(adapter) == pid) {
-		pid_set_stream2_pid(adapter, 0x1FFF);
-
-		filter_enable_stream2_filter(adapter, 0);
-
-		return 1;
-	}
-
-	if (pid_get_pcr_pid(adapter) == pid) {
-		pid_set_pcr_pid(adapter, 0x1FFF);
-
-		filter_enable_pcr_filter(adapter, 0);
-
-		return 1;
-	}
-
-	if (pid_get_pmt_pid(adapter) == pid) {
-		pid_set_pmt_pid(adapter, 0x1FFF);
-
-		filter_enable_pmt_filter(adapter, 0);
-
-		return 1;
-	}
-
-	if (pid_get_emm_pid(adapter) == pid) {
-		pid_set_emm_pid(adapter, 0x1FFF);
-
-		filter_enable_emm_fFilter(adapter, 0);
+	for (i = 0; i < NUM_OF_HW_FILT_SINGLE; i++) {
+		if (pid_get_single_filter(adapter, i) == pid) {
+			pid_set_single_filter(adapter, i, 0x1FFF);
 
-		return 1;
+			return 1;
+		}
 	}
 
-	if (pid_get_ecm_pid(adapter) == pid) {
-		pid_set_ecm_pid(adapter, 0x1FFF);
-
-		filter_enable_ecm_filter(adapter, 0);
-
-		return 1;
-	}
 
 	return -1;
 }
@@ -1422,9 +1283,11 @@
 	if (check_pid(adapter, pid) == 1)
 		return 1;
 
-	for (i = 0; i < 0x27; i++) {
+	for (i = 0; i < MAX_FILTERED_PIDS; i++) {
 		if (adapter->pids[i] == 0x1FFF)	// find free pid filter
 		{
+			dprintk("%s: pid=%d, array position=%d\n", __FUNCTION__, pid, i);
+
 			adapter->pids[i] = pid;
 
 			if (pid == 0x2000 || add_hw_pid(adapter, pid) < 0)
@@ -1446,7 +1309,7 @@
 	if (pid > 0x1FFE)
 		return -1;
 
-	for (i = 0; i < 0x27; i++) {
+	for (i = 0; i < MAX_FILTERED_PIDS; i++) {
 		if (adapter->pids[i] == pid) {
 			adapter->pids[i] = 0x1FFF;
 
@@ -2040,6 +1903,7 @@
 {
 	struct adapter *adapter;
 	u32 tmp;
+	int i;
 	
 	if (!(adapter = kmalloc(sizeof(struct adapter), GFP_KERNEL))) {
 		dprintk("%s: out of memory!\n", __FUNCTION__);
@@ -2079,12 +1943,9 @@
 
 	pid_set_group_pid(adapter, 0);
 	pid_set_group_mask(adapter, 0x1FE0);
-	pid_set_stream1_pid(adapter, 0x1FFF);
-	pid_set_stream2_pid(adapter, 0x1FFF);
-	pid_set_pmt_pid(adapter, 0x1FFF);
-	pid_set_pcr_pid(adapter, 0x1FFF);
-	pid_set_ecm_pid(adapter, 0x1FFF);
-	pid_set_emm_pid(adapter, 0x1FFF);
+	for (i = 0; i < NUM_OF_HW_FILT_SINGLE; i++) {
+		pid_set_single_filter(adapter, i, 0x1FFF);
+	}
 
 	init_dma_queue(adapter);