dw4002.c

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

						else 
						{
							memcpy (tp->FilterPID[i].PacketBuf+188 * tp->FilterPID[i].packet_num, TsBuf, 188);
							tp->FilterPID[i].packet_num++;
						}
					}
					else {  // mode == 0
						if (tp->FilterPID[i].indicator) 
						{
							if (pTsHead->start_indicator) 
							{ // over
								tp->FilterPID[i].status = FILTERPID_OK;
							}
							else 
							{
								memcpy (tp->FilterPID[i].PacketBuf+188 * tp->FilterPID[i].packet_num, TsBuf, 188);
								tp->FilterPID[i].packet_num++;
							}
						}
						else 
						{
							if (pTsHead->start_indicator) 
							{
								memcpy (tp->FilterPID[i].PacketBuf+188 * tp->FilterPID[i].packet_num, TsBuf, 188);
								tp->FilterPID[i].packet_num = 1;
								tp->FilterPID[i].indicator = 1;
							}
						}
					} // else {  // mode == 0
					
					break;   // break for (j...
				} // if (wPID ==
			}  // for (j...
		} // if (tp->FilterPID[i].status
	} // for (i...
}

// Deal with 188 X 128 Bytes every call time.
void IndicatePacket (struct net_device *dev)
{
	struct dm1105_private *tp = dev->priv;
	PTS_PACKET_HEAD pTsHead;
	
	if (tp->bedoing == FALSE)
		return;
	
	unsigned char* pBufPtr = (unsigned char*)(tp->RxBufDataPtr);
	int kk;
	
	for (kk = 0; kk < (DM1105_IRQ_DATA_LENGTH/188); kk++) 
	{
		pTsHead = (PTS_PACKET_HEAD) pBufPtr;
		if (pTsHead->sync_byte != 0x47) 
		{
			pBufPtr += 188;
			continue;
		}
		
		if (pTsHead->error_indicator) 
		{
			pBufPtr += 188;
			continue;
		}
		
		if (tp->bFilterPIDFlag)
		{
			FilterPacket (dev, pBufPtr);
		}
		
		if (tp->bScanMpePIDFlag)
		{
			ScanMpePID (dev, pBufPtr);
		}
		
		if (tp->bDecIPFlag)
		{
			DecodeIP (dev, pBufPtr);
		}
		
		pBufPtr += 188;  // next ts packet
	} // for (...
	//	}
    return;
}

//This function deal with the TS data!
void dm1105_rx_interrupt (struct net_device *dev)
{
	struct dm1105_private *tp = dev->priv;
	
	assert (dev != NULL);
	assert (tp != NULL);

	void *ioaddr = tp->base_addr;

	if (PacketOK (dev)) 
	{
//		printk("\nOne Packet OK!\n");
		IndicatePacket (dev);
		tp->PacketErrorCount=0;
		tp->FramesRcvGood++;
	}

	else
	{
		tp->PacketErrorCount++;
//		printk("Bad Packet Found! NIC Device Reset !  ----%d\n",tp->PacketErrorCount);
		if((tp->PacketErrorCount >= 2)&&(DMARSTFLAG == 0))	//Fixed by Kully 10-31-2006
		{
			//We should reset the chip when Bad Packet Found!
			////////////////////////////////////////////////// Added by Kully 11-2-2006
			//Restart INT /////////////Added here
			disable_irq (dev->irq);

			////////////////////////////////// Old code here
			ANY_W8 (NIC_CR, 0);
			
			//reset device
			ANY_W8(NIC_RST,0x01);
			
			// Must enable Tx/Rx before setting transfer thresholds! 
			ANY_W8 (NIC_CR, 0x01);
			///////////////////////////////////

			ANY_W8(NIC_INTSTS,0x0F);
			ANY_W8(NIC_INTMAK, INTMAK_ALLMASK);
			need_reception = 0;
			need_reception_count =0;
			enable_irq (dev->irq);
			//////////////////////////////////////////////////
			
			tp->RxBufDataPtr=tp->RxBufDataStart;
			tp->PacketErrorCount=0;
			tp->LostIPTotal=0;
			DMARSTFLAG=1;
			return;
		}
	}

	tp->RxBufDataPtr += DM1105_IRQ_DATA_LENGTH;
	if (tp->RxBufDataPtr >= tp->RxBufDataEnd)
	{
		tp->RxBufDataPtr = tp->RxBufDataStart + (tp->RxBufDataPtr - tp->RxBufDataEnd);
	}
}

