source: tools/oebuild/data/pti_np/pti_hal.c @ 45168

Last change on this file since 45168 was 45168, checked in by obi, 19 months ago

add oebuild building files

  • Property svn:executable set to *
File size: 51.9 KB
Line 
1/*
2 * indent -bl -bli0 -cdb -sc -bap -bad -pcs -prs -bls -lp -npsl -bbb
3 *
4 * Hardware Abstraction Layer for our pti driver
5 *
6 *                Session
7 *                   |
8 *                   |
9 *          Slot1 ...... SlotN
10 *            | (N:1)      | (N:1)
11 *            |            |
12 *           DMA      Descrambler
13 *         
14 * Currently Missing is the presentation of multiple ptis
15 * as for 7109 architecture. Must think on this ;-)
16 */
17
18/* FIXME:
19 * - Da wir nur noch einen Buffer pro Session benutzen kann Session Loop eigentlich
20 * bei buffer sachen raus
21 * - Descrambler sind auch nicht wirklich pro Slot ?!; muss ich noch einbauen
22 */
23#include <linux/init.h>
24#include <linux/slab.h>
25#include <linux/wait.h>
26#include <linux/module.h>
27#include <linux/usb.h>
28#include <linux/delay.h>
29#include <linux/time.h>
30#include <linux/errno.h>
31
32#include <linux/version.h>
33
34#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
35#include <linux/semaphore.h>
36#else
37#include <asm/semaphore.h>
38#endif
39#include <linux/platform_device.h>
40#include <linux/mutex.h>
41
42#include <asm/io.h>
43#if defined (CONFIG_KERNELVERSION) || LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
44#include <linux/bpa2.h>
45#else
46#include <linux/bigphysarea.h>
47#endif
48#include <dvb_demux.h>
49
50/* fixme: this one is still sucking */
51#include "../player2/linux/drivers/media/dvb/stm/dvb/dvb_module.h"
52
53#include "pti_hal.h"
54#include "pti.h"
55#include "pti_main.h"
56#include "pti_session.h"
57#include "pti_slot.h"
58#include "pti_buffer.h"
59#include "pti_descrambler.h"
60
61extern void setDmaThreshold(int a, int b);
62
63/* ********************************
64 * Definitions
65 */
66
67#define SessionHandleStart 10000
68#define SlotHandleStart 20000
69#define DMAHandleStart 30000 /* DMA Handle = Buffer Handle */
70#define DescramblerHandleStart 40000
71
72/* fixme: bringt e2 zum haengen
73 * mal mit spin lock probieren?!
74 */
75#undef use_hal_mutex
76
77/* ********************************
78 * Global Vars
79 */
80
81static int numberOfAvailableDMAs = 0;
82static int numberOfAvailableSlots = 0;
83static int numberOfAvailableCarousels = 0; /* not used */
84static int numberOfAvailableSectionFilter = 0;
85static int numberOfAvailableSessions = 0;
86static int numberOfAvailableSectionIndex = 0;
87static int numberOfAvailableDescramblerKeys = 0;
88
89/* fixme: hacky ->think about this */
90void (*demultiplexDvbPackets)(struct dvb_demux *demux, const u8 *buf, int count) = NULL;
91struct stpti *pti = NULL;
92
93#define AUD_BUF_SIZE (128 * 188)
94#define MISC_BUF_SIZE (256 * 188)
95
96#define AUD_BUF_NUM 10
97#define MISC_BUF_NUM 3
98
99extern int videoMem;
100// see TC_Params_p->TC_NumberDMAs
101int max_pti_dma = 0X0037;
102
103static int BufferSizes[] =
104{
105        0
106};
107
108static int BufferCounts[] =
109{
110        1
111};
112
113/* ********************************
114 * Structures
115 */
116
117struct tSlot
118{
119        int Handle; /* Our Handle */
120
121        u32 TCIndex; /* Index in the TC Structure */
122
123        int inUse;
124
125        int SessionHandle; /* Our Session Handle */
126        struct tBuffer *pBuffer; /* Our Buffer/DMA Handle if linked */
127        int DescramblerHandle; /* Our Descrambler Handle if linked */
128
129        u16 pid; /* Current set pid */
130
131        int dvb_type; /* linuxDVB Type */
132        int dvb_pes_type; /* linuxDVB pes Type */
133
134        struct dvb_demux *demux; /* linuxDVB Demuxer */
135
136        struct StreamContext_s *DemuxStream;
137        struct DeviceContext_s *DeviceContext;
138
139};
140
141struct tDescrambler
142{
143        int Handle; /* Our Handle */
144
145        u32 TCIndex; /* Index in the TC Structure */
146
147        int inUse;
148
149        int SlotHandle; /* Our Slot Handle if linked */
150
151};
152
153struct tSession
154{
155        int Handle; /* Our Handle */
156
157        u32 TCIndex; /* Index in the TC Structure */
158        u32 TSMergerTag;
159        u32 OldTSMergerTag;
160
161        int inUse;
162
163        struct tSlot **vSlots;
164        struct tDescrambler **vDescrambler;
165
166        struct tBuffer *pBufferList;
167};
168
169static struct tSession **vSessions = NULL;
170
171#ifdef use_hal_mutex
172
173/* fixme: hatte vor das ganze mal mit spinlocks zu testen
174 * deshalb hier mit eigenen funktionen
175 */
176
177static struct mutex HALLock;
178
179int hal_mutex_lock(struct mutex *lock)
180{
181        mutex_lock(lock);
182}
183
184int hal_mutex_unlock(struct mutex *lock)
185{
186        mutex_unlock(lock);
187}
188
189#endif
190
191static int pti_hal_convert_source(const tInputSource source, int *pTag);
192
193/* **************************************************************
194 * Intialize our data structures depening on TC-Code. For this
195 * reason we call pti_main_loadtc() here.
196 */
197void pti_hal_init(struct stpti *pti , struct dvb_demux *demux, void (*_demultiplexDvbPackets)(struct dvb_demux *demux, const u8 *buf, int count), int numVideoBuffers)
198{
199        STPTI_TCParameters_t *TC_Params_p = &tc_params;
200        int vLoopSession, vLoopSlots, vLoopDescrambler;
201        int i;
202        dprintk("%s >\n", __func__);
203        pti_main_loadtc(pti);
204        numberOfAvailableSessions = TC_Params_p->TC_NumberOfSessions;
205        numberOfAvailableCarousels = TC_Params_p->TC_NumberCarousels;
206        numberOfAvailableDMAs = TC_Params_p->TC_NumberDMAs;
207        numberOfAvailableDescramblerKeys =
208                TC_Params_p->TC_NumberDescramblerKeys / TC_Params_p->TC_NumberOfSessions;
209        numberOfAvailableSectionFilter = TC_Params_p->TC_NumberSectionFilters;
210        numberOfAvailableSlots =
211                TC_Params_p->TC_NumberSlots / TC_Params_p->TC_NumberOfSessions;
212        numberOfAvailableSectionIndex = TC_Params_p->TC_NumberIndexs;
213#ifdef use_hal_mutex
214        mutex_init(&HALLock);
215#endif
216        BufferCounts[0] = numVideoBuffers;
217        /* Dagobert: goHackHack: I would like to make the buffer adjustable,
218         * vor first glance I only make the videoBufferSize adjustable
219         * and assume it is on position 0 in this array!
220         */
221        BufferSizes[0] = videoMem * 188;
222        // calc the max dma buffers for pti_task
223        // use of static value (TC_Params_p->TC_NumberDMAs) needs performance
224        max_pti_dma = 0;
225        for (i = 0; i < sizeof(BufferCounts) / sizeof(BufferCounts[0]); i++)
226        {
227                max_pti_dma += BufferCounts[i];
228        }
229        printk("using videoMem = %d (packets = %d), max_dma %d\n", videoMem * 188, videoMem, max_pti_dma);
230        /* initialize the buffer pools */
231        pti_buffer_pool_init(sizeof(BufferSizes) / sizeof(BufferSizes[0]),
232                             BufferSizes, BufferCounts);
233        /*
234         * very memory wasting but I think its ok
235         */
236        vSessions =
237                kmalloc(sizeof(struct tSession *) * numberOfAvailableSessions,
238                        GFP_KERNEL);
239        for (vLoopSession = 0; vLoopSession < numberOfAvailableSessions;
240                        vLoopSession++)
241        {
242                vSessions[vLoopSession] =
243                        kmalloc(sizeof(struct tSession), GFP_KERNEL);
244                memset(vSessions[vLoopSession], 0, sizeof(struct tSession));
245                /*
246                 * set-up handle
247                 */
248                vSessions[vLoopSession]->Handle = SessionHandleStart + vLoopSession;
249                vSessions[vLoopSession]->TCIndex = vLoopSession;
250                vSessions[vLoopSession]->vSlots =
251                        kmalloc(sizeof(struct tSlot *) * numberOfAvailableSlots,
252                                GFP_KERNEL);
253                for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots; vLoopSlots++)
254                {
255                        vSessions[vLoopSession]->vSlots[vLoopSlots] =
256                                kmalloc(sizeof(struct tSlot), GFP_KERNEL);
257                        memset(vSessions[vLoopSession]->vSlots[vLoopSlots], 0,
258                               sizeof(struct tSlot));
259                        /*
260                         * set-up handles
261                         */
262                        vSessions[vLoopSession]->vSlots[vLoopSlots]->Handle =
263                                SlotHandleStart + vLoopSlots + (vLoopSession * 1000);
264                        /*
265                         * slots will be count globally from 0 to max
266                         */
267                        vSessions[vLoopSession]->vSlots[vLoopSlots]->TCIndex =
268                                vLoopSession * numberOfAvailableSlots + vLoopSlots;
269                }
270                vSessions[vLoopSession]->vDescrambler =
271                        kmalloc(sizeof(struct tDescrambler *) *
272                                numberOfAvailableDescramblerKeys, GFP_KERNEL);
273                for (vLoopDescrambler = 0;
274                                vLoopDescrambler < numberOfAvailableDescramblerKeys;
275                                vLoopDescrambler++)
276                {
277                        vSessions[vLoopSession]->vDescrambler[vLoopDescrambler] =
278                                kmalloc(sizeof(struct tDescrambler), GFP_KERNEL);
279                        memset(vSessions[vLoopSession]->vDescrambler[vLoopDescrambler], 0,
280                               sizeof(struct tDescrambler));
281                        /*
282                         * set-up handles
283                         */
284                        vSessions[vLoopSession]->vDescrambler[vLoopDescrambler]->Handle =
285                                DescramblerHandleStart + vLoopDescrambler + (vLoopSession * 1000);
286                        /*
287                         * descrambler will be count globally from 0 to max
288                         */
289                        vSessions[vLoopSession]->vDescrambler[vLoopDescrambler]->TCIndex =
290                                vLoopSession * numberOfAvailableDescramblerKeys + vLoopDescrambler;
291                }
292        }
293        demultiplexDvbPackets = _demultiplexDvbPackets;
294        // FIXME: remove
295        //pti_session_init ( STPTI_STREAM_ID_TSIN1, vSessions[0]->vSlots[0]->TCIndex,
296        // numberOfAvailableSlots );
297#ifdef use_irq
298        dprintk("%s !!!!!!!!!!!!! start irq !!!!!!!!!!!!!!!\n", __func__);
299        if (request_irq
300                        (160, pti_interrupt_handler, SA_INTERRUPT, "PTI", pti) != 0)
301        {
302                dprintk("request irq failed\n");
303        }
304        //enable the pti interrupt
305        {
306                TCDevice_t *myTC = (TCDevice_t *) pti->pti_io;
307                writel(3, (void *) &myTC->PTIIntEnable0);
308                //writel ( 0x7, pti->pti_io + PTI_DMAEMPTY_EN );
309        }
310#endif
311        spin_lock_init(&pti->irq_lock);
312        kernel_thread(pti_task, pti, 0);
313        pti_hal_descrambler_set_null();
314        dprintk("%s <\n", __func__);
315}
316
317/* *************************************************************
318 * Helper Functions for Sessions
319 */
320
321/* *********************************
322 * Get a new session handle.
323 * pti_hal_init must be called before.
324 *
325 * O: Errorcode or session handle
326 */
327int pti_hal_get_new_session_handle(tInputSource source, struct dvb_demux *demux)
328{
329        int session_handle = cHALNoFreeSession;
330        int vLoopSessions;
331        int srcTag = 0;
332        dprintk("%s >\n", __func__);
333        if (vSessions == NULL)
334                return cHALNotInitialized;
335        if (pti_hal_convert_source(source, &srcTag) != 0)
336        {
337                return cHALNotInitialized;
338        }
339#ifdef use_hal_mutex
340        hal_mutext_lock(&(HALLock));
341#endif
342        // FIXME: start with 0
343        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
344                        vLoopSessions++)
345        {
346                if (vSessions[vLoopSessions]->inUse == 0)
347                {
348                        session_handle = vSessions[vLoopSessions]->Handle;
349                        vSessions[vLoopSessions]->inUse = 1;
350                        vSessions[vLoopSessions]->TSMergerTag = STPTI_STREAM_ID_NONE;
351                        vSessions[vLoopSessions]->OldTSMergerTag = STPTI_STREAM_ID_NONE;
352                        vSessions[vLoopSessions]->TCIndex =
353                                pti_session_init(STPTI_STREAM_ID_NONE, //STPTI_STREAM_ID_TSIN0 + vLoopSessions,
354                                                 vSessions[vLoopSessions]->vSlots[0]->TCIndex,
355                                                 numberOfAvailableSlots);
356                        /*
357                         * this should never happen!
358                         */
359                        if (vSessions[vLoopSessions]->TCIndex == -1)
360                        {
361                                vSessions[vLoopSessions]->inUse = 0;
362                                session_handle = cHALNoFreeSession;
363                        }
364                        break;
365                }
366        }
367#ifdef use_hal_mutex
368        hal_mutex_unlock(&(HALLock));
369#endif
370        dprintk("%s (%d) <\n", __func__, session_handle);
371        return session_handle;
372}
373
374int pti_hal_get_session_handle(int tc_session_number)
375{
376        int session_handle = cHALNotInitialized;
377        int vLoopSessions;
378//      dprintk("%s >\n", __func__);
379        if (vSessions == NULL)
380                return cHALNotInitialized;
381#ifdef use_hal_mutex
382        mutex_lock(&(HALLock));
383#endif
384        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
385                        vLoopSessions++)
386        {
387                if ((vSessions[vLoopSessions]->inUse == 1)
388                                && (vSessions[vLoopSessions]->TCIndex == tc_session_number))
389                {
390                        session_handle = vSessions[vLoopSessions]->Handle;
391                        break;
392                }
393        }
394//      dprintk("%s (%d)<\n", __func__, session_handle);
395#ifdef use_hal_mutex
396        mutex_unlock(&(HALLock));
397#endif
398        return session_handle;
399}
400
401/* **************************************
402 * Die Slots sind zwar global definiert
403 * aber auf die Sessions aufgeteilt,
404 * so koennen wir bestimmen wie die
405 * interne session nummer ist.
406 */
407int pti_hal_get_session_number_from_tc_slot_number(int tc_slot_number)
408{
409        int tc_session_number = cHALNotInitialized;
410        int vLoopSessions, vLoopSlots;
411//      dprintk("%s >\n", __func__);
412        if (vSessions == NULL)
413                return cHALNotInitialized;
414#ifdef use_hal_mutex
415        mutex_lock(&(HALLock));
416#endif
417        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
418                        vLoopSessions++)
419        {
420                if (vSessions[vLoopSessions]->inUse == 1)
421                {
422                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
423                                        vLoopSlots++)
424                        {
425                                if ((vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse == 1) &&
426                                                (vSessions[vLoopSessions]->vSlots[vLoopSlots]->TCIndex ==
427                                                 tc_slot_number))
428                                {
429                                        tc_session_number = vSessions[vLoopSessions]->TCIndex;
430                                        break;
431                                }
432                        }
433                }
434        }
435//      dprintk("%s (%d) <\n", __func__, tc_session_number);
436#ifdef use_hal_mutex
437        mutex_unlock(&(HALLock));
438#endif
439        return tc_session_number;
440}
441
442struct dvb_demux *pti_hal_get_demux_from_dma_index(int dmaIndex)
443{
444        int vLoopSessions;
445        int vLoopSlots;
446        struct dvb_demux *pDemux = NULL;
447        if (vSessions == NULL)
448                return NULL;
449#ifdef use_hal_mutex
450        mutex_lock(&(HALLock));
451#endif
452        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
453                        vLoopSessions++)
454        {
455                if (vSessions[vLoopSessions]->inUse == 1)
456                {
457                        struct tBuffer *pBuffer = vSessions[vLoopSessions]->pBufferList;
458                        /* find the buffer assigned to the specified DMA */
459                        while (pBuffer != NULL)
460                        {
461                                if (pBuffer->dmaIndex == dmaIndex)
462                                {
463                                        /* all slots of a session must be assigned to the same demux,
464                                         so take the demux from the first valid slot */
465                                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
466                                                        vLoopSlots++)
467                                        {
468                                                if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse == 1)
469                                                {
470                                                        pDemux = vSessions[vLoopSessions]->vSlots[vLoopSlots]->demux;
471                                                        break;
472                                                }
473                                        }
474                                }
475                                pBuffer = pBuffer->pNext;
476                        }
477                        if (pDemux != NULL)
478                                break;
479                }
480        }
481#ifdef use_hal_mutex
482        mutex_unlock(&(HALLock));
483#endif
484        return pDemux;
485}
486
487int pti_hal_free_session(int session_handle)
488{
489        /* fixme: free all slots, dmas ... */
490        printk("FIXME: %s not implemented currently \n", __func__);
491        return -1;
492}
493
494/* *************************************************************
495 *
496 * Helper function for setting the session source (frontend)
497 *
498 *************************************************************/
499static int pti_hal_convert_source(const tInputSource source, int *pTag)
500{
501        *pTag = source + STPTI_STREAM_ID_TSIN0;
502        return 0;
503}
504
505int pti_hal_set_source(int session_handle, const tInputSource source)
506{
507        int i;
508        int tsmerger_tag = 0;
509        if (pti_hal_convert_source(source, &tsmerger_tag) != 0)
510        {
511                return -EINVAL;
512        }
513        for (i = 0; i < numberOfAvailableSessions; i++)
514        {
515                if (vSessions[i]->Handle == session_handle)
516                {
517                        pti_session_set_source(vSessions[i]->TCIndex, tsmerger_tag);
518                        vSessions[i]->TSMergerTag = tsmerger_tag;
519                        vSessions[i]->OldTSMergerTag = tsmerger_tag;
520                        printk("%s(): %d, %d\n", __func__, vSessions[i]->TCIndex, tsmerger_tag);
521                        break;
522                }
523        }
524        if (i == numberOfAvailableSessions)
525        {
526                printk("%s(): invalid session (%x)\n", __func__, session_handle);
527                return -EINVAL;
528        }
529        return 0;
530}
531
532/* *************************************************************
533 * Helper Functions for Slots
534 */
535int pti_hal_get_new_slot_handle(int session_handle, int dvb_type,
536                                int dvb_pes_type, struct dvb_demux *demux,
537                                void * /*struct DvbStreamContext_s or struct StreamContext_s*/ DemuxStream,
538                                struct DeviceContext_s *DeviceContext)
539{
540        int slot_handle = cHALNotInitialized;
541        int noFree = 0;
542        int vLoopSessions, vLoopSlots;
543        int numSlotsInUse = 0;
544#if defined(PLAYER228)
545        struct DvbStreamContext_s *DemuxStreamContext = DemuxStream;
546#else
547        struct StreamContext_s *DemuxStreamContext = DemuxStream;
548#endif
549        dprintk("%s >\n", __func__);
550        if (vSessions == NULL)
551                return cHALNotInitialized;
552#ifdef use_hal_mutex
553        mutex_lock(&(HALLock));
554#endif
555        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions; vLoopSessions++)
556        {
557                if (vSessions[vLoopSessions]->Handle == session_handle)
558                {
559                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
560                                        vLoopSlots++)
561                        {
562                                if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse)
563                                        numSlotsInUse++;
564                        }
565                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
566                                        vLoopSlots++)
567                        {
568                                if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse == 0)
569                                {
570                                        slot_handle = vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle;
571                                        pti_slot_allocate(vSessions[vLoopSessions]->vSlots[vLoopSlots]->
572                                                          TCIndex, dvb_type, dvb_pes_type);
573                                        /*
574                                         * this should never happen
575                                         */
576                                        if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->TCIndex == -1)
577                                        {
578                                                slot_handle = cHALNoFreeSlot;
579                                        }
580                                        else
581                                        {
582                                                vSessions[vLoopSessions]->vSlots[vLoopSlots]->demux = demux;
583                                                vSessions[vLoopSessions]->vSlots[vLoopSlots]->DemuxStream = DemuxStreamContext;
584                                                vSessions[vLoopSessions]->vSlots[vLoopSlots]->DeviceContext = DeviceContext;
585                                                vSessions[vLoopSessions]->vSlots[vLoopSlots]->dvb_type = dvb_type;
586                                                vSessions[vLoopSessions]->vSlots[vLoopSlots]->dvb_pes_type = dvb_pes_type;
587                                                vSessions[vLoopSessions]->vSlots[vLoopSlots]->SessionHandle = vSessions[vLoopSessions]->Handle;
588                                                vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse = 1;
589                                        }
590                                        if (numSlotsInUse == 0) /* then this is first again */
591                                        {
592                                                if ((vSessions[vLoopSessions]->OldTSMergerTag != vSessions[vLoopSessions]->TSMergerTag) &&
593                                                                (vSessions[vLoopSessions]->OldTSMergerTag != STPTI_STREAM_ID_NONE))
594                                                {
595                                                        vSessions[vLoopSessions]->TSMergerTag = vSessions[vLoopSessions]->OldTSMergerTag;
596                                                        pti_session_set_source(vSessions[vLoopSessions]->TCIndex, vSessions[vLoopSessions]->OldTSMergerTag);
597                                                        printk("*********** automatic set stream id to %d for Session %d-%d\n", vSessions[vLoopSessions]->OldTSMergerTag, vLoopSessions, vSessions[vLoopSessions]->TCIndex);
598                                                }
599                                                //printk("old tag %d, new tag %d numinuse %d\n", vSessions[vLoopSessions]->OldTSMergerTag, vSessions[vLoopSessions]->TSMergerTag, numSlotsInUse);
600                                        }
601                                        noFree = 1;
602                                        break;
603                                }
604                        } /* for slots */
605                        if (noFree == 0)
606                                slot_handle = cHALNoFreeSlot;
607                }
608        } /* for sessions */
609        dprintk("%s (%d) <\n", __func__, slot_handle);
610#ifdef use_hal_mutex
611        mutex_unlock(&(HALLock));
612#endif
613        return slot_handle;
614}
615
616int pti_hal_slot_set_pid(int session_handle, int slot_handle, u16 pid)
617{
618        int error = cHALNotInitialized;
619        int vLoopSessions, vLoopSlots;
620        dprintk("%s >\n", __func__);
621        if (vSessions == NULL)
622                return cHALNotInitialized;
623#ifdef use_hal_mutex
624        mutex_lock(&(HALLock));
625#endif
626        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
627                        vLoopSessions++)
628        {
629                if (vSessions[vLoopSessions]->Handle == session_handle)
630                {
631                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
632                                        vLoopSlots++)
633                        {
634                                if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle ==
635                                                slot_handle)
636                                {
637                                        if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->
638                                                        DescramblerHandle != 0)
639                                        {
640                                                int vLoopDescrambler;
641                                                for (vLoopDescrambler = 0;
642                                                                vLoopDescrambler < numberOfAvailableDescramblerKeys;
643                                                                vLoopDescrambler++)
644                                                {
645                                                        if ((vSessions[vLoopSessions]->
646                                                                        vDescrambler[vLoopDescrambler]->Handle ==
647                                                                        vSessions[vLoopSessions]->vSlots[vLoopSlots]->
648                                                                        DescramblerHandle)
649                                                                        && (vSessions[vLoopSessions]->
650                                                                            vDescrambler[vLoopDescrambler]->inUse == 1))
651                                                        {
652                                                                //u8 Data[8] = {0,0,0,0,0,0,0,0};
653                                                                /*
654                                                                 * set descrambler invalid
655                                                                 * pti_descrambler_set(vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->TCIndex, 0, &Data[0]);
656                                                                 * pti_descrambler_set(vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->TCIndex, 1, &Data[0]);
657                                                                 */
658                                                        }
659                                                }
660                                        }
661                                        vSessions[vLoopSessions]->vSlots[vLoopSlots]->pid = pid;
662                                        pti_slot_set_pid(vSessions[vLoopSessions]->vSlots[vLoopSlots]->TCIndex, pid);
663                                        error = cHALNoError;
664                                        break;
665                                }
666                        } /* for slots */
667                }
668        } /* for sessions */
669        dprintk("%s (%d) <\n", __func__, error);
670#ifdef use_hal_mutex
671        mutex_unlock(&(HALLock));
672#endif
673        return error;
674}
675
676int pti_hal_slot_clear_pid(int session_handle, int slot_handle)
677{
678        int error = cHALNotInitialized;
679        int vLoopSessions, vLoopSlots;
680        if (vSessions == NULL)
681                return cHALNotInitialized;
682#ifdef use_hal_mutex
683        mutex_lock(&(HALLock));
684#endif
685        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
686                        vLoopSessions++)
687        {
688                if (vSessions[vLoopSessions]->Handle == session_handle)
689                {
690                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
691                                        vLoopSlots++)
692                        {
693                                if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle ==
694                                                slot_handle)
695                                {
696                                        if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->
697                                                        DescramblerHandle != 0)
698                                        {
699                                                int vLoopDescrambler;
700                                                for (vLoopDescrambler = 0;
701                                                                vLoopDescrambler < numberOfAvailableDescramblerKeys;
702                                                                vLoopDescrambler++)
703                                                {
704                                                        if ((vSessions[vLoopSessions]->
705                                                                        vDescrambler[vLoopDescrambler]->Handle ==
706                                                                        vSessions[vLoopSessions]->vSlots[vLoopSlots]->
707                                                                        DescramblerHandle)
708                                                                        && (vSessions[vLoopSessions]->
709                                                                            vDescrambler[vLoopDescrambler]->inUse == 1))
710                                                        {
711                                                                //u8 Data[8] = {0,0,0,0,0,0,0,0};
712                                                                /*
713                                                                 * set descrambler invalid
714                                                                 * pti_descrambler_set(vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->TCIndex, 0, &Data[0]);
715                                                                 * pti_descrambler_set(vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->TCIndex, 1, &Data[0]);
716                                                                 */
717                                                        }
718                                                }
719                                        }
720                                        vSessions[vLoopSessions]->vSlots[vLoopSlots]->pid = 0;
721                                        pti_slot_clear_pid(vSessions[vLoopSessions]->vSlots[vLoopSlots]->
722                                                           TCIndex,
723                                                           pti_hal_get_tc_dma_number(session_handle,
724                                                                                     slot_handle), 1);
725                                        error = cHALNoError;
726                                        break;
727                                }
728                        } /* for slots */
729                }
730        } /* for sessions */
731#ifdef use_hal_mutex
732        mutex_unlock(&(HALLock));
733#endif
734        return error;
735}
736
737int pti_hal_slot_link_buffer(int session_handle, int slot_handle,
738                             BUFFER_TYPE bufType)
739{
740        int error = cHALNotInitialized;
741        int vLoopSessions, vLoopSlots;
742        struct tBuffer *pBuffer = NULL;
743        int found = 0;
744        int allocated = 0;
745        dprintk("%s >\n", __func__);
746        if (vSessions == NULL)
747                return cHALNotInitialized;
748#ifdef use_hal_mutex
749        mutex_lock(&(HALLock));
750#endif
751        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
752                        vLoopSessions++)
753        {
754                if (vSessions[vLoopSessions]->Handle == session_handle)
755                {
756                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
757                                        vLoopSlots++)
758                        {
759                                if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle ==
760                                                slot_handle)
761                                {
762                                        if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->pBuffer !=
763                                                        NULL)
764                                        {
765                                                error = cHALSlotAlreadyInUse;
766                                        }
767                                        else
768                                        {
769                                                found = 1;
770                                                break;
771                                        }
772                                }
773                        }
774                        if (found)
775                                break;
776                }
777        }
778        if (found)
779        {
780#if defined(SEPARATE_MISC_BUFFERS)
781                /* SEC and TS types other than video and audio are
782                 collected in separate buffers */
783                if (bufType == MISC_BUFFER)
784                {
785                        pBuffer = pti_buffer_get(MISC_BUF_SIZE);
786                        allocated = 1;
787                }
788#endif
789#if defined(SEPARATE_AUDIO_BUFFERS)
790                /* audio TS packets are collected in separate buffers */
791                if (bufType == AUD_BUFFER)
792                {
793                        pBuffer = pti_buffer_get(AUD_BUF_SIZE);
794                        allocated = 1;
795                }
796#endif
797                if (pBuffer == NULL)
798                {
799                        /* no buffer found so far
800                         check whether a video buffer is already allocated */
801                        //if(bufType != VID_BUFFER)
802                        {
803                                pBuffer = vSessions[vLoopSessions]->pBufferList;
804                                while (pBuffer != NULL)
805                                {
806                                        if (pBuffer->bufSize == videoMem * 188)
807                                        {
808                                                break;
809                                        }
810                                        pBuffer = pBuffer->pNext;
811                                }
812                        }
813                        if (pBuffer == NULL)
814                        {
815                                /* no video buffer in the list yet */
816                                pBuffer = pti_buffer_get(videoMem * 188);
817                                allocated = 1;
818                        }
819                }
820                if (pBuffer == NULL)
821                {
822                        return error;
823                }
824                /* prepend the buffer to the list head */
825                if (allocated)
826                {
827                        pBuffer->pNext = vSessions[vLoopSessions]->pBufferList;
828                        vSessions[vLoopSessions]->pBufferList = pBuffer;
829                }
830                pBuffer->sessionHandle = session_handle;
831                if (bufType == VID_BUFFER)
832                {
833                        /* increase the DMA threshold to reduce the interrupt rate caused by
834                         the video stream */
835                        setDmaThreshold(pBuffer->dmaIndex, TC_DMA_THRESHOLD_HIGH);
836                }
837                pti_slot_link_to_buffer(vSessions[vLoopSessions]->
838                                        vSlots[vLoopSlots]->TCIndex,
839                                        pBuffer->dmaIndex);
840                pBuffer->slotCount++;
841                vSessions[vLoopSessions]->vSlots[vLoopSlots]->pBuffer = pBuffer;
842                error = cHALNoError;
843        }
844        dprintk("%s (%d) <\n", __func__, error);
845#ifdef use_hal_mutex
846        mutex_unlock(&(HALLock));
847#endif
848        return error;
849}
850
851int pti_hal_get_slot_handle(int session_handle, int tc_slot_number)
852{
853        int slot_handle = cHALNotInitialized;
854        int vLoopSessions, vLoopSlots;
855        if (vSessions == NULL)
856                return cHALNotInitialized;
857#ifdef use_hal_mutex
858        mutex_lock(&(HALLock));
859#endif
860        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
861                        vLoopSessions++)
862        {
863                if (vSessions[vLoopSessions]->Handle == session_handle)
864                {
865                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
866                                        vLoopSlots++)
867                        {
868                                if ((vSessions[vLoopSessions]->vSlots[vLoopSlots]->TCIndex ==
869                                                tc_slot_number)
870                                                && vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse == 1)
871                                {
872                                        slot_handle = vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle;
873                                        break;
874                                }
875                        }
876                }
877        }
878#ifdef use_hal_mutex
879        mutex_unlock(&(HALLock));
880#endif
881        return slot_handle;
882}
883
884struct dvb_demux *pti_hal_get_demux_from_slot(int session_handle,
885                                              int slot_handle)
886{
887        struct dvb_demux *demux = NULL;
888        int vLoopSessions, vLoopSlots;
889        if (vSessions == NULL)
890                return NULL;
891#ifdef use_hal_mutex
892        mutex_lock(&(HALLock));
893#endif
894        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
895                        vLoopSessions++)
896        {
897                if (vSessions[vLoopSessions]->Handle == session_handle)
898                {
899                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
900                                        vLoopSlots++)
901                        {
902                                if ((vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle ==
903                                                slot_handle)
904                                                && vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse == 1)
905                                {
906                                        demux = vSessions[vLoopSessions]->vSlots[vLoopSlots]->demux;
907                                        break;
908                                }
909                        }
910                }
911        }
912#ifdef use_hal_mutex
913        mutex_unlock(&(HALLock));
914#endif
915        return demux;
916}
917
918int pti_hal_get_type_from_slot(int session_handle, int slot_handle,
919                               int *ts_type, int *pes_type)
920{
921        int error = cHALNotInitialized;
922        int vLoopSessions, vLoopSlots;
923        if (vSessions == NULL)
924                return cHALNotInitialized;
925#ifdef use_hal_mutex
926        mutex_lock(&(HALLock));
927#endif
928        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
929                        vLoopSessions++)
930        {
931                if (vSessions[vLoopSessions]->Handle == session_handle)
932                {
933                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
934                                        vLoopSlots++)
935                        {
936                                if ((vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle ==
937                                                slot_handle)
938                                                && vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse == 1)
939                                {
940                                        *ts_type = vSessions[vLoopSessions]->vSlots[vLoopSlots]->dvb_type;
941                                        *pes_type =
942                                                vSessions[vLoopSessions]->vSlots[vLoopSlots]->dvb_pes_type;
943                                        error = cHALNoError;
944                                        break;
945                                }
946                        }
947                }
948        }
949#ifdef use_hal_mutex
950        mutex_unlock(&(HALLock));
951#endif
952        return error;
953}
954
955#if defined(PLAYER228)
956struct DvbStreamContext_s *pti_hal_get_stream_from_slot(int session_handle, int slot_handle)
957#else
958struct StreamContext_s *pti_hal_get_stream_from_slot(int session_handle, int slot_handle)
959#endif
960{
961#if defined(PLAYER228)
962        struct DvbStreamContext_s *stream = NULL;
963#else
964        struct StreamContext_s *stream = NULL;
965#endif
966        int vLoopSessions, vLoopSlots;
967        if (vSessions == NULL)
968                return NULL;
969#ifdef use_hal_mutex
970        mutex_lock(&(HALLock));
971#endif
972        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
973                        vLoopSessions++)
974        {
975                if (vSessions[vLoopSessions]->Handle == session_handle)
976                {
977                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
978                                        vLoopSlots++)
979                        {
980                                if ((vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle ==
981                                                slot_handle)
982                                                && vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse == 1)
983                                {
984                                        stream = vSessions[vLoopSessions]->vSlots[vLoopSlots]->DemuxStream;
985                                        break;
986                                }
987                        }
988                }
989        }
990#ifdef use_hal_mutex
991        mutex_unlock(&(HALLock));
992#endif
993        return stream;
994}
995
996struct DeviceContext_s *pti_hal_get_context_from_slot(int session_handle,
997                                                      int slot_handle)
998{
999        struct DeviceContext_s *context = NULL;
1000        int vLoopSessions, vLoopSlots;
1001        if (vSessions == NULL)
1002                return NULL;
1003#ifdef use_hal_mutex
1004        mutex_lock(&(HALLock));
1005#endif
1006        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
1007                        vLoopSessions++)
1008        {
1009                if (vSessions[vLoopSessions]->Handle == session_handle)
1010                {
1011                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
1012                                        vLoopSlots++)
1013                        {
1014                                if ((vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle ==
1015                                                slot_handle)
1016                                                && vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse == 1)
1017                                {
1018                                        context =
1019                                                vSessions[vLoopSessions]->vSlots[vLoopSlots]->DeviceContext;
1020                                        break;
1021                                }
1022                        }
1023                }
1024        }
1025#ifdef use_hal_mutex
1026        mutex_unlock(&(HALLock));
1027#endif
1028        return context;
1029}
1030
1031void pti_hal_get_slots_for_pid(int session_handle, u16 pid, int **slots,
1032                               int *number_slots)
1033{
1034        int vLoopSessions, vLoopSlots;
1035        if (vSessions == NULL)
1036                return;
1037#ifdef use_hal_mutex
1038        mutex_lock(&(HALLock));
1039#endif
1040        *slots = NULL;
1041        *number_slots = 0;
1042        //dprintk("%s >(session_handle %d, pid %d)\n", __func__,session_handle, pid);
1043        /*
1044         * I think in the kernel is no realloc so I first count the slots ;-)
1045         */
1046        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
1047                        vLoopSessions++)
1048        {
1049                if (vSessions[vLoopSessions]->Handle == session_handle)
1050                {
1051                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
1052                                        vLoopSlots++)
1053                        {
1054                                // dprintk("test pid = %d\n", vSessions[vLoopSessions]->vSlots[vLoopSlots]->pid);
1055                                if ((vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse == 1) &&
1056                                                (vSessions[vLoopSessions]->vSlots[vLoopSlots]->pid == pid))
1057                                {
1058                                        *number_slots += 1;
1059                                }
1060                        }
1061                }
1062        }
1063        if (*number_slots != 0)
1064        {
1065                int *vSlots;
1066                int count = 0;
1067                vSlots = kmalloc(sizeof(int) * *number_slots, GFP_KERNEL);
1068                for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
1069                                vLoopSessions++)
1070                {
1071                        if (vSessions[vLoopSessions]->Handle == session_handle)
1072                        {
1073                                for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
1074                                                vLoopSlots++)
1075                                {
1076                                        if ((vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse == 1) &&
1077                                                        (vSessions[vLoopSessions]->vSlots[vLoopSlots]->pid == pid))
1078                                        {
1079                                                vSlots[count++] =
1080                                                        vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle;
1081                                        }
1082                                }
1083                        }
1084                }
1085                if (count != *number_slots)
1086                        printk("something went wrong\n");
1087                /*
1088                 * remeber to free outside
1089                 */
1090                *slots = vSlots;
1091        }
1092#ifdef use_hal_mutex
1093        mutex_unlock(&(HALLock));
1094#endif
1095}
1096
1097int pti_hal_slot_unlink_buffer(int session_handle, int slot_handle)
1098{
1099        int error = cHALNotInitialized;
1100        int vLoopSessions, vLoopSlots;
1101        struct tBuffer *pBuffer = NULL;
1102        dprintk("%s > %x, %x, %p\n", __func__, session_handle, slot_handle,
1103                pBuffer);
1104        if (vSessions == NULL)
1105                return cHALNotInitialized;
1106#ifdef use_hal_mutex
1107        mutex_lock(&(HALLock));
1108#endif
1109        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
1110                        vLoopSessions++)
1111        {
1112                if (vSessions[vLoopSessions]->Handle == session_handle)
1113                {
1114                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
1115                                        vLoopSlots++)
1116                        {
1117                                if ((vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle ==
1118                                                slot_handle)
1119                                                && vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse == 1)
1120                                {
1121                                        /*
1122                                         * unlink buffer / dma from slot in hw
1123                                         */
1124                                        pti_slot_unlink_buffer(vSessions[vLoopSessions]->
1125                                                               vSlots[vLoopSlots]->TCIndex);
1126                                        pBuffer = vSessions[vLoopSessions]->vSlots[vLoopSlots]->pBuffer;
1127                                        if (pBuffer != NULL)
1128                                        {
1129                                                if (pBuffer->slotCount > 0)
1130                                                        pBuffer->slotCount--;
1131                                                else
1132                                                        printk("%s(): INVALID SLOT COUNT (%d)\n", __func__,
1133                                                               pBuffer->slotCount);
1134                                                if (pBuffer->slotCount == 0)
1135                                                {
1136                                                        /* invalidate references to the buffer */
1137                                                        if (vSessions[vLoopSessions]->pBufferList == pBuffer)
1138                                                        {
1139                                                                /* the buffer is the first on the list */
1140                                                                vSessions[vLoopSessions]->pBufferList =
1141                                                                        vSessions[vLoopSessions]->pBufferList->pNext;
1142                                                        }
1143                                                        else
1144                                                        {
1145                                                                struct tBuffer *pTmp = vSessions[vLoopSessions]->pBufferList;
1146                                                                int loop = 0;
1147                                                                while (pTmp != NULL)
1148                                                                {
1149                                                                        printk(" pTmp = %p\n", pTmp);
1150                                                                        if (pTmp->pNext == pBuffer)
1151                                                                        {
1152                                                                                /* remove the buffer from the list */
1153                                                                                pTmp->pNext = pBuffer->pNext;
1154                                                                                break;
1155                                                                        }
1156                                                                        if ((pTmp == pBuffer->pNext) || (loop > 50))
1157                                                                        {
1158                                                                                printk("%s(): LIST ERROR %p, %p, %p\n", __func__, pTmp, pBuffer, pBuffer->pNext);
1159                                                                                pTmp->pNext = NULL;
1160                                                                                break;
1161                                                                        }
1162                                                                        pTmp = pTmp->pNext;
1163                                                                        loop++;
1164                                                                }
1165                                                                if (pTmp == NULL)
1166                                                                        printk("%s(): buffer not found in the list\n", __func__);
1167                                                        }
1168                                                        /* no buffer references, release buffer */
1169                                                        pti_buffer_free(pBuffer);
1170                                                }
1171                                                else
1172                                                {
1173                                                        if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->dvb_pes_type == DMX_TS_PES_VIDEO)
1174                                                        {
1175                                                                /* increase the DMA threshold to allow low-bitrate
1176                                                                 interrupts to arrive on time */
1177                                                                setDmaThreshold(pBuffer->dmaIndex, TC_DMA_THRESHOLD_LOW);
1178                                                        }
1179                                                }
1180                                                /*
1181                                                 * we have no buffer linkage
1182                                                 */
1183                                                vSessions[vLoopSessions]->vSlots[vLoopSlots]->pBuffer = NULL;
1184                                                error = cHALNoError;
1185                                        }
1186                                        else
1187                                        {
1188                                                printk("%s(): no buffer attached\n", __func__);
1189                                        }
1190                                        break;
1191                                }
1192                        }
1193                }
1194        }
1195        dprintk("%s (%d) <\n", __func__, error);
1196#ifdef use_hal_mutex
1197        mutex_unlock(&(HALLock));
1198#endif
1199        return error;
1200}
1201
1202int pti_hal_slot_free(int session_handle, int slot_handle)
1203{
1204        int error = cHALNotInitialized;
1205        int vLoopSessions, vLoopSlots;
1206        int numSlotsInUse = 0;
1207        dprintk("%s >\n", __func__);
1208        if (vSessions == NULL)
1209                return cHALNotInitialized;
1210#ifdef use_hal_mutex
1211        mutex_lock(&(HALLock));
1212#endif
1213        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
1214                        vLoopSessions++)
1215        {
1216                if (vSessions[vLoopSessions]->Handle == session_handle)
1217                {
1218                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
1219                                        vLoopSlots++)
1220                        {
1221                                if ((vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle ==
1222                                                slot_handle)
1223                                                && vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse == 1)
1224                                {
1225                                        /*
1226                                         * clear the pid in hw
1227                                         */
1228                                        pti_slot_clear_pid(vSessions[vLoopSessions]->vSlots[vLoopSlots]->
1229                                                           TCIndex,
1230                                                           pti_hal_get_tc_dma_number(session_handle,
1231                                                                                     slot_handle), 1);
1232                                        /*
1233                                         * unlink from buffer if necessary
1234                                         */
1235                                        if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->pBuffer !=
1236                                                        NULL)
1237                                                pti_hal_slot_unlink_buffer(session_handle, slot_handle);
1238                                        /*
1239                                         * free the slot in hw
1240                                         */
1241                                        pti_slot_free(vSessions[vLoopSessions]->vSlots[vLoopSlots]->
1242                                                      TCIndex);
1243                                        /*
1244                                         * init our handling
1245                                         */
1246                                        vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse = 0;
1247                                        vSessions[vLoopSessions]->vSlots[vLoopSlots]->demux = NULL;
1248                                        // DB: commented out to allow resetting the DMA threshold
1249                                        //vSessions[vLoopSessions]->vSlots[vLoopSlots]->dvb_type = 0;
1250                                        //vSessions[vLoopSessions]->vSlots[vLoopSlots]->dvb_pes_type = 0;
1251                                        vSessions[vLoopSessions]->vSlots[vLoopSlots]->pid = 0;
1252                                        vSessions[vLoopSessions]->vSlots[vLoopSlots]->DescramblerHandle = 0;
1253                                        error = cHALNoError;
1254                                        break;
1255                                }
1256                        } /* for slots */
1257                        /* if no more slots are in use let us set the source for this
1258                         * session to invalid! there seems to be no legal call from
1259                         * dvb-api and therefor e2 point of view. in some cases, when
1260                         * recording and watching with different tuners this kills
1261                         * one session completly (ERROR STREAM ALREADY IN USE).
1262                         * this is indeed a fact why we can only collect a stream on one
1263                         * session.
1264                         */
1265                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
1266                                        vLoopSlots++)
1267                        {
1268                                if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse)
1269                                        numSlotsInUse++;
1270                        }
1271                        if (numSlotsInUse == 0)
1272                        {
1273                                vSessions[vLoopSessions]->OldTSMergerTag = vSessions[vLoopSessions]->TSMergerTag;
1274                                vSessions[vLoopSessions]->TSMergerTag = STPTI_STREAM_ID_NONE;
1275                                pti_session_set_source(vSessions[vLoopSessions]->TCIndex, STPTI_STREAM_ID_NONE);
1276                                printk("*********** STPTI_STREAM_ID_NONE for Session %d-%d\n", vLoopSessions, vSessions[vLoopSessions]->TCIndex);
1277                        }
1278                }
1279        }
1280        dprintk("%s (%d) <\n", __func__, slot_handle);
1281#ifdef use_hal_mutex
1282        mutex_unlock(&(HALLock));
1283#endif
1284        return slot_handle;
1285}
1286
1287/* *************************************************************
1288 * Helper Functions for DMAs
1289 */
1290
1291int pti_hal_get_tc_dma_number(int session_handle, int slot_handle)
1292{
1293        int tc_dma_number = cHALNotInitialized;
1294        int vLoopSessions, vLoopSlots;
1295//      dprintk("%s >\n", __func__);
1296        if (vSessions == NULL)
1297                return cHALNotInitialized;
1298#ifdef use_hal_mutex
1299        mutex_lock(&(HALLock));
1300#endif
1301        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
1302                        vLoopSessions++)
1303        {
1304                if (vSessions[vLoopSessions]->Handle == session_handle)
1305                {
1306                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
1307                                        vLoopSlots++)
1308                        {
1309                                if ((vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle ==
1310                                                slot_handle)
1311                                                && vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse == 1)
1312                                {
1313                                        if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->pBuffer != NULL)
1314                                        {
1315                                                tc_dma_number = vSessions[vLoopSessions]->vSlots[vLoopSlots]->pBuffer->dmaIndex;
1316                                                break;
1317                                        }
1318                                }
1319                        }
1320                } /* if */
1321        } /* for sessions */
1322//      dprintk("%s <\n", __func__);
1323#ifdef use_hal_mutex
1324        mutex_unlock(&(HALLock));
1325#endif
1326        return tc_dma_number;
1327}
1328
1329#if 0
1330
1331int pti_hal_buffer_enable(int session_handle, struct tBuffer *pBuffer)
1332{
1333        int error = cHALNotInitialized;
1334        return 0;
1335        dprintk("%s >\n", __func__);
1336        if (vSessions == NULL)
1337                return cHALNotInitialized;
1338#ifdef use_hal_mutex
1339        mutex_lock(&(HALLock));
1340#endif
1341        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
1342                        vLoopSessions++)
1343        {
1344                if (vSessions[vLoopSessions]->Handle == session_handle)
1345                {
1346                        for (vLoopDMAs = 0; vLoopDMAs < numberOfAvailableDMAs; vLoopDMAs++)
1347                        {
1348                                if ((vDMAs[vLoopDMAs]->Handle == buffer_handle) &&
1349                                                (vDMAs[vLoopDMAs]->inUse == 1) &&
1350                                                (vDMAs[vLoopDMAs]->SlotUsage != 0))
1351                                {
1352                                        vDMAs[vLoopDMAs]->EnableCount++;
1353                                        if (vDMAs[vLoopDMAs]->EnableCount == vDMAs[vLoopDMAs]->SlotUsage)
1354                                        {
1355                                                /*
1356                                                 * enable the signalling
1357                                                 */
1358                                                pti_buffer_enable_signalling(vDMAs[vLoopDMAs]->TCIndex);
1359                                                dprintk("enable dma signalling now\n");
1360                                        }
1361                                        else
1362                                        {
1363                                                dprintk("EnableCount = %d, SlotUsage = %d\n",
1364                                                        vDMAs[vLoopDMAs]->EnableCount,
1365                                                        vDMAs[vLoopDMAs]->SlotUsage);
1366                                        }
1367                                        error = cHALNoError;
1368                                        break;
1369                                }
1370                        }
1371                }
1372        }
1373        dprintk("%s (%d) <\n", __func__, error);
1374#ifdef use_hal_mutex
1375        mutex_unlock(&(HALLock));
1376#endif
1377        return error;
1378}
1379
1380int pti_hal_buffer_disable(int session_handle, int buffer_handle)
1381{
1382        int error = cHALNotInitialized;
1383        int vLoopSessions, vLoopDMAs;
1384        dprintk("%s >\n", __func__);
1385        if (vSessions == NULL)
1386                return cHALNotInitialized;
1387#ifdef use_hal_mutex
1388        mutex_lock(&(HALLock));
1389#endif
1390        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
1391                        vLoopSessions++)
1392        {
1393                if (vSessions[vLoopSessions]->Handle == session_handle)
1394                {
1395                        for (vLoopDMAs = 0; vLoopDMAs < numberOfAvailableDMAs; vLoopDMAs++)
1396                        {
1397                                if ((vDMAs[vLoopDMAs]->Handle == buffer_handle) &&
1398                                                (vDMAs[vLoopDMAs]->inUse == 1) &&
1399                                                (vDMAs[vLoopDMAs]->SlotUsage != 0))
1400                                {
1401                                        vDMAs[vLoopDMAs]->EnableCount--;
1402                                        if (vDMAs[vLoopDMAs]->EnableCount != vDMAs[vLoopDMAs]->SlotUsage)
1403                                        {
1404                                                /*
1405                                                 * disable the signalling
1406                                                 */
1407                                                pti_buffer_disable_signalling(vDMAs[vLoopDMAs]->TCIndex);
1408                                        }
1409                                        error = cHALNoError;
1410                                        break;
1411                                }
1412                        }
1413                }
1414        }
1415        dprintk("%s <\n", __func__);
1416#ifdef use_hal_mutex
1417        mutex_unlock(&(HALLock));
1418#endif
1419        return error;
1420}
1421#endif
1422
1423/* ***************************************************************
1424 * Descrambler
1425 */
1426
1427int pti_hal_get_new_descrambler(int session_handle)
1428{
1429        int descrambler_handle = cHALNotInitialized;
1430        int noFree = 0;
1431        int vLoopSessions, vLoopDescrambler;
1432        dprintk("%s >\n", __func__);
1433        if (vSessions == NULL)
1434                return cHALNotInitialized;
1435#ifdef use_hal_mutex
1436        mutex_lock(&(HALLock));
1437#endif
1438        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
1439                        vLoopSessions++)
1440        {
1441                if (vSessions[vLoopSessions]->Handle == session_handle)
1442                {
1443                        for (vLoopDescrambler = 0;
1444                                        vLoopDescrambler < numberOfAvailableDescramblerKeys;
1445                                        vLoopDescrambler++)
1446                        {
1447                                if (vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->
1448                                                inUse == 0)
1449                                {
1450                                        descrambler_handle =
1451                                                vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->Handle;
1452                                        pti_descrambler_allocate(vSessions[vLoopSessions]->
1453                                                                 vDescrambler[vLoopDescrambler]->
1454                                                                 TCIndex);
1455                                        /*
1456                                         * this should never happen
1457                                         */
1458                                        if (vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->
1459                                                        TCIndex == -1)
1460                                        {
1461                                                descrambler_handle = cHALNoFreeDescrambler;
1462                                        }
1463                                        else
1464                                        {
1465                                                vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->inUse =
1466                                                        1;
1467                                                noFree = 1;
1468                                                break;
1469                                        } /* else */
1470                                } /* if */
1471                        } /* for descrambler */
1472                        if (noFree == 0)
1473                                descrambler_handle = cHALNoFreeDescrambler;
1474                } /* if */
1475        } /* for sessions */
1476#ifdef CONFIG_PRINTK
1477        printk("%s (%d) >\n", __func__, descrambler_handle);
1478#endif
1479#ifdef use_hal_mutex
1480        mutex_unlock(&(HALLock));
1481#endif
1482        return descrambler_handle;
1483}
1484
1485int pti_hal_descrambler_link(int session_handle, int descrambler_handle,
1486                             int slot_handle)
1487{
1488        int error = cHALNotInitialized;
1489        int vLoopSessions, vLoopSlots, vLoopDescrambler;
1490        dprintk("%s >\n", __func__);
1491        if (vSessions == NULL)
1492                return cHALNotInitialized;
1493#ifdef use_hal_mutex
1494        mutex_lock(&(HALLock));
1495#endif
1496        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
1497                        vLoopSessions++)
1498        {
1499                if (vSessions[vLoopSessions]->Handle == session_handle)
1500                {
1501                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
1502                                        vLoopSlots++)
1503                        {
1504                                if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle ==
1505                                                slot_handle)
1506                                {
1507                                        if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->
1508                                                        DescramblerHandle != 0)
1509                                        {
1510                                                /*quack: do not retun an error instead unlink the
1511                                                 current descrambler and link the new one*/
1512                                                /*error = cHALSlotAlreadyInUse;*/
1513                                                for (vLoopDescrambler = 0;
1514                                                                vLoopDescrambler < numberOfAvailableDescramblerKeys;
1515                                                                vLoopDescrambler++)
1516                                                {
1517                                                        if ((vSessions[vLoopSessions]->
1518                                                                        vDescrambler[vLoopDescrambler]->Handle ==
1519                                                                        vSessions[vLoopSessions]->vSlots[vLoopSlots]->DescramblerHandle)
1520                                                                        && (vSessions[vLoopSessions]->
1521                                                                            vDescrambler[vLoopDescrambler]->inUse == 1))
1522                                                                pti_descrambler_disassociate_from_slot(vSessions[vLoopSessions]->
1523                                                                                                       vDescrambler
1524                                                                                                       [vLoopDescrambler]->
1525                                                                                                       TCIndex,
1526                                                                                                       vSessions[vLoopSessions]->
1527                                                                                                       vSlots[vLoopSlots]->
1528                                                                                                       TCIndex);
1529                                                }
1530                                        }
1531                                        /*else*/
1532                                        {
1533                                                /*
1534                                                 * descrambler suchen
1535                                                 */
1536                                                for (vLoopDescrambler = 0;
1537                                                                vLoopDescrambler < numberOfAvailableDescramblerKeys;
1538                                                                vLoopDescrambler++)
1539                                                {
1540                                                        if ((vSessions[vLoopSessions]->
1541                                                                        vDescrambler[vLoopDescrambler]->Handle ==
1542                                                                        descrambler_handle)
1543                                                                        && (vSessions[vLoopSessions]->
1544                                                                            vDescrambler[vLoopDescrambler]->inUse == 1)
1545                                                                        /*
1546                                                                         * &&
1547                                                                         * descrambler können mit mehreren slots verlinkt werden,
1548                                                                         * * muss ich also irgendwie anders mache
1549                                                                         * (vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->SlotHandle == 0) dont link twice
1550                                                                         */)
1551                                                        {
1552                                                                pti_descrambler_associate_with_slot(vSessions
1553                                                                                                    [vLoopSessions]->
1554                                                                                                    vDescrambler
1555                                                                                                    [vLoopDescrambler]->
1556                                                                                                    TCIndex,
1557                                                                                                    vSessions
1558                                                                                                    [vLoopSessions]->
1559                                                                                                    vSlots[vLoopSlots]->
1560                                                                                                    TCIndex);
1561                                                                /*
1562                                                                 * internal link
1563                                                                 */
1564                                                                vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->
1565                                                                SlotHandle = slot_handle;
1566                                                                vSessions[vLoopSessions]->vSlots[vLoopSlots]->
1567                                                                DescramblerHandle = descrambler_handle;
1568                                                                error = cHALNoError;
1569                                                                break;
1570                                                        } /* if */
1571                                                } /* for descrambler */
1572                                        } /* else */
1573                                } /* if */
1574                        } /* for slots */
1575                } /* if */
1576        } /* for sessions */
1577        dprintk("%s (%d)<\n", __func__, error);
1578#ifdef use_hal_mutex
1579        mutex_unlock(&(HALLock));
1580#endif
1581        return error;
1582}
1583
1584int pti_hal_descrambler_unlink(int session_handle, int descrambler_handle)
1585{
1586        int error = cHALNotInitialized;
1587        int vLoopSessions, vLoopSlots, vLoopDescrambler;
1588        if (vSessions == NULL)
1589                return cHALNotInitialized;
1590#ifdef use_hal_mutex
1591        mutex_lock(&(HALLock));
1592#endif
1593        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
1594                        vLoopSessions++)
1595        {
1596                if (vSessions[vLoopSessions]->Handle == session_handle)
1597                {
1598                        /*
1599                         * descrambler suchen
1600                         */
1601                        for (vLoopDescrambler = 0;
1602                                        vLoopDescrambler < numberOfAvailableDescramblerKeys;
1603                                        vLoopDescrambler++)
1604                        {
1605                                if ((vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->
1606                                                Handle == descrambler_handle)
1607                                                && (vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->
1608                                                    SlotHandle != 0)
1609                                                && (vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->
1610                                                    inUse == 1))
1611                                {
1612                                        /*
1613                                         * get slot index
1614                                         */
1615                                        for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
1616                                                        vLoopSlots++)
1617                                        {
1618                                                if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle ==
1619                                                                vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->
1620                                                                SlotHandle)
1621                                                        break;
1622                                        }
1623                                        /*
1624                                         * hw unlink
1625                                         */
1626                                        pti_descrambler_disassociate_from_slot(vSessions[vLoopSessions]->
1627                                                                               vDescrambler
1628                                                                               [vLoopDescrambler]->
1629                                                                               TCIndex,
1630                                                                               vSessions[vLoopSessions]->
1631                                                                               vSlots[vLoopSlots]->
1632                                                                               TCIndex);
1633                                        /*
1634                                         * internal unlink
1635                                         */
1636                                        vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->
1637                                        SlotHandle = 0;
1638                                        vSessions[vLoopSessions]->vSlots[vLoopSlots]->DescramblerHandle = 0;
1639                                        error = cHALNoError;
1640                                        break;
1641                                } /* if */
1642                        } /* for descrambler */
1643                } /* if */
1644        } /* for sessions */
1645#ifdef use_hal_mutex
1646        mutex_unlock(&(HALLock));
1647#endif
1648        return error;
1649}
1650
1651int pti_hal_descrambler_set(int session_handle, int descrambler_handle,
1652                            u8 *Data, int parity)
1653{
1654        int error = cHALNotInitialized;
1655        int vLoopSessions, vLoopDescrambler;
1656        if (vSessions == NULL)
1657                return cHALNotInitialized;
1658#ifdef use_hal_mutex
1659        mutex_lock(&(HALLock));
1660#endif
1661#ifdef CONFIG_PRINTK
1662        printk("%s session=%d descrambler=%d\n", __func__, session_handle, descrambler_handle);
1663#endif
1664        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
1665                        vLoopSessions++)
1666        {
1667                if (vSessions[vLoopSessions]->Handle == session_handle)
1668                {
1669                        /*
1670                         * descrambler suchen
1671                         */
1672                        for (vLoopDescrambler = 0;
1673                                        vLoopDescrambler < numberOfAvailableDescramblerKeys;
1674                                        vLoopDescrambler++)
1675                        {
1676                                if ((vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->
1677                                                Handle == descrambler_handle)
1678                                                && (vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->
1679                                                    inUse == 1))
1680                                {
1681                                        pti_descrambler_set(vSessions[vLoopSessions]->
1682                                                            vDescrambler[vLoopDescrambler]->TCIndex,
1683                                                            parity, Data);
1684                                        error = cHALNoError;
1685                                        break;
1686                                } /* if */
1687                        } /* for descrambler */
1688                } /* if */
1689        } /* for sessions */
1690#ifdef use_hal_mutex
1691        mutex_unlock(&(HALLock));
1692#endif
1693        return error;
1694}
1695
1696int pti_hal_descrambler_set_aes(int session_handle, int descrambler_handle,
1697                                u8 *Data, int parity, int data_type)
1698{
1699        int error = cHALNotInitialized;
1700        int vLoopSessions, vLoopDescrambler;
1701        if (vSessions == NULL)
1702                return cHALNotInitialized;
1703#ifdef use_hal_mutex
1704        mutex_lock(&(HALLock));
1705#endif
1706#ifdef CONFIG_PRINTK
1707        printk("%s session=%d descrambler=%d\n", __func__, session_handle, descrambler_handle);
1708#endif
1709        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
1710                        vLoopSessions++)
1711        {
1712                if (vSessions[vLoopSessions]->Handle == session_handle)
1713                {
1714                        /*
1715                         * descrambler suchen
1716                         */
1717                        for (vLoopDescrambler = 0;
1718                                        vLoopDescrambler < numberOfAvailableDescramblerKeys;
1719                                        vLoopDescrambler++)
1720                        {
1721                                if ((vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->
1722                                                Handle == descrambler_handle)
1723                                                && (vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->
1724                                                    inUse == 1))
1725                                {
1726                                        pti_descrambler_set_aes(vSessions[vLoopSessions]->
1727                                                                vDescrambler[vLoopDescrambler]->TCIndex,
1728                                                                parity, Data, data_type);
1729                                        error = cHALNoError;
1730                                        break;
1731                                } /* if */
1732                        } /* for descrambler */
1733                } /* if */
1734        } /* for sessions */
1735#ifdef use_hal_mutex
1736        mutex_unlock(&(HALLock));
1737#endif
1738        return error;
1739}
1740
1741int pti_hal_descrambler_set_null(void)
1742{
1743        u8 cw[8] = { 0x47,0x11,0x08,0x15,0x09,0xc4,0x09,0x8c };
1744        int error = cHALNotInitialized;
1745        int vLoopSessions, vLoopDescrambler;
1746        if (vSessions == NULL)
1747                return cHALNotInitialized;
1748#ifdef use_hal_mutex
1749        mutex_lock(&(HALLock));
1750#endif
1751        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions; vLoopSessions++)
1752        {
1753                for (vLoopDescrambler = 0; vLoopDescrambler < numberOfAvailableDescramblerKeys; vLoopDescrambler++)
1754                {
1755                        pti_descrambler_set(vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->TCIndex, 0, cw);
1756                        pti_descrambler_set(vSessions[vLoopSessions]->vDescrambler[vLoopDescrambler]->TCIndex, 1, cw);
1757                        error = cHALNoError;
1758                }
1759        }
1760#ifdef use_hal_mutex
1761        mutex_unlock(&(HALLock));
1762#endif
1763        return error;
1764}
1765
1766int pti_hal_descrambler_clear(void)
1767{
1768        return -1;
1769}
1770
1771int pti_hal_descrambler_free(void)
1772{
1773        return -1;
1774}
1775
1776/* return:
1777 * check if a audio / video pid has changed and
1778 * if the status of the slot is scrambled or not.
1779 * needed for ufs910 to modify the stream routing ad hoc.
1780 *
1781 * -1 if nothing happens
1782 * 0 not scrampbled but status changed
1783 * 1 scrambled and status chaned
1784 *
1785 */
1786int pti_hal_get_scrambled(void)
1787{
1788        int vLoopSessions, vLoopSlots;
1789        int state;
1790        static u16 lastAudioPid = -1;
1791        static u16 lastVideoPid = -1;
1792        static int lastAudioState = -1;
1793        static int lastVideoState = -1;
1794        int result = -1;
1795        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
1796                        vLoopSessions++)
1797        {
1798                for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
1799                                vLoopSlots++)
1800                {
1801                        if (!vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse)
1802                                continue;
1803                        if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->dvb_type != DMX_TYPE_TS)
1804                                continue;
1805                        if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->dvb_pes_type == DMX_TS_PES_VIDEO)
1806                        {
1807                                if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->pid == lastVideoPid)
1808                                        continue;
1809                                lastVideoPid = vSessions[vLoopSessions]->vSlots[vLoopSlots]->pid;
1810                                state = pti_slot_get_state(vSessions[vLoopSessions]->vSlots[vLoopSlots]->TCIndex);
1811                                if (state & (TC_MAIN_INFO_SLOT_STATE_SCRAMBLED |
1812                                                TC_MAIN_INFO_SLOT_STATE_TRANSPORT_SCRAMBLED))
1813                                {
1814                                        if (lastVideoState == 1)
1815                                                continue;
1816                                        lastVideoState = 1;
1817                                        return 1;
1818                                }
1819                                else
1820                                {
1821                                        if (lastVideoState == 0)
1822                                                continue;
1823                                        lastVideoState = 0;
1824                                        return 0;
1825                                }
1826                        }
1827                        else if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->dvb_pes_type == DMX_TS_PES_AUDIO)
1828                        {
1829                                if (vSessions[vLoopSessions]->vSlots[vLoopSlots]->pid == lastAudioPid)
1830                                        continue;
1831                                lastAudioPid = vSessions[vLoopSessions]->vSlots[vLoopSlots]->pid;
1832                                state = pti_slot_get_state(vSessions[vLoopSessions]->vSlots[vLoopSlots]->TCIndex);
1833                                if (state & (TC_MAIN_INFO_SLOT_STATE_SCRAMBLED |
1834                                                TC_MAIN_INFO_SLOT_STATE_TRANSPORT_SCRAMBLED))
1835                                {
1836                                        if (lastAudioState == 1)
1837                                                continue;
1838                                        lastAudioState = 1;
1839                                        return 1;
1840                                }
1841                                else
1842                                {
1843                                        if (lastAudioState == 0)
1844                                                continue;
1845                                        lastAudioState = 0;
1846                                        return 0;
1847                                }
1848                        }
1849                } /* for slots */
1850        } /* for sessions */
1851        return result;
1852}
1853
1854void pti_hal_output_slot_state(void)
1855{
1856        int vLoopSessions, vLoopSlots;
1857        dprintk("%s >\n", __func__);
1858        if (vSessions == NULL)
1859                return;
1860#ifdef use_hal_mutex
1861        mutex_lock(&(HALLock));
1862#endif
1863        for (vLoopSessions = 0; vLoopSessions < numberOfAvailableSessions;
1864                        vLoopSessions++)
1865        {
1866                for (vLoopSlots = 0; vLoopSlots < numberOfAvailableSlots;
1867                                vLoopSlots++)
1868                {
1869                        if (!vSessions[vLoopSessions]->vSlots[vLoopSlots]->inUse)
1870                                continue;
1871                        printk("session %d, slot %d, pid 0x%04X, TCIndex = %02d, state = 0x%04x\n",
1872                               vSessions[vLoopSessions]->Handle,
1873                               vSessions[vLoopSessions]->vSlots[vLoopSlots]->Handle,
1874                               vSessions[vLoopSessions]->vSlots[vLoopSlots]->pid,
1875                               vSessions[vLoopSessions]->vSlots[vLoopSlots]->TCIndex,
1876                               pti_slot_get_state(vSessions[vLoopSessions]->vSlots[vLoopSlots]->TCIndex)
1877                              );
1878                } /* for slots */
1879        } /* for sessions */
1880        dprintk("%s <\n", __func__);
1881#ifdef use_hal_mutex
1882        mutex_unlock(&(HALLock));
1883#endif
1884        return;
1885}
1886
1887EXPORT_SYMBOL(pti_hal_descrambler_set);
1888EXPORT_SYMBOL(pti_hal_descrambler_set_aes);
1889EXPORT_SYMBOL(pti_hal_descrambler_unlink);
1890EXPORT_SYMBOL(pti_hal_descrambler_link);
1891EXPORT_SYMBOL(pti_hal_get_new_descrambler);
1892EXPORT_SYMBOL(pti_hal_slot_free);
1893EXPORT_SYMBOL(pti_hal_slot_unlink_buffer);
1894EXPORT_SYMBOL(pti_hal_slot_link_buffer);
1895EXPORT_SYMBOL(pti_hal_slot_clear_pid);
1896EXPORT_SYMBOL(pti_hal_slot_set_pid);
1897EXPORT_SYMBOL(pti_hal_get_new_slot_handle);
1898EXPORT_SYMBOL(pti_hal_set_source);
1899EXPORT_SYMBOL(pti_hal_get_session_handle);
1900EXPORT_SYMBOL(pti_hal_get_new_session_handle);
1901EXPORT_SYMBOL(pti_hal_init);
Note: See TracBrowser for help on using the repository browser.