skystar2.c

linux TV 源码

	adapter->dma_status = adapter->dma_status | 0x20000000;

        dprintk("%s: allocated dma buffer at 0x%x, length=%d\n", __FUNCTION__, (int)adapter->DmaQ2.buffer, (int)SizeOfBufDMA2);
		
    } else {

	adapter->dma_status = adapter->dma_status & ~0x20000000;
    }
}

//-------------------------------------------------------------------
void FreeDmaQueue(struct adapter *adapter)
{
    if ( adapter->DmaQ1.buffer != 0 )
    {
	pci_free_consistent(adapter->pdev, SizeOfBufDMA1 + 0x80, adapter->DmaQ1.buffer, adapter->DmaQ1.bus_addr);

	adapter->DmaQ1.bus_addr    = 0;
	adapter->DmaQ1.head        = 0;
	adapter->DmaQ1.tail        = 0;
	adapter->DmaQ1.buffer_size = 0;
	adapter->DmaQ1.buffer      = 0;
    }

    if ( adapter->DmaQ2.buffer != 0 )
    {
	pci_free_consistent(adapter->pdev, SizeOfBufDMA2 + 0x80, adapter->DmaQ2.buffer, adapter->DmaQ2.bus_addr);

	adapter->DmaQ2.bus_addr    = 0;
	adapter->DmaQ2.head        = 0;
	adapter->DmaQ2.tail        = 0;
	adapter->DmaQ2.buffer_size = 0;
	adapter->DmaQ2.buffer      = 0;
    }
}

//-------------------------------------------------------------------
void FreeAdapterObject(struct adapter *adapter)
{
    dprintk("%s:\n", __FUNCTION__);

    CloseStream(adapter, 0);

    if ( adapter->irq != 0 ) free_irq(adapter->irq, adapter);

    FreeDmaQueue(adapter);

    if ( adapter->io_mem != 0 ) iounmap((void *)adapter->io_mem);

    if ( adapter != 0 ) kfree(adapter);
}

//-------------------------------------------------------------------
int ClaimAdapter(struct adapter *adapter)
{
    struct pci_dev *pdev = adapter->pdev;

    u16 var;

    if ( !request_region(pci_resource_start(pdev,1), pci_resource_len(pdev,1), pdev->name) ) return -EBUSY;

    if ( !request_mem_region(pci_resource_start(pdev,0), pci_resource_len(pdev,0), pdev->name) ) return -EBUSY;


    pci_read_config_byte(pdev, PCI_CLASS_REVISION, &adapter->card_revision);

    dprintk("%s: card revision %x \n", __FUNCTION__, adapter->card_revision);

    if ( pci_enable_device(pdev) ) return -EIO;

    pci_read_config_word(pdev, 4, &var);

    if ( ( var & 4 ) == 0 ) pci_set_master(pdev);

    adapter->io_port  = pdev->resource[1].start;    

    adapter->io_mem = (u32)ioremap( pdev->resource[0].start, 0x800);

    if ( adapter->io_mem == 0 )
    {
        dprintk("%s: can not map io memory\n", __FUNCTION__);
	
        return 2;
    }
	
    dprintk("%s: io memory maped at %x\n", __FUNCTION__, adapter->io_mem);
    
    return 1;
}

//-------------------------------------------------------------------
int SLL_reset_FlexCOP(struct adapter * adapter)
{
    WriteRegDW(adapter, 0x208, 0);
    WriteRegDW(adapter, 0x210, 0xB2FF);

    return 0;
}

