firesat: update isochronous interface, add CI support

I have finally managed to get the CI support for the card working. The
implementation is a bare minimum to get encrypted channels to work in
kaffeine. It works fine with my T/CI card. Now and then I get an AVC
timeout and have to retune a channel in order to get it to work. Once
the CAM seemed to hang so I needed to remove and insert it again. I.e.
there are a number of glitches.

The latest version contains the following changes:

  - Implemented the new hpsb iso interface so that data can be received
    from the card
  - Reduced some timers for demux setup which caused scanning to timeout
  - Added possibility to unload driver
  - Added support for getting C/N ratio
  - Added two debug parameters to the driver; ca_debug and
    avc_comm_debug.
  - Added CI support that works for me in kaffeine
  - Started working on CI MMI support. It now supports:
      o Enter menu
      o Receiving MMI objects
  - Added support for 64-bit platforms
  - Corrected DVB-C modulations problems

Signed-off-by: Henrik Kurelid <henrik@kurelid.se>
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de> (rebased, whitespace)
This commit is contained in:
Henrik Kurelid 2008-08-01 10:00:45 +02:00 committed by Stefan Richter
parent 2c22861459
commit df4846c352
10 changed files with 1488 additions and 495 deletions

View File

@ -1,6 +1,7 @@
firesat-objs := firesat_1394.o \
firesat_dvb.o \
firesat_fe.o \
firesat_iso.o \
avc_api.o \
cmp.o \
firesat-rc.o \

View File

