dw4002.c

linux下DVB/IP驱动原代码 DVBWorld 公司产品 www.worlddvb.com

				case CONTINUEFILTER:
					tp->bScanMpePIDFlag = TRUE;
					result = 0;
					break;

				case CHECKFILTER:
					if (tp->bScanMpePIDFlag == FALSE) 
					{
						data->val_out = tp->MpePIDNum;
						memcpy( data->buf, (char*)tp->MpePID, tp->MpePIDNum * sizeof(MPE_PID));
//						printk ("Scan MPE PID success %d.\n", tp->MpePIDNum);
					}
					else
					{
						data->val_out = 0;
						data->val_in = tp->MpePIDNum;
					}
					result = 0;
					break;

				case STOPFILTER:
					tp->bScanMpePIDFlag = FALSE;
//					printk ("Stop Scan MPE PID %d\n", tp->MpePIDNum);
					data->val_out = tp->MpePIDNum;
					memcpy (data->buf, (char*)tp->MpePID, tp->MpePIDNum * sizeof(MPE_PID));
					result = 0;
					break;

				default:
					break;
			}
			break;

		case FILTERIP:
			switch (type) 
			{
				int j, k;
				unsigned short pid, pidbuf[MaxDecodeIP];

				case APPLYFILTER:
				case STARTFILTER:
				case SETFILTERPID:
					for (i = 0, k = 0; i < num; i++) 
					{
						pid = bufptr[i];
//						printk("pid = %x\n", pid);
						for (j = 0; j < MaxDecodeIP; j++) 
						{
							if (tp->DecodeIP[j].wPID == pid)
									break;
						}

						if (j < MaxDecodeIP) 
						{  // the MPE PID exist
							tp->DecodeIP[j].status = FILTERPID_RUN;
							pidbuf[k++] = pid;
							continue;  // next filter pid
						}

						for (j = 0; j < MaxDecodeIP; j++) 
						{
						   //find a pid that is not being filtered
							if (tp->DecodeIP[j].status == FILTERPID_READY) 
							{
//							            printk("pid = %x ,FILTERPID_READY", pid);
								memset (&tp->DecodeIP[j], 0x00, sizeof (DECODE_IP));
								tp->DecodeIP[j].status = FILTERPID_RUN;  //begain filter this pid
								tp->DecodeIP[j].wPID = pid;
								tp->DecodeIP[j].bInitFlag = FALSE;

								pidbuf[k++] = pid;

								break;
							}
						}
					}

					data->val_out = k;
					memcpy (data->buf, pidbuf, k * sizeof (unsigned short));
					tp->bDecIPFlag = TRUE;
					result = 0;
					break;

				case STOPFILTER:
					for (i = 0, k = 0; i < num; i++) 
					{
						pid = bufptr[i];
//						printk("STOPFILTER ,pid = %x\n",pid);
						for (j = 0; j < MaxDecodeIP; j++) 
						{
							if (tp->DecodeIP[j].wPID == pid) 
							{
								tp->DecodeIP[j].status = FILTERPID_READY;  //stop filter this pid
								pidbuf[k++] = pid;
								break;
							}
						}
					}

					for (j = 0; j < MaxDecodeIP; j++) 
					{
						if (tp->DecodeIP[j].status != FILTERPID_READY)
							break;
					}

					if (j >= MaxDecodeIP)
					{
						tp->ReceivePacketCount = 0;
						tp->RecDataLength = 0;
						tp->LostIPTotal = 0;	//added by Hong Fei
						tp->IPPacketTotalNum = 0;
						tp->bDecIPFlag = FALSE;    //stop filter all pids	
						for(i = 0; i < MaxDecodeIP; i++)
							tp->DecodeIP[i].IPTotalLen = 0;
					}
					data->val_out = k;
					memcpy (data->buf, pidbuf, k * 2);

					result = 0;
					break;

				case PAUSEFILTER:
					for (i = 0, k = 0; i < num; i++) 
					{
						pid = bufptr[i];
						for (j = 0; j < MaxDecodeIP; j++) 
						{
							if (tp->DecodeIP[j].wPID == pid && tp->DecodeIP[j].status == FILTERPID_RUN) 
							{
								tp->DecodeIP[j].status = FILTERPID_PAUSE;
								pidbuf[k++] = pid;
								break;
							}
						}
					}
					data->val_out = k;
					memcpy (data->buf, pidbuf, k * 2);

					result = 0;
					break;

				case CONTINUEFILTER:
					for (i = 0, k = 0; i < num; i++) 
					{
						pid = bufptr[i];
						for (j = 0; j < MaxDecodeIP; j++) 
						{
							if (tp->DecodeIP[j].wPID == pid && tp->DecodeIP[j].status == FILTERPID_PAUSE) 
							{
								tp->DecodeIP[j].status = FILTERPID_RUN;
								pidbuf[k++] = pid;
								break;
							}
						}
					}
					data->val_out = k;
					memcpy (data->buf, pidbuf, k * 2);

					result = 0;
					break;

				case RESTOREFILTER:
//					printk("\nRESTOREFILTER\n");
					for (j = 0; j < MaxDecodeIP; j++)
						tp->DecodeIP[j].status = FILTERPID_READY;
					tp->bDecIPFlag = FALSE;
					
					result = 0;					
					break;

				default:
					break;
			}
			break;

		case FILTEREXT:
		default:
			break;
	} // switch (operation)

	tp->bedoing = tp->bFilterPIDFlag | tp->bScanMpePIDFlag | tp->bDecIPFlag;

	if(result == 0)
		return 0;

	return -EINVAL;
}

