drivers/media/pci/bt8xx/dst_ca.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3         CA-driver for TwinHan DST Frontend/Card
   4
   5         Copyright (C) 2004, 2005 Manu Abraham (manu@kromtek.com)
   6
   7 */
   8
   9 #include <linux/kernel.h>
  10 #include <linux/module.h>
  11 #include <linux/slab.h>
  12 #include <linux/init.h>
  13 #include <linux/mutex.h>
  14 #include <linux/string.h>
  15 #include <linux/dvb/ca.h>
  16 #include <media/dvbdev.h>
  17 #include <media/dvb_frontend.h>
  18 #include "dst_ca.h"
  19 #include "dst_common.h"
  20
  21 #define DST_CA_ERROR            0
  22 #define DST_CA_NOTICE           1
  23 #define DST_CA_INFO             2
  24 #define DST_CA_DEBUG            3
  25
  26 #define dprintk(x, y, z, format, arg...) do {                                           \
  27         if (z) {                                                                        \
  28                 if      ((x > DST_CA_ERROR) && (x > y))                                 \
  29                         printk(KERN_ERR "%s: " format "\n", __func__ , ##arg);  \
  30                 else if ((x > DST_CA_NOTICE) && (x > y))                                \
  31                         printk(KERN_NOTICE "%s: " format "\n", __func__ , ##arg);       \
  32                 else if ((x > DST_CA_INFO) && (x > y))                                  \
  33                         printk(KERN_INFO "%s: " format "\n", __func__ , ##arg); \
  34                 else if ((x > DST_CA_DEBUG) && (x > y))                                 \
  35                         printk(KERN_DEBUG "%s: " format "\n", __func__ , ##arg);        \
  36         } else {                                                                        \
  37                 if (x > y)                                                              \
  38                         printk(format, ## arg);                                         \
  39         }                                                                               \
  40 } while(0)
  41
  42
  43 static DEFINE_MUTEX(dst_ca_mutex);
  44 static unsigned int verbose = 5;
  45 module_param(verbose, int, 0644);
  46 MODULE_PARM_DESC(verbose, "verbose startup messages, default is 1 (yes)");
  47
  48 static void put_command_and_length(u8 *data, int command, int length)
  49 {
  50         data[0] = (command >> 16) & 0xff;
  51         data[1] = (command >> 8) & 0xff;
  52         data[2] = command & 0xff;
  53         data[3] = length;
  54 }
  55
  56 static void put_checksum(u8 *check_string, int length)
  57 {
  58         dprintk(verbose, DST_CA_DEBUG, 1, " Computing string checksum.");
  59         dprintk(verbose, DST_CA_DEBUG, 1, "  -> string length : 0x%02x", length);
  60         check_string[length] = dst_check_sum (check_string, length);
  61         dprintk(verbose, DST_CA_DEBUG, 1, "  -> checksum      : 0x%02x", check_string[length]);
  62 }
  63
  64 static int dst_ci_command(struct dst_state* state, u8 * data, u8 *ca_string, u8 len, int read)
  65 {
  66         u8 reply;
  67
  68         mutex_lock(&state->dst_mutex);
  69         dst_comm_init(state);
  70         msleep(65);
  71
  72         if (write_dst(state, data, len)) {
  73                 dprintk(verbose, DST_CA_INFO, 1, " Write not successful, trying to recover");
  74                 dst_error_recovery(state);
  75                 goto error;
  76         }
  77         if ((dst_pio_disable(state)) < 0) {
  78                 dprintk(verbose, DST_CA_ERROR, 1, " DST PIO disable failed.");
  79                 goto error;
  80         }
  81         if (read_dst(state, &reply, GET_ACK) < 0) {
  82                 dprintk(verbose, DST_CA_INFO, 1, " Read not successful, trying to recover");
  83                 dst_error_recovery(state);
  84                 goto error;
  85         }
  86         if (read) {
  87                 if (! dst_wait_dst_ready(state, LONG_DELAY)) {
  88                         dprintk(verbose, DST_CA_NOTICE, 1, " 8820 not ready");
  89                         goto error;
  90                 }
  91                 if (read_dst(state, ca_string, 128) < 0) {      /*      Try to make this dynamic        */
  92                         dprintk(verbose, DST_CA_INFO, 1, " Read not successful, trying to recover");
  93                         dst_error_recovery(state);
  94                         goto error;
  95                 }
  96         }
  97         mutex_unlock(&state->dst_mutex);
  98         return 0;
  99
 100 error:
 101         mutex_unlock(&state->dst_mutex);
 102         return -EIO;
 103 }
 104
 105
 106 static int dst_put_ci(struct dst_state *state, u8 *data, int len, u8 *ca_string, int read)
 107 {
 108         u8 dst_ca_comm_err = 0;
 109
 110         while (dst_ca_comm_err < RETRIES) {
 111                 dprintk(verbose, DST_CA_NOTICE, 1, " Put Command");
 112                 if (dst_ci_command(state, data, ca_string, len, read)) {        // If error
 113                         dst_error_recovery(state);
 114                         dst_ca_comm_err++; // work required here.
 115                 } else {
 116                         break;
 117                 }
 118         }
 119
 120         if(dst_ca_comm_err == RETRIES)
 121                 return -EIO;
 122
 123         return 0;
 124 }
 125
 126
 127
 128 static int ca_get_app_info(struct dst_state *state)
 129 {
 130         int length, str_length;
 131         static u8 command[8] = {0x07, 0x40, 0x01, 0x00, 0x01, 0x00, 0x00, 0xff};
 132
 133         put_checksum(&command[0], command[0]);
 134         if ((dst_put_ci(state, command, sizeof(command), state->messages, GET_REPLY)) < 0) {
 135                 dprintk(verbose, DST_CA_ERROR, 1, " -->dst_put_ci FAILED !");
 136                 return -EIO;
 137         }
 138         dprintk(verbose, DST_CA_INFO, 1, " -->dst_put_ci SUCCESS !");
 139         dprintk(verbose, DST_CA_INFO, 1, " ================================ CI Module Application Info ======================================");
 140         dprintk(verbose, DST_CA_INFO, 1, " Application Type=[%d], Application Vendor=[%d], Vendor Code=[%d]\n%s: Application info=[%s]",
 141                 state->messages[7], (state->messages[8] << 8) | state->messages[9],
 142                 (state->messages[10] << 8) | state->messages[11], __func__, (char *)(&state->messages[12]));
 143         dprintk(verbose, DST_CA_INFO, 1, " ==================================================================================================");
 144
 145         // Transform dst message to correct application_info message
 146         length = state->messages[5];
 147         str_length = length - 6;
 148         if (str_length < 0) {
 149                 str_length = 0;
 150                 dprintk(verbose, DST_CA_ERROR, 1, "Invalid string length returned in ca_get_app_info(). Recovering.");
 151         }
 152
 153         // First, the command and length fields
 154         put_command_and_length(&state->messages[0], CA_APP_INFO, length);
 155
 156         // Copy application_type, application_manufacturer and manufacturer_code
 157         memmove(&state->messages[4], &state->messages[7], 5);
 158
 159         // Set string length and copy string
 160         state->messages[9] = str_length;
 161         memmove(&state->messages[10], &state->messages[12], str_length);
 162
 163         return 0;
 164 }
 165
 166 static int ca_get_ca_info(struct dst_state *state)
 167 {
 168         int srcPtr, dstPtr, i, num_ids;
 169         static u8 slot_command[8] = {0x07, 0x40, 0x00, 0x00, 0x02, 0x00, 0x00, 0xff};
 170         const int in_system_id_pos = 8, out_system_id_pos = 4, in_num_ids_pos = 7;
 171
 172         put_checksum(&slot_command[0], slot_command[0]);
 173         if ((dst_put_ci(state, slot_command, sizeof (slot_command), state->messages, GET_REPLY)) < 0) {
 174                 dprintk(verbose, DST_CA_ERROR, 1, " -->dst_put_ci FAILED !");
 175                 return -EIO;
 176         }
 177         dprintk(verbose, DST_CA_INFO, 1, " -->dst_put_ci SUCCESS !");
 178
 179         // Print raw data
 180         dprintk(verbose, DST_CA_INFO, 0, " DST data = [");
 181         for (i = 0; i < state->messages[0] + 1; i++) {
 182                 dprintk(verbose, DST_CA_INFO, 0, " 0x%02x", state->messages[i]);
 183         }
 184         dprintk(verbose, DST_CA_INFO, 0, "]\n");
 185
 186         // Set the command and length of the output
 187         num_ids = state->messages[in_num_ids_pos];
 188         if (num_ids >= 100) {
 189                 num_ids = 100;
 190                 dprintk(verbose, DST_CA_ERROR, 1, "Invalid number of ids (>100). Recovering.");
 191         }
 192         put_command_and_length(&state->messages[0], CA_INFO, num_ids * 2);
 193
 194         dprintk(verbose, DST_CA_INFO, 0, " CA_INFO = [");
 195         srcPtr = in_system_id_pos;
 196         dstPtr = out_system_id_pos;
 197         for(i = 0; i < num_ids; i++) {
 198                 dprintk(verbose, DST_CA_INFO, 0, " 0x%02x%02x", state->messages[srcPtr + 0], state->messages[srcPtr + 1]);
 199                 // Append to output
 200                 state->messages[dstPtr + 0] = state->messages[srcPtr + 0];
 201                 state->messages[dstPtr + 1] = state->messages[srcPtr + 1];
 202                 srcPtr += 2;
 203                 dstPtr += 2;
 204         }
 205         dprintk(verbose, DST_CA_INFO, 0, "]\n");
 206
 207         return 0;
 208 }
 209
 210 static int ca_get_slot_caps(struct dst_state *state, struct ca_caps *p_ca_caps, void __user *arg)
 211 {
 212         int i;
 213         u8 slot_cap[256];
 214         static u8 slot_command[8] = {0x07, 0x40, 0x02, 0x00, 0x02, 0x00, 0x00, 0xff};
 215
 216         put_checksum(&slot_command[0], slot_command[0]);
 217         if ((dst_put_ci(state, slot_command, sizeof (slot_command), slot_cap, GET_REPLY)) < 0) {
 218                 dprintk(verbose, DST_CA_ERROR, 1, " -->dst_put_ci FAILED !");
 219                 return -EIO;
 220         }
 221         dprintk(verbose, DST_CA_NOTICE, 1, " -->dst_put_ci SUCCESS !");
 222
 223         /*      Will implement the rest soon            */
 224
 225         dprintk(verbose, DST_CA_INFO, 1, " Slot cap = [%d]", slot_cap[7]);
 226         dprintk(verbose, DST_CA_INFO, 0, "===================================\n");
 227         for (i = 0; i < slot_cap[0] + 1; i++)
 228                 dprintk(verbose, DST_CA_INFO, 0, " %d", slot_cap[i]);
 229         dprintk(verbose, DST_CA_INFO, 0, "\n");
 230
 231         p_ca_caps->slot_num = 1;
 232         p_ca_caps->slot_type = 1;
 233         p_ca_caps->descr_num = slot_cap[7];
 234         p_ca_caps->descr_type = 1;
 235
 236         if (copy_to_user(arg, p_ca_caps, sizeof (struct ca_caps)))
 237                 return -EFAULT;
 238
 239         return 0;
 240 }
 241
 242 /*      Need some more work     */
 243 static int ca_get_slot_descr(struct dst_state *state, struct ca_msg *p_ca_message, void __user *arg)
 244 {
 245         return -EOPNOTSUPP;
 246 }
 247
 248
 249 static int ca_get_slot_info(struct dst_state *state, struct ca_slot_info *p_ca_slot_info, void __user *arg)
 250 {
 251         int i;
 252         static u8 slot_command[8] = {0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff};
 253
 254         u8 *slot_info = state->messages;
 255
 256         put_checksum(&slot_command[0], 7);
 257         if ((dst_put_ci(state, slot_command, sizeof (slot_command), slot_info, GET_REPLY)) < 0) {
 258                 dprintk(verbose, DST_CA_ERROR, 1, " -->dst_put_ci FAILED !");
 259                 return -EIO;
 260         }
 261         dprintk(verbose, DST_CA_INFO, 1, " -->dst_put_ci SUCCESS !");
 262
 263         /*      Will implement the rest soon            */
 264
 265         dprintk(verbose, DST_CA_INFO, 1, " Slot info = [%d]", slot_info[3]);
 266         dprintk(verbose, DST_CA_INFO, 0, "===================================\n");
 267         for (i = 0; i < 8; i++)
 268                 dprintk(verbose, DST_CA_INFO, 0, " %d", slot_info[i]);
 269         dprintk(verbose, DST_CA_INFO, 0, "\n");
 270
 271         if (slot_info[4] & 0x80) {
 272                 p_ca_slot_info->flags = CA_CI_MODULE_PRESENT;
 273                 p_ca_slot_info->num = 1;
 274                 p_ca_slot_info->type = CA_CI;
 275         } else if (slot_info[4] & 0x40) {
 276                 p_ca_slot_info->flags = CA_CI_MODULE_READY;
 277                 p_ca_slot_info->num = 1;
 278                 p_ca_slot_info->type = CA_CI;
 279         } else
 280                 p_ca_slot_info->flags = 0;
 281
 282         if (copy_to_user(arg, p_ca_slot_info, sizeof (struct ca_slot_info)))
 283                 return -EFAULT;
 284
 285         return 0;
 286 }
 287
 288
 289 static int ca_get_message(struct dst_state *state, struct ca_msg *p_ca_message, void __user *arg)
 290 {
 291         u8 i = 0;
 292         u32 command = 0;
 293
 294         if (copy_from_user(p_ca_message, arg, sizeof (struct ca_msg)))
 295                 return -EFAULT;
 296
 297         dprintk(verbose, DST_CA_NOTICE, 1, " Message = [%*ph]",
 298                 3, p_ca_message->msg);
 299
 300         for (i = 0; i < 3; i++) {
 301                 command = command | p_ca_message->msg[i];
 302                 if (i < 2)
 303                         command = command << 8;
 304         }
 305         dprintk(verbose, DST_CA_NOTICE, 1, " Command=[0x%x]", command);
 306
 307         switch (command) {
 308         case CA_APP_INFO:
 309                 memcpy(p_ca_message->msg, state->messages, 128);
 310                 if (copy_to_user(arg, p_ca_message, sizeof (struct ca_msg)) )
 311                         return -EFAULT;
 312                 break;
 313         case CA_INFO:
 314                 memcpy(p_ca_message->msg, state->messages, 128);
 315                 if (copy_to_user(arg, p_ca_message, sizeof (struct ca_msg)) )
 316                         return -EFAULT;
 317                 break;
 318         }
 319
 320         return 0;
 321 }
 322
 323 static int handle_dst_tag(struct dst_state *state, struct ca_msg *p_ca_message, struct ca_msg *hw_buffer, u32 length)
 324 {
 325         if (state->dst_hw_cap & DST_TYPE_HAS_SESSION) {
 326                 hw_buffer->msg[2] = p_ca_message->msg[1];       /*      MSB     */
 327                 hw_buffer->msg[3] = p_ca_message->msg[2];       /*      LSB     */
 328         } else {
 329                 if (length > 247) {
 330                         dprintk(verbose, DST_CA_ERROR, 1, " Message too long ! *** Bailing Out *** !");
 331                         return -EIO;
 332                 }
 333                 hw_buffer->msg[0] = (length & 0xff) + 7;
 334                 hw_buffer->msg[1] = 0x40;
 335                 hw_buffer->msg[2] = 0x03;
 336                 hw_buffer->msg[3] = 0x00;
 337                 hw_buffer->msg[4] = 0x03;
 338                 hw_buffer->msg[5] = length & 0xff;
 339                 hw_buffer->msg[6] = 0x00;
 340
 341                 /*
 342                  *      Need to compute length for EN50221 section 8.3.2, for the time being
 343                  *      assuming 8.3.2 is not applicable
 344                  */
 345                 memcpy(&hw_buffer->msg[7], &p_ca_message->msg[4], length);
 346         }
 347
 348         return 0;
 349 }
 350
 351 static int write_to_8820(struct dst_state *state, struct ca_msg *hw_buffer, u8 length, u8 reply)
 352 {
 353         if ((dst_put_ci(state, hw_buffer->msg, length, hw_buffer->msg, reply)) < 0) {
 354                 dprintk(verbose, DST_CA_ERROR, 1, " DST-CI Command failed.");
 355                 dprintk(verbose, DST_CA_NOTICE, 1, " Resetting DST.");
 356                 rdc_reset_state(state);
 357                 return -EIO;
 358         }
 359         dprintk(verbose, DST_CA_NOTICE, 1, " DST-CI Command success.");
 360
 361         return 0;
 362 }
 363
 364 static u32 asn_1_decode(u8 *asn_1_array)
 365 {
 366         u8 length_field = 0, word_count = 0, count = 0;
 367         u32 length = 0;
 368
 369         length_field = asn_1_array[0];
 370         dprintk(verbose, DST_CA_DEBUG, 1, " Length field=[%02x]", length_field);
 371         if (length_field < 0x80) {
 372                 length = length_field & 0x7f;
 373                 dprintk(verbose, DST_CA_DEBUG, 1, " Length=[%02x]\n", length);
 374         } else {
 375                 word_count = length_field & 0x7f;
 376                 for (count = 0; count < word_count; count++) {
 377                         length = length  << 8;
 378                         length += asn_1_array[count + 1];
 379                         dprintk(verbose, DST_CA_DEBUG, 1, " Length=[%04x]", length);
 380                 }
 381         }
 382         return length;
 383 }
 384
 385 static int debug_string(u8 *msg, u32 length, u32 offset)
 386 {
 387         u32 i;
 388
 389         dprintk(verbose, DST_CA_DEBUG, 0, " String=[ ");
 390         for (i = offset; i < length; i++)
 391                 dprintk(verbose, DST_CA_DEBUG, 0, "%02x ", msg[i]);
 392         dprintk(verbose, DST_CA_DEBUG, 0, "]\n");
 393
 394         return 0;
 395 }
 396
 397
 398 static int ca_set_pmt(struct dst_state *state, struct ca_msg *p_ca_message, struct ca_msg *hw_buffer, u8 reply, u8 query)
 399 {
 400         u32 length = 0;
 401         u8 tag_length = 8;
 402
 403         length = asn_1_decode(&p_ca_message->msg[3]);
 404         dprintk(verbose, DST_CA_DEBUG, 1, " CA Message length=[%d]", length);
 405         debug_string(&p_ca_message->msg[4], length, 0); /*      length is excluding tag & length        */
 406
 407         memset(hw_buffer->msg, '\0', length);
 408         handle_dst_tag(state, p_ca_message, hw_buffer, length);
 409         put_checksum(hw_buffer->msg, hw_buffer->msg[0]);
 410
 411         debug_string(hw_buffer->msg, (length + tag_length), 0); /*      tags too        */
 412         write_to_8820(state, hw_buffer, (length + tag_length), reply);
 413
 414         return 0;
 415 }
 416
 417
 418 /*      Board supports CA PMT reply ?           */
 419 static int dst_check_ca_pmt(struct dst_state *state, struct ca_msg *p_ca_message, struct ca_msg *hw_buffer)
 420 {
 421         int ca_pmt_reply_test = 0;
 422
 423         /*      Do test board                   */
 424         /*      Not there yet but soon          */
 425
 426         /*      CA PMT Reply capable            */
 427         if (ca_pmt_reply_test) {
 428                 if ((ca_set_pmt(state, p_ca_message, hw_buffer, 1, GET_REPLY)) < 0) {
 429                         dprintk(verbose, DST_CA_ERROR, 1, " ca_set_pmt.. failed !");
 430                         return -EIO;
 431                 }
 432
 433         /*      Process CA PMT Reply            */
 434         /*      will implement soon             */
 435                 dprintk(verbose, DST_CA_ERROR, 1, " Not there yet");
 436         }
 437         /*      CA PMT Reply not capable        */
 438         if (!ca_pmt_reply_test) {
 439                 if ((ca_set_pmt(state, p_ca_message, hw_buffer, 0, NO_REPLY)) < 0) {
 440                         dprintk(verbose, DST_CA_ERROR, 1, " ca_set_pmt.. failed !");
 441                         return -EIO;
 442                 }
 443                 dprintk(verbose, DST_CA_NOTICE, 1, " ca_set_pmt.. success !");
 444         /*      put a dummy message             */
 445
 446         }
 447         return 0;
 448 }
 449
 450 static int ca_send_message(struct dst_state *state, struct ca_msg *p_ca_message, void __user *arg)
 451 {
 452         int i;
 453         u32 command;
 454         struct ca_msg *hw_buffer;
 455         int result = 0;
 456
 457         hw_buffer = kmalloc(sizeof(*hw_buffer), GFP_KERNEL);
 458         if (!hw_buffer)
 459                 return -ENOMEM;
 460         dprintk(verbose, DST_CA_DEBUG, 1, " ");
 461
 462         if (copy_from_user(p_ca_message, arg, sizeof (struct ca_msg))) {
 463                 result = -EFAULT;
 464                 goto free_mem_and_exit;
 465         }
 466
 467         /*      EN50221 tag     */
 468         command = 0;
 469
 470         for (i = 0; i < 3; i++) {
 471                 command = command | p_ca_message->msg[i];
 472                 if (i < 2)
 473                         command = command << 8;
 474         }
 475         dprintk(verbose, DST_CA_DEBUG, 1, " Command=[0x%x]\n", command);
 476
 477         switch (command) {
 478         case CA_PMT:
 479                 dprintk(verbose, DST_CA_DEBUG, 1, "Command = SEND_CA_PMT");
 480                 if ((ca_set_pmt(state, p_ca_message, hw_buffer, 0, 0)) < 0) {   // code simplification started
 481                         dprintk(verbose, DST_CA_ERROR, 1, " -->CA_PMT Failed !");
 482                         result = -1;
 483                         goto free_mem_and_exit;
 484                 }
 485                 dprintk(verbose, DST_CA_INFO, 1, " -->CA_PMT Success !");
 486                 break;
 487         case CA_PMT_REPLY:
 488                 dprintk(verbose, DST_CA_INFO, 1, "Command = CA_PMT_REPLY");
 489                 /*      Have to handle the 2 basic types of cards here  */
 490                 if ((dst_check_ca_pmt(state, p_ca_message, hw_buffer)) < 0) {
 491                         dprintk(verbose, DST_CA_ERROR, 1, " -->CA_PMT_REPLY Failed !");
 492                         result = -1;
 493                         goto free_mem_and_exit;
 494                 }
 495                 dprintk(verbose, DST_CA_INFO, 1, " -->CA_PMT_REPLY Success !");
 496                 break;
 497         case CA_APP_INFO_ENQUIRY:               // only for debugging
 498                 dprintk(verbose, DST_CA_INFO, 1, " Getting Cam Application information");
 499
 500                 if ((ca_get_app_info(state)) < 0) {
 501                         dprintk(verbose, DST_CA_ERROR, 1, " -->CA_APP_INFO_ENQUIRY Failed !");
 502                         result = -1;
 503                         goto free_mem_and_exit;
 504                 }
 505                 dprintk(verbose, DST_CA_INFO, 1, " -->CA_APP_INFO_ENQUIRY Success !");
 506                 break;
 507         case CA_INFO_ENQUIRY:
 508                 dprintk(verbose, DST_CA_INFO, 1, " Getting CA Information");
 509
 510                 if ((ca_get_ca_info(state)) < 0) {
 511                         dprintk(verbose, DST_CA_ERROR, 1, " -->CA_INFO_ENQUIRY Failed !");
 512                         result = -1;
 513                         goto free_mem_and_exit;
 514                 }
 515                 dprintk(verbose, DST_CA_INFO, 1, " -->CA_INFO_ENQUIRY Success !");
 516                 break;
 517         }
 518
 519 free_mem_and_exit:
 520         kfree (hw_buffer);
 521
 522         return result;
 523 }
 524
 525 static long dst_ca_ioctl(struct file *file, unsigned int cmd, unsigned long ioctl_arg)
 526 {
 527         struct dvb_device *dvbdev;
 528         struct dst_state *state;
 529         struct ca_slot_info *p_ca_slot_info;
 530         struct ca_caps *p_ca_caps;
 531         struct ca_msg *p_ca_message;
 532         void __user *arg = (void __user *)ioctl_arg;
 533         int result = 0;
 534
 535         mutex_lock(&dst_ca_mutex);
 536         dvbdev = file->private_data;
 537         state = (struct dst_state *)dvbdev->priv;
 538         p_ca_message = kmalloc(sizeof (struct ca_msg), GFP_KERNEL);
 539         p_ca_slot_info = kmalloc(sizeof (struct ca_slot_info), GFP_KERNEL);
 540         p_ca_caps = kmalloc(sizeof (struct ca_caps), GFP_KERNEL);
 541         if (!p_ca_message || !p_ca_slot_info || !p_ca_caps) {
 542                 result = -ENOMEM;
 543                 goto free_mem_and_exit;
 544         }
 545
 546         /*      We have now only the standard ioctl's, the driver is upposed to handle internals.       */
 547         switch (cmd) {
 548         case CA_SEND_MSG:
 549                 dprintk(verbose, DST_CA_INFO, 1, " Sending message");
 550                 result = ca_send_message(state, p_ca_message, arg);
 551
 552                 if (result < 0) {
 553                         dprintk(verbose, DST_CA_ERROR, 1, " -->CA_SEND_MSG Failed !");
 554                         goto free_mem_and_exit;
 555                 }
 556                 break;
 557         case CA_GET_MSG:
 558                 dprintk(verbose, DST_CA_INFO, 1, " Getting message");
 559                 result = ca_get_message(state, p_ca_message, arg);
 560                 if (result < 0) {
 561                         dprintk(verbose, DST_CA_ERROR, 1, " -->CA_GET_MSG Failed !");
 562                         goto free_mem_and_exit;
 563                 }
 564                 dprintk(verbose, DST_CA_INFO, 1, " -->CA_GET_MSG Success !");
 565                 break;
 566         case CA_RESET:
 567                 dprintk(verbose, DST_CA_ERROR, 1, " Resetting DST");
 568                 dst_error_bailout(state);
 569                 msleep(4000);
 570                 break;
 571         case CA_GET_SLOT_INFO:
 572                 dprintk(verbose, DST_CA_INFO, 1, " Getting Slot info");
 573                 result = ca_get_slot_info(state, p_ca_slot_info, arg);
 574                 if (result < 0) {
 575                         dprintk(verbose, DST_CA_ERROR, 1, " -->CA_GET_SLOT_INFO Failed !");
 576                         result = -1;
 577                         goto free_mem_and_exit;
 578                 }
 579                 dprintk(verbose, DST_CA_INFO, 1, " -->CA_GET_SLOT_INFO Success !");
 580                 break;
 581         case CA_GET_CAP:
 582                 dprintk(verbose, DST_CA_INFO, 1, " Getting Slot capabilities");
 583                 result = ca_get_slot_caps(state, p_ca_caps, arg);
 584                 if (result < 0) {
 585                         dprintk(verbose, DST_CA_ERROR, 1, " -->CA_GET_CAP Failed !");
 586                         goto free_mem_and_exit;
 587                 }
 588                 dprintk(verbose, DST_CA_INFO, 1, " -->CA_GET_CAP Success !");
 589                 break;
 590         case CA_GET_DESCR_INFO:
 591                 dprintk(verbose, DST_CA_INFO, 1, " Getting descrambler description");
 592                 result = ca_get_slot_descr(state, p_ca_message, arg);
 593                 if (result < 0) {
 594                         dprintk(verbose, DST_CA_ERROR, 1, " -->CA_GET_DESCR_INFO Failed !");
 595                         goto free_mem_and_exit;
 596                 }
 597                 dprintk(verbose, DST_CA_INFO, 1, " -->CA_GET_DESCR_INFO Success !");
 598                 break;
 599         default:
 600                 result = -EOPNOTSUPP;
 601         }
 602  free_mem_and_exit:
 603         kfree (p_ca_message);
 604         kfree (p_ca_slot_info);
 605         kfree (p_ca_caps);
 606
 607         mutex_unlock(&dst_ca_mutex);
 608         return result;
 609 }
 610
 611 static int dst_ca_open(struct inode *inode, struct file *file)
 612 {
 613         dprintk(verbose, DST_CA_DEBUG, 1, " Device opened [%p] ", file);
 614
 615         return 0;
 616 }
 617
 618 static int dst_ca_release(struct inode *inode, struct file *file)
 619 {
 620         dprintk(verbose, DST_CA_DEBUG, 1, " Device closed.");
 621
 622         return 0;
 623 }
 624
 625 static ssize_t dst_ca_read(struct file *file, char __user *buffer, size_t length, loff_t *offset)
 626 {
 627         dprintk(verbose, DST_CA_DEBUG, 1, " Device read.");
 628
 629         return 0;
 630 }
 631
 632 static ssize_t dst_ca_write(struct file *file, const char __user *buffer, size_t length, loff_t *offset)
 633 {
 634         dprintk(verbose, DST_CA_DEBUG, 1, " Device write.");
 635
 636         return 0;
 637 }
 638
 639 static const struct file_operations dst_ca_fops = {
 640         .owner = THIS_MODULE,
 641         .unlocked_ioctl = dst_ca_ioctl,
 642         .open = dst_ca_open,
 643         .release = dst_ca_release,
 644         .read = dst_ca_read,
 645         .write = dst_ca_write,
 646         .llseek = noop_llseek,
 647 };
 648
 649 static struct dvb_device dvbdev_ca = {
 650         .priv = NULL,
 651         .users = 1,
 652         .readers = 1,
 653         .writers = 1,
 654         .fops = &dst_ca_fops
 655 };
 656
 657 struct dvb_device *dst_ca_attach(struct dst_state *dst, struct dvb_adapter *dvb_adapter)
 658 {
 659         struct dvb_device *dvbdev;
 660
 661         dprintk(verbose, DST_CA_ERROR, 1, "registering DST-CA device");
 662         if (dvb_register_device(dvb_adapter, &dvbdev, &dvbdev_ca, dst,
 663                                 DVB_DEVICE_CA, 0) == 0) {
 664                 dst->dst_ca = dvbdev;
 665                 return dst->dst_ca;
 666         }
 667
 668         return NULL;
 669 }
 670
 671 EXPORT_SYMBOL(dst_ca_attach);
 672
 673 MODULE_DESCRIPTION("DST DVB-S/T/C Combo CA driver");
 674 MODULE_AUTHOR("Manu Abraham");
 675 MODULE_LICENSE("GPL");