static ssize_t mv_trace_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len)
{
const char *name = attr->attr.name;
int err = 0;
unsigned int a, b;
if (!capable(CAP_NET_ADMIN))
return -EPERM;
/* Read arguments */
sscanf(buf, "%x %x", &a, &b);
if (!strcmp(name, "start")) {
if (a)
TRC_START();
else
TRC_STOP();
} else if (!strcmp(name, "mode"))
TRC_MODE(a);
else if (!strcmp(name, "dump"))
TRC_OUTPUT(a, b);
else {
printk(KERN_ERR "%s: illegal operation <%s>\n", __func__, attr->attr.name);
err = -EINVAL;
}
return err ? -EINVAL : len;
}
void tdm_if_exit(void)
{
/* Check if already stopped */
if(!irq_init && !pcm_enable && !tdm_init)
return;
TRC_REC("->%s\n",__FUNCTION__);
if(irq_init) {
/* Release IRQ */
free_irq(irqnr, NULL);
irq_init = 0;
}
/* Stop PCM data sampling */
if(pcm_enable)
tdm_if_pcm_stop();
if(tdm_init) {
#ifdef CONFIG_MV_TDM_SUPPORT
mvTdmRelease();
#else
mvCommUnitRelease();
#endif
tdm_init = 0;
}
/* Remove proc directory & entries */
remove_proc_entry("tdm_init", tdm_stats);
remove_proc_entry("rx_miss", tdm_stats);
remove_proc_entry("tx_miss", tdm_stats);
remove_proc_entry("rx_over", tdm_stats);
remove_proc_entry("tx_under", tdm_stats);
remove_proc_entry("tdm", NULL);
TRC_REC("<-%s\n",__FUNCTION__);
TRC_OUTPUT();
TRC_RELEASE();
}
static int mp_close(struct inode *inode, struct file *file_p)
{
MV_PHONE *mp = file_p->private_data;
printk("Closing Marvell phone%d device\n",mp->ch);
TRC_REC("->%s ch%d\n",__FUNCTION__,mp->ch);
mvTdmChStop(mp->ch_info);
free_irq(mp->irq, mp);
if (file_p->f_mode & FMODE_READ)
mp->readers--;
if (file_p->f_mode & FMODE_WRITE)
mp->writers--;
file_p->private_data = NULL;
TRC_REC("<-%s\n",__FUNCTION__);
TRC_OUTPUT();
return 0;
}
static void __exit mp_exit(void)
{
MV_PHONE *mp;
int i;
TRC_REC("->%s\n",__FUNCTION__);
for(i=0; i<MV_TDM_MAX_CHANNELS; i++) {
TRC_REC("ch%d remove\n",i);
mp = get_mp(i);
mvTdmChRemove(mp->ch_info);
mp->irq = 0;
mp->p.f_op = NULL;
mp->p.open = NULL;
mp->p.board = 0;
phone_unregister_device(&mp->p);
printk("phone%d removed\n",i);
}
TRC_REC("<-%s\n",__FUNCTION__);
TRC_OUTPUT();
TRC_RELEASE();
}
MV_STATUS mvCesaIfReadyGet(MV_U8 chan, MV_CESA_RESULT *pResult)
{
MV_STATUS status;
MV_CESA_RESULT *pRes = NULL;
/* Skip policy handling for single channel */
if(MV_CESA_CHANNELS == 1)
return mvCesaReadyGet(chan, pResult);
while(MV_TRUE) {
if(readyStatus[chan] == MV_FALSE)
break;
pRes = &resQueue[reqEmpty];
/* Get next request */
status = mvCesaReadyGet(chan, pRes);
if(status != MV_OK) {
readyStatus[chan] = MV_FALSE;
break;
}
switch(currCesaPolicy) {
case CESA_WEIGHTED_CHAN_POLICY:
case CESA_NULL_POLICY:
chanWeight[chan] -= pRes->mbufSize;
break;
case CESA_FLOW_ASSOC_CHAN_POLICY:
/* TBD - handle policy */
break;
case CESA_SINGLE_CHAN_POLICY:
break;
default:
mvOsPrintf("%s: Error, policy not supported\n", __func__);
return MV_ERROR;
}
if(pResQueue[pRes->reqId] != NULL) {
mvOsPrintf("%s: Warning, results queue entry is being override(reqId=%d)\n", __func__, pRes->reqId);
TRC_OUTPUT();
}
pResQueue[pRes->reqId] = pRes;
reqEmpty = ((reqEmpty+1) % resQueueDepth);
}
if(pResQueue[currReqId] == NULL) {
readyStatus[chan] = MV_TRUE;
return MV_NOT_READY;
}
else {
/* Release results in order */
readyStatus[chan] = MV_FALSE;
/*memcpy(pResult, pResQueue[currReqId], sizeof(MV_CESA_RESULT));*/
pResult->retCode = ((MV_CESA_RESULT*)pResQueue[currReqId])->retCode;
pResult->pReqPrv = ((MV_CESA_RESULT*)pResQueue[currReqId])->pReqPrv;
pResult->sessionId = ((MV_CESA_RESULT*)pResQueue[currReqId])->sessionId;
pResult->mbufSize = ((MV_CESA_RESULT*)pResQueue[currReqId])->mbufSize;
pResult->reqId = ((MV_CESA_RESULT*)pResQueue[currReqId])->reqId;
pResQueue[currReqId] = NULL;
currReqId = ((currReqId+1) % resQueueDepth);
return MV_OK;
}
}