int dev_info_ioctl(struct net_device *dev, unsigned char *userdata)
{
	struct dm1105_ioctl_data *data = (struct dm1105_ioctl_data *) userdata;
	struct dm1105_private *tp = dev->priv;

	card_info *pdev_info = 0;//( pcard_info ) data->buf;
	//memset (data->buf, 0, sizeof ( card_info));
	unsigned char cmd;
	
	cmd = data->val_in;
	switch (cmd) 
	{
	case ScanDeviceCmd:
		//printk("Tiger test: ScanDeviceCmd - John add for test\n");
		return 0;
		
	case DeviceInfoCmd:
		pdev_info = ( pcard_info )data->buf;
		memset (data->buf, 0, sizeof ( card_info));
		pdev_info->vendor_id = tp->dev_info.vendor_id;
		pdev_info->device_id = tp->dev_info.device_id;
//		printk("Tiger TEST: V_ID: 0x%x ; P_ID:0x%x\n", 
//			pdev_info->vendor_id, pdev_info->device_id);
		
		strcpy (pdev_info->version, DRV_VERSION);
		strcpy (pdev_info->name, DRV_NAME);
		return 0;
		
	case ApplyUseCmd:		//All Deleted by Kully 11-3-2006
//		if (tp->found_and_inuse)
//		{
//			return -EINVAL;
//		}
//		else 
		{
			start_dev(dev);
//			tp->found_and_inuse = 1;
			return 0;
		}
		
	case FreeUseCmd:
		sync_stop_dev(dev);
//		tp->found_and_inuse = 1;
		return 0;
		
	default:
		return -EINVAL;
	}
}


