0dc348215b72d0666fd43ddc87629441784484ab
[sfrench/cifs-2.6.git] / drivers / media / pci / cx23885 / altera-ci.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * altera-ci.c
4  *
5  *  CI driver in conjunction with NetUp Dual DVB-T/C RF CI card
6  *
7  * Copyright (C) 2010,2011 NetUP Inc.
8  * Copyright (C) 2010,2011 Igor M. Liplianin <liplianin@netup.ru>
9  */
10
11 /*
12  * currently cx23885 GPIO's used.
13  * GPIO-0 ~INT in
14  * GPIO-1 TMS out
15  * GPIO-2 ~reset chips out
16  * GPIO-3 to GPIO-10 data/addr for CA in/out
17  * GPIO-11 ~CS out
18  * GPIO-12 AD_RG out
19  * GPIO-13 ~WR out
20  * GPIO-14 ~RD out
21  * GPIO-15 ~RDY in
22  * GPIO-16 TCK out
23  * GPIO-17 TDO in
24  * GPIO-18 TDI out
25  */
26 /*
27  *  Bit definitions for MC417_RWD and MC417_OEN registers
28  * bits 31-16
29  * +-----------+
30  * | Reserved  |
31  * +-----------+
32  *   bit 15  bit 14  bit 13 bit 12  bit 11  bit 10  bit 9   bit 8
33  * +-------+-------+-------+-------+-------+-------+-------+-------+
34  * |  TDI  |  TDO  |  TCK  |  RDY# |  #RD  |  #WR  | AD_RG |  #CS  |
35  * +-------+-------+-------+-------+-------+-------+-------+-------+
36  *  bit 7   bit 6   bit 5   bit 4   bit 3   bit 2   bit 1   bit 0
37  * +-------+-------+-------+-------+-------+-------+-------+-------+
38  * |  DATA7|  DATA6|  DATA5|  DATA4|  DATA3|  DATA2|  DATA1|  DATA0|
39  * +-------+-------+-------+-------+-------+-------+-------+-------+
40  */
41
42 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
43
44 #include <media/dvb_demux.h>
45 #include <media/dvb_frontend.h>
46 #include "altera-ci.h"
47 #include <media/dvb_ca_en50221.h>
48
49 /* FPGA regs */
50 #define NETUP_CI_INT_CTRL       0x00
51 #define NETUP_CI_BUSCTRL2       0x01
52 #define NETUP_CI_ADDR0          0x04
53 #define NETUP_CI_ADDR1          0x05
54 #define NETUP_CI_DATA           0x06
55 #define NETUP_CI_BUSCTRL        0x07
56 #define NETUP_CI_PID_ADDR0      0x08
57 #define NETUP_CI_PID_ADDR1      0x09
58 #define NETUP_CI_PID_DATA       0x0a
59 #define NETUP_CI_TSA_DIV        0x0c
60 #define NETUP_CI_TSB_DIV        0x0d
61 #define NETUP_CI_REVISION       0x0f
62
63 /* const for ci op */
64 #define NETUP_CI_FLG_CTL        1
65 #define NETUP_CI_FLG_RD         1
66 #define NETUP_CI_FLG_AD         1
67
68 static unsigned int ci_dbg;
69 module_param(ci_dbg, int, 0644);
70 MODULE_PARM_DESC(ci_dbg, "Enable CI debugging");
71
72 static unsigned int pid_dbg;
73 module_param(pid_dbg, int, 0644);
74 MODULE_PARM_DESC(pid_dbg, "Enable PID filtering debugging");
75
76 MODULE_DESCRIPTION("altera FPGA CI module");
77 MODULE_AUTHOR("Igor M. Liplianin  <liplianin@netup.ru>");
78 MODULE_LICENSE("GPL");
79
80 #define ci_dbg_print(fmt, args...) \
81         do { \
82                 if (ci_dbg) \
83                         printk(KERN_DEBUG pr_fmt("%s: " fmt), \
84                                __func__, ##args); \
85         } while (0)
86
87 #define pid_dbg_print(fmt, args...) \
88         do { \
89                 if (pid_dbg) \
90                         printk(KERN_DEBUG pr_fmt("%s: " fmt), \
91                                __func__, ##args); \
92         } while (0)
93
94 struct altera_ci_state;
95 struct netup_hw_pid_filter;
96
97 struct fpga_internal {
98         void *dev;
99         struct mutex fpga_mutex;/* two CI's on the same fpga */
100         struct netup_hw_pid_filter *pid_filt[2];
101         struct altera_ci_state *state[2];
102         struct work_struct work;
103         int (*fpga_rw) (void *dev, int flag, int data, int rw);
104         int cis_used;
105         int filts_used;
106         int strt_wrk;
107 };
108
109 /* stores all private variables for communication with CI */
110 struct altera_ci_state {
111         struct fpga_internal *internal;
112         struct dvb_ca_en50221 ca;
113         int status;
114         int nr;
115 };
116
117 /* stores all private variables for hardware pid filtering */
118 struct netup_hw_pid_filter {
119         struct fpga_internal *internal;
120         struct dvb_demux *demux;
121         /* save old functions */
122         int (*start_feed)(struct dvb_demux_feed *feed);
123         int (*stop_feed)(struct dvb_demux_feed *feed);
124
125         int status;
126         int nr;
127 };
128
129 /* internal params node */
130 struct fpga_inode {
131         /* pointer for internal params, one for each pair of CI's */
132         struct fpga_internal            *internal;
133         struct fpga_inode               *next_inode;
134 };
135
136 /* first internal params */
137 static struct fpga_inode *fpga_first_inode;
138
139 /* find chip by dev */
140 static struct fpga_inode *find_inode(void *dev)
141 {
142         struct fpga_inode *temp_chip = fpga_first_inode;
143
144         if (temp_chip == NULL)
145                 return temp_chip;
146
147         /*
148          Search for the last fpga CI chip or
149          find it by dev */
150         while ((temp_chip != NULL) &&
151                                 (temp_chip->internal->dev != dev))
152                 temp_chip = temp_chip->next_inode;
153
154         return temp_chip;
155 }
156 /* check demux */
157 static struct fpga_internal *check_filter(struct fpga_internal *temp_int,
158                                                 void *demux_dev, int filt_nr)
159 {
160         if (temp_int == NULL)
161                 return NULL;
162
163         if ((temp_int->pid_filt[filt_nr]) == NULL)
164                 return NULL;
165
166         if (temp_int->pid_filt[filt_nr]->demux == demux_dev)
167                 return temp_int;
168
169         return NULL;
170 }
171
172 /* find chip by demux */
173 static struct fpga_inode *find_dinode(void *demux_dev)
174 {
175         struct fpga_inode *temp_chip = fpga_first_inode;
176         struct fpga_internal *temp_int;
177
178         /*
179          * Search of the last fpga CI chip or
180          * find it by demux
181          */
182         while (temp_chip != NULL) {
183                 if (temp_chip->internal != NULL) {
184                         temp_int = temp_chip->internal;
185                         if (check_filter(temp_int, demux_dev, 0))
186                                 break;
187                         if (check_filter(temp_int, demux_dev, 1))
188                                 break;
189                 }
190
191                 temp_chip = temp_chip->next_inode;
192         }
193
194         return temp_chip;
195 }
196
197 /* deallocating chip */
198 static void remove_inode(struct fpga_internal *internal)
199 {
200         struct fpga_inode *prev_node = fpga_first_inode;
201         struct fpga_inode *del_node = find_inode(internal->dev);
202
203         if (del_node != NULL) {
204                 if (del_node == fpga_first_inode) {
205                         fpga_first_inode = del_node->next_inode;
206                 } else {
207                         while (prev_node->next_inode != del_node)
208                                 prev_node = prev_node->next_inode;
209
210                         if (del_node->next_inode == NULL)
211                                 prev_node->next_inode = NULL;
212                         else
213                                 prev_node->next_inode =
214                                         prev_node->next_inode->next_inode;
215                 }
216
217                 kfree(del_node);
218         }
219 }
220
221 /* allocating new chip */
222 static struct fpga_inode *append_internal(struct fpga_internal *internal)
223 {
224         struct fpga_inode *new_node = fpga_first_inode;
225
226         if (new_node == NULL) {
227                 new_node = kmalloc(sizeof(struct fpga_inode), GFP_KERNEL);
228                 fpga_first_inode = new_node;
229         } else {
230                 while (new_node->next_inode != NULL)
231                         new_node = new_node->next_inode;
232
233                 new_node->next_inode =
234                                 kmalloc(sizeof(struct fpga_inode), GFP_KERNEL);
235                 if (new_node->next_inode != NULL)
236                         new_node = new_node->next_inode;
237                 else
238                         new_node = NULL;
239         }
240
241         if (new_node != NULL) {
242                 new_node->internal = internal;
243                 new_node->next_inode = NULL;
244         }
245
246         return new_node;
247 }
248
249 static int netup_fpga_op_rw(struct fpga_internal *inter, int addr,
250                                                         u8 val, u8 read)
251 {
252         inter->fpga_rw(inter->dev, NETUP_CI_FLG_AD, addr, 0);
253         return inter->fpga_rw(inter->dev, 0, val, read);
254 }
255
256 /* flag - mem/io, read - read/write */
257 static int altera_ci_op_cam(struct dvb_ca_en50221 *en50221, int slot,
258                                 u8 flag, u8 read, int addr, u8 val)
259 {
260
261         struct altera_ci_state *state = en50221->data;
262         struct fpga_internal *inter = state->internal;
263
264         u8 store;
265         int mem = 0;
266
267         if (0 != slot)
268                 return -EINVAL;
269
270         mutex_lock(&inter->fpga_mutex);
271
272         netup_fpga_op_rw(inter, NETUP_CI_ADDR0, ((addr << 1) & 0xfe), 0);
273         netup_fpga_op_rw(inter, NETUP_CI_ADDR1, ((addr >> 7) & 0x7f), 0);
274         store = netup_fpga_op_rw(inter, NETUP_CI_BUSCTRL, 0, NETUP_CI_FLG_RD);
275
276         store &= 0x0f;
277         store |= ((state->nr << 7) | (flag << 6));
278
279         netup_fpga_op_rw(inter, NETUP_CI_BUSCTRL, store, 0);
280         mem = netup_fpga_op_rw(inter, NETUP_CI_DATA, val, read);
281
282         mutex_unlock(&inter->fpga_mutex);
283
284         ci_dbg_print("%s: %s: addr=[0x%02x], %s=%x\n", __func__,
285                         (read) ? "read" : "write", addr,
286                         (flag == NETUP_CI_FLG_CTL) ? "ctl" : "mem",
287                         (read) ? mem : val);
288
289         return mem;
290 }
291
292 static int altera_ci_read_attribute_mem(struct dvb_ca_en50221 *en50221,
293                                         int slot, int addr)
294 {
295         return altera_ci_op_cam(en50221, slot, 0, NETUP_CI_FLG_RD, addr, 0);
296 }
297
298 static int altera_ci_write_attribute_mem(struct dvb_ca_en50221 *en50221,
299                                          int slot, int addr, u8 data)
300 {
301         return altera_ci_op_cam(en50221, slot, 0, 0, addr, data);
302 }
303
304 static int altera_ci_read_cam_ctl(struct dvb_ca_en50221 *en50221,
305                                   int slot, u8 addr)
306 {
307         return altera_ci_op_cam(en50221, slot, NETUP_CI_FLG_CTL,
308                                                 NETUP_CI_FLG_RD, addr, 0);
309 }
310
311 static int altera_ci_write_cam_ctl(struct dvb_ca_en50221 *en50221, int slot,
312                                    u8 addr, u8 data)
313 {
314         return altera_ci_op_cam(en50221, slot, NETUP_CI_FLG_CTL, 0, addr, data);
315 }
316
317 static int altera_ci_slot_reset(struct dvb_ca_en50221 *en50221, int slot)
318 {
319         struct altera_ci_state *state = en50221->data;
320         struct fpga_internal *inter = state->internal;
321         /* reasonable timeout for CI reset is 10 seconds */
322         unsigned long t_out = jiffies + msecs_to_jiffies(9999);
323         int ret;
324
325         ci_dbg_print("%s\n", __func__);
326
327         if (0 != slot)
328                 return -EINVAL;
329
330         mutex_lock(&inter->fpga_mutex);
331
332         ret = netup_fpga_op_rw(inter, NETUP_CI_BUSCTRL, 0, NETUP_CI_FLG_RD);
333         netup_fpga_op_rw(inter, NETUP_CI_BUSCTRL,
334                                 (ret & 0xcf) | (1 << (5 - state->nr)), 0);
335
336         mutex_unlock(&inter->fpga_mutex);
337
338         for (;;) {
339                 msleep(50);
340
341                 mutex_lock(&inter->fpga_mutex);
342
343                 ret = netup_fpga_op_rw(inter, NETUP_CI_BUSCTRL,
344                                                 0, NETUP_CI_FLG_RD);
345                 mutex_unlock(&inter->fpga_mutex);
346
347                 if ((ret & (1 << (5 - state->nr))) == 0)
348                         break;
349                 if (time_after(jiffies, t_out))
350                         break;
351         }
352
353
354         ci_dbg_print("%s: %d msecs\n", __func__,
355                 jiffies_to_msecs(jiffies + msecs_to_jiffies(9999) - t_out));
356
357         return 0;
358 }
359
360 static int altera_ci_slot_shutdown(struct dvb_ca_en50221 *en50221, int slot)
361 {
362         /* not implemented */
363         return 0;
364 }
365
366 static int altera_ci_slot_ts_ctl(struct dvb_ca_en50221 *en50221, int slot)
367 {
368         struct altera_ci_state *state = en50221->data;
369         struct fpga_internal *inter = state->internal;
370         int ret;
371
372         ci_dbg_print("%s\n", __func__);
373
374         if (0 != slot)
375                 return -EINVAL;
376
377         mutex_lock(&inter->fpga_mutex);
378
379         ret = netup_fpga_op_rw(inter, NETUP_CI_BUSCTRL, 0, NETUP_CI_FLG_RD);
380         netup_fpga_op_rw(inter, NETUP_CI_BUSCTRL,
381                                 (ret & 0x0f) | (1 << (3 - state->nr)), 0);
382
383         mutex_unlock(&inter->fpga_mutex);
384
385         return 0;
386 }
387
388 /* work handler */
389 static void netup_read_ci_status(struct work_struct *work)
390 {
391         struct fpga_internal *inter =
392                         container_of(work, struct fpga_internal, work);
393         int ret;
394
395         ci_dbg_print("%s\n", __func__);
396
397         mutex_lock(&inter->fpga_mutex);
398         /* ack' irq */
399         ret = netup_fpga_op_rw(inter, NETUP_CI_INT_CTRL, 0, NETUP_CI_FLG_RD);
400         ret = netup_fpga_op_rw(inter, NETUP_CI_BUSCTRL, 0, NETUP_CI_FLG_RD);
401
402         mutex_unlock(&inter->fpga_mutex);
403
404         if (inter->state[1] != NULL) {
405                 inter->state[1]->status =
406                                 ((ret & 1) == 0 ?
407                                 DVB_CA_EN50221_POLL_CAM_PRESENT |
408                                 DVB_CA_EN50221_POLL_CAM_READY : 0);
409                 ci_dbg_print("%s: setting CI[1] status = 0x%x\n",
410                                 __func__, inter->state[1]->status);
411         }
412
413         if (inter->state[0] != NULL) {
414                 inter->state[0]->status =
415                                 ((ret & 2) == 0 ?
416                                 DVB_CA_EN50221_POLL_CAM_PRESENT |
417                                 DVB_CA_EN50221_POLL_CAM_READY : 0);
418                 ci_dbg_print("%s: setting CI[0] status = 0x%x\n",
419                                 __func__, inter->state[0]->status);
420         }
421 }
422
423 /* CI irq handler */
424 int altera_ci_irq(void *dev)
425 {
426         struct fpga_inode *temp_int = NULL;
427         struct fpga_internal *inter = NULL;
428
429         ci_dbg_print("%s\n", __func__);
430
431         if (dev != NULL) {
432                 temp_int = find_inode(dev);
433                 if (temp_int != NULL) {
434                         inter = temp_int->internal;
435                         schedule_work(&inter->work);
436                 }
437         }
438
439         return 1;
440 }
441 EXPORT_SYMBOL(altera_ci_irq);
442
443 static int altera_poll_ci_slot_status(struct dvb_ca_en50221 *en50221,
444                                       int slot, int open)
445 {
446         struct altera_ci_state *state = en50221->data;
447
448         if (0 != slot)
449                 return -EINVAL;
450
451         return state->status;
452 }
453
454 static void altera_hw_filt_release(void *main_dev, int filt_nr)
455 {
456         struct fpga_inode *temp_int = find_inode(main_dev);
457         struct netup_hw_pid_filter *pid_filt = NULL;
458
459         ci_dbg_print("%s\n", __func__);
460
461         if (temp_int != NULL) {
462                 pid_filt = temp_int->internal->pid_filt[filt_nr - 1];
463                 /* stored old feed controls */
464                 pid_filt->demux->start_feed = pid_filt->start_feed;
465                 pid_filt->demux->stop_feed = pid_filt->stop_feed;
466
467                 if (((--(temp_int->internal->filts_used)) <= 0) &&
468                          ((temp_int->internal->cis_used) <= 0)) {
469
470                         ci_dbg_print("%s: Actually removing\n", __func__);
471
472                         remove_inode(temp_int->internal);
473                         kfree(pid_filt->internal);
474                 }
475
476                 kfree(pid_filt);
477
478         }
479
480 }
481
482 void altera_ci_release(void *dev, int ci_nr)
483 {
484         struct fpga_inode *temp_int = find_inode(dev);
485         struct altera_ci_state *state = NULL;
486
487         ci_dbg_print("%s\n", __func__);
488
489         if (temp_int != NULL) {
490                 state = temp_int->internal->state[ci_nr - 1];
491                 altera_hw_filt_release(dev, ci_nr);
492
493
494                 if (((temp_int->internal->filts_used) <= 0) &&
495                                 ((--(temp_int->internal->cis_used)) <= 0)) {
496
497                         ci_dbg_print("%s: Actually removing\n", __func__);
498
499                         remove_inode(temp_int->internal);
500                         kfree(state->internal);
501                 }
502
503                 if (state != NULL) {
504                         if (state->ca.data != NULL)
505                                 dvb_ca_en50221_release(&state->ca);
506
507                         kfree(state);
508                 }
509         }
510
511 }
512 EXPORT_SYMBOL(altera_ci_release);
513
514 static void altera_pid_control(struct netup_hw_pid_filter *pid_filt,
515                 u16 pid, int onoff)
516 {
517         struct fpga_internal *inter = pid_filt->internal;
518         u8 store = 0;
519
520         /* pid 0-0x1f always enabled, don't touch them */
521         if ((pid == 0x2000) || (pid < 0x20))
522                 return;
523
524         mutex_lock(&inter->fpga_mutex);
525
526         netup_fpga_op_rw(inter, NETUP_CI_PID_ADDR0, (pid >> 3) & 0xff, 0);
527         netup_fpga_op_rw(inter, NETUP_CI_PID_ADDR1,
528                         ((pid >> 11) & 0x03) | (pid_filt->nr << 2), 0);
529
530         store = netup_fpga_op_rw(inter, NETUP_CI_PID_DATA, 0, NETUP_CI_FLG_RD);
531
532         if (onoff)/* 0 - on, 1 - off */
533                 store |= (1 << (pid & 7));
534         else
535                 store &= ~(1 << (pid & 7));
536
537         netup_fpga_op_rw(inter, NETUP_CI_PID_DATA, store, 0);
538
539         mutex_unlock(&inter->fpga_mutex);
540
541         pid_dbg_print("%s: (%d) set pid: %5d 0x%04x '%s'\n", __func__,
542                 pid_filt->nr, pid, pid, onoff ? "off" : "on");
543 }
544
545 static void altera_toggle_fullts_streaming(struct netup_hw_pid_filter *pid_filt,
546                                         int filt_nr, int onoff)
547 {
548         struct fpga_internal *inter = pid_filt->internal;
549         u8 store = 0;
550         int i;
551
552         pid_dbg_print("%s: pid_filt->nr[%d]  now %s\n", __func__, pid_filt->nr,
553                         onoff ? "off" : "on");
554
555         if (onoff)/* 0 - on, 1 - off */
556                 store = 0xff;/* ignore pid */
557         else
558                 store = 0;/* enable pid */
559
560         mutex_lock(&inter->fpga_mutex);
561
562         for (i = 0; i < 1024; i++) {
563                 netup_fpga_op_rw(inter, NETUP_CI_PID_ADDR0, i & 0xff, 0);
564
565                 netup_fpga_op_rw(inter, NETUP_CI_PID_ADDR1,
566                                 ((i >> 8) & 0x03) | (pid_filt->nr << 2), 0);
567                 /* pid 0-0x1f always enabled */
568                 netup_fpga_op_rw(inter, NETUP_CI_PID_DATA,
569                                 (i > 3 ? store : 0), 0);
570         }
571
572         mutex_unlock(&inter->fpga_mutex);
573 }
574
575 static int altera_pid_feed_control(void *demux_dev, int filt_nr,
576                 struct dvb_demux_feed *feed, int onoff)
577 {
578         struct fpga_inode *temp_int = find_dinode(demux_dev);
579         struct fpga_internal *inter = temp_int->internal;
580         struct netup_hw_pid_filter *pid_filt = inter->pid_filt[filt_nr - 1];
581
582         altera_pid_control(pid_filt, feed->pid, onoff ? 0 : 1);
583         /* call old feed proc's */
584         if (onoff)
585                 pid_filt->start_feed(feed);
586         else
587                 pid_filt->stop_feed(feed);
588
589         if (feed->pid == 0x2000)
590                 altera_toggle_fullts_streaming(pid_filt, filt_nr,
591                                                 onoff ? 0 : 1);
592
593         return 0;
594 }
595
596 static int altera_ci_start_feed(struct dvb_demux_feed *feed, int num)
597 {
598         altera_pid_feed_control(feed->demux, num, feed, 1);
599
600         return 0;
601 }
602
603 static int altera_ci_stop_feed(struct dvb_demux_feed *feed, int num)
604 {
605         altera_pid_feed_control(feed->demux, num, feed, 0);
606
607         return 0;
608 }
609
610 static int altera_ci_start_feed_1(struct dvb_demux_feed *feed)
611 {
612         return altera_ci_start_feed(feed, 1);
613 }
614
615 static int altera_ci_stop_feed_1(struct dvb_demux_feed *feed)
616 {
617         return altera_ci_stop_feed(feed, 1);
618 }
619
620 static int altera_ci_start_feed_2(struct dvb_demux_feed *feed)
621 {
622         return altera_ci_start_feed(feed, 2);
623 }
624
625 static int altera_ci_stop_feed_2(struct dvb_demux_feed *feed)
626 {
627         return altera_ci_stop_feed(feed, 2);
628 }
629
630 static int altera_hw_filt_init(struct altera_ci_config *config, int hw_filt_nr)
631 {
632         struct netup_hw_pid_filter *pid_filt = NULL;
633         struct fpga_inode *temp_int = find_inode(config->dev);
634         struct fpga_internal *inter = NULL;
635         int ret = 0;
636
637         pid_filt = kzalloc(sizeof(struct netup_hw_pid_filter), GFP_KERNEL);
638
639         ci_dbg_print("%s\n", __func__);
640
641         if (!pid_filt) {
642                 ret = -ENOMEM;
643                 goto err;
644         }
645
646         if (temp_int != NULL) {
647                 inter = temp_int->internal;
648                 (inter->filts_used)++;
649                 ci_dbg_print("%s: Find Internal Structure!\n", __func__);
650         } else {
651                 inter = kzalloc(sizeof(struct fpga_internal), GFP_KERNEL);
652                 if (!inter) {
653                         ret = -ENOMEM;
654                         goto err;
655                 }
656
657                 temp_int = append_internal(inter);
658                 if (!temp_int) {
659                         ret = -ENOMEM;
660                         goto err;
661                 }
662                 inter->filts_used = 1;
663                 inter->dev = config->dev;
664                 inter->fpga_rw = config->fpga_rw;
665                 mutex_init(&inter->fpga_mutex);
666                 inter->strt_wrk = 1;
667                 ci_dbg_print("%s: Create New Internal Structure!\n", __func__);
668         }
669
670         ci_dbg_print("%s: setting hw pid filter = %p for ci = %d\n", __func__,
671                                                 pid_filt, hw_filt_nr - 1);
672         inter->pid_filt[hw_filt_nr - 1] = pid_filt;
673         pid_filt->demux = config->demux;
674         pid_filt->internal = inter;
675         pid_filt->nr = hw_filt_nr - 1;
676         /* store old feed controls */
677         pid_filt->start_feed = config->demux->start_feed;
678         pid_filt->stop_feed = config->demux->stop_feed;
679         /* replace with new feed controls */
680         if (hw_filt_nr == 1) {
681                 pid_filt->demux->start_feed = altera_ci_start_feed_1;
682                 pid_filt->demux->stop_feed = altera_ci_stop_feed_1;
683         } else if (hw_filt_nr == 2) {
684                 pid_filt->demux->start_feed = altera_ci_start_feed_2;
685                 pid_filt->demux->stop_feed = altera_ci_stop_feed_2;
686         }
687
688         altera_toggle_fullts_streaming(pid_filt, 0, 1);
689
690         return 0;
691 err:
692         ci_dbg_print("%s: Can't init hardware filter: Error %d\n",
693                      __func__, ret);
694
695         kfree(pid_filt);
696         kfree(inter);
697
698         return ret;
699 }
700
701 int altera_ci_init(struct altera_ci_config *config, int ci_nr)
702 {
703         struct altera_ci_state *state;
704         struct fpga_inode *temp_int = find_inode(config->dev);
705         struct fpga_internal *inter = NULL;
706         int ret = 0;
707         u8 store = 0;
708
709         state = kzalloc(sizeof(struct altera_ci_state), GFP_KERNEL);
710
711         ci_dbg_print("%s\n", __func__);
712
713         if (!state) {
714                 ret = -ENOMEM;
715                 goto err;
716         }
717
718         if (temp_int != NULL) {
719                 inter = temp_int->internal;
720                 (inter->cis_used)++;
721                 inter->fpga_rw = config->fpga_rw;
722                 ci_dbg_print("%s: Find Internal Structure!\n", __func__);
723         } else {
724                 inter = kzalloc(sizeof(struct fpga_internal), GFP_KERNEL);
725                 if (!inter) {
726                         ret = -ENOMEM;
727                         goto err;
728                 }
729
730                 temp_int = append_internal(inter);
731                 if (!temp_int) {
732                         ret = -ENOMEM;
733                         goto err;
734                 }
735                 inter->cis_used = 1;
736                 inter->dev = config->dev;
737                 inter->fpga_rw = config->fpga_rw;
738                 mutex_init(&inter->fpga_mutex);
739                 inter->strt_wrk = 1;
740                 ci_dbg_print("%s: Create New Internal Structure!\n", __func__);
741         }
742
743         ci_dbg_print("%s: setting state = %p for ci = %d\n", __func__,
744                                                 state, ci_nr - 1);
745         state->internal = inter;
746         state->nr = ci_nr - 1;
747
748         state->ca.owner = THIS_MODULE;
749         state->ca.read_attribute_mem = altera_ci_read_attribute_mem;
750         state->ca.write_attribute_mem = altera_ci_write_attribute_mem;
751         state->ca.read_cam_control = altera_ci_read_cam_ctl;
752         state->ca.write_cam_control = altera_ci_write_cam_ctl;
753         state->ca.slot_reset = altera_ci_slot_reset;
754         state->ca.slot_shutdown = altera_ci_slot_shutdown;
755         state->ca.slot_ts_enable = altera_ci_slot_ts_ctl;
756         state->ca.poll_slot_status = altera_poll_ci_slot_status;
757         state->ca.data = state;
758
759         ret = dvb_ca_en50221_init(config->adapter,
760                                    &state->ca,
761                                    /* flags */ 0,
762                                    /* n_slots */ 1);
763         if (0 != ret)
764                 goto err;
765
766         inter->state[ci_nr - 1] = state;
767
768         altera_hw_filt_init(config, ci_nr);
769
770         if (inter->strt_wrk) {
771                 INIT_WORK(&inter->work, netup_read_ci_status);
772                 inter->strt_wrk = 0;
773         }
774
775         ci_dbg_print("%s: CI initialized!\n", __func__);
776
777         mutex_lock(&inter->fpga_mutex);
778
779         /* Enable div */
780         netup_fpga_op_rw(inter, NETUP_CI_TSA_DIV, 0x0, 0);
781         netup_fpga_op_rw(inter, NETUP_CI_TSB_DIV, 0x0, 0);
782
783         /* enable TS out */
784         store = netup_fpga_op_rw(inter, NETUP_CI_BUSCTRL2, 0, NETUP_CI_FLG_RD);
785         store |= (3 << 4);
786         netup_fpga_op_rw(inter, NETUP_CI_BUSCTRL2, store, 0);
787
788         ret = netup_fpga_op_rw(inter, NETUP_CI_REVISION, 0, NETUP_CI_FLG_RD);
789         /* enable irq */
790         netup_fpga_op_rw(inter, NETUP_CI_INT_CTRL, 0x44, 0);
791
792         mutex_unlock(&inter->fpga_mutex);
793
794         ci_dbg_print("%s: NetUP CI Revision = 0x%x\n", __func__, ret);
795
796         schedule_work(&inter->work);
797
798         return 0;
799 err:
800         ci_dbg_print("%s: Cannot initialize CI: Error %d.\n", __func__, ret);
801
802         kfree(state);
803         kfree(inter);
804
805         return ret;
806 }
807 EXPORT_SYMBOL(altera_ci_init);
808
809 int altera_ci_tuner_reset(void *dev, int ci_nr)
810 {
811         struct fpga_inode *temp_int = find_inode(dev);
812         struct fpga_internal *inter = NULL;
813         u8 store;
814
815         ci_dbg_print("%s\n", __func__);
816
817         if (temp_int == NULL)
818                 return -1;
819
820         if (temp_int->internal == NULL)
821                 return -1;
822
823         inter = temp_int->internal;
824
825         mutex_lock(&inter->fpga_mutex);
826
827         store = netup_fpga_op_rw(inter, NETUP_CI_BUSCTRL2, 0, NETUP_CI_FLG_RD);
828         store &= ~(4 << (2 - ci_nr));
829         netup_fpga_op_rw(inter, NETUP_CI_BUSCTRL2, store, 0);
830         msleep(100);
831         store |= (4 << (2 - ci_nr));
832         netup_fpga_op_rw(inter, NETUP_CI_BUSCTRL2, store, 0);
833
834         mutex_unlock(&inter->fpga_mutex);
835
836         return 0;
837 }
838 EXPORT_SYMBOL(altera_ci_tuner_reset);