//-------------------------------------------------------------------
u32 DriverInitialize(struct pci_dev * pdev)
{
    struct adapter * adapter;
    u32 tmp;
    u8 key[16];

    if ( ! (adapter = kmalloc( sizeof(struct adapter), GFP_KERNEL) ) ) 
    {
        dprintk("%s: out of memory!\n", __FUNCTION__);

        return -ENOMEM;
    }

    memset(adapter, 0, sizeof(struct adapter) );

    pdev->driver_data = adapter;

    adapter->pdev = pdev;
    adapter->irq  = pdev->irq;
	
    if ( ( ClaimAdapter(adapter) ) != 1 )
    {
    	FreeAdapterObject(adapter);

	return 2;
    }

    IrqDmaEnableDisableIrq(adapter, 0);

    if ( request_irq(pdev->irq, isr, 0x4000000, "Skystar2", adapter) != 0 )
    {
	dprintk("%s: unable to allocate irq=%d !\n", __FUNCTION__, pdev->irq);

	FreeAdapterObject(adapter);
	
	return 2;
    }
    
    ReadRegDW(adapter, 0x208);
    WriteRegDW(adapter, 0x208, 0);
    WriteRegDW(adapter, 0x210, 0xB2FF);
    WriteRegDW(adapter, 0x208, 0x40);

    InitPIDsInfo(adapter);

    PidSetGroupPID(adapter, 0);
    PidSetGroupMASK(adapter, 0x1FE0);
    PidSetStream1PID(adapter, 0x1FFF);
    PidSetStream2PID(adapter, 0x1FFF);
    PidSetPmtPID(adapter, 0x1FFF);
    PidSetPcrPID(adapter, 0x1FFF);
    PidSetEcmPID(adapter, 0x1FFF);
    PidSetEmmPID(adapter, 0x1FFF);

    InitDmaQueue(adapter);

    if ( (adapter->dma_status & 0x30000000) == 0 )
    {
	FreeAdapterObject(adapter);

	return 2;
    }

    adapter->B2C2_revision = ( ReadRegDW(adapter, 0x204) >> 0x18);

    switch(adapter->B2C2_revision) {
    case 0x82:
        printk("%s: FlexCopII(rev.130) chip found\n", __FILE__);
	break;
    case 0xC3:
        printk("%s: FlexCopIIB(rev.195) chip found\n", __FILE__);
        break;
    default:
        printk("%s: The revision of the FlexCopII chip on your card is %d\n", __FILE__, adapter->B2C2_revision);
        printk("%s: This driver works only with FlexCopII(rev.130) and FlexCopIIB(rev.195).\n", __FILE__);
	printk("%s: Please report to <[e-mail]>!\n", __FILE__);

    	FreeAdapterObject(adapter);
	return 2;
    }

    tmp = ReadRegDW(adapter, 0x204);

    WriteRegDW(adapter, 0x204, 0);
    linuxdelayms(20);

    WriteRegDW(adapter, 0x204, tmp);
    linuxdelayms(10);

    tmp = ReadRegDW(adapter, 0x308);
    WriteRegDW(adapter, 0x308, 0x4000 | tmp );


    adapter->dwSramType = 0x10000;

    SLL_detectSramSize(adapter);
    
    dprintk("%s: sram length = %d, sram type= %x\n", __FUNCTION__, SRAM_length(adapter), adapter->dwSramType);
    
    SRAMSetMediaDest(adapter, 1);
    SRAMSetNetDest(adapter, 1);

    CtrlEnableSmc(adapter, 0);

    SRAMSetCaiDest(adapter, 2);
    SRAMSetCaoDest(adapter, 2);


    DmaEnableDisableIrq(adapter, 1, 0, 0);

    if ( EEPROM_getMacAddr(adapter, 0, adapter->mac_addr) != 0 )
    {
	printk("%s: MAC address = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x \n", __FILE__,
	    adapter->mac_addr[0], adapter->mac_addr[1],
	    adapter->mac_addr[2], adapter->mac_addr[3],
	    adapter->mac_addr[4], adapter->mac_addr[5],
	    adapter->mac_addr[6], adapter->mac_addr[7]
	);
	
	CASetMacDstAddrFilter(adapter, adapter->mac_addr);
	CtrlEnableMAC(adapter, 1);
    }
    
    EEPROM_readKey(adapter, key, 16);

    printk("%s: key = \n %02x %02x %02x %02x \n %02x %02x %02x %02x \n %02x %02x %02x %02x \n %02x %02x %02x %02x \n", __FILE__,
	    key[0],  key[1],  key[2],  key[3],
	    key[4],  key[5],  key[6],  key[7],
	    key[8],  key[9],  key[10], key[11],
	    key[12], key[13], key[14], key[15]
    );

    adapter->lock = SPIN_LOCK_UNLOCKED;

    return 1;
}

//-------------------------------------------------------------------
void DriverHalt(struct pci_dev * pdev)
{
    struct adapter * adapter;

    adapter = pci_get_drvdata(pdev);

    IrqDmaEnableDisableIrq(adapter, 0);
    
    CtrlEnableReceiveData(adapter, 0);

    FreeAdapterObject(adapter);
    
    pci_set_drvdata(pdev, NULL);
    
    release_region(pci_resource_start(pdev,1), pci_resource_len(pdev,1));
    
    release_mem_region(pci_resource_start(pdev,0), pci_resource_len(pdev,0));
}