void  IrProc(struct net_device *dev)
{

}

////////////////////////////////////////////////////////////////////
void IP_RX_tasklet_action(unsigned long t) //Added by Kully 11-2-2006
{
//	struct net_device *dev = (struct net_device *) t;
//	printk("\n RX Tasklet One Time!\n");
	if(local_dev == NULL)
	{
		if (stop_tasklet == 0)
			tasklet_schedule (&my_tasklet);
		return;
	}
//	struct dm1105_private *tp = local_dev->priv;
	
	if (need_reception_count != need_reception)
	{
//		printk("\n RX_Reception One Time! ----------%d\n",need_reception_count);
		dm1105_rx_interrupt (local_dev);
		need_reception_count ++;
		if (need_reception_count > 888)
			need_reception_count = 1;
	}
	if (stop_tasklet == 0)
		tasklet_schedule (&my_tasklet);
}

void dm1105_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
{
	struct net_device *dev = (struct net_device *) dev_instance;
	struct dm1105_private *tp = dev->priv;
//	int boguscnt = max_interrupt_work;		// Deleted by Kully 10-31-2006 
	void *ioaddr = tp->base_addr;
	int status;
	//int link_changed = 0; /* avoid bogus "uninit" warning */

//	spin_lock (&tp->lock);
//	if(irq != 22)
//		printk("\n (IRQ Error) Current IRQ == %d\n",irq);
		
	status = ANY_R8 (NIC_INTSTS);

	/* h/w no longer present (hotplug?) or major error, bail */
	if (status == 0xff) 
	{
	// chip is out of power or iobase is wrong
//			printk("TEST: The interrupt register's status is wrong \n");
		tp->RegStatus=0;
		ANY_W8 (NIC_INTSTS, 0x00);
		ANY_W8(NIC_INTMAK, INTMAK_ALLMASK);
//		spin_unlock (&tp->lock);
		return IRQ_HANDLED;
	}

	if ((status &INTMAK_ALLMASK) == 0)
	{
//			printk("OK, The Interrupt is jump out :-) \n");
		tp->RegStatus=0;
		ANY_W8(NIC_INTMAK, INTMAK_ALLMASK);
//		spin_unlock (&tp->lock);
		return IRQ_HANDLED;
	}

	status&=0x0f;
	tp->RegStatus = status;

	if(status&0x01)
	{
		need_reception ++;
		if(need_reception > 888)
			need_reception = 1;
		if(local_dev == NULL)
			local_dev = dev;
	}
//	ANY_W8(NIC_INTMAK, 0);	//Deleted by Kully 11-2-2006
	// clr interrupt
	ANY_W8(NIC_INTSTS,status);
	ANY_W8(NIC_INTMAK, INTMAK_ALLMASK);
//	spin_unlock (&tp->lock);
	//tiger end
	return IRQ_HANDLED;
}

int dm1105_close (struct net_device *dev)
{
	struct dm1105_private *tp = dev->priv;
	void *ioaddr = tp->base_addr;
	//int ret = 0;
	unsigned long flags;
	
	My_Task_Clean();
	
//	printk ("\nDM1105 Close!");
	
//	netif_stop_queue (dev);

	//DPRINTK ("%s: Shutting down ethercard, status was 0x%4.4x.\n",dev->name, ANY_R8 (NIC_ISR));
//	printk("%s: Shutting down ethercard\n",dev->name);

	spin_lock_irqsave (&tp->lock, flags);

	// Stop the chip's Tx and Rx DMA processes. 
	ANY_W8 (NIC_CR, 0);

	// Disable interrupts by clearing the interrupt mask. 
	ANY_W8 (NIC_INTMAK, 0);
	//tiger end

	spin_unlock_irqrestore (&tp->lock, flags);

	synchronize_irq (dev->irq);
	free_irq (dev->irq, dev);

	dm1105_tx_clear (tp);

	pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN, tp->rx_ring, tp->rx_ring_dma);
	tp->rx_ring = NULL;

	pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN, tp->tx_bufs, tp->tx_bufs_dma);
	tp->tx_bufs = NULL;

	return 0;
}

