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