drivers/media/pci/cx23885/altera-ci.c

   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 */
 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 */
 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 */
 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 */
 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 */
 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
 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 */
 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
 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
 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
 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
 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
 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
 365 static int altera_ci_slot_shutdown(struct dvb_ca_en50221 *en50221, int slot)
 366 {
 367         /* not implemented */
 368         return 0;
 369 }
 370
 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 */
 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 */
 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
 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
 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
 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
 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
 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
 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
 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
 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
 617 static int altera_ci_start_feed_1(struct dvb_demux_feed *feed)
 618 {
 619         return altera_ci_start_feed(feed, 1);
 620 }
 621
 622 static int altera_ci_stop_feed_1(struct dvb_demux_feed *feed)
 623 {
 624         return altera_ci_stop_feed(feed, 1);
 625 }
 626
 627 static int altera_ci_start_feed_2(struct dvb_demux_feed *feed)
 628 {
 629         return altera_ci_start_feed(feed, 2);
 630 }
 631
 632 static int altera_ci_stop_feed_2(struct dvb_demux_feed *feed)
 633 {
 634         return altera_ci_stop_feed(feed, 2);
 635 }
 636
 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
 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
 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);