//
//tiger add to statistics
int statistics_ioctl(struct net_device *dev, unsigned char *userdata)
{
	static int StartCount = 0;
	struct dm1105_ioctl_data *data = (struct dm1105_ioctl_data *) userdata;
	struct dm1105_private *tp = dev->priv;
	unsigned char *count;
	int i,j;

	StartCount++;
//	printk("\nStatistic IOCTL start! %d",StartCount);
	data->val_out = 0;
	if (data->val_in > 128)
	{
//		printk("The data->val_in > 128,so return\n");
		return -EINVAL;
	}

	if(1==data->param1) //statistics
	{

		count=(unsigned char *)&(tp->RecDataLength);
		memcpy(data->buf,count,8);

//		printk("Statistics_Ioctl Received data bytes = 0X%X\n", *(long long *)data->buf);
		data->val_out = 8;
		return 1;
	}
	if(2 == data->param1)  //get current pid data length
	{
		unsigned short pid ;
		long long datalen;
		
		memcpy(&pid, data->buf, 2);
//		printk("\nHF TEST ....  DataRate Pid = %x\n", pid);
		for(i = 0; i < MaxDecodeIP; i++)
		{
			if( tp->DecodeIP[i].wPID == pid)
			{
				datalen = tp->DecodeIP[i].IPTotalLen;
//				printk("HF TEST ....  PID Packet Total = %d\n", datalen);
				
				data->val_out = 8;
				memcpy(data->buf, (unsigned char *)&datalen, 8);
				return 1;
			}
		}
	}
	if(3 == data->param1)  //get total lost num
	{
//		printk("\nHF TEST ....  Lost IP = %x\n",*(long *)&(tp->LostIPTotal));
//		printk("\nHF TEST ....  Total IP = %x\n",*(long *)&(tp->IPPacketTotalNum));
		j = 0;
		for (i = 0; i < MaxDecodeIP; i++) 
		{
			if (tp->DecodeIP[i].status == FILTERPID_RUN) 
				{
					j ++;
				}
		}
		j = tp->LostIPTotal - j;
		if(j < 0) j =0;

		*((unsigned long*)(data->buf)) = (unsigned long)j;

		count=(unsigned char *)&(tp->IPPacketTotalNum);
		memcpy(data->buf + 4, count, 4);
		data->val_out = 8;
		return 1;
	}
	
		
	else	//do nothing but return.
	{
		return -EINVAL;
	}

}


int set_reg_ioctl(struct net_device *dev, unsigned char *userdata)	//Fixed by Kully 11-3-2006, GPIO Controller
{
	// This function just for H/V GPIO control!
	struct dm1105_ioctl_data *data = (struct dm1105_ioctl_data *) userdata;
	struct dm1105_private *tp = dev->priv;
	void *ioaddr = tp->base_addr;

	 if(data->val_in!=1)
		return -1;
//	printk("Set H/V voltage start!\n");
	ANY_R32(NIC_GPIOCTR);
	ANY_W32(NIC_GPIOCTR,0xFFFCFFFF);
	if ((unsigned char)(data->buf[0]) ==1)
	{
//		printk("Set H/V voltage 18V!\n");
		ANY_R32(NIC_POWER);
		ANY_W32 (NIC_POWER, 0xFCFFFF);//18V
	}
	else if ((unsigned char)(data->buf[0]) ==0)
	{
//		printk("Set H/V voltage 13V!\n");
		ANY_R32(NIC_POWER);
		ANY_W32 (NIC_POWER, 0xFDFFFF);//13V
	}
	else if  ((unsigned char)(data->buf[0]) ==2)
	{
//		printk("Set H/V voltage OFF!\n");
		ANY_R32(NIC_POWER);
		ANY_W32 (NIC_POWER, 0xFFFFFF);//LNB OFF
	}

	return 0;
}

int netdev_ethtool_ioctl (void *ioaddr, void *useraddr)
{
	// do nothing
	return -EOPNOTSUPP;
}


int dm1105_ioctl (struct net_device *dev,  void *userdata,  int cmd)
{
//	printk("Tiger TEST: IN dm1105_ioctl()\n");

	struct dm1105_private *tp = dev->priv;
	void *ioaddr = tp->base_addr;
	int rc = 0;

	ioaddr = tp->base_addr;
	switch (cmd) 
	{
		case IOCTL_Dm1105_ReadReg:
			rc = IoReadRegs_IoctlFun (ioaddr, userdata);
			break;

		case IOCTL_Dm1105_WriteReg:
			rc = IoWriteRegs_IoctlFun (ioaddr, userdata);
			break;

		case IOCTL_Dm1105_DeviceInfo:
			dev_info_ioctl(dev, userdata);
			break;

		case IOCTL_Dm1105_FilterPID:  // filter PID
			rc = FilterPID_IoctlFun (dev, userdata);
			break;
			
		case IOCTL_Dm1105_Statistics:
//			printk("\nStatistic IOCTL !");
			rc=statistics_ioctl(dev, userdata);
			break;
			
		case IOCTL_Dm1105_ConfigReg:
			rc=set_reg_ioctl(dev, userdata);
			break;
			
		default:
			rc = -EOPNOTSUPP;
			break;
	}
	
	return rc;
}