int IoReadRegs_IoctlFun (void *ioaddr, unsigned char *userdata)
{
	struct dm1105_ioctl_data *data = (struct dm1105_ioctl_data *) userdata;
	int i;

	data->val_out = 0;

	if (data->param2 == 0 || data->param2 == 1) 
	{
		for (i = 0; i < data->val_in; i++)
		{
			data->buf[i] = ANY_R8 (data->param1 + i);
		}
	}
	else if (data->param2 == 2) 
	{
		for (i = 0; i < data->val_in; i+=2)
			*(u16 *) (data->buf+i) = ANY_R16 (data->param1 + i);
	}
	else if (data->param2 == 4) 
	{
		for (i = 0; i < data->val_in; i+=4)
			*(u32 *) (data->buf+i) = ANY_R32 (data->param1 + i);
	}
	else
		return -EINVAL;

	data->val_out = data->val_in;

	return 0;
}


int IoWriteRegs_IoctlFun (void *ioaddr, unsigned char *userdata)
{
	struct dm1105_ioctl_data *data = (struct dm1105_ioctl_data *) userdata;
	int i;

	data->val_out = 0;

	///printk("TEST:WriteRegs");
	//for (i = 0; i < data->val_in; i++)
	//{
	//	printk("write addr :0x%02x; data :0x%x  .\n",data->param1 + i, data->buf[i]);
	//}
	
	if (data->val_in > 128)
	{
		return -EINVAL;
	}

	if (data->param2 == 1 || data->param2 == 0) 
	{
		for (i = 0; i < data->val_in; i++)
			ANY_W8 (data->param1 + i, data->buf[i]);
	}
	else if (data->param2 == 2) 
	{
		for (i = 0; i < data->val_in; i+=2)
			ANY_W16 (data->param1 + i, *(u16 *) (data->buf+i));
	}
	else if (data->param2 == 4) 
	{
		for (i = 0; i < data->val_in; i+=4)
			ANY_W32 (data->param1 + i, *(u32 *) (data->buf+i));
	}
	else
		return -EINVAL;

	data->val_out = data->val_in;

	//printk("TEST:WriteRegs end\n\n");

	return 0;
}