static int dvb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
{
    struct dvb_demux * dvbdmx  = dvbdmxfeed->demux;
    struct adapter   * adapter = (struct adapter *) dvbdmx->priv;

    dprintk("%s: PID=%d, type=%d\n", __FUNCTION__, dvbdmxfeed->pid, dvbdmxfeed->type);

    OpenStream(adapter, dvbdmxfeed->pid);

    return 0;
}

static int dvb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
{
    struct dvb_demux * dvbdmx       = dvbdmxfeed->demux;
    struct adapter   * adapter = (struct adapter *) dvbdmx->priv;

    dprintk("%s: PID=%d, type=%d\n", __FUNCTION__, dvbdmxfeed->pid, dvbdmxfeed->type);

    CloseStream(adapter, dvbdmxfeed->pid);

    return 0;    
}

/////////////////////////////////////////////////////////////////////
//			LNB control
/////////////////////////////////////////////////////////////////////

//-------------------------------------------------------------------
void set_tuner_tone(struct adapter * adapter, u8 tone)
{
    u16 wzHalfPeriodFor45MHz[] = {0x01FF, 0x0154, 0x00FF, 0x00CC};
    u16 ax;

    dprintk("%s: %u\n", __FUNCTION__, tone);

    switch ( tone )
    {	
	case 1: ax =  wzHalfPeriodFor45MHz[0]; break;
	case 2: ax =  wzHalfPeriodFor45MHz[1]; break;
	case 3: ax =  wzHalfPeriodFor45MHz[2]; break;
	case 4: ax =  wzHalfPeriodFor45MHz[3]; break;

	default: ax =  0;
    }

    if ( ax != 0 )
    {
	WriteRegDW(adapter, 0x200, ( ( ax << 0x0F ) + ( ax & 0x7FFF ) ) | 0x40000000);

    } else {

	WriteRegDW(adapter, 0x200, 0x40FF8000);
    }
}

//-------------------------------------------------------------------
void set_tuner_polarity(struct adapter * adapter, u8 polarity)
{
    u32 var;

    dprintk("%s : polarity = %u \n", __FUNCTION__, polarity);

    var = ReadRegDW(adapter, 0x204);

    if ( polarity == 0 )
    {
	dprintk ("%s: LNB power off\n", __FUNCTION__);    
	var = var | 1;
    };

    if ( polarity == 1 )
    {
	var = var & ~1;
	var = var & ~4;
    };

    if ( polarity == 2 )
    {
	var = var & ~1;	
	var = var | 4;
    }

    WriteRegDW(adapter, 0x204, var);
}

static int flexcop_diseqc_ioctl (struct dvb_frontend *fe, unsigned int cmd, void *arg)
{
    struct adapter * adapter = fe->before_after_data;

    switch (cmd)
    {
	case FE_SLEEP:
	{
	    printk ("%s: FE_SLEEP\n", __FUNCTION__);
	    
	    set_tuner_polarity(adapter, 0);

	    // return -EOPNOTSUPP, to make DVB core also send "FE_SLEEP" command to frontend.
	    return -EOPNOTSUPP;
	}

	case FE_SET_VOLTAGE:
	{	
	    dprintk ("%s: FE_SET_VOLTAGE\n", __FUNCTION__);

	    switch ((fe_sec_voltage_t) arg)
	    {
		case SEC_VOLTAGE_13:

	            printk ("%s: SEC_VOLTAGE_13, %x\n", __FUNCTION__, SEC_VOLTAGE_13);
	    
		    set_tuner_polarity(adapter, 1);
	
		    break;	    

		case SEC_VOLTAGE_18:

		    printk ("%s: SEC_VOLTAGE_18, %x\n", __FUNCTION__, SEC_VOLTAGE_18);

		    set_tuner_polarity(adapter, 2);
	    
		    break;	    

		default:
	    
		    return -EINVAL;
	    };

	    break;
	}
	
	case FE_SET_TONE:
	{	
	    dprintk ("%s: FE_SET_TONE\n", __FUNCTION__);

	    switch ((fe_sec_tone_mode_t) arg)
	    {
		case SEC_TONE_ON:

		    printk ("%s: SEC_TONE_ON, %x\n", __FUNCTION__, SEC_TONE_ON);

		    set_tuner_tone(adapter, 1);

    		    break;
	    	    
		case SEC_TONE_OFF:
	
		    printk ("%s: SEC_TONE_OFF, %x\n", __FUNCTION__, SEC_TONE_OFF);	    	

		    set_tuner_tone(adapter, 0);

		    break;
	    
		default:

		    return -EINVAL;
	    };

	    break;	    
	}
	
        default:

	    return -EOPNOTSUPP;
    };

    return 0;
}

