dvbdev.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989
  1. /*
  2. * dvbdev.c
  3. *
  4. * Copyright (C) 2000 Ralph Metzler <ralph@convergence.de>
  5. * & Marcus Metzler <marcus@convergence.de>
  6. * for convergence integrated media GmbH
  7. *
  8. * This program is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU Lesser General Public License
  10. * as published by the Free Software Foundation; either version 2.1
  11. * of the License, or (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU Lesser General Public License
  19. * along with this program; if not, write to the Free Software
  20. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21. *
  22. */
  23. #define pr_fmt(fmt) "dvbdev: " fmt
  24. #include <linux/types.h>
  25. #include <linux/errno.h>
  26. #include <linux/string.h>
  27. #include <linux/module.h>
  28. #include <linux/kernel.h>
  29. #include <linux/init.h>
  30. #include <linux/slab.h>
  31. #include <linux/device.h>
  32. #include <linux/fs.h>
  33. #include <linux/cdev.h>
  34. #include <linux/mutex.h>
  35. #include "dvbdev.h"
  36. /* Due to enum tuner_pad_index */
  37. #include <media/tuner.h>
  38. static DEFINE_MUTEX(dvbdev_mutex);
  39. static int dvbdev_debug;
  40. module_param(dvbdev_debug, int, 0644);
  41. MODULE_PARM_DESC(dvbdev_debug, "Turn on/off device debugging (default:off).");
  42. #define dprintk(fmt, arg...) do { \
  43. if (dvbdev_debug) \
  44. printk(KERN_DEBUG pr_fmt("%s: " fmt), \
  45. __func__, ##arg); \
  46. } while (0)
  47. static LIST_HEAD(dvb_adapter_list);
  48. static DEFINE_MUTEX(dvbdev_register_lock);
  49. static const char * const dnames[] = {
  50. "video", "audio", "sec", "frontend", "demux", "dvr", "ca",
  51. "net", "osd"
  52. };
  53. #ifdef CONFIG_DVB_DYNAMIC_MINORS
  54. #define MAX_DVB_MINORS 256
  55. #define DVB_MAX_IDS MAX_DVB_MINORS
  56. #else
  57. #define DVB_MAX_IDS 4
  58. #define nums2minor(num, type, id) ((num << 6) | (id << 4) | type)
  59. #define MAX_DVB_MINORS (DVB_MAX_ADAPTERS*64)
  60. #endif
  61. static struct class *dvb_class;
  62. static struct dvb_device *dvb_minors[MAX_DVB_MINORS];
  63. static DECLARE_RWSEM(minor_rwsem);
  64. static int dvb_device_open(struct inode *inode, struct file *file)
  65. {
  66. struct dvb_device *dvbdev;
  67. mutex_lock(&dvbdev_mutex);
  68. down_read(&minor_rwsem);
  69. dvbdev = dvb_minors[iminor(inode)];
  70. if (dvbdev && dvbdev->fops) {
  71. int err = 0;
  72. const struct file_operations *new_fops;
  73. new_fops = fops_get(dvbdev->fops);
  74. if (!new_fops)
  75. goto fail;
  76. file->private_data = dvbdev;
  77. replace_fops(file, new_fops);
  78. if (file->f_op->open)
  79. err = file->f_op->open(inode, file);
  80. up_read(&minor_rwsem);
  81. mutex_unlock(&dvbdev_mutex);
  82. return err;
  83. }
  84. fail:
  85. up_read(&minor_rwsem);
  86. mutex_unlock(&dvbdev_mutex);
  87. return -ENODEV;
  88. }
  89. static const struct file_operations dvb_device_fops =
  90. {
  91. .owner = THIS_MODULE,
  92. .open = dvb_device_open,
  93. .llseek = noop_llseek,
  94. };
  95. static struct cdev dvb_device_cdev;
  96. int dvb_generic_open(struct inode *inode, struct file *file)
  97. {
  98. struct dvb_device *dvbdev = file->private_data;
  99. if (!dvbdev)
  100. return -ENODEV;
  101. if (!dvbdev->users)
  102. return -EBUSY;
  103. if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
  104. if (!dvbdev->readers)
  105. return -EBUSY;
  106. dvbdev->readers--;
  107. } else {
  108. if (!dvbdev->writers)
  109. return -EBUSY;
  110. dvbdev->writers--;
  111. }
  112. dvbdev->users--;
  113. return 0;
  114. }
  115. EXPORT_SYMBOL(dvb_generic_open);
  116. int dvb_generic_release(struct inode *inode, struct file *file)
  117. {
  118. struct dvb_device *dvbdev = file->private_data;
  119. if (!dvbdev)
  120. return -ENODEV;
  121. if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
  122. dvbdev->readers++;
  123. } else {
  124. dvbdev->writers++;
  125. }
  126. dvbdev->users++;
  127. return 0;
  128. }
  129. EXPORT_SYMBOL(dvb_generic_release);
  130. long dvb_generic_ioctl(struct file *file,
  131. unsigned int cmd, unsigned long arg)
  132. {
  133. struct dvb_device *dvbdev = file->private_data;
  134. if (!dvbdev)
  135. return -ENODEV;
  136. if (!dvbdev->kernel_ioctl)
  137. return -EINVAL;
  138. return dvb_usercopy(file, cmd, arg, dvbdev->kernel_ioctl);
  139. }
  140. EXPORT_SYMBOL(dvb_generic_ioctl);
  141. static int dvbdev_get_free_id (struct dvb_adapter *adap, int type)
  142. {
  143. u32 id = 0;
  144. while (id < DVB_MAX_IDS) {
  145. struct dvb_device *dev;
  146. list_for_each_entry(dev, &adap->device_list, list_head)
  147. if (dev->type == type && dev->id == id)
  148. goto skip;
  149. return id;
  150. skip:
  151. id++;
  152. }
  153. return -ENFILE;
  154. }
  155. static void dvb_media_device_free(struct dvb_device *dvbdev)
  156. {
  157. #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
  158. if (dvbdev->entity) {
  159. media_device_unregister_entity(dvbdev->entity);
  160. kfree(dvbdev->entity);
  161. kfree(dvbdev->pads);
  162. dvbdev->entity = NULL;
  163. dvbdev->pads = NULL;
  164. }
  165. if (dvbdev->tsout_entity) {
  166. int i;
  167. for (i = 0; i < dvbdev->tsout_num_entities; i++) {
  168. media_device_unregister_entity(&dvbdev->tsout_entity[i]);
  169. kfree(dvbdev->tsout_entity[i].name);
  170. }
  171. kfree(dvbdev->tsout_entity);
  172. kfree(dvbdev->tsout_pads);
  173. dvbdev->tsout_entity = NULL;
  174. dvbdev->tsout_pads = NULL;
  175. dvbdev->tsout_num_entities = 0;
  176. }
  177. if (dvbdev->intf_devnode) {
  178. media_devnode_remove(dvbdev->intf_devnode);
  179. dvbdev->intf_devnode = NULL;
  180. }
  181. if (dvbdev->adapter->conn) {
  182. media_device_unregister_entity(dvbdev->adapter->conn);
  183. dvbdev->adapter->conn = NULL;
  184. kfree(dvbdev->adapter->conn_pads);
  185. dvbdev->adapter->conn_pads = NULL;
  186. }
  187. #endif
  188. }
  189. #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
  190. static int dvb_create_tsout_entity(struct dvb_device *dvbdev,
  191. const char *name, int npads)
  192. {
  193. int i, ret = 0;
  194. dvbdev->tsout_pads = kcalloc(npads, sizeof(*dvbdev->tsout_pads),
  195. GFP_KERNEL);
  196. if (!dvbdev->tsout_pads)
  197. return -ENOMEM;
  198. dvbdev->tsout_entity = kcalloc(npads, sizeof(*dvbdev->tsout_entity),
  199. GFP_KERNEL);
  200. if (!dvbdev->tsout_entity)
  201. return -ENOMEM;
  202. dvbdev->tsout_num_entities = npads;
  203. for (i = 0; i < npads; i++) {
  204. struct media_pad *pads = &dvbdev->tsout_pads[i];
  205. struct media_entity *entity = &dvbdev->tsout_entity[i];
  206. entity->name = kasprintf(GFP_KERNEL, "%s #%d", name, i);
  207. if (!entity->name)
  208. return -ENOMEM;
  209. entity->function = MEDIA_ENT_F_IO_DTV;
  210. pads->flags = MEDIA_PAD_FL_SINK;
  211. ret = media_entity_pads_init(entity, 1, pads);
  212. if (ret < 0)
  213. return ret;
  214. ret = media_device_register_entity(dvbdev->adapter->mdev,
  215. entity);
  216. if (ret < 0)
  217. return ret;
  218. }
  219. return 0;
  220. }
  221. #define DEMUX_TSOUT "demux-tsout"
  222. #define DVR_TSOUT "dvr-tsout"
  223. static int dvb_create_media_entity(struct dvb_device *dvbdev,
  224. int type, int demux_sink_pads)
  225. {
  226. int i, ret, npads;
  227. switch (type) {
  228. case DVB_DEVICE_FRONTEND:
  229. npads = 2;
  230. break;
  231. case DVB_DEVICE_DVR:
  232. ret = dvb_create_tsout_entity(dvbdev, DVR_TSOUT,
  233. demux_sink_pads);
  234. return ret;
  235. case DVB_DEVICE_DEMUX:
  236. npads = 1 + demux_sink_pads;
  237. ret = dvb_create_tsout_entity(dvbdev, DEMUX_TSOUT,
  238. demux_sink_pads);
  239. if (ret < 0)
  240. return ret;
  241. break;
  242. case DVB_DEVICE_CA:
  243. npads = 2;
  244. break;
  245. case DVB_DEVICE_NET:
  246. /*
  247. * We should be creating entities for the MPE/ULE
  248. * decapsulation hardware (or software implementation).
  249. *
  250. * However, the number of for the MPE/ULE decaps may not be
  251. * fixed. As we don't have yet dynamic support for PADs at
  252. * the Media Controller, let's not create the decap
  253. * entities yet.
  254. */
  255. return 0;
  256. default:
  257. return 0;
  258. }
  259. dvbdev->entity = kzalloc(sizeof(*dvbdev->entity), GFP_KERNEL);
  260. if (!dvbdev->entity)
  261. return -ENOMEM;
  262. dvbdev->entity->name = dvbdev->name;
  263. if (npads) {
  264. dvbdev->pads = kcalloc(npads, sizeof(*dvbdev->pads),
  265. GFP_KERNEL);
  266. if (!dvbdev->pads)
  267. return -ENOMEM;
  268. }
  269. switch (type) {
  270. case DVB_DEVICE_FRONTEND:
  271. dvbdev->entity->function = MEDIA_ENT_F_DTV_DEMOD;
  272. dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
  273. dvbdev->pads[1].flags = MEDIA_PAD_FL_SOURCE;
  274. break;
  275. case DVB_DEVICE_DEMUX:
  276. dvbdev->entity->function = MEDIA_ENT_F_TS_DEMUX;
  277. dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
  278. for (i = 1; i < npads; i++)
  279. dvbdev->pads[i].flags = MEDIA_PAD_FL_SOURCE;
  280. break;
  281. case DVB_DEVICE_CA:
  282. dvbdev->entity->function = MEDIA_ENT_F_DTV_CA;
  283. dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
  284. dvbdev->pads[1].flags = MEDIA_PAD_FL_SOURCE;
  285. break;
  286. default:
  287. /* Should never happen, as the first switch prevents it */
  288. kfree(dvbdev->entity);
  289. kfree(dvbdev->pads);
  290. dvbdev->entity = NULL;
  291. dvbdev->pads = NULL;
  292. return 0;
  293. }
  294. if (npads) {
  295. ret = media_entity_pads_init(dvbdev->entity, npads, dvbdev->pads);
  296. if (ret)
  297. return ret;
  298. }
  299. ret = media_device_register_entity(dvbdev->adapter->mdev,
  300. dvbdev->entity);
  301. if (ret)
  302. return ret;
  303. pr_info("%s: media entity '%s' registered.\n",
  304. __func__, dvbdev->entity->name);
  305. return 0;
  306. }
  307. #endif
  308. static int dvb_register_media_device(struct dvb_device *dvbdev,
  309. int type, int minor,
  310. unsigned demux_sink_pads)
  311. {
  312. #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
  313. struct media_link *link;
  314. u32 intf_type;
  315. int ret;
  316. if (!dvbdev->adapter->mdev)
  317. return 0;
  318. ret = dvb_create_media_entity(dvbdev, type, demux_sink_pads);
  319. if (ret)
  320. return ret;
  321. switch (type) {
  322. case DVB_DEVICE_FRONTEND:
  323. intf_type = MEDIA_INTF_T_DVB_FE;
  324. break;
  325. case DVB_DEVICE_DEMUX:
  326. intf_type = MEDIA_INTF_T_DVB_DEMUX;
  327. break;
  328. case DVB_DEVICE_DVR:
  329. intf_type = MEDIA_INTF_T_DVB_DVR;
  330. break;
  331. case DVB_DEVICE_CA:
  332. intf_type = MEDIA_INTF_T_DVB_CA;
  333. break;
  334. case DVB_DEVICE_NET:
  335. intf_type = MEDIA_INTF_T_DVB_NET;
  336. break;
  337. default:
  338. return 0;
  339. }
  340. dvbdev->intf_devnode = media_devnode_create(dvbdev->adapter->mdev,
  341. intf_type, 0,
  342. DVB_MAJOR, minor);
  343. if (!dvbdev->intf_devnode)
  344. return -ENOMEM;
  345. /*
  346. * Create the "obvious" link, e. g. the ones that represent
  347. * a direct association between an interface and an entity.
  348. * Other links should be created elsewhere, like:
  349. * DVB FE intf -> tuner
  350. * DVB demux intf -> dvr
  351. */
  352. if (!dvbdev->entity)
  353. return 0;
  354. link = media_create_intf_link(dvbdev->entity, &dvbdev->intf_devnode->intf,
  355. MEDIA_LNK_FL_ENABLED);
  356. if (!link)
  357. return -ENOMEM;
  358. #endif
  359. return 0;
  360. }
  361. int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
  362. const struct dvb_device *template, void *priv, int type,
  363. int demux_sink_pads)
  364. {
  365. struct dvb_device *dvbdev;
  366. struct file_operations *dvbdevfops;
  367. struct device *clsdev;
  368. int minor;
  369. int id, ret;
  370. mutex_lock(&dvbdev_register_lock);
  371. if ((id = dvbdev_get_free_id (adap, type)) < 0){
  372. mutex_unlock(&dvbdev_register_lock);
  373. *pdvbdev = NULL;
  374. pr_err("%s: couldn't find free device id\n", __func__);
  375. return -ENFILE;
  376. }
  377. *pdvbdev = dvbdev = kzalloc(sizeof(*dvbdev), GFP_KERNEL);
  378. if (!dvbdev){
  379. mutex_unlock(&dvbdev_register_lock);
  380. return -ENOMEM;
  381. }
  382. dvbdevfops = kzalloc(sizeof(struct file_operations), GFP_KERNEL);
  383. if (!dvbdevfops){
  384. kfree (dvbdev);
  385. mutex_unlock(&dvbdev_register_lock);
  386. return -ENOMEM;
  387. }
  388. memcpy(dvbdev, template, sizeof(struct dvb_device));
  389. dvbdev->type = type;
  390. dvbdev->id = id;
  391. dvbdev->adapter = adap;
  392. dvbdev->priv = priv;
  393. dvbdev->fops = dvbdevfops;
  394. init_waitqueue_head (&dvbdev->wait_queue);
  395. memcpy(dvbdevfops, template->fops, sizeof(struct file_operations));
  396. dvbdevfops->owner = adap->module;
  397. list_add_tail (&dvbdev->list_head, &adap->device_list);
  398. down_write(&minor_rwsem);
  399. #ifdef CONFIG_DVB_DYNAMIC_MINORS
  400. for (minor = 0; minor < MAX_DVB_MINORS; minor++)
  401. if (dvb_minors[minor] == NULL)
  402. break;
  403. if (minor == MAX_DVB_MINORS) {
  404. kfree(dvbdevfops);
  405. kfree(dvbdev);
  406. up_write(&minor_rwsem);
  407. mutex_unlock(&dvbdev_register_lock);
  408. return -EINVAL;
  409. }
  410. #else
  411. minor = nums2minor(adap->num, type, id);
  412. #endif
  413. dvbdev->minor = minor;
  414. dvb_minors[minor] = dvbdev;
  415. up_write(&minor_rwsem);
  416. ret = dvb_register_media_device(dvbdev, type, minor, demux_sink_pads);
  417. if (ret) {
  418. pr_err("%s: dvb_register_media_device failed to create the mediagraph\n",
  419. __func__);
  420. dvb_media_device_free(dvbdev);
  421. kfree(dvbdevfops);
  422. kfree(dvbdev);
  423. up_write(&minor_rwsem);
  424. mutex_unlock(&dvbdev_register_lock);
  425. return ret;
  426. }
  427. mutex_unlock(&dvbdev_register_lock);
  428. clsdev = device_create(dvb_class, adap->device,
  429. MKDEV(DVB_MAJOR, minor),
  430. dvbdev, "dvb%d.%s%d", adap->num, dnames[type], id);
  431. if (IS_ERR(clsdev)) {
  432. pr_err("%s: failed to create device dvb%d.%s%d (%ld)\n",
  433. __func__, adap->num, dnames[type], id, PTR_ERR(clsdev));
  434. return PTR_ERR(clsdev);
  435. }
  436. dprintk("DVB: register adapter%d/%s%d @ minor: %i (0x%02x)\n",
  437. adap->num, dnames[type], id, minor, minor);
  438. return 0;
  439. }
  440. EXPORT_SYMBOL(dvb_register_device);
  441. void dvb_remove_device(struct dvb_device *dvbdev)
  442. {
  443. if (!dvbdev)
  444. return;
  445. down_write(&minor_rwsem);
  446. dvb_minors[dvbdev->minor] = NULL;
  447. up_write(&minor_rwsem);
  448. dvb_media_device_free(dvbdev);
  449. device_destroy(dvb_class, MKDEV(DVB_MAJOR, dvbdev->minor));
  450. list_del (&dvbdev->list_head);
  451. }
  452. EXPORT_SYMBOL(dvb_remove_device);
  453. void dvb_free_device(struct dvb_device *dvbdev)
  454. {
  455. if (!dvbdev)
  456. return;
  457. kfree (dvbdev->fops);
  458. kfree (dvbdev);
  459. }
  460. EXPORT_SYMBOL(dvb_free_device);
  461. void dvb_unregister_device(struct dvb_device *dvbdev)
  462. {
  463. dvb_remove_device(dvbdev);
  464. dvb_free_device(dvbdev);
  465. }
  466. EXPORT_SYMBOL(dvb_unregister_device);
  467. #ifdef CONFIG_MEDIA_CONTROLLER_DVB
  468. static int dvb_create_io_intf_links(struct dvb_adapter *adap,
  469. struct media_interface *intf,
  470. char *name)
  471. {
  472. struct media_device *mdev = adap->mdev;
  473. struct media_entity *entity;
  474. struct media_link *link;
  475. media_device_for_each_entity(entity, mdev) {
  476. if (entity->function == MEDIA_ENT_F_IO_DTV) {
  477. if (strncmp(entity->name, name, strlen(name)))
  478. continue;
  479. link = media_create_intf_link(entity, intf,
  480. MEDIA_LNK_FL_ENABLED);
  481. if (!link)
  482. return -ENOMEM;
  483. }
  484. }
  485. return 0;
  486. }
  487. int dvb_create_media_graph(struct dvb_adapter *adap,
  488. bool create_rf_connector)
  489. {
  490. struct media_device *mdev = adap->mdev;
  491. struct media_entity *entity, *tuner = NULL, *demod = NULL, *conn;
  492. struct media_entity *demux = NULL, *ca = NULL;
  493. struct media_link *link;
  494. struct media_interface *intf;
  495. unsigned demux_pad = 0;
  496. unsigned dvr_pad = 0;
  497. unsigned ntuner = 0, ndemod = 0;
  498. int ret;
  499. static const char *connector_name = "Television";
  500. if (!mdev)
  501. return 0;
  502. media_device_for_each_entity(entity, mdev) {
  503. switch (entity->function) {
  504. case MEDIA_ENT_F_TUNER:
  505. tuner = entity;
  506. ntuner++;
  507. break;
  508. case MEDIA_ENT_F_DTV_DEMOD:
  509. demod = entity;
  510. ndemod++;
  511. break;
  512. case MEDIA_ENT_F_TS_DEMUX:
  513. demux = entity;
  514. break;
  515. case MEDIA_ENT_F_DTV_CA:
  516. ca = entity;
  517. break;
  518. }
  519. }
  520. /*
  521. * Prepare to signalize to media_create_pad_links() that multiple
  522. * entities of the same type exists and a 1:n or n:1 links need to be
  523. * created.
  524. * NOTE: if both tuner and demod have multiple instances, it is up
  525. * to the caller driver to create such links.
  526. */
  527. if (ntuner > 1)
  528. tuner = NULL;
  529. if (ndemod > 1)
  530. demod = NULL;
  531. if (create_rf_connector) {
  532. conn = kzalloc(sizeof(*conn), GFP_KERNEL);
  533. if (!conn)
  534. return -ENOMEM;
  535. adap->conn = conn;
  536. adap->conn_pads = kzalloc(sizeof(*adap->conn_pads), GFP_KERNEL);
  537. if (!adap->conn_pads)
  538. return -ENOMEM;
  539. conn->flags = MEDIA_ENT_FL_CONNECTOR;
  540. conn->function = MEDIA_ENT_F_CONN_RF;
  541. conn->name = connector_name;
  542. adap->conn_pads->flags = MEDIA_PAD_FL_SOURCE;
  543. ret = media_entity_pads_init(conn, 1, adap->conn_pads);
  544. if (ret)
  545. return ret;
  546. ret = media_device_register_entity(mdev, conn);
  547. if (ret)
  548. return ret;
  549. if (!ntuner)
  550. ret = media_create_pad_links(mdev,
  551. MEDIA_ENT_F_CONN_RF,
  552. conn, 0,
  553. MEDIA_ENT_F_DTV_DEMOD,
  554. demod, 0,
  555. MEDIA_LNK_FL_ENABLED,
  556. false);
  557. else
  558. ret = media_create_pad_links(mdev,
  559. MEDIA_ENT_F_CONN_RF,
  560. conn, 0,
  561. MEDIA_ENT_F_TUNER,
  562. tuner, TUNER_PAD_RF_INPUT,
  563. MEDIA_LNK_FL_ENABLED,
  564. false);
  565. if (ret)
  566. return ret;
  567. }
  568. if (ntuner && ndemod) {
  569. ret = media_create_pad_links(mdev,
  570. MEDIA_ENT_F_TUNER,
  571. tuner, TUNER_PAD_OUTPUT,
  572. MEDIA_ENT_F_DTV_DEMOD,
  573. demod, 0, MEDIA_LNK_FL_ENABLED,
  574. false);
  575. if (ret)
  576. return ret;
  577. }
  578. if (ndemod && demux) {
  579. ret = media_create_pad_links(mdev,
  580. MEDIA_ENT_F_DTV_DEMOD,
  581. demod, 1,
  582. MEDIA_ENT_F_TS_DEMUX,
  583. demux, 0, MEDIA_LNK_FL_ENABLED,
  584. false);
  585. if (ret)
  586. return ret;
  587. }
  588. if (demux && ca) {
  589. ret = media_create_pad_link(demux, 1, ca,
  590. 0, MEDIA_LNK_FL_ENABLED);
  591. if (ret)
  592. return ret;
  593. }
  594. /* Create demux links for each ringbuffer/pad */
  595. if (demux) {
  596. media_device_for_each_entity(entity, mdev) {
  597. if (entity->function == MEDIA_ENT_F_IO_DTV) {
  598. if (!strncmp(entity->name, DVR_TSOUT,
  599. strlen(DVR_TSOUT))) {
  600. ret = media_create_pad_link(demux,
  601. ++dvr_pad,
  602. entity, 0, 0);
  603. if (ret)
  604. return ret;
  605. }
  606. if (!strncmp(entity->name, DEMUX_TSOUT,
  607. strlen(DEMUX_TSOUT))) {
  608. ret = media_create_pad_link(demux,
  609. ++demux_pad,
  610. entity, 0, 0);
  611. if (ret)
  612. return ret;
  613. }
  614. }
  615. }
  616. }
  617. /* Create interface links for FE->tuner, DVR->demux and CA->ca */
  618. media_device_for_each_intf(intf, mdev) {
  619. if (intf->type == MEDIA_INTF_T_DVB_CA && ca) {
  620. link = media_create_intf_link(ca, intf,
  621. MEDIA_LNK_FL_ENABLED);
  622. if (!link)
  623. return -ENOMEM;
  624. }
  625. if (intf->type == MEDIA_INTF_T_DVB_FE && tuner) {
  626. link = media_create_intf_link(tuner, intf,
  627. MEDIA_LNK_FL_ENABLED);
  628. if (!link)
  629. return -ENOMEM;
  630. }
  631. #if 0
  632. /*
  633. * Indirect link - let's not create yet, as we don't know how
  634. * to handle indirect links, nor if this will
  635. * actually be needed.
  636. */
  637. if (intf->type == MEDIA_INTF_T_DVB_DVR && demux) {
  638. link = media_create_intf_link(demux, intf,
  639. MEDIA_LNK_FL_ENABLED);
  640. if (!link)
  641. return -ENOMEM;
  642. }
  643. #endif
  644. if (intf->type == MEDIA_INTF_T_DVB_DVR) {
  645. ret = dvb_create_io_intf_links(adap, intf, DVR_TSOUT);
  646. if (ret)
  647. return ret;
  648. }
  649. if (intf->type == MEDIA_INTF_T_DVB_DEMUX) {
  650. ret = dvb_create_io_intf_links(adap, intf, DEMUX_TSOUT);
  651. if (ret)
  652. return ret;
  653. }
  654. }
  655. return 0;
  656. }
  657. EXPORT_SYMBOL_GPL(dvb_create_media_graph);
  658. #endif
  659. static int dvbdev_check_free_adapter_num(int num)
  660. {
  661. struct list_head *entry;
  662. list_for_each(entry, &dvb_adapter_list) {
  663. struct dvb_adapter *adap;
  664. adap = list_entry(entry, struct dvb_adapter, list_head);
  665. if (adap->num == num)
  666. return 0;
  667. }
  668. return 1;
  669. }
  670. static int dvbdev_get_free_adapter_num (void)
  671. {
  672. int num = 0;
  673. while (num < DVB_MAX_ADAPTERS) {
  674. if (dvbdev_check_free_adapter_num(num))
  675. return num;
  676. num++;
  677. }
  678. return -ENFILE;
  679. }
  680. int dvb_register_adapter(struct dvb_adapter *adap, const char *name,
  681. struct module *module, struct device *device,
  682. short *adapter_nums)
  683. {
  684. int i, num;
  685. mutex_lock(&dvbdev_register_lock);
  686. for (i = 0; i < DVB_MAX_ADAPTERS; ++i) {
  687. num = adapter_nums[i];
  688. if (num >= 0 && num < DVB_MAX_ADAPTERS) {
  689. /* use the one the driver asked for */
  690. if (dvbdev_check_free_adapter_num(num))
  691. break;
  692. } else {
  693. num = dvbdev_get_free_adapter_num();
  694. break;
  695. }
  696. num = -1;
  697. }
  698. if (num < 0) {
  699. mutex_unlock(&dvbdev_register_lock);
  700. return -ENFILE;
  701. }
  702. memset (adap, 0, sizeof(struct dvb_adapter));
  703. INIT_LIST_HEAD (&adap->device_list);
  704. pr_info("DVB: registering new adapter (%s)\n", name);
  705. adap->num = num;
  706. adap->name = name;
  707. adap->module = module;
  708. adap->device = device;
  709. adap->mfe_shared = 0;
  710. adap->mfe_dvbdev = NULL;
  711. mutex_init (&adap->mfe_lock);
  712. list_add_tail (&adap->list_head, &dvb_adapter_list);
  713. mutex_unlock(&dvbdev_register_lock);
  714. return num;
  715. }
  716. EXPORT_SYMBOL(dvb_register_adapter);
  717. int dvb_unregister_adapter(struct dvb_adapter *adap)
  718. {
  719. mutex_lock(&dvbdev_register_lock);
  720. list_del (&adap->list_head);
  721. mutex_unlock(&dvbdev_register_lock);
  722. return 0;
  723. }
  724. EXPORT_SYMBOL(dvb_unregister_adapter);
  725. /* if the miracle happens and "generic_usercopy()" is included into
  726. the kernel, then this can vanish. please don't make the mistake and
  727. define this as video_usercopy(). this will introduce a dependecy
  728. to the v4l "videodev.o" module, which is unnecessary for some
  729. cards (ie. the budget dvb-cards don't need the v4l module...) */
  730. int dvb_usercopy(struct file *file,
  731. unsigned int cmd, unsigned long arg,
  732. int (*func)(struct file *file,
  733. unsigned int cmd, void *arg))
  734. {
  735. char sbuf[128];
  736. void *mbuf = NULL;
  737. void *parg = NULL;
  738. int err = -EINVAL;
  739. /* Copy arguments into temp kernel buffer */
  740. switch (_IOC_DIR(cmd)) {
  741. case _IOC_NONE:
  742. /*
  743. * For this command, the pointer is actually an integer
  744. * argument.
  745. */
  746. parg = (void *) arg;
  747. break;
  748. case _IOC_READ: /* some v4l ioctls are marked wrong ... */
  749. case _IOC_WRITE:
  750. case (_IOC_WRITE | _IOC_READ):
  751. if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
  752. parg = sbuf;
  753. } else {
  754. /* too big to allocate from stack */
  755. mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
  756. if (NULL == mbuf)
  757. return -ENOMEM;
  758. parg = mbuf;
  759. }
  760. err = -EFAULT;
  761. if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
  762. goto out;
  763. break;
  764. }
  765. /* call driver */
  766. if ((err = func(file, cmd, parg)) == -ENOIOCTLCMD)
  767. err = -ENOTTY;
  768. if (err < 0)
  769. goto out;
  770. /* Copy results into user buffer */
  771. switch (_IOC_DIR(cmd))
  772. {
  773. case _IOC_READ:
  774. case (_IOC_WRITE | _IOC_READ):
  775. if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
  776. err = -EFAULT;
  777. break;
  778. }
  779. out:
  780. kfree(mbuf);
  781. return err;
  782. }
  783. static int dvb_uevent(struct device *dev, struct kobj_uevent_env *env)
  784. {
  785. struct dvb_device *dvbdev = dev_get_drvdata(dev);
  786. add_uevent_var(env, "DVB_ADAPTER_NUM=%d", dvbdev->adapter->num);
  787. add_uevent_var(env, "DVB_DEVICE_TYPE=%s", dnames[dvbdev->type]);
  788. add_uevent_var(env, "DVB_DEVICE_NUM=%d", dvbdev->id);
  789. return 0;
  790. }
  791. static char *dvb_devnode(struct device *dev, umode_t *mode)
  792. {
  793. struct dvb_device *dvbdev = dev_get_drvdata(dev);
  794. return kasprintf(GFP_KERNEL, "dvb/adapter%d/%s%d",
  795. dvbdev->adapter->num, dnames[dvbdev->type], dvbdev->id);
  796. }
  797. static int __init init_dvbdev(void)
  798. {
  799. int retval;
  800. dev_t dev = MKDEV(DVB_MAJOR, 0);
  801. if ((retval = register_chrdev_region(dev, MAX_DVB_MINORS, "DVB")) != 0) {
  802. pr_err("dvb-core: unable to get major %d\n", DVB_MAJOR);
  803. return retval;
  804. }
  805. cdev_init(&dvb_device_cdev, &dvb_device_fops);
  806. if ((retval = cdev_add(&dvb_device_cdev, dev, MAX_DVB_MINORS)) != 0) {
  807. pr_err("dvb-core: unable register character device\n");
  808. goto error;
  809. }
  810. dvb_class = class_create(THIS_MODULE, "dvb");
  811. if (IS_ERR(dvb_class)) {
  812. retval = PTR_ERR(dvb_class);
  813. goto error;
  814. }
  815. dvb_class->dev_uevent = dvb_uevent;
  816. dvb_class->devnode = dvb_devnode;
  817. return 0;
  818. error:
  819. cdev_del(&dvb_device_cdev);
  820. unregister_chrdev_region(dev, MAX_DVB_MINORS);
  821. return retval;
  822. }
  823. static void __exit exit_dvbdev(void)
  824. {
  825. class_destroy(dvb_class);
  826. cdev_del(&dvb_device_cdev);
  827. unregister_chrdev_region(MKDEV(DVB_MAJOR, 0), MAX_DVB_MINORS);
  828. }
  829. subsys_initcall(init_dvbdev);
  830. module_exit(exit_dvbdev);
  831. MODULE_DESCRIPTION("DVB Core Driver");
  832. MODULE_AUTHOR("Marcus Metzler, Ralph Metzler, Holger Waechtler");
  833. MODULE_LICENSE("GPL");