int FilterPID_IoctlFun (struct net_device *dev, unsigned char *userdata)
{
	struct dm1105_ioctl_data *data = (struct dm1105_ioctl_data *) userdata;
	struct dm1105_private *tp = dev->priv;
	unsigned short type, index, num;
	unsigned short *bufptr;
	int i, result = -1;  // failed
	unsigned char operation;

	assert (dev != NULL);
	assert (tp != NULL);

	bufptr = (unsigned short*)data->buf;
	data->val_out = 0;
	operation = data->val_in;

	type = *bufptr++ ;
	index = *bufptr++;
	num = *bufptr++;

	switch( operation ) 
	{
		case FILTERPSI:
		case FILTERSAVE:
		case FILTERPLAY:
			switch (type) 
			{
				case APPLYFILTER:
					for (i = 0; i < MaxIRPQueue; i++) 
					{
						if (tp->FilterPID[i].status == FILTERPID_READY) 
						{
							tp->FilterPID[i].status = FILTERPID_INIT;
							if (operation == FILTERPSI)
								tp->FilterPID[i].mode = 0;
							else
								tp->FilterPID[i].mode = 1;
							tp->FilterPID[i].packet_num = 0;
							tp->FilterPID[i].lost_num = 0;
							tp->FilterPID[i].indicator = 0;
							tp->FilterPID[i].bmove_flag = FALSE;
							data->val_out = i & 0xff;
							result = 0;
							break;
						}
					}
					break;

				case SETFILTERPID:
					if (tp->FilterPID[index].status != FILTERPID_RUN) 
					{
						if (num > 0) 
						{
							if (num > MaxFilterPID)
								num = MaxFilterPID;
							tp->FilterPID[index].status = FILTERPID_SET;
							memcpy (tp->FilterPID[index].wPID, bufptr, num * 2);
							tp->FilterPID[index].pid_num = num;
							data->val_out = num;
							result = 0;
						}
					}
					break;

				case STARTFILTER:

					tp->FilterPID[index].status = FILTERPID_RUN;
					tp->FilterPID[index].packet_num = 0;
					tp->FilterPID[index].bmove_flag = FALSE;
					tp->bFilterPIDFlag = TRUE;
					result = 0;
					break;

				case PAUSEFILTER:
					if (tp->FilterPID[index].status == FILTERPID_RUN)
					{
						tp->FilterPID[index].status = FILTERPID_PAUSE;
						for (i = 0; i < MaxIRPQueue; i++) 
						{
							if (tp->FilterPID[i].status != FILTERPID_RUN)
								break;
						}

						if (i >= MaxIRPQueue)  // No filter
							tp->bFilterPIDFlag = FALSE;
					}
					result = 0;
					break;

				case CONTINUEFILTER:
					if (tp->FilterPID[index].status == FILTERPID_PAUSE) 
					{
						tp->FilterPID[index].status = FILTERPID_RUN;
						tp->bFilterPIDFlag = TRUE;
					}
					result = 0;
					break;

				case RESTARTFILTER:

					tp->FilterPID[index].status = FILTERPID_RUN;
					tp->FilterPID[index].packet_num = 0;
					tp->FilterPID[index].bmove_flag = FALSE;
					tp->FilterPID[index].indicator = 0;
					tp->bFilterPIDFlag = TRUE;
					result = 0;
					break;

				case CHECKFILTER:
					if (operation == FILTERPSI) 
					{
						if (tp->FilterPID[index].status == FILTERPID_OK) 
						{
						//	printk ("Filter OK : %d\n", index);
							data->val_out = tp->FilterPID[index].packet_num & 0xff;
							memcpy (data->buf, tp->FilterPID[index].PacketBuf, tp->FilterPID[index].packet_num * 188);
						//	printk ("total packets : %d\n", tp->FilterPID[index].packet_num);
						}
						else
							data->val_out = 0;
					}
					else 
					{ // play and save
						if (tp->FilterPID[index].packet_num > 0) 
						{
							tp->FilterPID[index].move_num = tp->FilterPID[index].packet_num;
							memcpy (data->buf, tp->FilterPID[index].PacketBuf, tp->FilterPID[index].move_num * 188);
							data->val_out = tp->FilterPID[index].move_num;
							tp->FilterPID[index].bmove_flag = TRUE;

						}
					}
					result = 0;
					break;

				case STOPFILTER:
				//	printk ("Stop filter : %d\n", index);
					tp->FilterPID[index].status = FILTERPID_READY;
					for (i = 0; i < MaxIRPQueue; i++) 
					{
						if (tp->FilterPID[i].status == FILTERPID_RUN)
							break;
					}

					if (i >= MaxIRPQueue)  // No filter
						tp->bFilterPIDFlag = FALSE;
					else
						tp->bFilterPIDFlag = TRUE;
					result = 0;
					break;

				case RESTOREFILTER:
					for (i = 0; i < MaxIRPQueue; i++) 
					{
						tp->FilterPID[i].status = FILTERPID_READY;
					}
					tp->bFilterPIDFlag = FALSE;
					result = 0;
					break;

				default:
					break;
			} // switch (status)
			break; // case FILTERPSI:

		case FILTERMPE:  // scan MPE PID
			switch( type ) 
			{
				case APPLYFILTER:
				case STARTFILTER:
				case RESTARTFILTER:
					if( tp->bScanMpePIDFlag == TRUE )
						break;

					tp->bScanMpePIDFlag = TRUE;
					tp->MpePIDNum = 0;
					tp->ScanTime = jiffies + SCANMPETIME;
					result = 0;
					data->buf[0] = 0x00;
//					printk ("tp->bScanMpePIDFlag = TRUE\n");
					break;

				case PAUSEFILTER:
					tp->bScanMpePIDFlag = FALSE;
					result = 0;
					break;