//-------------------------------------------------------------------
static int skystar2_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
    struct adapter      * adapter;
    struct dvb_adapter  * dvb_adapter;
    struct dvb_demux    * dvbdemux;

    int ret;

    if ( pdev == NULL ) return -ENODEV;

    if ( DriverInitialize(pdev) != 1 ) return -ENODEV;
	
    dvb_register_adapter(&dvb_adapter, pdev->name);
    
    if (dvb_adapter == NULL)
    {
    	printk("%s: Error registering DVB adapter\n", __FUNCTION__);
    
        DriverHalt(pdev);

        return -ENODEV;
    }
    
    adapter = (struct adapter *) pdev->driver_data;    

    adapter->dvb_adapter = dvb_adapter;

    init_MUTEX(&adapter->i2c_sem);

    adapter->i2c_bus = dvb_register_i2c_bus(master_xfer, adapter, adapter->dvb_adapter, 0);

    if (!adapter->i2c_bus) return -ENOMEM;

    dvb_add_frontend_ioctls(adapter->dvb_adapter,  flexcop_diseqc_ioctl, NULL, adapter);

    dvbdemux = &adapter->demux;
    
    dvbdemux->priv             = (void *) adapter;
    dvbdemux->filternum        = 32;
    dvbdemux->feednum          = 32;
    dvbdemux->start_feed       = dvb_start_feed;
    dvbdemux->stop_feed        = dvb_stop_feed;
    dvbdemux->write_to_decoder = 0;
    dvbdemux->dmx.vendor       = "B2C2";
    dvbdemux->dmx.model        = "FlexCop II";
    dvbdemux->dmx.id           = "demux0";
    dvbdemux->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING);

    dvb_dmx_init(&adapter->demux);

    adapter->hw_frontend.id     = "hw_frontend";
    adapter->hw_frontend.vendor = "SAMSUNG";
    adapter->hw_frontend.model  = "DVBS";
    adapter->hw_frontend.source = DMX_FRONTEND_0;

    adapter->dmxdev.filternum    = 32;
    adapter->dmxdev.demux        = &dvbdemux->dmx;
    adapter->dmxdev.capabilities = 0;
    
    dvb_dmxdev_init(&adapter->dmxdev, adapter->dvb_adapter);

    ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &adapter->hw_frontend);
    if (ret < 0) return ret;
    
    adapter->mem_frontend.id     = "mem_frontend";
    adapter->mem_frontend.vendor = "memory";
    adapter->mem_frontend.model  = "sw";
    adapter->mem_frontend.source = DMX_MEMORY_FE;
    
    ret=dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &adapter->mem_frontend);
    if (ret < 0) return ret;
        
    ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx, &adapter->hw_frontend);
    if (ret < 0) return ret;
    
    dvb_net_init(adapter->dvb_adapter, &adapter->dvbnet, &dvbdemux->dmx);
    return 0;
}

//-------------------------------------------------------------------
static void skystar2_remove(struct pci_dev * pdev)
{
    struct adapter * adapter;
    struct dvb_demux * dvbdemux;

    if ( pdev == NULL ) return;

    adapter = pci_get_drvdata(pdev);

    if ( adapter != NULL )
    {
	dvb_net_release(&adapter->dvbnet);
	dvbdemux = &adapter->demux;
	
    	dvbdemux->dmx.close(&dvbdemux->dmx);
	dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &adapter->hw_frontend);
	dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &adapter->mem_frontend);
	
	dvb_dmxdev_release(&adapter->dmxdev);
	dvb_dmx_release(&adapter->demux);

	if ( adapter->dvb_adapter != NULL )
	{
	    dvb_remove_fro