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);
839