1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * av7110_ca.c: CA and CI stuff 4 * 5 * Copyright (C) 1999-2002 Ralph Metzler 6 * & Marcus Metzler for convergence integrated media GmbH 7 * 8 * originally based on code by: 9 * Copyright (C) 1998,1999 Christian Theiss <mistert@rz.fh-augsburg.de> 10 * 11 * the project's page is at https://linuxtv.org 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/types.h> 16 #include <linux/delay.h> 17 #include <linux/fs.h> 18 #include <linux/timer.h> 19 #include <linux/poll.h> 20 #include <linux/gfp.h> 21 22 #include "av7110.h" 23 #include "av7110_hw.h" 24 #include "av7110_ca.h" 25 26 27 void CI_handle(struct av7110 *av7110, u8 *data, u16 len) 28 { 29 dprintk(8, "av7110:%p\n",av7110); 30 31 if (len < 3) 32 return; 33 switch (data[0]) { 34 case CI_MSG_CI_INFO: 35 if (data[2] != 1 && data[2] != 2) 36 break; 37 switch (data[1]) { 38 case 0: 39 av7110->ci_slot[data[2] - 1].flags = 0; 40 break; 41 case 1: 42 av7110->ci_slot[data[2] - 1].flags |= CA_CI_MODULE_PRESENT; 43 break; 44 case 2: 45 av7110->ci_slot[data[2] - 1].flags |= CA_CI_MODULE_READY; 46 break; 47 } 48 break; 49 case CI_SWITCH_PRG_REPLY: 50 //av7110->ci_stat=data[1]; 51 break; 52 default: 53 break; 54 } 55 } 56 57 58 void ci_get_data(struct dvb_ringbuffer *cibuf, u8 *data, int len) 59 { 60 if (dvb_ringbuffer_free(cibuf) < len + 2) 61 return; 62 63 DVB_RINGBUFFER_WRITE_BYTE(cibuf, len >> 8); 64 DVB_RINGBUFFER_WRITE_BYTE(cibuf, len & 0xff); 65 dvb_ringbuffer_write(cibuf, data, len); 66 wake_up_interruptible(&cibuf->queue); 67 } 68 69 70 /****************************************************************************** 71 * CI link layer file ops 72 ******************************************************************************/ 73 74 static int ci_ll_init(struct dvb_ringbuffer *cirbuf, struct dvb_ringbuffer *ciwbuf, int size) 75 { 76 struct dvb_ringbuffer *tab[] = { cirbuf, ciwbuf, NULL }, **p; 77 void *data; 78 79 for (p = tab; *p; p++) { 80 data = vmalloc(size); 81 if (!data) { 82 while (p-- != tab) { 83 vfree(p[0]->data); 84 p[0]->data = NULL; 85 } 86 return -ENOMEM; 87 } 88 dvb_ringbuffer_init(*p, data, size); 89 } 90 return 0; 91 } 92 93 static void ci_ll_flush(struct dvb_ringbuffer *cirbuf, struct dvb_ringbuffer *ciwbuf) 94 { 95 dvb_ringbuffer_flush_spinlock_wakeup(cirbuf); 96 dvb_ringbuffer_flush_spinlock_wakeup(ciwbuf); 97 } 98 99 static void ci_ll_release(struct dvb_ringbuffer *cirbuf, struct dvb_ringbuffer *ciwbuf) 100 { 101 vfree(cirbuf->data); 102 cirbuf->data = NULL; 103 vfree(ciwbuf->data); 104 ciwbuf->data = NULL; 105 } 106 107 static int ci_ll_reset(struct dvb_ringbuffer *cibuf, struct file *file, 108 int slots, struct ca_slot_info *slot) 109 { 110 int i; 111 int len = 0; 112 u8 msg[8] = { 0x00, 0x06, 0x00, 0x00, 0xff, 0x02, 0x00, 0x00 }; 113 114 for (i = 0; i < 2; i++) { 115 if (slots & (1 << i)) 116 len += 8; 117 } 118 119 if (dvb_ringbuffer_free(cibuf) < len) 120 return -EBUSY; 121 122 for (i = 0; i < 2; i++) { 123 if (slots & (1 << i)) { 124 msg[2] = i; 125 dvb_ringbuffer_write(cibuf, msg, 8); 126 slot[i].flags = 0; 127 } 128 } 129 130 return 0; 131 } 132 133 static ssize_t ci_ll_write(struct dvb_ringbuffer *cibuf, struct file *file, 134 const char __user *buf, size_t count, loff_t *ppos) 135 { 136 int free; 137 int non_blocking = file->f_flags & O_NONBLOCK; 138 u8 *page = (u8 *)__get_free_page(GFP_USER); 139 int res; 140 141 if (!page) 142 return -ENOMEM; 143 144 res = -EINVAL; 145 if (count > 2048) 146 goto out; 147 148 res = -EFAULT; 149 if (copy_from_user(page, buf, count)) 150 goto out; 151 152 free = dvb_ringbuffer_free(cibuf); 153 if (count + 2 > free) { 154 res = -EWOULDBLOCK; 155 if (non_blocking) 156 goto out; 157 res = -ERESTARTSYS; 158 if (wait_event_interruptible(cibuf->queue, 159 (dvb_ringbuffer_free(cibuf) >= count + 2))) 160 goto out; 161 } 162 163 DVB_RINGBUFFER_WRITE_BYTE(cibuf, count >> 8); 164 DVB_RINGBUFFER_WRITE_BYTE(cibuf, count & 0xff); 165 166 res = dvb_ringbuffer_write(cibuf, page, count); 167 out: 168 free_page((unsigned long)page); 169 return res; 170 } 171 172 static ssize_t ci_ll_read(struct dvb_ringbuffer *cibuf, struct file *file, 173 char __user *buf, size_t count, loff_t *ppos) 174 { 175 int avail; 176 int non_blocking = file->f_flags & O_NONBLOCK; 177 ssize_t len; 178 179 if (!cibuf->data || !count) 180 return 0; 181 if (non_blocking && (dvb_ringbuffer_empty(cibuf))) 182 return -EWOULDBLOCK; 183 if (wait_event_interruptible(cibuf->queue, 184 !dvb_ringbuffer_empty(cibuf))) 185 return -ERESTARTSYS; 186 avail = dvb_ringbuffer_avail(cibuf); 187 if (avail < 4) 188 return 0; 189 len = DVB_RINGBUFFER_PEEK(cibuf, 0) << 8; 190 len |= DVB_RINGBUFFER_PEEK(cibuf, 1); 191 if (avail < len + 2 || count < len) 192 return -EINVAL; 193 DVB_RINGBUFFER_SKIP(cibuf, 2); 194 195 return dvb_ringbuffer_read_user(cibuf, buf, len); 196 } 197 198 static int dvb_ca_open(struct inode *inode, struct file *file) 199 { 200 struct dvb_device *dvbdev = file->private_data; 201 struct av7110 *av7110 = dvbdev->priv; 202 int err = dvb_generic_open(inode, file); 203 204 dprintk(8, "av7110:%p\n",av7110); 205 206 if (err < 0) 207 return err; 208 ci_ll_flush(&av7110->ci_rbuffer, &av7110->ci_wbuffer); 209 return 0; 210 } 211 212 static __poll_t dvb_ca_poll (struct file *file, poll_table *wait) 213 { 214 struct dvb_device *dvbdev = file->private_data; 215 struct av7110 *av7110 = dvbdev->priv; 216 struct dvb_ringbuffer *rbuf = &av7110->ci_rbuffer; 217 struct dvb_ringbuffer *wbuf = &av7110->ci_wbuffer; 218 __poll_t mask = 0; 219 220 dprintk(8, "av7110:%p\n",av7110); 221 222 poll_wait(file, &rbuf->queue, wait); 223 poll_wait(file, &wbuf->queue, wait); 224 225 if (!dvb_ringbuffer_empty(rbuf)) 226 mask |= (EPOLLIN | EPOLLRDNORM); 227 228 if (dvb_ringbuffer_free(wbuf) > 1024) 229 mask |= (EPOLLOUT | EPOLLWRNORM); 230 231 return mask; 232 } 233 234 static int dvb_ca_ioctl(struct file *file, unsigned int cmd, void *parg) 235 { 236 struct dvb_device *dvbdev = file->private_data; 237 struct av7110 *av7110 = dvbdev->priv; 238 unsigned long arg = (unsigned long) parg; 239 int ret = 0; 240 241 dprintk(8, "av7110:%p\n",av7110); 242 243 if (mutex_lock_interruptible(&av7110->ioctl_mutex)) 244 return -ERESTARTSYS; 245 246 switch (cmd) { 247 case CA_RESET: 248 ret = ci_ll_reset(&av7110->ci_wbuffer, file, arg, 249 &av7110->ci_slot[0]); 250 break; 251 case CA_GET_CAP: 252 { 253 struct ca_caps cap; 254 255 cap.slot_num = 2; 256 cap.slot_type = (FW_CI_LL_SUPPORT(av7110->arm_app) ? 257 CA_CI_LINK : CA_CI) | CA_DESCR; 258 cap.descr_num = 16; 259 cap.descr_type = CA_ECD; 260 memcpy(parg, &cap, sizeof(cap)); 261 break; 262 } 263 264 case CA_GET_SLOT_INFO: 265 { 266 struct ca_slot_info *info=(struct ca_slot_info *)parg; 267 268 if (info->num < 0 || info->num > 1) { 269 mutex_unlock(&av7110->ioctl_mutex); 270 return -EINVAL; 271 } 272 av7110->ci_slot[info->num].num = info->num; 273 av7110->ci_slot[info->num].type = FW_CI_LL_SUPPORT(av7110->arm_app) ? 274 CA_CI_LINK : CA_CI; 275 memcpy(info, &av7110->ci_slot[info->num], sizeof(struct ca_slot_info)); 276 break; 277 } 278 279 case CA_GET_MSG: 280 break; 281 282 case CA_SEND_MSG: 283 break; 284 285 case CA_GET_DESCR_INFO: 286 { 287 struct ca_descr_info info; 288 289 info.num = 16; 290 info.type = CA_ECD; 291 memcpy(parg, &info, sizeof (info)); 292 break; 293 } 294 295 case CA_SET_DESCR: 296 { 297 struct ca_descr *descr = (struct ca_descr*) parg; 298 299 if (descr->index >= 16 || descr->parity > 1) { 300 mutex_unlock(&av7110->ioctl_mutex); 301 return -EINVAL; 302 } 303 av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetDescr, 5, 304 (descr->index<<8)|descr->parity, 305 (descr->cw[0]<<8)|descr->cw[1], 306 (descr->cw[2]<<8)|descr->cw[3], 307 (descr->cw[4]<<8)|descr->cw[5], 308 (descr->cw[6]<<8)|descr->cw[7]); 309 break; 310 } 311 312 default: 313 ret = -EINVAL; 314 break; 315 } 316 317 mutex_unlock(&av7110->ioctl_mutex); 318 return ret; 319 } 320 321 static ssize_t dvb_ca_write(struct file *file, const char __user *buf, 322 size_t count, loff_t *ppos) 323 { 324 struct dvb_device *dvbdev = file->private_data; 325 struct av7110 *av7110 = dvbdev->priv; 326 327 dprintk(8, "av7110:%p\n",av7110); 328 return ci_ll_write(&av7110->ci_wbuffer, file, buf, count, ppos); 329 } 330 331 static ssize_t dvb_ca_read(struct file *file, char __user *buf, 332 size_t count, loff_t *ppos) 333 { 334 struct dvb_device *dvbdev = file->private_data; 335 struct av7110 *av7110 = dvbdev->priv; 336 337 dprintk(8, "av7110:%p\n",av7110); 338 return ci_ll_read(&av7110->ci_rbuffer, file, buf, count, ppos); 339 } 340 341 static const struct file_operations dvb_ca_fops = { 342 .owner = THIS_MODULE, 343 .read = dvb_ca_read, 344 .write = dvb_ca_write, 345 .unlocked_ioctl = dvb_generic_ioctl, 346 .open = dvb_ca_open, 347 .release = dvb_generic_release, 348 .poll = dvb_ca_poll, 349 .llseek = default_llseek, 350 }; 351 352 static struct dvb_device dvbdev_ca = { 353 .priv = NULL, 354 .users = 1, 355 .writers = 1, 356 .fops = &dvb_ca_fops, 357 .kernel_ioctl = dvb_ca_ioctl, 358 }; 359 360 361 int av7110_ca_register(struct av7110 *av7110) 362 { 363 return dvb_register_device(&av7110->dvb_adapter, &av7110->ca_dev, 364 &dvbdev_ca, av7110, DVB_DEVICE_CA, 0); 365 } 366 367 void av7110_ca_unregister(struct av7110 *av7110) 368 { 369 dvb_unregister_device(av7110->ca_dev); 370 } 371 372 int av7110_ca_init(struct av7110* av7110) 373 { 374 return ci_ll_init(&av7110->ci_rbuffer, &av7110->ci_wbuffer, 8192); 375 } 376 377 void av7110_ca_exit(struct av7110* av7110) 378 { 379 ci_ll_release(&av7110->ci_rbuffer, &av7110->ci_wbuffer); 380 } 381