@ -3,6 +3,7 @@
*
* Copyright (c) 2004 Andreas Monitzer <andy@monitzer.com>
* Copyright (c) 2008 Ben Backx <ben@bbackx.com>
* Copyright (c) 2008 Henrik Kurelid <henrik@kurelid.se>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
@ -15,6 +16,7 @@
#include <nodemgr.h>
#include <asm/byteorder.h>
#include <linux/delay.h>
#include <linux/crc32.h>
#include "avc_api.h"
#include "firesat-rc.h"
@ -22,6 +24,10 @@
#define COMMAND_REGISTER 0xFFFFF0000B00ULL
#define PCR_BASE_ADDRESS 0xFFFFF0000900ULL
static unsigned int avc_comm_debug = 0;
module_param(avc_comm_debug, int, 0644);
MODULE_PARM_DESC(avc_comm_debug, "debug logging of AV/C communication, default is 0 (no)");
static int __AVCRegisterRemoteControl(struct firesat*firesat, int internal);
/* Frees an allocated packet */
@ -47,7 +53,124 @@ static int avc_down_timeout(atomic_t *done, int timeout)
return ((i > 0) ? 0:1);
}
static int __AVCWrite(struct firesat *firesat, const AVCCmdFrm *CmdFrm, AVCRspFrm *RspFrm) {
static const char* get_ctype_string(__u8 ctype)
{
switch(ctype)
{
case 0:
return "CONTROL";
case 1:
return "STATUS";
case 2:
return "SPECIFIC_INQUIRY";
case 3:
return "NOTIFY";
case 4:
return "GENERAL_INQUIRY";
}
return "UNKNOWN";
}
static const char* get_resp_string(__u8 ctype)
{
switch(ctype)
{
case 8:
return "NOT_IMPLEMENTED";
case 9:
return "ACCEPTED";
case 10:
return "REJECTED";
case 11:
return "IN_TRANSITION";
case 12:
return "IMPLEMENTED_STABLE";
case 13:
return "CHANGED";
case 15:
return "INTERIM";
}
return "UNKNOWN";
}
static const char* get_subunit_address(__u8 subunit_id, __u8 subunit_type)
{
if (subunit_id == 7 && subunit_type == 0x1F)
return "Unit";
if (subunit_id == 0 && subunit_type == 0x05)
return "Tuner(0)";
return "Unsupported";
}
static const char* get_opcode_string(__u8 opcode)
{
switch(opcode)
{
case 0x02:
return "PlugInfo";
case 0x08:
return "OpenDescriptor";
case 0x09:
return "ReadDescriptor";
case 0x18:
return "OutputPlugSignalFormat";
case 0x31:
return "SubunitInfo";
case 0x30:
return "UnitInfo";
case 0xB2:
return "Power";
case 0xC8:
return "DirectSelectInformationType";
case 0xCB:
return "DirectSelectData";
case 0x00:
return "Vendor";
}
return "Unknown";
}
static void log_command_frame(const AVCCmdFrm *CmdFrm)
{
int k;
printk(KERN_INFO "AV/C Command Frame:\n");
printk("CommandType=%s, Address=%s(0x%02X,0x%02X), opcode=%s(0x%02X), "
"length=%d\n", get_ctype_string(CmdFrm->ctype),
get_subunit_address(CmdFrm->suid, CmdFrm->sutyp),
CmdFrm->suid, CmdFrm->sutyp, get_opcode_string(CmdFrm->opcode),
CmdFrm->opcode, CmdFrm->length);
for(k = 0; k < CmdFrm->length - 3; k++) {
if (k % 5 != 0)
printk(", ");
else if (k != 0)
printk("\n");
printk("operand[%d] = %02X", k, CmdFrm->operand[k]);
}
printk("\n");
}
static void log_response_frame(const AVCRspFrm *RspFrm)
{
int k;
printk(KERN_INFO "AV/C Response Frame:\n");
printk("Response=%s, Address=%s(0x%02X,0x%02X), opcode=%s(0x%02X), "
"length=%d\n", get_resp_string(RspFrm->resp),
get_subunit_address(RspFrm->suid, RspFrm->sutyp),
RspFrm->suid, RspFrm->sutyp, get_opcode_string(RspFrm->opcode),
RspFrm->opcode, RspFrm->length);
for(k = 0; k < RspFrm->length - 3; k++) {
if (k % 5 != 0)
printk(", ");
else if (k != 0)
printk("\n");
printk("operand[%d] = %02X", k, RspFrm->operand[k]);
}
printk("\n");
}
static int __AVCWrite(struct firesat *firesat, const AVCCmdFrm *CmdFrm,
AVCRspFrm *RspFrm) {
struct hpsb_packet *packet;
struct node_entry *ne;
@ -58,39 +181,50 @@ static int __AVCWrite(struct firesat *firesat, const AVCCmdFrm *CmdFrm, AVCRspFr
}
/* need all input data */
if(!firesat || !ne || !CmdFrm)
if(!firesat || !ne || !CmdFrm) {
printk("%s: missing input data!\n",__func__);
return -EINVAL;
}
// printk(KERN_INFO "AVCWrite command %x\n",CmdFrm->opcode);
// for(k=0;k<CmdFrm->length;k++)
// printk(KERN_INFO "CmdFrm[%d] = %08x\n", k, ((quadlet_t*)CmdFrm)[k]);
packet=hpsb_make_writepacket(ne->host, ne->nodeid, COMMAND_REGISTER,
(quadlet_t*)CmdFrm, CmdFrm->length);
hpsb_set_packet_complete_task(packet, (void (*)(void*))avc_free_packet,
packet);
hpsb_node_fill_packet(ne, packet);
if (avc_comm_debug == 1) {
log_command_frame(CmdFrm);
}
if(RspFrm)
atomic_set(&firesat->avc_reply_received, 0);
packet=hpsb_make_writepacket(ne->host, ne->nodeid,
COMMAND_REGISTER,
(quadlet_t*)CmdFrm,
CmdFrm->length);
hpsb_set_packet_complete_task(packet,
(void (*)(void*))avc_free_packet,
packet);
hpsb_node_fill_packet(ne, packet);
if (hpsb_send_packet(packet) < 0) {
avc_free_packet(packet);
atomic_set(&firesat->avc_reply_received, 1);
printk("%s: send failed!\n",__func__);
return -EIO;
}
if(RspFrm) {
if(avc_down_timeout(&firesat->avc_reply_received,HZ/2)) {
printk("%s: timeout waiting for avc response\n",__func__);
// AV/C specs say that answers should be send within
// 150 ms so let's time out after 200 ms
if(avc_down_timeout(&firesat->avc_reply_received,
HZ / 5)) {
printk("%s: timeout waiting for avc response\n",
__func__);
atomic_set(&firesat->avc_reply_received, 1);
return -ETIMEDOUT;
}
memcpy(RspFrm,firesat->respfrm,firesat->resp_length);
return -ETIMEDOUT;
}
memcpy(RspFrm, firesat->respfrm,
firesat->resp_length);
RspFrm->length = firesat->resp_length;
if (avc_comm_debug == 1) {
log_response_frame(RspFrm);
}
}
return 0;
@ -137,6 +271,7 @@ int AVCRecv(struct firesat *firesat, u8 *data, size_t length) {
// remote control handling
#if 0
AVCRspFrm *RspFrm = (AVCRspFrm*)data;
if(/*RspFrm->length >= 8 && ###*/
@ -155,21 +290,21 @@ int AVCRecv(struct firesat *firesat, u8 *data, size_t length) {
printk(KERN_INFO "%s: remote control result = %d\n",__func__, RspFrm->resp);
return 0;
}
#endif
if(atomic_read(&firesat->avc_reply_received) == 1) {
printk("%s: received out-of-order AVC response, ignored\n",__func__);
return -EINVAL;
}
// AVCRspFrm *resp=(AVCRspFrm *)data;
// int k;
/*
printk(KERN_INFO "resp=0x%x\n",resp->resp);
printk(KERN_INFO "cts=0x%x\n",resp->cts);
printk(KERN_INFO "suid=0x%x\n",resp->suid);
printk(KERN_INFO "sutyp=0x%x\n",resp->sutyp);
printk(KERN_INFO "opcode=0x%x\n",resp->opcode);
printk(KERN_INFO "length=%d\n",resp->length);
*/
// printk(KERN_INFO "resp=0x%x\n",resp->resp);
// printk(KERN_INFO "cts=0x%x\n",resp->cts);
// printk(KERN_INFO "suid=0x%x\n",resp->suid);
// printk(KERN_INFO "sutyp=0x%x\n",resp->sutyp);
// printk(KERN_INFO "opcode=0x%x\n",resp->opcode);
// printk(KERN_INFO "length=%d\n",resp->length);
// for(k=0;k<2;k++)
// printk(KERN_INFO "operand[%d]=%02x\n",k,resp->operand[k]);
@ -183,6 +318,7 @@ int AVCRecv(struct firesat *firesat, u8 *data, size_t length) {
// tuning command for setting the relative LNB frequency (not supported by the AVC standard)
static void AVCTuner_tuneQPSK(struct firesat *firesat, struct dvb_frontend_parameters *params, AVCCmdFrm *CmdFrm) {
memset(CmdFrm, 0, sizeof(AVCCmdFrm));
CmdFrm->cts = AVC;
@ -249,7 +385,7 @@ static void AVCTuner_tuneQPSK(struct firesat *firesat, struct dvb_frontend_param
CmdFrm->length = 16;
}
int AVCTuner_DSD(struct firesat *firesat, struct dvb_frontend_parameters *params, BYTE *status) {
int AVCTuner_DSD(struct firesat *firesat, struct dvb_frontend_parameters *params, __u8 *status) {
AVCCmdFrm CmdFrm;
AVCRspFrm RspFrm;
M_VALID_FLAGS flags;
@ -274,21 +410,15 @@ int AVCTuner_DSD(struct firesat *firesat, struct dvb_frontend_parameters *params
flags.Bits_T.TransmissionMode = (params->u.ofdm.transmission_mode != TRANSMISSION_MODE_AUTO);
flags.Bits_T.NetworkId = 0;
} else {
flags.Bits.Modulation = 0;
if(firesat->type == FireSAT_DVB_S) {
flags.Bits.FEC_inner = 1;
} else if(firesat->type == FireSAT_DVB_C) {
flags.Bits.FEC_inner = 0;
}
flags.Bits.Modulation =
(params->u.qam.modulation != QAM_AUTO);
flags.Bits.FEC_inner =
(params->u.qam.fec_inner != FEC_AUTO);
flags.Bits.FEC_outer = 0;
flags.Bits.Symbol_Rate = 1;
flags.Bits.Frequency = 1;
flags.Bits.Orbital_Pos = 0;
if(firesat->type == FireSAT_DVB_S) {
flags.Bits.Polarisation = 1;
} else if(firesat->type == FireSAT_DVB_C) {
flags.Bits.Polarisation = 0;
}
flags.Bits.Polarisation = 0;
flags.Bits.reserved_fields = 0;
flags.Bits.reserved1 = 0;
flags.Bits.Network_ID = 0;
@ -306,15 +436,18 @@ int AVCTuner_DSD(struct firesat *firesat, struct dvb_frontend_parameters *params
CmdFrm.operand[1] = 0xD2; // subfunction replace
CmdFrm.operand[2] = 0x20; // system id = DVB
CmdFrm.operand[3] = 0x00; // antenna number
CmdFrm.operand[4] = (firesat->type == FireSAT_DVB_T)?0x0c:0x11; // system_specific_multiplex selection_length
// system_specific_multiplex selection_length
CmdFrm.operand[4] = (firesat->type == FireSAT_DVB_T)?0x0c:0x11;
CmdFrm.operand[5] = flags.Valid_Word.ByteHi; // valid_flags [0]
CmdFrm.operand[6] = flags.Valid_Word.ByteLo; // valid_flags [1]
if(firesat->type == FireSAT_DVB_T) {
CmdFrm.operand[7] = 0x0;
CmdFrm.operand[8] = (params->frequency/10) >> 24;
CmdFrm.operand[9] = ((params->frequency/10) >> 16) & 0xFF;
CmdFrm.operand[10] = ((params->frequency/10) >> 8) & 0xFF;
CmdFrm.operand[9] =
((params->frequency/10) >> 16) & 0xFF;
CmdFrm.operand[10] =
((params->frequency/10) >> 8) & 0xFF;
CmdFrm.operand[11] = (params->frequency/10) & 0xFF;
switch(params->u.ofdm.bandwidth) {
case BANDWIDTH_7_MHZ:
@ -416,28 +549,24 @@ int AVCTuner_DSD(struct firesat *firesat, struct dvb_frontend_parameters *params
CmdFrm.operand[16] = 0x00; // network_ID[1]
CmdFrm.operand[17] = 0x00; // Nr_of_dsd_sel_specs = 0 - > No PIDs are transmitted
CmdFrm.length = 20;
CmdFrm.length = 24;
} else {
CmdFrm.operand[7] = 0x00;
CmdFrm.operand[8] = (((firesat->voltage==SEC_VOLTAGE_18)?0:1)<<6); /* 0 = H, 1 = V */
CmdFrm.operand[8] = 0x00;
CmdFrm.operand[9] = 0x00;
CmdFrm.operand[10] = 0x00;
if(firesat->type == FireSAT_DVB_S) {
/* ### relative frequency -> absolute frequency */
CmdFrm.operand[11] = (((params->frequency/4) >> 16) & 0xFF) | (2 << 6);
CmdFrm.operand[12] = ((params->frequency/4) >> 8) & 0xFF;
CmdFrm.operand[13] = (params->frequency/4) & 0xFF;
} else if(firesat->type == FireSAT_DVB_C) {
CmdFrm.operand[11] = (((params->frequency/4000) >> 16) & 0xFF) | (2 << 6);
CmdFrm.operand[12] = ((params->frequency/4000) >> 8) & 0xFF;
CmdFrm.operand[13] = (params->frequency/4000) & 0xFF;
}
CmdFrm.operand[14] = ((params->u.qpsk.symbol_rate/1000) >> 12) & 0xFF;
CmdFrm.operand[15] = ((params->u.qpsk.symbol_rate/1000) >> 4) & 0xFF;
CmdFrm.operand[16] = ((params->u.qpsk.symbol_rate/1000) << 4) & 0xF0;
CmdFrm.operand[11] =
(((params->frequency/4000) >> 16) & 0xFF) | (2 << 6);
CmdFrm.operand[12] =
((params->frequency/4000) >> 8) & 0xFF;
CmdFrm.operand[13] = (params->frequency/4000) & 0xFF;
CmdFrm.operand[14] =
((params->u.qpsk.symbol_rate/1000) >> 12) & 0xFF;
CmdFrm.operand[15] =
((params->u.qpsk.symbol_rate/1000) >> 4) & 0xFF;
CmdFrm.operand[16] =
((params->u.qpsk.symbol_rate/1000) << 4) & 0xF0;
CmdFrm.operand[17] = 0x00;
switch(params->u.qpsk.fec_inner) {
case FEC_1_2:
@ -455,35 +584,35 @@ int AVCTuner_DSD(struct firesat *firesat, struct dvb_frontend_parameters *params
case FEC_7_8:
CmdFrm.operand[18] = 0x5;
break;
case FEC_4_5:
case FEC_8_9:
CmdFrm.operand[18] = 0x6;
break;
case FEC_4_5:
CmdFrm.operand[18] = 0x8;
break;
case FEC_AUTO:
default:
CmdFrm.operand[18] = 0x0;
}
if(firesat->type == FireSAT_DVB_S) {
switch(params->u.qam.modulation) {
case QAM_16:
CmdFrm.operand[19] = 0x08; // modulation
} else if(firesat->type == FireSAT_DVB_C) {
switch(params->u.qam.modulation) {
case QAM_16:
CmdFrm.operand[19] = 0x08; // modulation
break;
case QAM_32:
CmdFrm.operand[19] = 0x10; // modulation
break;
case QAM_64:
CmdFrm.operand[19] = 0x18; // modulation
break;
case QAM_128:
CmdFrm.operand[19] = 0x20; // modulation
break;
case QAM_256:
CmdFrm.operand[19] = 0x28; // modulation
break;
case QAM_AUTO:
default:
CmdFrm.operand[19] = 0x00; // modulation
}
break;
case QAM_32:
CmdFrm.operand[19] = 0x10; // modulation
break;
case QAM_64:
CmdFrm.operand[19] = 0x18; // modulation
break;
case QAM_128:
CmdFrm.operand[19] = 0x20; // modulation
break;
case QAM_256:
CmdFrm.operand[19] = 0x28; // modulation
break;
case QAM_AUTO:
default:
CmdFrm.operand[19] = 0x00; // modulation
}
CmdFrm.operand[20] = 0x00;
CmdFrm.operand[21] = 0x00;
@ -496,7 +625,6 @@ int AVCTuner_DSD(struct firesat *firesat, struct dvb_frontend_parameters *params
if((k=AVCWrite(firesat,&CmdFrm,&RspFrm)))
return k;
// msleep(250);
mdelay(500);
if(status)
@ -504,13 +632,12 @@ int AVCTuner_DSD(struct firesat *firesat, struct dvb_frontend_parameters *params
return 0;
}
int AVCTuner_SetPIDs(struct firesat *firesat, unsigned char pidc, u16 pid[]) {
int AVCTuner_SetPIDs(struct firesat *firesat, unsigned char pidc, u16 pid[])
{
AVCCmdFrm CmdFrm;
AVCRspFrm RspFrm;
int pos,k;
printk(KERN_INFO "%s\n", __func__);
if(pidc > 16 && pidc != 0xFF)
return -EINVAL;
@ -526,49 +653,11 @@ int AVCTuner_SetPIDs(struct firesat *firesat, unsigned char pidc, u16 pid[]) {
CmdFrm.operand[1] = 0xD2; // subfunction replace
CmdFrm.operand[2] = 0x20; // system id = DVB
CmdFrm.operand[3] = 0x00; // antenna number
CmdFrm.operand[4] = 0x11; // system_specific_multiplex selection_length
CmdFrm.operand[5] = 0x00; // valid_flags [0]
CmdFrm.operand[6] = 0x00; // valid_flags [1]
CmdFrm.operand[4] = 0x00; // system_specific_multiplex selection_length
CmdFrm.operand[5] = pidc; // Nr_of_dsd_sel_specs
if(firesat->type == FireSAT_DVB_T) {
/* CmdFrm.operand[7] = 0x00;
CmdFrm.operand[8] = 0x00;//(params->frequency/10) >> 24;
CmdFrm.operand[9] = 0x00;//((params->frequency/10) >> 16) & 0xFF;
CmdFrm.operand[10] = 0x00;//((params->frequency/10) >> 8) & 0xFF;
CmdFrm.operand[11] = 0x00;//(params->frequency/10) & 0xFF;
CmdFrm.operand[12] = 0x00;
CmdFrm.operand[13] = 0x00;
CmdFrm.operand[14] = 0x00;
CmdFrm.operand[15] = 0x00; // network_ID[0]
CmdFrm.operand[16] = 0x00; // network_ID[1]
*/ CmdFrm.operand[17] = pidc; // Nr_of_dsd_sel_specs
pos=18;
} else {
/* CmdFrm.operand[7] = 0x00;
CmdFrm.operand[8] = 0x00;
CmdFrm.operand[9] = 0x00;
CmdFrm.operand[10] = 0x00;
CmdFrm.operand[11] = 0x00;//(((params->frequency/4) >> 16) & 0xFF) | (2 << 6);
CmdFrm.operand[12] = 0x00;//((params->frequency/4) >> 8) & 0xFF;
CmdFrm.operand[13] = 0x00;//(params->frequency/4) & 0xFF;
CmdFrm.operand[14] = 0x00;//((params->u.qpsk.symbol_rate/1000) >> 12) & 0xFF;
CmdFrm.operand[15] = 0x00;//((params->u.qpsk.symbol_rate/1000) >> 4) & 0xFF;
CmdFrm.operand[16] = 0x00;//((params->u.qpsk.symbol_rate/1000) << 4) & 0xF0;
CmdFrm.operand[17] = 0x00;
CmdFrm.operand[18] = 0x00;
CmdFrm.operand[19] = 0x00; // modulation
CmdFrm.operand[20] = 0x00;
CmdFrm.operand[21] = 0x00;*/
CmdFrm.operand[22] = pidc; // Nr_of_dsd_sel_specs
pos=23;
}
if(pidc != 0xFF)
pos=6;
if(pidc != 0xFF) {
for(k=0;k<pidc;k++) {
CmdFrm.operand[pos++] = 0x13; // flowfunction relay
CmdFrm.operand[pos++] = 0x80; // dsd_sel_spec_valid_flags -> PID
@ -577,17 +666,16 @@ int AVCTuner_SetPIDs(struct firesat *firesat, unsigned char pidc, u16 pid[]) {
CmdFrm.operand[pos++] = 0x00; // tableID
CmdFrm.operand[pos++] = 0x00; // filter_length
}
}
CmdFrm.length = pos+3;
if((pos+3)%4)
CmdFrm.length += 4 - ((pos+3)%4);
if((k=AVCWrite(firesat,&CmdFrm,&RspFrm)))
return k;
mdelay(250);
mdelay(50);
return 0;
}
@ -596,7 +684,7 @@ int AVCTuner_GetTS(struct firesat *firesat){
AVCRspFrm RspFrm;
int k;
printk(KERN_INFO "%s\n", __func__);
//printk(KERN_INFO "%s\n", __func__);
memset(&CmdFrm, 0, sizeof(AVCCmdFrm));
@ -612,20 +700,21 @@ int AVCTuner_GetTS(struct firesat *firesat){
CmdFrm.operand[3] = 0x20; // system id = DVB
CmdFrm.operand[4] = 0x00; // antenna number
CmdFrm.operand[5] = 0x0; // system_specific_search_flags
CmdFrm.operand[6] = 0x11; // system_specific_multiplex selection_length
CmdFrm.operand[6] = (firesat->type == FireSAT_DVB_T)?0x0c:0x11; // system_specific_multiplex selection_length
CmdFrm.operand[7] = 0x00; // valid_flags [0]
CmdFrm.operand[8] = 0x00; // valid_flags [1]
CmdFrm.operand[24] = 0x00; // nr_of_dsit_sel_specs (always 0)
CmdFrm.operand[7 + (firesat->type == FireSAT_DVB_T)?0x0c:0x11] = 0x00; // nr_of_dsit_sel_specs (always 0)
CmdFrm.length = 28;
CmdFrm.length = (firesat->type == FireSAT_DVB_T)?24:28;
if((k=AVCWrite(firesat, &CmdFrm, &RspFrm))) return k;
if ((k=AVCWrite(firesat, &CmdFrm, &RspFrm)))
return k;
mdelay(250);
return 0;
}
int AVCIdentifySubunit(struct firesat *firesat, unsigned char *systemId, int *transport, int *has_ci) {
int AVCIdentifySubunit(struct firesat *firesat, unsigned char *systemId, int *transport) {
AVCCmdFrm CmdFrm;
AVCRspFrm RspFrm;
@ -660,8 +749,6 @@ int AVCIdentifySubunit(struct firesat *firesat, unsigned char *systemId, int *tr
}
if(systemId)
*systemId = RspFrm.operand[7];
if(has_ci)
*has_ci = (RspFrm.operand[14] >> 4) & 0x1;
return 0;
}
@ -679,14 +766,13 @@ int AVCTunerStatus(struct firesat *firesat, ANTENNA_INPUT_INFO *antenna_input_in
CmdFrm.opcode=READ_DESCRIPTOR;
CmdFrm.operand[0]=DESCRIPTOR_TUNER_STATUS;
CmdFrm.operand[1]=0xff;
CmdFrm.operand[2]=0x00;
CmdFrm.operand[3]=sizeof(ANTENNA_INPUT_INFO) >> 8;
CmdFrm.operand[4]=sizeof(ANTENNA_INPUT_INFO) & 0xFF;
CmdFrm.operand[1]=0xff; //read_result_status
CmdFrm.operand[2]=0x00; // reserver
CmdFrm.operand[3]=0;//sizeof(ANTENNA_INPUT_INFO) >> 8;
CmdFrm.operand[4]=0;//sizeof(ANTENNA_INPUT_INFO) & 0xFF;
CmdFrm.operand[5]=0x00;
CmdFrm.operand[6]=0x03;
CmdFrm.operand[6]=0x00;
CmdFrm.length=12;
//Absenden des AVC request und warten auf response
if (AVCWrite(firesat,&CmdFrm,&RspFrm) < 0)
return -EIO;
@ -695,10 +781,11 @@ int AVCTunerStatus(struct firesat *firesat, ANTENNA_INPUT_INFO *antenna_input_in
return -EINVAL;
}
length = (RspFrm.operand[3] << 8) + RspFrm.operand[4];
if(length == sizeof(ANTENNA_INPUT_INFO))
length = RspFrm.operand[9];
if(RspFrm.operand[1] == 0x10 && length == sizeof(ANTENNA_INPUT_INFO))
{
memcpy(antenna_input_info,&RspFrm.operand[7],length);
memcpy(antenna_input_info, &RspFrm.operand[10],
sizeof(ANTENNA_INPUT_INFO));
return 0;
}
printk("%s: invalid info returned from AVC\n",__func__);
@ -837,3 +924,384 @@ int AVCRegisterRemoteControl(struct firesat*firesat)
{
return __AVCRegisterRemoteControl(firesat, 0);
}
int AVCTuner_Host2Ca(struct firesat *firesat)
{
AVCCmdFrm CmdFrm;
AVCRspFrm RspFrm;
memset(&CmdFrm, 0, sizeof(AVCCmdFrm));
CmdFrm.cts = AVC;
CmdFrm.ctype = CONTROL;
CmdFrm.sutyp = 0x5;
CmdFrm.suid = firesat->subunit;
CmdFrm.opcode = VENDOR;
CmdFrm.operand[0]=SFE_VENDOR_DE_COMPANYID_0;
CmdFrm.operand[1]=SFE_VENDOR_DE_COMPANYID_1;
CmdFrm.operand[2]=SFE_VENDOR_DE_COMPANYID_2;
CmdFrm.operand[3]=SFE_VENDOR_OPCODE_HOST2CA;
CmdFrm.operand[4] = 0; // slot
CmdFrm.operand[5] = SFE_VENDOR_TAG_CA_APPLICATION_INFO; // ca tag
CmdFrm.operand[6] = 0; // more/last
CmdFrm.operand[7] = 0; // length
CmdFrm.length = 12;
if(AVCWrite(firesat,&CmdFrm,&RspFrm) < 0)
return -EIO;
return 0;
}
static int get_ca_object_pos(AVCRspFrm *RspFrm)
{
int length = 1;
// Check length of length field
if (RspFrm->operand[7] & 0x80)
length = (RspFrm->operand[7] & 0x7F) + 1;
return length + 7;
}
static int get_ca_object_length(AVCRspFrm *RspFrm)
{
int size = 0;
int i;
if (RspFrm->operand[7] & 0x80) {
for (i = 0; i < (RspFrm->operand[7] & 0x7F); i++) {
size <<= 8;
size += RspFrm->operand[8 + i];
}
}
return RspFrm->operand[7];
}
int avc_ca_app_info(struct firesat *firesat, char *app_info, int *length)
{
AVCCmdFrm CmdFrm;
AVCRspFrm RspFrm;
int pos;
memset(&CmdFrm, 0, sizeof(AVCCmdFrm));
CmdFrm.cts = AVC;
CmdFrm.ctype = STATUS;
CmdFrm.sutyp = 0x5;
CmdFrm.suid = firesat->subunit;
CmdFrm.opcode = VENDOR;
CmdFrm.operand[0]=SFE_VENDOR_DE_COMPANYID_0;
CmdFrm.operand[1]=SFE_VENDOR_DE_COMPANYID_1;
CmdFrm.operand[2]=SFE_VENDOR_DE_COMPANYID_2;
CmdFrm.operand[3]=SFE_VENDOR_OPCODE_CA2HOST;
CmdFrm.operand[4] = 0; // slot
CmdFrm.operand[5] = SFE_VENDOR_TAG_CA_APPLICATION_INFO; // ca tag
CmdFrm.length = 12;
if(AVCWrite(firesat,&CmdFrm,&RspFrm) < 0)
return -EIO;
pos = get_ca_object_pos(&RspFrm);
app_info[0] = (TAG_APP_INFO >> 16) & 0xFF;
app_info[1] = (TAG_APP_INFO >> 8) & 0xFF;
app_info[2] = (TAG_APP_INFO >> 0) & 0xFF;
app_info[3] = 6 + RspFrm.operand[pos + 4];
app_info[4] = 0x01;
memcpy(&app_info[5], &RspFrm.operand[pos], 5 + RspFrm.operand[pos + 4]);
*length = app_info[3] + 4;
return 0;
}
int avc_ca_info(struct firesat *firesat, char *app_info, int *length)
{
AVCCmdFrm CmdFrm;
AVCRspFrm RspFrm;
int pos;
memset(&CmdFrm, 0, sizeof(AVCCmdFrm));
CmdFrm.cts = AVC;
CmdFrm.ctype = STATUS;
CmdFrm.sutyp = 0x5;
CmdFrm.suid = firesat->subunit;
CmdFrm.opcode = VENDOR;
CmdFrm.operand[0]=SFE_VENDOR_DE_COMPANYID_0;
CmdFrm.operand[1]=SFE_VENDOR_DE_COMPANYID_1;
CmdFrm.operand[2]=SFE_VENDOR_DE_COMPANYID_2;
CmdFrm.operand[3]=SFE_VENDOR_OPCODE_CA2HOST;
CmdFrm.operand[4] = 0; // slot
CmdFrm.operand[5] = SFE_VENDOR_TAG_CA_APPLICATION_INFO; // ca tag
CmdFrm.length = 12;
if(AVCWrite(firesat,&CmdFrm,&RspFrm) < 0)
return -EIO;
pos = get_ca_object_pos(&RspFrm);
app_info[0] = (TAG_CA_INFO >> 16) & 0xFF;
app_info[1] = (TAG_CA_INFO >> 8) & 0xFF;
app_info[2] = (TAG_CA_INFO >> 0) & 0xFF;
app_info[3] = 2;
app_info[4] = app_info[5];
app_info[5] = app_info[6];
*length = app_info[3] + 4;
return 0;
}
int avc_ca_reset(struct firesat *firesat)
{
AVCCmdFrm CmdFrm;
AVCRspFrm RspFrm;
memset(&CmdFrm, 0, sizeof(AVCCmdFrm));
CmdFrm.cts = AVC;
CmdFrm.ctype = CONTROL;
CmdFrm.sutyp = 0x5;
CmdFrm.suid = firesat->subunit;
CmdFrm.opcode = VENDOR;
CmdFrm.operand[0]=SFE_VENDOR_DE_COMPANYID_0;
CmdFrm.operand[1]=SFE_VENDOR_DE_COMPANYID_1;
CmdFrm.operand[2]=SFE_VENDOR_DE_COMPANYID_2;
CmdFrm.operand[3]=SFE_VENDOR_OPCODE_HOST2CA;
CmdFrm.operand[4] = 0; // slot
CmdFrm.operand[5] = SFE_VENDOR_TAG_CA_RESET; // ca tag
CmdFrm.operand[6] = 0; // more/last
CmdFrm.operand[7] = 1; // length
CmdFrm.operand[8] = 0; // force hardware reset
CmdFrm.length = 12;
if(AVCWrite(firesat,&CmdFrm,&RspFrm) < 0)
return -EIO;
return 0;
}
int avc_ca_pmt(struct firesat *firesat, char *msg, int length)
{
AVCCmdFrm CmdFrm;
AVCRspFrm RspFrm;
int list_management;
int program_info_length;
int pmt_cmd_id;
int read_pos;
int write_pos;
int es_info_length;
int crc32_csum;
memset(&CmdFrm, 0, sizeof(AVCCmdFrm));
CmdFrm.cts = AVC;
CmdFrm.ctype = CONTROL;
CmdFrm.sutyp = 0x5;
CmdFrm.suid = firesat->subunit;
CmdFrm.opcode = VENDOR;
if (msg[0] != LIST_MANAGEMENT_ONLY) {
printk(KERN_ERR "The only list_manasgement parameter that is "
"supported by the firesat driver is \"only\" (3).");
return -EFAULT;
}
// We take the cmd_id from the programme level only!
list_management = msg[0];
program_info_length = ((msg[4] & 0x0F) << 8) + msg[5];
if (program_info_length > 0)
program_info_length--; // Remove pmt_cmd_id
pmt_cmd_id = msg[6];
CmdFrm.operand[0]=SFE_VENDOR_DE_COMPANYID_0;
CmdFrm.operand[1]=SFE_VENDOR_DE_COMPANYID_1;
CmdFrm.operand[2]=SFE_VENDOR_DE_COMPANYID_2;
CmdFrm.operand[3]=SFE_VENDOR_OPCODE_HOST2CA;
CmdFrm.operand[4] = 0; // slot
CmdFrm.operand[5] = SFE_VENDOR_TAG_CA_PMT; // ca tag
CmdFrm.operand[6] = 0; // more/last
//CmdFrm.operand[7] = XXXprogram_info_length + 17; // length
CmdFrm.operand[8] = list_management;
CmdFrm.operand[9] = 0x01; // pmt_cmd=OK_descramble
// TS program map table
// Table id=2
CmdFrm.operand[10] = 0x02;
// Section syntax + length
CmdFrm.operand[11] = 0x80;
//CmdFrm.operand[12] = XXXprogram_info_length + 12;
// Program number
CmdFrm.operand[13] = msg[1];
CmdFrm.operand[14] = msg[2];
// Version number=0 + current/next=1
CmdFrm.operand[15] = 0x01;
// Section number=0
CmdFrm.operand[16] = 0x00;
// Last section number=0
CmdFrm.operand[17] = 0x00;
// PCR_PID=1FFF
CmdFrm.operand[18] = 0x1F;
CmdFrm.operand[19] = 0xFF;
// Program info length
CmdFrm.operand[20] = (program_info_length >> 8);
CmdFrm.operand[21] = (program_info_length & 0xFF);
// CA descriptors at programme level
read_pos = 6;
write_pos = 22;
if (program_info_length > 0) {
/* printk(KERN_INFO "Copying descriptors at programme level.\n"); */
pmt_cmd_id = msg[read_pos++];
if (pmt_cmd_id != 1 && pmt_cmd_id !=4) {
printk(KERN_ERR "Invalid pmt_cmd_id=%d.\n",
pmt_cmd_id);
}
memcpy(&CmdFrm.operand[write_pos], &msg[read_pos],
program_info_length);
read_pos += program_info_length;
write_pos += program_info_length;
}
while (read_pos < length) {
/* printk(KERN_INFO "Copying descriptors at stream level for " */
/* "stream type %d.\n", msg[read_pos]); */
CmdFrm.operand[write_pos++] = msg[read_pos++];
CmdFrm.operand[write_pos++] = msg[read_pos++];
CmdFrm.operand[write_pos++] = msg[read_pos++];
es_info_length =
((msg[read_pos] & 0x0F) << 8) + msg[read_pos + 1];
read_pos += 2;
if (es_info_length > 0)
es_info_length--; // Remove pmt_cmd_id
CmdFrm.operand[write_pos++] = es_info_length >> 8;
CmdFrm.operand[write_pos++] = es_info_length & 0xFF;
if (es_info_length > 0) {
pmt_cmd_id = msg[read_pos++];
if (pmt_cmd_id != 1 && pmt_cmd_id !=4) {
printk(KERN_ERR "Invalid pmt_cmd_id=%d at "
"stream level.\n", pmt_cmd_id);
}
memcpy(&CmdFrm.operand[write_pos], &msg[read_pos],
es_info_length);
read_pos += es_info_length;
write_pos += es_info_length;
}
}
// CRC
CmdFrm.operand[write_pos++] = 0x00;
CmdFrm.operand[write_pos++] = 0x00;
CmdFrm.operand[write_pos++] = 0x00;
CmdFrm.operand[write_pos++] = 0x00;
CmdFrm.operand[7] = write_pos - 8;
CmdFrm.operand[12] = write_pos - 13;
crc32_csum = crc32_be(0, &CmdFrm.operand[10],
CmdFrm.operand[12] - 1);
CmdFrm.operand[write_pos - 4] = (crc32_csum >> 24) & 0xFF;
CmdFrm.operand[write_pos - 3] = (crc32_csum >> 16) & 0xFF;
CmdFrm.operand[write_pos - 2] = (crc32_csum >> 8) & 0xFF;
CmdFrm.operand[write_pos - 1] = (crc32_csum >> 0) & 0xFF;
CmdFrm.length = write_pos + 3;
if ((write_pos + 3) % 4)
CmdFrm.length += 4 - ((write_pos + 3) % 4);
if(AVCWrite(firesat,&CmdFrm,&RspFrm) < 0)
return -EIO;
if (RspFrm.resp != ACCEPTED) {
printk(KERN_ERR "Answer to CA PMT was %d\n", RspFrm.resp);
return -EFAULT;
}
return 0;
}
int avc_ca_get_time_date(struct firesat *firesat, int *interval)
{
AVCCmdFrm CmdFrm;
AVCRspFrm RspFrm;
memset(&CmdFrm, 0, sizeof(AVCCmdFrm));
CmdFrm.cts = AVC;
CmdFrm.ctype = STATUS;
CmdFrm.sutyp = 0x5;
CmdFrm.suid = firesat->subunit;
CmdFrm.opcode = VENDOR;
CmdFrm.operand[0]=SFE_VENDOR_DE_COMPANYID_0;
CmdFrm.operand[1]=SFE_VENDOR_DE_COMPANYID_1;
CmdFrm.operand[2]=SFE_VENDOR_DE_COMPANYID_2;
CmdFrm.operand[3]=SFE_VENDOR_OPCODE_CA2HOST;
CmdFrm.operand[4] = 0; // slot
CmdFrm.operand[5] = SFE_VENDOR_TAG_CA_DATE_TIME; // ca tag
CmdFrm.operand[6] = 0; // more/last
CmdFrm.operand[7] = 0; // length
CmdFrm.length = 12;
if(AVCWrite(firesat,&CmdFrm,&RspFrm) < 0)
return -EIO;
*interval = RspFrm.operand[get_ca_object_pos(&RspFrm)];
return 0;
}
int avc_ca_enter_menu(struct firesat *firesat)
{
AVCCmdFrm CmdFrm;
AVCRspFrm RspFrm;
memset(&CmdFrm, 0, sizeof(AVCCmdFrm));
CmdFrm.cts = AVC;
CmdFrm.ctype = STATUS;
CmdFrm.sutyp = 0x5;
CmdFrm.suid = firesat->subunit;
CmdFrm.opcode = VENDOR;
CmdFrm.operand[0]=SFE_VENDOR_DE_COMPANYID_0;
CmdFrm.operand[1]=SFE_VENDOR_DE_COMPANYID_1;
CmdFrm.operand[2]=SFE_VENDOR_DE_COMPANYID_2;
CmdFrm.operand[3]=SFE_VENDOR_OPCODE_HOST2CA;
CmdFrm.operand[4] = 0; // slot
CmdFrm.operand[5] = SFE_VENDOR_TAG_CA_ENTER_MENU;
CmdFrm.operand[6] = 0; // more/last
CmdFrm.operand[7] = 0; // length
CmdFrm.length = 12;
if(AVCWrite(firesat,&CmdFrm,&RspFrm) < 0)
return -EIO;
return 0;
}
int avc_ca_get_mmi(struct firesat *firesat, char *mmi_object, int *length)
{
AVCCmdFrm CmdFrm;
AVCRspFrm RspFrm;
memset(&CmdFrm, 0, sizeof(AVCCmdFrm));
CmdFrm.cts = AVC;
CmdFrm.ctype = STATUS;
CmdFrm.sutyp = 0x5;
CmdFrm.suid = firesat->subunit;
CmdFrm.opcode = VENDOR;
CmdFrm.operand[0]=SFE_VENDOR_DE_COMPANYID_0;
CmdFrm.operand[1]=SFE_VENDOR_DE_COMPANYID_1;
CmdFrm.operand[2]=SFE_VENDOR_DE_COMPANYID_2;
CmdFrm.operand[3]=SFE_VENDOR_OPCODE_CA2HOST;
CmdFrm.operand[4] = 0; // slot
CmdFrm.operand[5] = SFE_VENDOR_TAG_CA_MMI;
CmdFrm.operand[6] = 0; // more/last
CmdFrm.operand[7] = 0; // length
CmdFrm.length = 12;
if(AVCWrite(firesat,&CmdFrm,&RspFrm) < 0)
return -EIO;
*length = get_ca_object_length(&RspFrm);
memcpy(mmi_object, &RspFrm.operand[get_ca_object_pos(&RspFrm)], *length);
return 0;
}

View File

@ -4,6 +4,7 @@
begin : Wed May 1 2000
copyright : (C) 2000 by Manfred Weihs
copyright : (C) 2003 by Philipp Gutgsell
copyright : (C) 2008 by Henrik Kurelid (henrik@kurelid.se)
email : 0014guph@edu.fh-kaernten.ac.at
***************************************************************************/
@ -27,12 +28,10 @@
#include <linux/dvb/frontend.h>
#define BYTE unsigned char
#define WORD unsigned short
#define DWORD unsigned long
#define ULONG unsigned long
#define LONG long
/*************************************************************
Constants from EN510221
**************************************************************/
#define LIST_MANAGEMENT_ONLY 0x03
/*************************************************************
FCP Address range
@ -68,12 +67,12 @@ typedef struct {
typedef struct _AVCCmdFrm
{
// AV/C command frame
BYTE ctype : 4 ; // command type
BYTE cts : 4 ; // always 0x0 for AVC
BYTE suid : 3 ; // subunit ID
BYTE sutyp : 5 ; // subunit_typ
BYTE opcode : 8 ; // opcode
BYTE operand[509] ; // array of operands [1-507]
__u8 ctype : 4 ; // command type
__u8 cts : 4 ; // always 0x0 for AVC
__u8 suid : 3 ; // subunit ID
__u8 sutyp : 5 ; // subunit_typ
__u8 opcode : 8 ; // opcode
__u8 operand[509] ; // array of operands [1-507]
int length; //length of the command frame
} AVCCmdFrm ;
@ -81,12 +80,12 @@ typedef struct _AVCCmdFrm
typedef struct _AVCRspFrm
{
// AV/C response frame
BYTE resp : 4 ; // response type
BYTE cts : 4 ; // always 0x0 for AVC
BYTE suid : 3 ; // subunit ID
BYTE sutyp : 5 ; // subunit_typ
BYTE opcode : 8 ; // opcode
BYTE operand[509] ; // array of operands [1-507]
__u8 resp : 4 ; // response type
__u8 cts : 4 ; // always 0x0 for AVC
__u8 suid : 3 ; // subunit ID
__u8 sutyp : 5 ; // subunit_typ
__u8 opcode : 8 ; // opcode
__u8 operand[509] ; // array of operands [1-507]
int length; //length of the response frame
} AVCRspFrm ;
@ -94,23 +93,23 @@ typedef struct _AVCRspFrm
typedef struct _AVCCmdFrm
{
BYTE cts:4;
BYTE ctype:4;
BYTE sutyp:5;
BYTE suid:3;
BYTE opcode;
BYTE operand[509];
__u8 cts:4;
__u8 ctype:4;
__u8 sutyp:5;
__u8 suid:3;
__u8 opcode;
__u8 operand[509];
int length;
} AVCCmdFrm;
typedef struct _AVCRspFrm
{
BYTE cts:4;
BYTE resp:4;
BYTE sutyp:5;
BYTE suid:3;
BYTE opcode;
BYTE operand[509];
__u8 cts:4;
__u8 resp:4;
__u8 sutyp:5;
__u8 suid:3;
__u8 opcode;
__u8 operand[509];
int length;
} AVCRspFrm;
@ -197,6 +196,14 @@ typedef struct _AVCRspFrm
#define SFE_VENDOR_OPCODE_CISTATUS 0x59
#define SFE_VENDOR_OPCODE_TUNE_QPSK2 0x60 // QPSK command for DVB-S2 devices
// CA Tags
#define SFE_VENDOR_TAG_CA_RESET 0x00
#define SFE_VENDOR_TAG_CA_APPLICATION_INFO 0x01
#define SFE_VENDOR_TAG_CA_PMT 0x02
#define SFE_VENDOR_TAG_CA_DATE_TIME 0x04
#define SFE_VENDOR_TAG_CA_MMI 0x05
#define SFE_VENDOR_TAG_CA_ENTER_MENU 0x07
//AVCTuner DVB identifier service_ID
#define DVB 0x20
@ -209,8 +216,8 @@ typedef struct _AVCRspFrm
#define Tuner_Status_Descriptor 0x80
typedef struct {
BYTE Subunit_Type;
BYTE Max_Subunit_ID;
__u8 Subunit_Type;
__u8 Max_Subunit_ID;
} SUBUNIT_INFO;
/*************************************************************
@ -220,12 +227,12 @@ typedef struct {
**************************************************************/
typedef struct {
BYTE Byte0;
BYTE Byte1;
BYTE Byte2;
BYTE Byte3;
BYTE Byte4;
BYTE Byte5;
__u8 Byte0;
__u8 Byte1;
__u8 Byte2;
__u8 Byte3;
__u8 Byte4;
__u8 Byte5;
}OBJECT_ID;
/*************************************************************
@ -234,14 +241,14 @@ typedef struct {
typedef struct
{
#ifdef __LITTLE_ENDIAN
BYTE RF_frequency_hByte:6;
BYTE raster_Frequency:2;//Bit7,6 raster frequency
__u8 RF_frequency_hByte:6;
__u8 raster_Frequency:2;//Bit7,6 raster frequency
#else
BYTE raster_Frequency:2;
BYTE RF_frequency_hByte:6;
__u8 raster_Frequency:2;
__u8 RF_frequency_hByte:6;
#endif
BYTE RF_frequency_mByte;
BYTE RF_frequency_lByte;
__u8 RF_frequency_mByte;
__u8 RF_frequency_lByte;
}FREQUENCY;
@ -249,63 +256,63 @@ typedef struct
typedef struct
{
BYTE Modulation :1;
BYTE FEC_inner :1;
BYTE FEC_outer :1;
BYTE Symbol_Rate :1;
BYTE Frequency :1;
BYTE Orbital_Pos :1;
BYTE Polarisation :1;
BYTE reserved_fields :1;
BYTE reserved1 :7;
BYTE Network_ID :1;
__u8 Modulation :1;
__u8 FEC_inner :1;
__u8 FEC_outer :1;
__u8 Symbol_Rate :1;
__u8 Frequency :1;
__u8 Orbital_Pos :1;
__u8 Polarisation :1;
__u8 reserved_fields :1;
__u8 reserved1 :7;
__u8 Network_ID :1;
}MULTIPLEX_VALID_FLAGS;
typedef struct
{
BYTE GuardInterval:1;
BYTE CodeRateLPStream:1;
BYTE CodeRateHPStream:1;
BYTE HierarchyInfo:1;
BYTE Constellation:1;
BYTE Bandwidth:1;
BYTE CenterFrequency:1;
BYTE reserved1:1;
BYTE reserved2:5;
BYTE OtherFrequencyFlag:1;
BYTE TransmissionMode:1;
BYTE NetworkId:1;
__u8 GuardInterval:1;
__u8 CodeRateLPStream:1;
__u8 CodeRateHPStream:1;
__u8 HierarchyInfo:1;
__u8 Constellation:1;
__u8 Bandwidth:1;
__u8 CenterFrequency:1;
__u8 reserved1:1;
__u8 reserved2:5;
__u8 OtherFrequencyFlag:1;
__u8 TransmissionMode:1;
__u8 NetworkId:1;
}MULTIPLEX_VALID_FLAGS_DVBT;
#else
typedef struct {
BYTE reserved_fields:1;
BYTE Polarisation:1;
BYTE Orbital_Pos:1;
BYTE Frequency:1;
BYTE Symbol_Rate:1;
BYTE FEC_outer:1;
BYTE FEC_inner:1;
BYTE Modulation:1;
BYTE Network_ID:1;
BYTE reserved1:7;
__u8 reserved_fields:1;
__u8 Polarisation:1;
__u8 Orbital_Pos:1;
__u8 Frequency:1;
__u8 Symbol_Rate:1;
__u8 FEC_outer:1;
__u8 FEC_inner:1;
__u8 Modulation:1;
__u8 Network_ID:1;
__u8 reserved1:7;
}MULTIPLEX_VALID_FLAGS;
typedef struct {
BYTE reserved1:1;
BYTE CenterFrequency:1;
BYTE Bandwidth:1;
BYTE Constellation:1;
BYTE HierarchyInfo:1;
BYTE CodeRateHPStream:1;
BYTE CodeRateLPStream:1;
BYTE GuardInterval:1;
BYTE NetworkId:1;
BYTE TransmissionMode:1;
BYTE OtherFrequencyFlag:1;
BYTE reserved2:5;
__u8 reserved1:1;
__u8 CenterFrequency:1;
__u8 Bandwidth:1;
__u8 Constellation:1;
__u8 HierarchyInfo:1;
__u8 CodeRateHPStream:1;
__u8 CodeRateLPStream:1;
__u8 GuardInterval:1;
__u8 NetworkId:1;
__u8 TransmissionMode:1;
__u8 OtherFrequencyFlag:1;
__u8 reserved2:5;
}MULTIPLEX_VALID_FLAGS_DVBT;
#endif
@ -314,47 +321,98 @@ typedef union {
MULTIPLEX_VALID_FLAGS Bits;
MULTIPLEX_VALID_FLAGS_DVBT Bits_T;
struct {
BYTE ByteHi;
BYTE ByteLo;
__u8 ByteHi;
__u8 ByteLo;
} Valid_Word;
} M_VALID_FLAGS;
typedef struct
{
#ifdef __LITTLE_ENDIAN
BYTE ActiveSystem;
BYTE reserved:5;
BYTE NoRF:1;
BYTE Moving:1;
BYTE Searching:1;
__u8 ActiveSystem;
__u8 reserved:5;
__u8 NoRF:1;
__u8 Moving:1;
__u8 Searching:1;
BYTE SelectedAntenna:7;
BYTE Input:1;
__u8 SelectedAntenna:7;
__u8 Input:1;
BYTE BER[4];
__u8 BER[4];
BYTE SignalStrength;
__u8 SignalStrength;
FREQUENCY Frequency;
BYTE ManDepInfoLength;
__u8 ManDepInfoLength;
__u8 PowerSupply:1;
__u8 FrontEndPowerStatus:1;
__u8 reserved3:1;
__u8 AntennaError:1;
__u8 FrontEndError:1;
__u8 reserved2:3;
__u8 CarrierNoiseRatio[2];
__u8 reserved4[2];
__u8 PowerSupplyVoltage;
__u8 AntennaVoltage;
__u8 FirewireBusVoltage;
__u8 CaMmi:1;
__u8 reserved5:7;
__u8 reserved6:1;
__u8 CaInitializationStatus:1;
__u8 CaErrorFlag:1;
__u8 CaDvbFlag:1;
__u8 CaModulePresentStatus:1;
__u8 CaApplicationInfo:1;
__u8 CaDateTimeRequest:1;
__u8 CaPmtReply:1;
#else
BYTE ActiveSystem;
BYTE Searching:1;
BYTE Moving:1;
BYTE NoRF:1;
BYTE reserved:5;
__u8 ActiveSystem;
__u8 Searching:1;
__u8 Moving:1;
__u8 NoRF:1;
__u8 reserved:5;
BYTE Input:1;
BYTE SelectedAntenna:7;
__u8 Input:1;
__u8 SelectedAntenna:7;
BYTE BER[4];
__u8 BER[4];
BYTE SignalStrength;
__u8 SignalStrength;
FREQUENCY Frequency;
BYTE ManDepInfoLength;
__u8 ManDepInfoLength;
__u8 reserved2:3;
__u8 FrontEndError:1;
__u8 AntennaError:1;
__u8 reserved3:1;
__u8 FrontEndPowerStatus:1;
__u8 PowerSupply:1;
__u8 CarrierNoiseRatio[2];
__u8 reserved4[2];
__u8 PowerSupplyVoltage;
__u8 AntennaVoltage;
__u8 FirewireBusVoltage;
__u8 reserved5:7;
__u8 CaMmi:1;
__u8 CaPmtReply:1;
__u8 CaDateTimeRequest:1;
__u8 CaApplicationInfo:1;
__u8 CaModulePresentStatus:1;
__u8 CaDvbFlag:1;
__u8 CaErrorFlag:1;
__u8 CaInitializationStatus:1;
__u8 reserved6:1;
#endif
} ANTENNA_INPUT_INFO; // 11 Byte
} ANTENNA_INPUT_INFO; // 22 Byte
#define LNBCONTROL_DONTCARE 0xff
@ -365,17 +423,27 @@ extern int AVCRecv(struct firesat *firesat, u8 *data, size_t length);
extern int AVCTuner_DSIT(struct firesat *firesat,
int Source_Plug,
struct dvb_frontend_parameters *params,
BYTE *status);
__u8 *status);
extern int AVCTunerStatus(struct firesat *firesat, ANTENNA_INPUT_INFO *antenna_input_info);
extern int AVCTuner_DSD(struct firesat *firesat, struct dvb_frontend_parameters *params, BYTE *status);
extern int AVCTuner_DSD(struct firesat *firesat, struct dvb_frontend_parameters *params, __u8 *status);
extern int AVCTuner_SetPIDs(struct firesat *firesat, unsigned char pidc, u16 pid[]);
extern int AVCTuner_GetTS(struct firesat *firesat);
extern int AVCIdentifySubunit(struct firesat *firesat, unsigned char *systemId, int *transport, int *has_ci);
extern int AVCIdentifySubunit(struct firesat *firesat, unsigned char *systemId, int *transport);
extern int AVCLNBControl(struct firesat *firesat, char voltage, char burst, char conttone, char nrdiseq, struct dvb_diseqc_master_cmd *diseqcmd);
extern int AVCSubUnitInfo(struct firesat *firesat, char *subunitcount);
extern int AVCRegisterRemoteControl(struct firesat *firesat);
extern int AVCTuner_Host2Ca(struct firesat *firesat);
extern int avc_ca_app_info(struct firesat *firesat, char *app_info,
int *length);
extern int avc_ca_info(struct firesat *firesat, char *app_info, int *length);
extern int avc_ca_reset(struct firesat *firesat);
extern int avc_ca_pmt(struct firesat *firesat, char *app_info, int length);
extern int avc_ca_get_time_date(struct firesat *firesat, int *interval);
extern int avc_ca_enter_menu(struct firesat *firesat);
extern int avc_ca_get_mmi(struct firesat *firesat, char *mmi_object,
int *length);
#endif

View File

@ -1,3 +1,15 @@
/*
* FireSAT DVB driver
*
* Copyright (c) ?
* Copyright (c) 2008 Henrik Kurelid <henrik@kurelid.se>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*/
#include "cmp.h"
#include <ieee1394.h>
#include <nodemgr.h>
@ -10,18 +22,18 @@
typedef struct _OPCR
{
BYTE PTPConnCount : 6 ; // Point to point connect. counter
BYTE BrConnCount : 1 ; // Broadcast connection counter
BYTE OnLine : 1 ; // On Line
__u8 PTPConnCount : 6 ; // Point to point connect. counter
__u8 BrConnCount : 1 ; // Broadcast connection counter
__u8 OnLine : 1 ; // On Line
BYTE ChNr : 6 ; // Channel number
BYTE Res : 2 ; // Reserved
__u8 ChNr : 6 ; // Channel number
__u8 Res : 2 ; // Reserved
BYTE PayloadHi : 2 ; // Payoad high bits
BYTE OvhdID : 4 ; // Overhead ID
BYTE DataRate : 2 ; // Data Rate
__u8 PayloadHi : 2 ; // Payoad high bits
__u8 OvhdID : 4 ; // Overhead ID
__u8 DataRate : 2 ; // Data Rate
BYTE PayloadLo ; // Payoad low byte
__u8 PayloadLo ; // Payoad low byte
} OPCR ;
#define FIRESAT_SPEED IEEE1394_SPEED_400
@ -94,13 +106,13 @@ int try_CMPEstablishPPconnection(struct firesat *firesat, int output_plug, int i
u64 oPCR_address=0xfffff0000904ull+(output_plug << 2);
int result=cmp_read(firesat, &test_oPCR, oPCR_address, 4);
printk(KERN_INFO "%s: nodeid = %d\n",__func__,firesat->nodeentry->nodeid);
/* printk(KERN_INFO "%s: nodeid = %d\n",__func__,firesat->nodeentry->nodeid); */
if (result < 0) {
printk("%s: cannot read oPCR\n", __func__);
return result;
} else {
printk(KERN_INFO "%s: oPCR = %08x\n",__func__,test_oPCR);
/* printk(KERN_INFO "%s: oPCR = %08x\n",__func__,test_oPCR); */
do {
OPCR *hilf= (OPCR*) &test_oPCR;
@ -134,8 +146,8 @@ int try_CMPEstablishPPconnection(struct firesat *firesat, int output_plug, int i
hilf->PTPConnCount++;
new_oPCR=test_oPCR;
printk(KERN_INFO "%s: trying compare_swap...\n",__func__);
printk(KERN_INFO "%s: oPCR_old: %08x, oPCR_new: %08x\n",__func__, old_oPCR, new_oPCR);
/* printk(KERN_INFO "%s: trying compare_swap...\n",__func__); */
/* printk(KERN_INFO "%s: oPCR_old: %08x, oPCR_new: %08x\n",__func__, old_oPCR, new_oPCR); */
result=cmp_lock(firesat, &test_oPCR, oPCR_address, old_oPCR, 2);
if (result < 0) {
@ -169,7 +181,7 @@ int try_CMPBreakPPconnection(struct firesat *firesat, int output_plug,int iso_ch
u64 oPCR_address=0xfffff0000904ull+(output_plug << 2);
int result=cmp_read(firesat, &test_oPCR, oPCR_address, 4);
printk(KERN_INFO "%s\n",__func__);
/* printk(KERN_INFO "%s\n",__func__); */
if (result < 0) {
printk("%s: cannot read oPCR\n", __func__);

View File

@ -1,66 +1,303 @@
/*
* FireSAT DVB driver
*
* Copyright (c) 2008 Henrik Kurelid <henrik@kurelid.se>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*/
#include "firesat-ci.h"
#include "firesat.h"
#include "avc_api.h"
#include <linux/dvb/ca.h>
#include <dvbdev.h>
/*
static int firesat_ca_do_ioctl(struct inode *inode, struct file *file, unsigned int cmd, void *parg) {
//struct firesat *firesat = (struct firesat*)((struct dvb_device*)file->private_data)->priv;
int err;
// printk(KERN_INFO "%s: ioctl %d\n",__func__,cmd);
static unsigned int ca_debug = 0;
module_param(ca_debug, int, 0644);
MODULE_PARM_DESC(ca_debug, "debug logging of ca system, default is 0 (no)");
switch(cmd) {
case CA_RESET:
// TODO: Needs to be implemented with new AVC Vendor commands
break;
case CA_GET_CAP: {
ca_caps_t *cap=(ca_caps_t*)parg;
cap->slot_num = 1;
cap->slot_type = CA_CI_LINK;
cap->descr_num = 1;
cap->descr_type = CA_DSS;
static int firesat_ca_ready(ANTENNA_INPUT_INFO *info)
{
if (ca_debug != 0)
printk("%s: CaMmi=%d, CaInit=%d, CaError=%d, CaDvb=%d, "
"CaModule=%d, CaAppInfo=%d, CaDateTime=%d, "
"CaPmt=%d\n", __func__, info->CaMmi,
info->CaInitializationStatus, info->CaErrorFlag,
info->CaDvbFlag, info->CaModulePresentStatus,
info->CaApplicationInfo,
info->CaDateTimeRequest, info->CaPmtReply);
return info->CaInitializationStatus == 1 &&
info->CaErrorFlag == 0 &&
info->CaDvbFlag == 1 &&
info->CaModulePresentStatus == 1;
}
err = 0;
break;
static int firesat_get_ca_flags(ANTENNA_INPUT_INFO *info)
{
int flags = 0;
if (info->CaModulePresentStatus == 1)
flags |= CA_CI_MODULE_PRESENT;
if (info->CaInitializationStatus == 1 &&
info->CaErrorFlag == 0 &&
info->CaDvbFlag == 1)
flags |= CA_CI_MODULE_READY;
return flags;
}
static int firesat_ca_reset(struct firesat *firesat)
{
if (ca_debug)
printk(KERN_INFO "%s: ioctl CA_RESET\n", __func__);
if (avc_ca_reset(firesat))
return -EFAULT;
return 0;
}
static int firesat_ca_get_caps(struct firesat *firesat, void *arg)
{
struct ca_caps *cap_p = (struct ca_caps*)arg;
int err = 0;
cap_p->slot_num = 1;
cap_p->slot_type = CA_CI;
cap_p->descr_num = 1;
cap_p->descr_type = CA_ECD;
if (ca_debug)
printk(KERN_INFO "%s: ioctl CA_GET_CAP\n", __func__);
return err;
}
static int firesat_ca_get_slot_info(struct firesat *firesat, void *arg)
{
ANTENNA_INPUT_INFO info;
struct ca_slot_info *slot_p = (struct ca_slot_info*)arg;
if (ca_debug)
printk(KERN_INFO "%s: ioctl CA_GET_SLOT_INFO on slot %d.\n",
__func__, slot_p->num);
if (AVCTunerStatus(firesat, &info))
return -EFAULT;
if (slot_p->num == 0) {
slot_p->type = CA_CI;
slot_p->flags = firesat_get_ca_flags(&info);
}
case CA_GET_SLOT_INFO: {
ca_slot_info_t *slot=(ca_slot_info_t*)parg;
if(slot->num == 0) {
slot->type = CA_CI | CA_CI_LINK | CA_DESCR;
slot->flags = CA_CI_MODULE_PRESENT | CA_CI_MODULE_READY;
} else {
slot->type = 0;
slot->flags = 0;
else {
return -EFAULT;
}
return 0;
}
static int firesat_ca_app_info(struct firesat *firesat, void *arg)
{
struct ca_msg *reply_p = (struct ca_msg*)arg;
int i;
if (avc_ca_app_info(firesat, reply_p->msg, &reply_p->length))
return -EFAULT;
if (ca_debug) {
printk(KERN_INFO "%s: Creating TAG_APP_INFO message:",
__func__);
for (i = 0; i < reply_p->length; i++)
printk("0x%02X, ", (unsigned char)reply_p->msg[i]);
printk("\n");
}
return 0;
}
static int firesat_ca_info(struct firesat *firesat, void *arg)
{
struct ca_msg *reply_p = (struct ca_msg*)arg;
int i;
if (avc_ca_info(firesat, reply_p->msg, &reply_p->length))
return -EFAULT;
if (ca_debug) {
printk(KERN_INFO "%s: Creating TAG_CA_INFO message:",
__func__);
for (i = 0; i < reply_p->length; i++)
printk("0x%02X, ", (unsigned char)reply_p->msg[i]);
printk("\n");
}
return 0;
}
static int firesat_ca_get_mmi(struct firesat *firesat, void *arg)
{
struct ca_msg *reply_p = (struct ca_msg*)arg;
int i;
if (avc_ca_get_mmi(firesat, reply_p->msg, &reply_p->length))
return -EFAULT;
if (ca_debug) {
printk(KERN_INFO "%s: Creating MMI reply INFO message:",
__func__);
for (i = 0; i < reply_p->length; i++)
printk("0x%02X, ", (unsigned char)reply_p->msg[i]);
printk("\n");
}
return 0;
}
static int firesat_ca_get_msg(struct firesat *firesat, void *arg)
{
int err;
ANTENNA_INPUT_INFO info;
switch (firesat->ca_last_command) {
case TAG_APP_INFO_ENQUIRY:
err = firesat_ca_app_info(firesat, arg);
break;
case TAG_CA_INFO_ENQUIRY:
err = firesat_ca_info(firesat, arg);
break;
default:
if (AVCTunerStatus(firesat, &info))
err = -EFAULT;
else if (info.CaMmi == 1) {
err = firesat_ca_get_mmi(firesat, arg);
}
else {
printk(KERN_INFO "%s: Unhandled message 0x%08X\n",
__func__, firesat->ca_last_command);
err = -EFAULT;
}
}
firesat->ca_last_command = 0;
return err;
}
static int firesat_ca_pmt(struct firesat *firesat, void *arg)
{
struct ca_msg *msg_p = (struct ca_msg*)arg;
int data_pos;
if (msg_p->msg[3] & 0x80)
data_pos = (msg_p->msg[4] && 0x7F) + 4;
else
data_pos = 4;
if (avc_ca_pmt(firesat, &msg_p->msg[data_pos],
msg_p->length - data_pos))
return -EFAULT;
return 0;
}
static int firesat_ca_send_msg(struct firesat *firesat, void *arg)
{
int err;
struct ca_msg *msg_p = (struct ca_msg*)arg;
// Do we need a semaphore for this?
firesat->ca_last_command =
(msg_p->msg[0] << 16) + (msg_p->msg[1] << 8) + msg_p->msg[2];
switch (firesat->ca_last_command) {
case TAG_CA_PMT:
if (ca_debug != 0)
printk(KERN_INFO "%s: Message received: TAG_CA_PMT\n",
__func__);
err = firesat_ca_pmt(firesat, arg);
break;
case TAG_APP_INFO_ENQUIRY:
// This is all handled in ca_get_msg
if (ca_debug != 0)
printk(KERN_INFO "%s: Message received: "
"TAG_APP_INFO_ENQUIRY\n", __func__);
err = 0;
break;
}
case TAG_CA_INFO_ENQUIRY:
// This is all handled in ca_get_msg
if (ca_debug != 0)
printk(KERN_INFO "%s: Message received: "
"TAG_CA_APP_INFO_ENQUIRY\n", __func__);
err = 0;
break;
case TAG_ENTER_MENU:
if (ca_debug != 0)
printk(KERN_INFO "%s: Entering CA menu.\n", __func__);
err = avc_ca_enter_menu(firesat);
break;
default:
err=-EINVAL;
printk(KERN_ERR "%s: Unhandled unknown message 0x%08X\n",
__func__, firesat->ca_last_command);
err = -EFAULT;
}
return err;
}
*/
static int firesat_ca_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) {
//return dvb_usercopy(inode, file, cmd, arg, firesat_ca_do_ioctl);
return dvb_generic_ioctl(inode, file, cmd, arg);
static int firesat_ca_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, void *arg)
{
struct dvb_device* dvbdev = (struct dvb_device*) file->private_data;
struct firesat *firesat = dvbdev->priv;
int err;
ANTENNA_INPUT_INFO info;
switch(cmd) {
case CA_RESET:
err = firesat_ca_reset(firesat);
break;
case CA_GET_CAP:
err = firesat_ca_get_caps(firesat, arg);
break;
case CA_GET_SLOT_INFO:
err = firesat_ca_get_slot_info(firesat, arg);
break;
case CA_GET_MSG:
err = firesat_ca_get_msg(firesat, arg);
break;
case CA_SEND_MSG:
err = firesat_ca_send_msg(firesat, arg);
break;
default:
printk(KERN_INFO "%s: Unhandled ioctl, command: %u\n",__func__,
cmd);
err = -EOPNOTSUPP;
}
if (AVCTunerStatus(firesat, &info))
return err;
firesat_ca_ready(&info);
return err;
}
static int firesat_ca_io_open(struct inode *inode, struct file *file) {
printk(KERN_INFO "%s!\n",__func__);
static int firesat_get_date_time_request(struct firesat *firesat)
{
if (ca_debug)
printk(KERN_INFO "%s: Retrieving Time/Date request\n",
__func__);
if (avc_ca_get_time_date(firesat, &firesat->ca_time_interval))
return -EFAULT;
if (ca_debug)
printk(KERN_INFO "%s: Time/Date interval is %d\n",
__func__, firesat->ca_time_interval);
return 0;
}
static int firesat_ca_io_open(struct inode *inode, struct file *file)
{
if (ca_debug != 0)
printk(KERN_INFO "%s\n",__func__);
return dvb_generic_open(inode, file);
}
static int firesat_ca_io_release(struct inode *inode, struct file *file) {
printk(KERN_INFO "%s!\n",__func__);
static int firesat_ca_io_release(struct inode *inode, struct file *file)
{
if (ca_debug != 0)
printk(KERN_INFO "%s\n",__func__);
return dvb_generic_release(inode, file);
}
static unsigned int firesat_ca_io_poll(struct file *file, poll_table *wait) {
// printk(KERN_INFO "%s!\n",__func__);
static unsigned int firesat_ca_io_poll(struct file *file, poll_table *wait)
{
if (ca_debug != 0)
printk(KERN_INFO "%s\n",__func__);
return POLLIN;
}
@ -68,7 +305,7 @@ static struct file_operations firesat_ca_fops = {
.owner = THIS_MODULE,
.read = NULL, // There is no low level read anymore
.write = NULL, // There is no low level write anymore
.ioctl = firesat_ca_ioctl,
.ioctl = dvb_generic_ioctl,
.open = firesat_ca_io_open,
.release = firesat_ca_io_release,
.poll = firesat_ca_io_poll,
@ -80,16 +317,37 @@ static struct dvb_device firesat_ca = {
.readers = 1,
.writers = 1,
.fops = &firesat_ca_fops,
.kernel_ioctl = firesat_ca_ioctl,
};
int firesat_ca_init(struct firesat *firesat) {
int ret = dvb_register_device(firesat->adapter, &firesat->cadev, &firesat_ca, firesat, DVB_DEVICE_CA);
if(ret) return ret;
int firesat_ca_init(struct firesat *firesat)
{
int err;
ANTENNA_INPUT_INFO info;
// avoid unnecessary delays, we're not talking to the CI yet anyways
return 0;
if (AVCTunerStatus(firesat, &info))
return -EINVAL;
if (firesat_ca_ready(&info)) {
err = dvb_register_device(firesat->adapter,
&firesat->cadev,
&firesat_ca, firesat,
DVB_DEVICE_CA);
if (info.CaApplicationInfo == 0)
printk(KERN_ERR "%s: CaApplicationInfo is not set.\n",
__func__);
if (info.CaDateTimeRequest == 1)
firesat_get_date_time_request(firesat);
}
else
err = -EFAULT;
return err;
}
void firesat_ca_release(struct firesat *firesat) {
void firesat_ca_release(struct firesat *firesat)
{
if (firesat->cadev)
dvb_unregister_device(firesat->cadev);
}

View File

@ -1,3 +1,15 @@
/*
* FireSAT DVB driver
*
* Copyright (c) ?
* Copyright (c) 2008 Henrik Kurelid <henrik@kurelid.se>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*/
#ifndef __FIRESAT_H
#define __FIRESAT_H
@ -6,15 +18,108 @@
#include "dvb_demux.h"
#include "dvb_net.h"
#include <linux/version.h>
#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
#include <linux/semaphore.h>
#endif
#include <linux/dvb/frontend.h>
#include <linux/dvb/dmx.h>
#include <iso.h>
#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
#define DVB_REGISTER_ADAPTER(x, y, z, w, v) dvb_register_adapter(x, y, z, w, v)
#else
#define DVB_REGISTER_ADAPTER(x, y, z, w, v) dvb_register_adapter(x, y, z, w)
#define DVB_DEFINE_MOD_OPT_ADAPTER_NR(x)
#endif
/*****************************************************************
* CA message command constants from en50221_app_tags.h of libdvb
*****************************************************************/
/* Resource Manager */
#define TAG_PROFILE_ENQUIRY 0x9f8010
#define TAG_PROFILE 0x9f8011
#define TAG_PROFILE_CHANGE 0x9f8012
/* Application Info */
#define TAG_APP_INFO_ENQUIRY 0x9f8020
#define TAG_APP_INFO 0x9f8021
#define TAG_ENTER_MENU 0x9f8022
/* CA Support */
#define TAG_CA_INFO_ENQUIRY 0x9f8030
#define TAG_CA_INFO 0x9f8031
#define TAG_CA_PMT 0x9f8032
#define TAG_CA_PMT_REPLY 0x9f8033
/* Host Control */
#define TAG_TUNE 0x9f8400
#define TAG_REPLACE 0x9f8401
#define TAG_CLEAR_REPLACE 0x9f8402
#define TAG_ASK_RELEASE 0x9f8403
/* Date and Time */
#define TAG_DATE_TIME_ENQUIRY 0x9f8440
#define TAG_DATE_TIME 0x9f8441
/* Man Machine Interface (MMI) */
#define TAG_CLOSE_MMI 0x9f8800
#define TAG_DISPLAY_CONTROL 0x9f8801
#define TAG_DISPLAY_REPLY 0x9f8802
#define TAG_TEXT_LAST 0x9f8803
#define TAG_TEXT_MORE 0x9f8804
#define TAG_KEYPAD_CONTROL 0x9f8805
#define TAG_KEYPRESS 0x9f8806
#define TAG_ENQUIRY 0x9f8807
#define TAG_ANSWER 0x9f8808
#define TAG_MENU_LAST 0x9f8809
#define TAG_MENU_MORE 0x9f880a
#define TAG_MENU_ANSWER 0x9f880b
#define TAG_LIST_LAST 0x9f880c
#define TAG_LIST_MORE 0x9f880d
#define TAG_SUBTITLE_SEGMENT_LAST 0x9f880e
#define TAG_SUBTITLE_SEGMENT_MORE 0x9f880f
#define TAG_DISPLAY_MESSAGE 0x9f8810
#define TAG_SCENE_END_MARK 0x9f8811
#define TAG_SCENE_DONE 0x9f8812
#define TAG_SCENE_CONTROL 0x9f8813
#define TAG_SUBTITLE_DOWNLOAD_LAST 0x9f8814
#define TAG_SUBTITLE_DOWNLOAD_MORE 0x9f8815
#define TAG_FLUSH_DOWNLOAD 0x9f8816
#define TAG_DOWNLOAD_REPLY 0x9f8817
/* Low Speed Communications */
#define TAG_COMMS_COMMAND 0x9f8c00
#define TAG_CONNECTION_DESCRIPTOR 0x9f8c01
#define TAG_COMMS_REPLY 0x9f8c02
#define TAG_COMMS_SEND_LAST 0x9f8c03
#define TAG_COMMS_SEND_MORE 0x9f8c04
#define TAG_COMMS_RECV_LAST 0x9f8c05
#define TAG_COMMS_RECV_MORE 0x9f8c06
/* Authentication */
#define TAG_AUTH_REQ 0x9f8200
#define TAG_AUTH_RESP 0x9f8201
/* Teletext */
#define TAG_TELETEXT_EBU 0x9f9000
/* Smartcard */
#define TAG_SMARTCARD_COMMAND 0x9f8e00
#define TAG_SMARTCARD_REPLY 0x9f8e01
#define TAG_SMARTCARD_SEND 0x9f8e02
#define TAG_SMARTCARD_RCV 0x9f8e03
/* EPG */
#define TAG_EPG_ENQUIRY 0x9f8f00
#define TAG_EPG_REPLY 0x9f8f01
enum model_type {
FireSAT_DVB_S = 1,
FireSAT_DVB_C = 2,
FireSAT_DVB_T = 3,
FireSAT_DVB_S2 = 4
FireSAT_DVB_S = 1,
FireSAT_DVB_C = 2,
FireSAT_DVB_T = 3,
FireSAT_DVB_S2 = 4
};
struct firesat {
@ -31,12 +136,13 @@ struct firesat {
struct dvb_frontend *fe;
struct dvb_device *cadev;
int has_ci;
int ca_last_command;
int ca_time_interval;
struct semaphore avc_sem;
atomic_t avc_reply_received;
atomic_t avc_reply_received;
atomic_t reschedule_remotecontrol;
atomic_t reschedule_remotecontrol;
struct firesat_channel {
struct firesat *firesat;
@ -53,20 +159,54 @@ struct firesat {
void *respfrm;
int resp_length;
// nodeid_t nodeid;
struct hpsb_host *host;
struct hpsb_host *host;
u64 guid; /* GUID of this node */
u32 guid_vendor_id; /* Top 24bits of guid */
struct node_entry *nodeentry;
enum model_type type;
char subunit;
enum model_type type;
char subunit;
fe_sec_voltage_t voltage;
fe_sec_tone_mode_t tone;
int isochannel;
struct hpsb_iso *iso_handle;
struct list_head list;
struct list_head list;
};
struct firewireheader {
union {
struct {
__u8 tcode:4;
__u8 sy:4;
__u8 tag:2;
__u8 channel:6;
__u8 length_l;
__u8 length_h;
} hdr;
__u32 val;
};
};
struct CIPHeader {
union {
struct {
__u8 syncbits:2;
__u8 sid:6;
__u8 dbs;
__u8 fn:2;
__u8 qpc:3;
__u8 sph:1;
__u8 rsv:2;
__u8 dbc;
__u8 syncbits2:2;
__u8 fmt:6;
__u32 fdf:24;
} cip;
__u64 val;
};
};
extern struct list_head firesat_list;
@ -76,11 +216,15 @@ extern spinlock_t firesat_list_lock;
extern int firesat_start_feed(struct dvb_demux_feed *dvbdmxfeed);
extern int firesat_stop_feed(struct dvb_demux_feed *dvbdmxfeed);
extern int firesat_dvbdev_init(struct firesat *firesat,
struct device *dev,
struct dvb_frontend *fe);
struct device *dev,
struct dvb_frontend *fe);
/* firesat_fe.c */
extern int firesat_frontend_attach(struct firesat *firesat, struct dvb_frontend *fe);
extern int firesat_frontend_attach(struct firesat *firesat,
struct dvb_frontend *fe);
/* firesat_iso.c */
extern int setup_iso_channel(struct firesat *firesat);
extern void tear_down_iso_channel(struct firesat *firesat);
#endif

View File

@ -3,6 +3,7 @@
*
* Copyright (c) 2004 Andreas Monitzer <andy@monitzer.com>
* Copyright (c) 2007-2008 Ben Backx <ben@bbackx.com>
* Copyright (c) 2008 Henrik Kurelid <henrik@kurelid.se>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
@ -18,7 +19,6 @@
#include <linux/time.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/semaphore.h>
#include <ieee1394_hotplug.h>
#include <nodemgr.h>
#include <highlevel.h>
@ -79,11 +79,6 @@ static void firesat_add_host(struct hpsb_host *host);
static void firesat_remove_host(struct hpsb_host *host);
static void firesat_host_reset(struct hpsb_host *host);
/*
static void iso_receive(struct hpsb_host *host, int channel, quadlet_t *data,
size_t length);
*/
static void fcp_request(struct hpsb_host *host,
int nodeid,
int direction,
@ -96,7 +91,6 @@ static struct hpsb_highlevel firesat_highlevel = {
.add_host = firesat_add_host,
.remove_host = firesat_remove_host,
.host_reset = firesat_host_reset,
// FIXME .iso_receive = iso_receive,
.fcp_request = fcp_request,
};
@ -127,100 +121,6 @@ static void firesat_host_reset(struct hpsb_host *host)
printk(KERN_INFO "FireSAT host_reset (nodeid = 0x%x, hosts active = %d)\n",host->node_id,host->nodes_active);
}
struct firewireheader {
union {
struct {
unsigned char tcode:4;
unsigned char sy:4;
unsigned char tag:2;
unsigned char channel:6;
unsigned char length_l;
unsigned char length_h;
} hdr;
unsigned long val;
};
};
struct CIPHeader {
union {
struct {
unsigned char syncbits:2;
unsigned char sid:6;
unsigned char dbs;
unsigned char fn:2;
unsigned char qpc:3;
unsigned char sph:1;
unsigned char rsv:2;
unsigned char dbc;
unsigned char syncbits2:2;
unsigned char fmt:6;
unsigned long fdf:24;
} cip;
unsigned long long val;
};
};
struct MPEG2Header {
union {
struct {
unsigned char sync; // must be 0x47
unsigned char transport_error_indicator:1;
unsigned char payload_unit_start_indicator:1;
unsigned char transport_priority:1;
unsigned short pid:13;
unsigned char transport_scrambling_control:2;
unsigned char adaption_field_control:2;
unsigned char continuity_counter:4;
} hdr;
unsigned long val;
};
};
#if 0
static void iso_receive(struct hpsb_host *host,
int channel,
quadlet_t *data,
size_t length)
{
struct firesat *firesat = NULL;
struct firesat *firesat_entry;
unsigned long flags;
// printk(KERN_INFO "FireSAT iso_receive: channel %d, length = %d\n", channel, length);
if (length <= 12)
return; // ignore empty packets
else {
spin_lock_irqsave(&firesat_list_lock, flags);
list_for_each_entry(firesat_entry,&firesat_list,list) {
if(firesat_entry->host == host && firesat_entry->isochannel == channel) {
firesat=firesat_entry;
break;
}
}
spin_unlock_irqrestore(&firesat_list_lock, flags);
if (firesat) {
char *buf= ((char*)data) + sizeof(struct firewireheader)+sizeof(struct CIPHeader);
int count = (length-sizeof(struct CIPHeader)) / 192;
// printk(KERN_INFO "%s: length = %u\n data[0] = %08x\n data[1] = %08x\n data[2] = %08x\n data[3] = %08x\n data[4] = %08x\n",__func__, length, data[0],data[1],data[2],data[3],data[4]);
while (count--) {
if (buf[sizeof(quadlet_t) /*timestamp*/] == 0x47)
dvb_dmx_swfilter_packets(&firesat->demux, &buf[sizeof(quadlet_t)], 1);
else
printk("%s: invalid packet, skipping\n", __func__);
buf += 188 + sizeof (quadlet_t) /* timestamp */;
}
}
}
}
#endif
static void fcp_request(struct hpsb_host *host,
int nodeid,
int direction,
@ -251,7 +151,9 @@ static void fcp_request(struct hpsb_host *host,
AVCRecv(firesat,data,length);
else
printk("%s: received fcp request from unknown source, ignored\n", __func__);
} // else ignore
}
else
printk("%s: received invalid fcp request, ignored\n", __func__);
}
static int firesat_probe(struct device *dev)
@ -260,7 +162,6 @@ static int firesat_probe(struct device *dev)
struct firesat *firesat;
struct dvb_frontend *fe;
unsigned long flags;
int result;
unsigned char subunitcount = 0xff, subunit;
struct firesat **firesats = kmalloc(sizeof (void*) * 2,GFP_KERNEL);
int kv_len;
@ -298,6 +199,7 @@ static int firesat_probe(struct device *dev)
firesat->isochannel = -1;
firesat->tone = 0xff;
firesat->voltage = 0xff;
firesat->fe = fe;
if (!(firesat->respfrm = kmalloc(sizeof (AVCRspFrm), GFP_KERNEL))) {
printk("%s: couldn't allocate memory.\n", __func__);
@ -357,7 +259,7 @@ static int firesat_probe(struct device *dev)
}
kfree(kv_buf);
if (AVCIdentifySubunit(firesat, NULL, (int*)&firesat->type, &firesat->has_ci)) {
if (AVCIdentifySubunit(firesat, NULL, (int*)&firesat->type)) {
printk("%s: cannot identify subunit %d\n", __func__, subunit);
spin_lock_irqsave(&firesat_list_lock, flags);
list_del(&firesat->list);
@ -382,7 +284,6 @@ static int firesat_probe(struct device *dev)
static int firesat_remove(struct device *dev)
{
struct unit_directory *ud = container_of(dev, struct unit_directory, device);
struct dvb_frontend* fe;
struct firesat **firesats = ud->device.driver_data;
int k;
unsigned long flags;
@ -390,18 +291,9 @@ static int firesat_remove(struct device *dev)
if (firesats) {
for (k = 0; k < 2; k++)
if (firesats[k]) {
if (firesats[k]->has_ci)
firesat_ca_release(firesats[k]);
#if 0
if (!(fe = kmalloc(sizeof (struct dvb_frontend), GFP_KERNEL))) {
fe->ops = firesat_ops;
fe->dvb = firesats[k]->adapter;
dvb_unregister_frontend(fe);
kfree(fe);
}
#endif
dvb_unregister_frontend(firesats[k]->fe);
dvb_net_release(&firesats[k]->dvbnet);
firesats[k]->demux.dmx.close(&firesats[k]->demux.dmx);
firesats[k]->demux.dmx.remove_frontend(&firesats[k]->demux.dmx, &firesats[k]->frontend);
@ -413,6 +305,7 @@ static int firesat_remove(struct device *dev)
list_del(&firesats[k]->list);
spin_unlock_irqrestore(&firesat_list_lock, flags);
kfree(firesats[k]->fe);
kfree(firesats[k]->adapter);
kfree(firesats[k]->respfrm);
kfree(firesats[k]);

View File

@ -1,3 +1,15 @@
/*
* FireSAT DVB driver
*
* Copyright (c) ?
* Copyright (c) 2008 Henrik Kurelid <henrik@kurelid.se>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*/
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/wait.h>
@ -6,7 +18,6 @@
#include <linux/time.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/semaphore.h>
#include <ieee1394_hotplug.h>
#include <nodemgr.h>
#include <highlevel.h>
@ -26,13 +37,13 @@ static struct firesat_channel *firesat_channel_allocate(struct firesat *firesat)
{
int k;
printk(KERN_INFO "%s\n", __func__);
//printk(KERN_INFO "%s\n", __func__);
if (down_interruptible(&firesat->demux_sem))
return NULL;
for (k = 0; k < 16; k++) {
printk(KERN_INFO "%s: channel %d: active = %d, pid = 0x%x\n",__func__,k,firesat->channel[k].active,firesat->channel[k].pid);
//printk(KERN_INFO "%s: channel %d: active = %d, pid = 0x%x\n",__func__,k,firesat->channel[k].active,firesat->channel[k].pid);
if (firesat->channel[k].active == 0) {
firesat->channel[k].active = 1;
@ -82,14 +93,15 @@ int firesat_start_feed(struct dvb_demux_feed *dvbdmxfeed)
int pidc,k;
u16 pids[16];
printk(KERN_INFO "%s (pid %u)\n",__func__,dvbdmxfeed->pid);
// printk(KERN_INFO "%s (pid %u)\n", __func__, dvbdmxfeed->pid);
switch (dvbdmxfeed->type) {
case DMX_TYPE_TS:
case DMX_TYPE_SEC:
break;
default:
printk("%s: invalid type %u\n",__func__,dvbdmxfeed->type);
printk(KERN_ERR "%s: invalid type %u\n",
__func__, dvbdmxfeed->type);
return -EINVAL;
}
@ -110,7 +122,8 @@ int firesat_start_feed(struct dvb_demux_feed *dvbdmxfeed)
channel = firesat_channel_allocate(firesat);
break;
default:
printk("%s: invalid pes type %u\n",__func__, dvbdmxfeed->pes_type);
printk(KERN_ERR "%s: invalid pes type %u\n",
__func__, dvbdmxfeed->pes_type);
return -EINVAL;
}
} else {
@ -118,7 +131,7 @@ int firesat_start_feed(struct dvb_demux_feed *dvbdmxfeed)
}
if (!channel) {
printk("%s: busy!\n", __func__);
printk(KERN_ERR "%s: busy!\n", __func__);
return -EBUSY;
}
@ -131,22 +144,23 @@ int firesat_start_feed(struct dvb_demux_feed *dvbdmxfeed)
if (firesat_channel_collect(firesat, &pidc, pids)) {
firesat_channel_release(firesat, channel);
printk(KERN_ERR "%s: could not collect pids!\n", __func__);
return -EINTR;
}
if(dvbdmxfeed->pid == 8192) {
if((k=AVCTuner_GetTS(firesat))) {
if((k = AVCTuner_GetTS(firesat))) {
firesat_channel_release(firesat, channel);
printk("%s: AVCTuner_GetTS failed with error %d\n",
__func__,k);
__func__, k);
return k;
}
}
else {
if((k=AVCTuner_SetPIDs(firesat, pidc, pids))) {
if((k = AVCTuner_SetPIDs(firesat, pidc, pids))) {
firesat_channel_release(firesat, channel);
printk("%s: AVCTuner_SetPIDs failed with error %d\n",
__func__,k);
__func__, k);
return k;
}
}
@ -161,7 +175,7 @@ int firesat_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
int k, l = 0;
u16 pids[16];
printk(KERN_INFO "%s (pid %u)\n", __func__, dvbdmxfeed->pid);
//printk(KERN_INFO "%s (pid %u)\n", __func__, dvbdmxfeed->pid);
if (dvbdmxfeed->type == DMX_TYPE_TS && !((dvbdmxfeed->ts_type & TS_PACKET) &&
(demux->dmx.frontend->source != DMX_MEMORY_FE))) {
@ -189,12 +203,13 @@ int firesat_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
// list except channel to be removed
for (k = 0; k < 16; k++)
if (firesat->channel[k].active == 1)
if (firesat->channel[k].active == 1) {
if (&firesat->channel[k] !=
(struct firesat_channel *)dvbdmxfeed->priv)
pids[l++] = firesat->channel[k].pid;
else
firesat->channel[k].active = 0;
}
if ((k = AVCTuner_SetPIDs(firesat, l, pids))) {
up(&firesat->demux_sem);
@ -214,8 +229,6 @@ int firesat_dvbdev_init(struct firesat *firesat,
{
int result;
firesat->has_ci = 1; // TEMP workaround
#if 0
switch (firesat->type) {
case FireSAT_DVB_S:
@ -254,7 +267,7 @@ int firesat_dvbdev_init(struct firesat *firesat,
return -ENOMEM;
}
if ((result = dvb_register_adapter(firesat->adapter,
if ((result = DVB_REGISTER_ADAPTER(firesat->adapter,
firesat->model_name,
THIS_MODULE,
dev, adapter_nr)) < 0) {
@ -271,6 +284,7 @@ int firesat_dvbdev_init(struct firesat *firesat,
return result;
}
memset(&firesat->demux, 0, sizeof(struct dvb_demux));
firesat->demux.dmx.capabilities = 0/*DMX_TS_FILTERING | DMX_SECTION_FILTERING*/;
firesat->demux.priv = (void *)firesat;
@ -343,8 +357,9 @@ int firesat_dvbdev_init(struct firesat *firesat,
return result;
}
if (firesat->has_ci)
firesat_ca_init(firesat);
return 0;
}

View File

@ -1,3 +1,15 @@
/*
* FireSAT DVB driver
*
* Copyright (c) ?
* Copyright (c) 2008 Henrik Kurelid <henrik@kurelid.se>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*/
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/wait.h>
@ -6,7 +18,6 @@
#include <linux/time.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/semaphore.h>
#include <ieee1394_hotplug.h>
#include <nodemgr.h>
#include <highlevel.h>
@ -22,22 +33,29 @@
static int firesat_dvb_init(struct dvb_frontend *fe)
{
int result;
struct firesat *firesat = fe->sec_priv;
printk("fdi: 1\n");
// printk("fdi: 1\n");
firesat->isochannel = firesat->adapter->num; //<< 1 | (firesat->subunit & 0x1); // ### ask IRM
printk("fdi: 2\n");
try_CMPEstablishPPconnection(firesat, firesat->subunit, firesat->isochannel);
printk("fdi: 3\n");
//FIXME hpsb_listen_channel(&firesat_highlevel, firesat->host, firesat->isochannel);
printk("fdi: 4\n");
return 0;
// printk("fdi: 2\n");
result = try_CMPEstablishPPconnection(firesat, firesat->subunit, firesat->isochannel);
if (result != 0) {
printk(KERN_ERR "Could not establish point to point "
"connection.\n");
return -1;
}
// printk("fdi: 3\n");
result = setup_iso_channel(firesat);
// printk("fdi: 4. Result was %d\n", result);
return result;
}
static int firesat_sleep(struct dvb_frontend *fe)
{
struct firesat *firesat = fe->sec_priv;
//FIXME hpsb_unlisten_channel(&firesat_highlevel, firesat->host, firesat->isochannel);
tear_down_iso_channel(firesat);
try_CMPBreakPPconnection(firesat, firesat->subunit, firesat->isochannel);
firesat->isochannel = -1;
return 0;
@ -83,19 +101,20 @@ static int firesat_read_status (struct dvb_frontend *fe, fe_status_t *status)
if (AVCTunerStatus(firesat, &info))
return -EINVAL;
if (info.NoRF)
if (info.NoRF) {
*status = 0;
else
*status = *status = FE_HAS_SIGNAL |
FE_HAS_VITERBI |
FE_HAS_SYNC |
FE_HAS_CARRIER |
FE_HAS_LOCK;
} else {
*status = FE_HAS_SIGNAL |
FE_HAS_VITERBI |
FE_HAS_SYNC |
FE_HAS_CARRIER |
FE_HAS_LOCK;
}
return 0;
}
static int firesat_read_ber (struct dvb_frontend *fe, u32 *ber)
static int firesat_read_ber(struct dvb_frontend *fe, u32 *ber)
{
struct firesat *firesat = fe->sec_priv;
ANTENNA_INPUT_INFO info;
@ -103,10 +122,10 @@ static int firesat_read_ber (struct dvb_frontend *fe, u32 *ber)
if (AVCTunerStatus(firesat, &info))
return -EINVAL;
*ber = ((info.BER[0] << 24) & 0xff) |
((info.BER[1] << 16) & 0xff) |
((info.BER[2] << 8) & 0xff) |
(info.BER[3] & 0xff);
*ber = (info.BER[0] << 24) |
(info.BER[1] << 16) |
(info.BER[2] << 8) |
info.BER[3];
return 0;
}
@ -115,19 +134,29 @@ static int firesat_read_signal_strength (struct dvb_frontend *fe, u16 *strength)
{
struct firesat *firesat = fe->sec_priv;
ANTENNA_INPUT_INFO info;
u16 *signal = strength;
if (AVCTunerStatus(firesat, &info))
return -EINVAL;
*signal = info.SignalStrength;
*strength = info.SignalStrength << 8;
return 0;
}
static int firesat_read_snr(struct dvb_frontend *fe, u16 *snr)
{
return -EOPNOTSUPP;
struct firesat *firesat = fe->sec_priv;
ANTENNA_INPUT_INFO info;
if (AVCTunerStatus(firesat, &info))
return -EINVAL;
*snr = (info.CarrierNoiseRatio[0] << 8) +
info.CarrierNoiseRatio[1];
*snr *= 257;
// C/N[dB] = -10 * log10(snr / 65535)
return 0;
}
static int firesat_read_uncorrected_blocks(struct dvb_frontend *fe, u32 *ucblocks)
@ -192,14 +221,13 @@ int firesat_frontend_attach(struct firesat *firesat, struct dvb_frontend *fe)
firesat->frontend_info = &firesat_T_frontend_info;
break;
default:
// printk("%s: unknown model type 0x%x on subunit %d!\n",
// __func__, firesat->type,subunit);
printk("%s: unknown model type 0x%x !\n",
__func__, firesat->type);
firesat->model_name = "Unknown";
firesat->frontend_info = NULL;
}
fe->ops = firesat_ops;
fe->ops.info = *(firesat->frontend_info);
fe->dvb = firesat->adapter;
return 0;

View File

@ -0,0 +1,106 @@
/*
* FireSAT DVB driver
*
* Copyright (c) 2008 Henrik Kurelid <henrik@kurelid.se>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*/
#include "firesat.h"
static void rawiso_activity_cb(struct hpsb_iso *iso);
void tear_down_iso_channel(struct firesat *firesat)
{
if (firesat->iso_handle != NULL) {
hpsb_iso_stop(firesat->iso_handle);
hpsb_iso_shutdown(firesat->iso_handle);
}
firesat->iso_handle = NULL;
}
int setup_iso_channel(struct firesat *firesat)
{
int result;
firesat->iso_handle =
hpsb_iso_recv_init(firesat->host,
256 * 200, //data_buf_size,
256, //buf_packets,
firesat->isochannel,
HPSB_ISO_DMA_DEFAULT, //dma_mode,
-1, //stat.config.irq_interval,
rawiso_activity_cb);
if (firesat->iso_handle == NULL) {
printk(KERN_ERR "Cannot initialize iso receive.\n");
return -EINVAL;
}
result = hpsb_iso_recv_start(firesat->iso_handle, -1, -1, 0);
if (result != 0) {
printk(KERN_ERR "Cannot start iso receive.\n");
return -EINVAL;
}
return 0;
}
static void rawiso_activity_cb(struct hpsb_iso *iso)
{
unsigned int num;
unsigned int i;
/* unsigned int j; */
unsigned int packet;
unsigned long flags;
struct firesat *firesat = NULL;
struct firesat *firesat_iterator;
spin_lock_irqsave(&firesat_list_lock, flags);
list_for_each_entry(firesat_iterator, &firesat_list, list) {
if(firesat_iterator->iso_handle == iso) {
firesat = firesat_iterator;
break;
}
}
spin_unlock_irqrestore(&firesat_list_lock, flags);
if (firesat) {
packet = iso->first_packet;
num = hpsb_iso_n_ready(iso);
for (i = 0; i < num; i++,
packet = (packet + 1) % iso->buf_packets) {
unsigned char *buf =
dma_region_i(&iso->data_buf, unsigned char,
iso->infos[packet].offset +
sizeof(struct CIPHeader));
int count = (iso->infos[packet].len -
sizeof(struct CIPHeader)) /
(188 + sizeof(struct firewireheader));
if (iso->infos[packet].len <= sizeof(struct CIPHeader))
continue; // ignore empty packet
/* printk("%s: Handling packets (%d): ", __func__, */
/* iso->infos[packet].len); */
/* for (j = 0; j < iso->infos[packet].len - */
/* sizeof(struct CIPHeader); j++) */
/* printk("%02X,", buf[j]); */
/* printk("\n"); */
while (count --) {
if (buf[sizeof(struct firewireheader)] == 0x47)
dvb_dmx_swfilter_packets(&firesat->demux,
&buf[sizeof(struct firewireheader)], 1);
else
printk("%s: invalid packet, skipping\n", __func__);
buf += 188 + sizeof(struct firewireheader);
}
}
hpsb_iso_recv_release_packets(iso, num);
}
else {
printk("%s: packets for unknown iso channel, skipping\n",
__func__);
hpsb_iso_recv_release_packets(iso, hpsb_iso_n_ready(iso));
}
}