int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
	struct dm1105_private *tp = dev->priv;
	int rc;

	//printk("Tiger TEST : netdev_ioctl()\n");

	if( !netif_running( dev ))
		return -EINVAL;

	if( cmd == SIOCETHTOOL ) {
		rc = netdev_ethtool_ioctl (dev, (void *) rq->ifr_data);
	}
	else if (cmd >= IOCTL_MINCMD && cmd <= IOCTL_MAXCMD)
	{
		spin_lock_irq(&tp->lock);
		rc = dm1105_ioctl (dev, rq->ifr_data, cmd);
		spin_unlock_irq(&tp->lock);
	}
	else {
		rc = -EINVAL;
	}

	return rc;
}


struct net_device_stats *dm1105_get_stats (struct net_device *dev)
{
	struct dm1105_private *tp = dev->priv;
	//void *ioaddr = tp->base_addr;
	unsigned long flags;

	if (netif_running(dev)) 
	{
		spin_lock_irqsave (&tp->lock, flags);
		tp->stats.rx_missed_errors += 0;//RTL_R32 (RxMissed);
		//RTL_W32 (RxMissed, 0);
		spin_unlock_irqrestore (&tp->lock, flags);
	}

	return &tp->stats;
}

/* Set or clear the multicast filter for this adaptor.
   This routine is not state sensitive and need not be SMP locked. */
void __set_rx_mode (struct net_device *dev)
{
}

void dm1105_set_rx_mode (struct net_device *dev)
{
/*
	unsigned long flags;
	struct dm1105_private *tp = dev->priv;

	spin_lock_irqsave (&tp->lock, flags);
	__set_rx_mode(dev);
	spin_unlock_irqrestore (&tp->lock, flags);
*/
}

#ifdef CONFIG_PM
int dm1105_suspend (struct pci_dev *pdev, u32 state)
{
	struct net_device *dev = pci_get_drvdata (pdev);
	struct dm1105_private *tp = dev->priv;
	void *ioaddr = tp->base_addr;
	unsigned long flags;

	if (!netif_running (dev))
		return 0;

	netif_device_detach (dev);
	
	spin_lock_irqsave (&tp->lock, flags);
//	printk("\n DM1105 Suspend!\n");
	//Disable interrupts, stop Tx and Rx.
	ANY_W8 (NIC_INTMAK, 0);
	ANY_W8 (NIC_CR, 0);

	spin_unlock_irqrestore (&tp->lock, flags);
	return 0;
}


int dm1105_resume (struct pci_dev *pdev)
{
	struct net_device *dev = pci_get_drvdata (pdev);

	if (!netif_running (dev))
		return 0;

	netif_device_attach (dev);
	dm1105_hw_start (dev);

	return 0;
}
#endif


struct pci_driver dm1105_pci_driver = 
{
	.name		= DRV_NAME,
	.id_table	= 	   dm1105_pci_tbl,
	.probe		= dm1105_probe_one,
	.remove		= __devexit_p(dm1105_remove_one),
#ifdef CONFIG_PM
	.suspend	= dm1105_suspend,
	.resume		= dm1105_resume,
#endif 
};


int __init dm1105_init_module (void)
{
	return pci_module_init (&dm1105_pci_driver);
}

void __exit dm1105_cleanup_module (void)
{
	pci_unregister_driver (&dm1105_pci_driver);
}


module_init(dm1105_init_module);
module_exit(dm1105_cleanup_module);