cx231xx-cards.c 30 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170
  1. /*
  2. cx231xx-cards.c - driver for Conexant Cx23100/101/102
  3. USB video capture devices
  4. Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
  5. Based on em28xx driver
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. GNU General Public License for more details.
  14. You should have received a copy of the GNU General Public License
  15. along with this program; if not, write to the Free Software
  16. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17. */
  18. #include <linux/init.h>
  19. #include <linux/module.h>
  20. #include <linux/slab.h>
  21. #include <linux/delay.h>
  22. #include <linux/i2c.h>
  23. #include <linux/usb.h>
  24. #include <media/tuner.h>
  25. #include <media/tveeprom.h>
  26. #include <media/v4l2-common.h>
  27. #include <media/v4l2-chip-ident.h>
  28. #include <media/cx25840.h>
  29. #include "dvb-usb-ids.h"
  30. #include "xc5000.h"
  31. #include "cx231xx.h"
  32. static int tuner = -1;
  33. module_param(tuner, int, 0444);
  34. MODULE_PARM_DESC(tuner, "tuner type");
  35. static int transfer_mode = 1;
  36. module_param(transfer_mode, int, 0444);
  37. MODULE_PARM_DESC(transfer_mode, "transfer mode (1-ISO or 0-BULK)");
  38. static unsigned int disable_ir;
  39. module_param(disable_ir, int, 0444);
  40. MODULE_PARM_DESC(disable_ir, "disable infrared remote support");
  41. /* Bitmask marking allocated devices from 0 to CX231XX_MAXBOARDS */
  42. static unsigned long cx231xx_devused;
  43. /*
  44. * Reset sequences for analog/digital modes
  45. */
  46. static struct cx231xx_reg_seq RDE250_XCV_TUNER[] = {
  47. {0x03, 0x01, 10},
  48. {0x03, 0x00, 30},
  49. {0x03, 0x01, 10},
  50. {-1, -1, -1},
  51. };
  52. /*
  53. * Board definitions
  54. */
  55. struct cx231xx_board cx231xx_boards[] = {
  56. [CX231XX_BOARD_UNKNOWN] = {
  57. .name = "Unknown CX231xx video grabber",
  58. .tuner_type = TUNER_ABSENT,
  59. .input = {{
  60. .type = CX231XX_VMUX_TELEVISION,
  61. .vmux = CX231XX_VIN_3_1,
  62. .amux = CX231XX_AMUX_VIDEO,
  63. .gpio = NULL,
  64. }, {
  65. .type = CX231XX_VMUX_COMPOSITE1,
  66. .vmux = CX231XX_VIN_2_1,
  67. .amux = CX231XX_AMUX_LINE_IN,
  68. .gpio = NULL,
  69. }, {
  70. .type = CX231XX_VMUX_SVIDEO,
  71. .vmux = CX231XX_VIN_1_1 |
  72. (CX231XX_VIN_1_2 << 8) |
  73. CX25840_SVIDEO_ON,
  74. .amux = CX231XX_AMUX_LINE_IN,
  75. .gpio = NULL,
  76. }
  77. },
  78. },
  79. [CX231XX_BOARD_CNXT_CARRAERA] = {
  80. .name = "Conexant Hybrid TV - CARRAERA",
  81. .tuner_type = TUNER_XC5000,
  82. .tuner_addr = 0x61,
  83. .tuner_gpio = RDE250_XCV_TUNER,
  84. .tuner_sif_gpio = 0x05,
  85. .tuner_scl_gpio = 0x1a,
  86. .tuner_sda_gpio = 0x1b,
  87. .decoder = CX231XX_AVDECODER,
  88. .output_mode = OUT_MODE_VIP11,
  89. .demod_xfer_mode = 0,
  90. .ctl_pin_status_mask = 0xFFFFFFC4,
  91. .agc_analog_digital_select_gpio = 0x0c,
  92. .gpio_pin_status_mask = 0x4001000,
  93. .tuner_i2c_master = 1,
  94. .demod_i2c_master = 2,
  95. .has_dvb = 1,
  96. .demod_addr = 0x02,
  97. .norm = V4L2_STD_PAL,
  98. .input = {{
  99. .type = CX231XX_VMUX_TELEVISION,
  100. .vmux = CX231XX_VIN_3_1,
  101. .amux = CX231XX_AMUX_VIDEO,
  102. .gpio = NULL,
  103. }, {
  104. .type = CX231XX_VMUX_COMPOSITE1,
  105. .vmux = CX231XX_VIN_2_1,
  106. .amux = CX231XX_AMUX_LINE_IN,
  107. .gpio = NULL,
  108. }, {
  109. .type = CX231XX_VMUX_SVIDEO,
  110. .vmux = CX231XX_VIN_1_1 |
  111. (CX231XX_VIN_1_2 << 8) |
  112. CX25840_SVIDEO_ON,
  113. .amux = CX231XX_AMUX_LINE_IN,
  114. .gpio = NULL,
  115. }
  116. },
  117. },
  118. [CX231XX_BOARD_CNXT_SHELBY] = {
  119. .name = "Conexant Hybrid TV - SHELBY",
  120. .tuner_type = TUNER_XC5000,
  121. .tuner_addr = 0x61,
  122. .tuner_gpio = RDE250_XCV_TUNER,
  123. .tuner_sif_gpio = 0x05,
  124. .tuner_scl_gpio = 0x1a,
  125. .tuner_sda_gpio = 0x1b,
  126. .decoder = CX231XX_AVDECODER,
  127. .output_mode = OUT_MODE_VIP11,
  128. .demod_xfer_mode = 0,
  129. .ctl_pin_status_mask = 0xFFFFFFC4,
  130. .agc_analog_digital_select_gpio = 0x0c,
  131. .gpio_pin_status_mask = 0x4001000,
  132. .tuner_i2c_master = 1,
  133. .demod_i2c_master = 2,
  134. .has_dvb = 1,
  135. .demod_addr = 0x32,
  136. .norm = V4L2_STD_NTSC,
  137. .input = {{
  138. .type = CX231XX_VMUX_TELEVISION,
  139. .vmux = CX231XX_VIN_3_1,
  140. .amux = CX231XX_AMUX_VIDEO,
  141. .gpio = NULL,
  142. }, {
  143. .type = CX231XX_VMUX_COMPOSITE1,
  144. .vmux = CX231XX_VIN_2_1,
  145. .amux = CX231XX_AMUX_LINE_IN,
  146. .gpio = NULL,
  147. }, {
  148. .type = CX231XX_VMUX_SVIDEO,
  149. .vmux = CX231XX_VIN_1_1 |
  150. (CX231XX_VIN_1_2 << 8) |
  151. CX25840_SVIDEO_ON,
  152. .amux = CX231XX_AMUX_LINE_IN,
  153. .gpio = NULL,
  154. }
  155. },
  156. },
  157. [CX231XX_BOARD_CNXT_RDE_253S] = {
  158. .name = "Conexant Hybrid TV - RDE253S",
  159. .tuner_type = TUNER_NXP_TDA18271,
  160. .tuner_addr = 0x60,
  161. .tuner_gpio = RDE250_XCV_TUNER,
  162. .tuner_sif_gpio = 0x05,
  163. .tuner_scl_gpio = 0x1a,
  164. .tuner_sda_gpio = 0x1b,
  165. .decoder = CX231XX_AVDECODER,
  166. .output_mode = OUT_MODE_VIP11,
  167. .demod_xfer_mode = 0,
  168. .ctl_pin_status_mask = 0xFFFFFFC4,
  169. .agc_analog_digital_select_gpio = 0x1c,
  170. .gpio_pin_status_mask = 0x4001000,
  171. .tuner_i2c_master = 1,
  172. .demod_i2c_master = 2,
  173. .has_dvb = 1,
  174. .demod_addr = 0x02,
  175. .norm = V4L2_STD_PAL,
  176. .input = {{
  177. .type = CX231XX_VMUX_TELEVISION,
  178. .vmux = CX231XX_VIN_3_1,
  179. .amux = CX231XX_AMUX_VIDEO,
  180. .gpio = NULL,
  181. }, {
  182. .type = CX231XX_VMUX_COMPOSITE1,
  183. .vmux = CX231XX_VIN_2_1,
  184. .amux = CX231XX_AMUX_LINE_IN,
  185. .gpio = NULL,
  186. }, {
  187. .type = CX231XX_VMUX_SVIDEO,
  188. .vmux = CX231XX_VIN_1_1 |
  189. (CX231XX_VIN_1_2 << 8) |
  190. CX25840_SVIDEO_ON,
  191. .amux = CX231XX_AMUX_LINE_IN,
  192. .gpio = NULL,
  193. }
  194. },
  195. },
  196. [CX231XX_BOARD_CNXT_RDU_253S] = {
  197. .name = "Conexant Hybrid TV - RDU253S",
  198. .tuner_type = TUNER_NXP_TDA18271,
  199. .tuner_addr = 0x60,
  200. .tuner_gpio = RDE250_XCV_TUNER,
  201. .tuner_sif_gpio = 0x05,
  202. .tuner_scl_gpio = 0x1a,
  203. .tuner_sda_gpio = 0x1b,
  204. .decoder = CX231XX_AVDECODER,
  205. .output_mode = OUT_MODE_VIP11,
  206. .demod_xfer_mode = 0,
  207. .ctl_pin_status_mask = 0xFFFFFFC4,
  208. .agc_analog_digital_select_gpio = 0x1c,
  209. .gpio_pin_status_mask = 0x4001000,
  210. .tuner_i2c_master = 1,
  211. .demod_i2c_master = 2,
  212. .has_dvb = 1,
  213. .demod_addr = 0x02,
  214. .norm = V4L2_STD_PAL,
  215. .input = {{
  216. .type = CX231XX_VMUX_TELEVISION,
  217. .vmux = CX231XX_VIN_3_1,
  218. .amux = CX231XX_AMUX_VIDEO,
  219. .gpio = NULL,
  220. }, {
  221. .type = CX231XX_VMUX_COMPOSITE1,
  222. .vmux = CX231XX_VIN_2_1,
  223. .amux = CX231XX_AMUX_LINE_IN,
  224. .gpio = NULL,
  225. }, {
  226. .type = CX231XX_VMUX_SVIDEO,
  227. .vmux = CX231XX_VIN_1_1 |
  228. (CX231XX_VIN_1_2 << 8) |
  229. CX25840_SVIDEO_ON,
  230. .amux = CX231XX_AMUX_LINE_IN,
  231. .gpio = NULL,
  232. }
  233. },
  234. },
  235. [CX231XX_BOARD_CNXT_VIDEO_GRABBER] = {
  236. .name = "Conexant VIDEO GRABBER",
  237. .tuner_type = TUNER_ABSENT,
  238. .decoder = CX231XX_AVDECODER,
  239. .output_mode = OUT_MODE_VIP11,
  240. .ctl_pin_status_mask = 0xFFFFFFC4,
  241. .agc_analog_digital_select_gpio = 0x1c,
  242. .gpio_pin_status_mask = 0x4001000,
  243. .norm = V4L2_STD_PAL,
  244. .input = {{
  245. .type = CX231XX_VMUX_COMPOSITE1,
  246. .vmux = CX231XX_VIN_2_1,
  247. .amux = CX231XX_AMUX_LINE_IN,
  248. .gpio = NULL,
  249. }, {
  250. .type = CX231XX_VMUX_SVIDEO,
  251. .vmux = CX231XX_VIN_1_1 |
  252. (CX231XX_VIN_1_2 << 8) |
  253. CX25840_SVIDEO_ON,
  254. .amux = CX231XX_AMUX_LINE_IN,
  255. .gpio = NULL,
  256. }
  257. },
  258. },
  259. [CX231XX_BOARD_CNXT_RDE_250] = {
  260. .name = "Conexant Hybrid TV - rde 250",
  261. .tuner_type = TUNER_XC5000,
  262. .tuner_addr = 0x61,
  263. .tuner_gpio = RDE250_XCV_TUNER,
  264. .tuner_sif_gpio = 0x05,
  265. .tuner_scl_gpio = 0x1a,
  266. .tuner_sda_gpio = 0x1b,
  267. .decoder = CX231XX_AVDECODER,
  268. .output_mode = OUT_MODE_VIP11,
  269. .demod_xfer_mode = 0,
  270. .ctl_pin_status_mask = 0xFFFFFFC4,
  271. .agc_analog_digital_select_gpio = 0x0c,
  272. .gpio_pin_status_mask = 0x4001000,
  273. .tuner_i2c_master = 1,
  274. .demod_i2c_master = 2,
  275. .has_dvb = 1,
  276. .demod_addr = 0x02,
  277. .norm = V4L2_STD_PAL,
  278. .input = {{
  279. .type = CX231XX_VMUX_TELEVISION,
  280. .vmux = CX231XX_VIN_2_1,
  281. .amux = CX231XX_AMUX_VIDEO,
  282. .gpio = NULL,
  283. }
  284. },
  285. },
  286. [CX231XX_BOARD_CNXT_RDU_250] = {
  287. .name = "Conexant Hybrid TV - RDU 250",
  288. .tuner_type = TUNER_XC5000,
  289. .tuner_addr = 0x61,
  290. .tuner_gpio = RDE250_XCV_TUNER,
  291. .tuner_sif_gpio = 0x05,
  292. .tuner_scl_gpio = 0x1a,
  293. .tuner_sda_gpio = 0x1b,
  294. .decoder = CX231XX_AVDECODER,
  295. .output_mode = OUT_MODE_VIP11,
  296. .demod_xfer_mode = 0,
  297. .ctl_pin_status_mask = 0xFFFFFFC4,
  298. .agc_analog_digital_select_gpio = 0x0c,
  299. .gpio_pin_status_mask = 0x4001000,
  300. .tuner_i2c_master = 1,
  301. .demod_i2c_master = 2,
  302. .has_dvb = 1,
  303. .demod_addr = 0x32,
  304. .norm = V4L2_STD_NTSC,
  305. .input = {{
  306. .type = CX231XX_VMUX_TELEVISION,
  307. .vmux = CX231XX_VIN_2_1,
  308. .amux = CX231XX_AMUX_VIDEO,
  309. .gpio = NULL,
  310. }
  311. },
  312. },
  313. [CX231XX_BOARD_HAUPPAUGE_EXETER] = {
  314. .name = "Hauppauge EXETER",
  315. .tuner_type = TUNER_NXP_TDA18271,
  316. .tuner_addr = 0x60,
  317. .tuner_gpio = RDE250_XCV_TUNER,
  318. .tuner_sif_gpio = 0x05,
  319. .tuner_scl_gpio = 0x1a,
  320. .tuner_sda_gpio = 0x1b,
  321. .decoder = CX231XX_AVDECODER,
  322. .output_mode = OUT_MODE_VIP11,
  323. .demod_xfer_mode = 0,
  324. .ctl_pin_status_mask = 0xFFFFFFC4,
  325. .agc_analog_digital_select_gpio = 0x0c,
  326. .gpio_pin_status_mask = 0x4001000,
  327. .tuner_i2c_master = 1,
  328. .demod_i2c_master = 2,
  329. .has_dvb = 1,
  330. .demod_addr = 0x0e,
  331. .norm = V4L2_STD_NTSC,
  332. .input = {{
  333. .type = CX231XX_VMUX_TELEVISION,
  334. .vmux = CX231XX_VIN_3_1,
  335. .amux = CX231XX_AMUX_VIDEO,
  336. .gpio = 0,
  337. }, {
  338. .type = CX231XX_VMUX_COMPOSITE1,
  339. .vmux = CX231XX_VIN_2_1,
  340. .amux = CX231XX_AMUX_LINE_IN,
  341. .gpio = 0,
  342. }, {
  343. .type = CX231XX_VMUX_SVIDEO,
  344. .vmux = CX231XX_VIN_1_1 |
  345. (CX231XX_VIN_1_2 << 8) |
  346. CX25840_SVIDEO_ON,
  347. .amux = CX231XX_AMUX_LINE_IN,
  348. .gpio = 0,
  349. } },
  350. },
  351. [CX231XX_BOARD_HAUPPAUGE_USBLIVE2] = {
  352. .name = "Hauppauge USB Live 2",
  353. .tuner_type = TUNER_ABSENT,
  354. .decoder = CX231XX_AVDECODER,
  355. .output_mode = OUT_MODE_VIP11,
  356. .demod_xfer_mode = 0,
  357. .ctl_pin_status_mask = 0xFFFFFFC4,
  358. .agc_analog_digital_select_gpio = 0x0c,
  359. .gpio_pin_status_mask = 0x4001000,
  360. .norm = V4L2_STD_NTSC,
  361. .input = {{
  362. .type = CX231XX_VMUX_COMPOSITE1,
  363. .vmux = CX231XX_VIN_2_1,
  364. .amux = CX231XX_AMUX_LINE_IN,
  365. .gpio = 0,
  366. }, {
  367. .type = CX231XX_VMUX_SVIDEO,
  368. .vmux = CX231XX_VIN_1_1 |
  369. (CX231XX_VIN_1_2 << 8) |
  370. CX25840_SVIDEO_ON,
  371. .amux = CX231XX_AMUX_LINE_IN,
  372. .gpio = 0,
  373. } },
  374. },
  375. };
  376. const unsigned int cx231xx_bcount = ARRAY_SIZE(cx231xx_boards);
  377. /* table of devices that work with this driver */
  378. struct usb_device_id cx231xx_id_table[] = {
  379. {USB_DEVICE(0x0572, 0x5A3C),
  380. .driver_info = CX231XX_BOARD_UNKNOWN},
  381. {USB_DEVICE_VER(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD, 0x4000,0x4fff),
  382. .driver_info = CX231XX_BOARD_UNKNOWN},
  383. {USB_DEVICE(0x0572, 0x58A2),
  384. .driver_info = CX231XX_BOARD_CNXT_CARRAERA},
  385. {USB_DEVICE(0x0572, 0x58A1),
  386. .driver_info = CX231XX_BOARD_CNXT_SHELBY},
  387. {USB_DEVICE(0x0572, 0x58A4),
  388. .driver_info = CX231XX_BOARD_CNXT_RDE_253S},
  389. {USB_DEVICE(0x0572, 0x58A5),
  390. .driver_info = CX231XX_BOARD_CNXT_RDU_253S},
  391. {USB_DEVICE(0x0572, 0x58A6),
  392. .driver_info = CX231XX_BOARD_CNXT_VIDEO_GRABBER},
  393. {USB_DEVICE(0x0572, 0x589E),
  394. .driver_info = CX231XX_BOARD_CNXT_RDE_250},
  395. {USB_DEVICE(0x0572, 0x58A0),
  396. .driver_info = CX231XX_BOARD_CNXT_RDU_250},
  397. {USB_DEVICE(0x2040, 0xb120),
  398. .driver_info = CX231XX_BOARD_HAUPPAUGE_EXETER},
  399. {USB_DEVICE(0x2040, 0xb140),
  400. .driver_info = CX231XX_BOARD_HAUPPAUGE_EXETER},
  401. {USB_DEVICE(0x2040, 0xc200),
  402. .driver_info = CX231XX_BOARD_HAUPPAUGE_USBLIVE2},
  403. {},
  404. };
  405. MODULE_DEVICE_TABLE(usb, cx231xx_id_table);
  406. /* cx231xx_tuner_callback
  407. * will be used to reset XC5000 tuner using GPIO pin
  408. */
  409. int cx231xx_tuner_callback(void *ptr, int component, int command, int arg)
  410. {
  411. int rc = 0;
  412. struct cx231xx *dev = ptr;
  413. if (dev->tuner_type == TUNER_XC5000) {
  414. if (command == XC5000_TUNER_RESET) {
  415. cx231xx_info
  416. ("Tuner CB: RESET: cmd %d : tuner type %d \n",
  417. command, dev->tuner_type);
  418. cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
  419. 1);
  420. msleep(10);
  421. cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
  422. 0);
  423. msleep(330);
  424. cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit,
  425. 1);
  426. msleep(10);
  427. }
  428. }
  429. return rc;
  430. }
  431. EXPORT_SYMBOL_GPL(cx231xx_tuner_callback);
  432. void cx231xx_reset_out(struct cx231xx *dev)
  433. {
  434. cx231xx_set_gpio_value(dev, CX23417_RESET, 1);
  435. msleep(200);
  436. cx231xx_set_gpio_value(dev, CX23417_RESET, 0);
  437. msleep(200);
  438. cx231xx_set_gpio_value(dev, CX23417_RESET, 1);
  439. }
  440. void cx231xx_enable_OSC(struct cx231xx *dev)
  441. {
  442. cx231xx_set_gpio_value(dev, CX23417_OSC_EN, 1);
  443. }
  444. void cx231xx_sleep_s5h1432(struct cx231xx *dev)
  445. {
  446. cx231xx_set_gpio_value(dev, SLEEP_S5H1432, 0);
  447. }
  448. static inline void cx231xx_set_model(struct cx231xx *dev)
  449. {
  450. memcpy(&dev->board, &cx231xx_boards[dev->model], sizeof(dev->board));
  451. }
  452. /* Since cx231xx_pre_card_setup() requires a proper dev->model,
  453. * this won't work for boards with generic PCI IDs
  454. */
  455. void cx231xx_pre_card_setup(struct cx231xx *dev)
  456. {
  457. cx231xx_set_model(dev);
  458. cx231xx_info("Identified as %s (card=%d)\n",
  459. dev->board.name, dev->model);
  460. /* set the direction for GPIO pins */
  461. if (dev->board.tuner_gpio) {
  462. cx231xx_set_gpio_direction(dev, dev->board.tuner_gpio->bit, 1);
  463. cx231xx_set_gpio_value(dev, dev->board.tuner_gpio->bit, 1);
  464. }
  465. if (dev->board.tuner_sif_gpio >= 0)
  466. cx231xx_set_gpio_direction(dev, dev->board.tuner_sif_gpio, 1);
  467. /* request some modules if any required */
  468. /* set the mode to Analog mode initially */
  469. cx231xx_set_mode(dev, CX231XX_ANALOG_MODE);
  470. /* Unlock device */
  471. /* cx231xx_set_mode(dev, CX231XX_SUSPEND); */
  472. }
  473. static void cx231xx_config_tuner(struct cx231xx *dev)
  474. {
  475. struct tuner_setup tun_setup;
  476. struct v4l2_frequency f;
  477. if (dev->tuner_type == TUNER_ABSENT)
  478. return;
  479. tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
  480. tun_setup.type = dev->tuner_type;
  481. tun_setup.addr = dev->tuner_addr;
  482. tun_setup.tuner_callback = cx231xx_tuner_callback;
  483. tuner_call(dev, tuner, s_type_addr, &tun_setup);
  484. #if 0
  485. if (tun_setup.type == TUNER_XC5000) {
  486. static struct xc2028_ctrl ctrl = {
  487. .fname = XC5000_DEFAULT_FIRMWARE,
  488. .max_len = 64,
  489. .demod = 0;
  490. };
  491. struct v4l2_priv_tun_config cfg = {
  492. .tuner = dev->tuner_type,
  493. .priv = &ctrl,
  494. };
  495. tuner_call(dev, tuner, s_config, &cfg);
  496. }
  497. #endif
  498. /* configure tuner */
  499. f.tuner = 0;
  500. f.type = V4L2_TUNER_ANALOG_TV;
  501. f.frequency = 9076; /* just a magic number */
  502. dev->ctl_freq = f.frequency;
  503. call_all(dev, tuner, s_frequency, &f);
  504. }
  505. void cx231xx_card_setup(struct cx231xx *dev)
  506. {
  507. cx231xx_set_model(dev);
  508. dev->tuner_type = cx231xx_boards[dev->model].tuner_type;
  509. if (cx231xx_boards[dev->model].tuner_addr)
  510. dev->tuner_addr = cx231xx_boards[dev->model].tuner_addr;
  511. /* request some modules */
  512. if (dev->board.decoder == CX231XX_AVDECODER) {
  513. dev->sd_cx25840 = v4l2_i2c_new_subdev(&dev->v4l2_dev,
  514. &dev->i2c_bus[0].i2c_adap,
  515. "cx25840", 0x88 >> 1, NULL);
  516. if (dev->sd_cx25840 == NULL)
  517. cx231xx_info("cx25840 subdev registration failure\n");
  518. cx25840_call(dev, core, load_fw);
  519. }
  520. /* Initialize the tuner */
  521. if (dev->board.tuner_type != TUNER_ABSENT) {
  522. dev->sd_tuner = v4l2_i2c_new_subdev(&dev->v4l2_dev,
  523. &dev->i2c_bus[dev->board.tuner_i2c_master].i2c_adap,
  524. "tuner",
  525. dev->tuner_addr, NULL);
  526. if (dev->sd_tuner == NULL)
  527. cx231xx_info("tuner subdev registration failure\n");
  528. else
  529. cx231xx_config_tuner(dev);
  530. }
  531. }
  532. /*
  533. * cx231xx_config()
  534. * inits registers with sane defaults
  535. */
  536. int cx231xx_config(struct cx231xx *dev)
  537. {
  538. /* TBD need to add cx231xx specific code */
  539. dev->mute = 1; /* maybe not the right place... */
  540. dev->volume = 0x1f;
  541. return 0;
  542. }
  543. /*
  544. * cx231xx_config_i2c()
  545. * configure i2c attached devices
  546. */
  547. void cx231xx_config_i2c(struct cx231xx *dev)
  548. {
  549. /* u32 input = INPUT(dev->video_input)->vmux; */
  550. call_all(dev, video, s_stream, 1);
  551. }
  552. /*
  553. * cx231xx_realease_resources()
  554. * unregisters the v4l2,i2c and usb devices
  555. * called when the device gets disconected or at module unload
  556. */
  557. void cx231xx_release_resources(struct cx231xx *dev)
  558. {
  559. cx231xx_release_analog_resources(dev);
  560. cx231xx_remove_from_devlist(dev);
  561. cx231xx_dev_uninit(dev);
  562. usb_put_dev(dev->udev);
  563. /* Mark device as unused */
  564. cx231xx_devused &= ~(1 << dev->devno);
  565. }
  566. /*
  567. * cx231xx_init_dev()
  568. * allocates and inits the device structs, registers i2c bus and v4l device
  569. */
  570. static int cx231xx_init_dev(struct cx231xx **devhandle, struct usb_device *udev,
  571. int minor)
  572. {
  573. struct cx231xx *dev = *devhandle;
  574. int retval = -ENOMEM;
  575. int errCode;
  576. unsigned int maxh, maxw;
  577. dev->udev = udev;
  578. mutex_init(&dev->lock);
  579. mutex_init(&dev->ctrl_urb_lock);
  580. mutex_init(&dev->gpio_i2c_lock);
  581. mutex_init(&dev->i2c_lock);
  582. spin_lock_init(&dev->video_mode.slock);
  583. spin_lock_init(&dev->vbi_mode.slock);
  584. spin_lock_init(&dev->sliced_cc_mode.slock);
  585. init_waitqueue_head(&dev->open);
  586. init_waitqueue_head(&dev->wait_frame);
  587. init_waitqueue_head(&dev->wait_stream);
  588. dev->cx231xx_read_ctrl_reg = cx231xx_read_ctrl_reg;
  589. dev->cx231xx_write_ctrl_reg = cx231xx_write_ctrl_reg;
  590. dev->cx231xx_send_usb_command = cx231xx_send_usb_command;
  591. dev->cx231xx_gpio_i2c_read = cx231xx_gpio_i2c_read;
  592. dev->cx231xx_gpio_i2c_write = cx231xx_gpio_i2c_write;
  593. /* Query cx231xx to find what pcb config it is related to */
  594. initialize_cx231xx(dev);
  595. /*To workaround error number=-71 on EP0 for VideoGrabber,
  596. need set alt here.*/
  597. if (dev->model == CX231XX_BOARD_CNXT_VIDEO_GRABBER ||
  598. dev->model == CX231XX_BOARD_HAUPPAUGE_USBLIVE2) {
  599. cx231xx_set_alt_setting(dev, INDEX_VIDEO, 3);
  600. cx231xx_set_alt_setting(dev, INDEX_VANC, 1);
  601. }
  602. /* Cx231xx pre card setup */
  603. cx231xx_pre_card_setup(dev);
  604. errCode = cx231xx_config(dev);
  605. if (errCode) {
  606. cx231xx_errdev("error configuring device\n");
  607. return -ENOMEM;
  608. }
  609. /* set default norm */
  610. dev->norm = dev->board.norm;
  611. /* register i2c bus */
  612. errCode = cx231xx_dev_init(dev);
  613. if (errCode < 0) {
  614. cx231xx_dev_uninit(dev);
  615. cx231xx_errdev("%s: cx231xx_i2c_register - errCode [%d]!\n",
  616. __func__, errCode);
  617. return errCode;
  618. }
  619. /* Do board specific init */
  620. cx231xx_card_setup(dev);
  621. /* configure the device */
  622. cx231xx_config_i2c(dev);
  623. maxw = norm_maxw(dev);
  624. maxh = norm_maxh(dev);
  625. /* set default image size */
  626. dev->width = maxw;
  627. dev->height = maxh;
  628. dev->interlaced = 0;
  629. dev->video_input = 0;
  630. errCode = cx231xx_config(dev);
  631. if (errCode < 0) {
  632. cx231xx_errdev("%s: cx231xx_config - errCode [%d]!\n",
  633. __func__, errCode);
  634. return errCode;
  635. }
  636. /* init video dma queues */
  637. INIT_LIST_HEAD(&dev->video_mode.vidq.active);
  638. INIT_LIST_HEAD(&dev->video_mode.vidq.queued);
  639. /* init vbi dma queues */
  640. INIT_LIST_HEAD(&dev->vbi_mode.vidq.active);
  641. INIT_LIST_HEAD(&dev->vbi_mode.vidq.queued);
  642. /* Reset other chips required if they are tied up with GPIO pins */
  643. cx231xx_add_into_devlist(dev);
  644. if (dev->model == CX231XX_BOARD_CNXT_VIDEO_GRABBER) {
  645. printk(KERN_INFO "attach 417 %d\n", dev->model);
  646. if (cx231xx_417_register(dev) < 0) {
  647. printk(KERN_ERR
  648. "%s() Failed to register 417 on VID_B\n",
  649. __func__);
  650. }
  651. }
  652. retval = cx231xx_register_analog_devices(dev);
  653. if (retval < 0) {
  654. cx231xx_release_resources(dev);
  655. goto fail_reg_devices;
  656. }
  657. cx231xx_init_extension(dev);
  658. return 0;
  659. fail_reg_devices:
  660. mutex_unlock(&dev->lock);
  661. return retval;
  662. }
  663. #if defined(CONFIG_MODULES) && defined(MODULE)
  664. static void request_module_async(struct work_struct *work)
  665. {
  666. struct cx231xx *dev = container_of(work,
  667. struct cx231xx, request_module_wk);
  668. if (dev->has_alsa_audio)
  669. request_module("cx231xx-alsa");
  670. if (dev->board.has_dvb)
  671. request_module("cx231xx-dvb");
  672. }
  673. static void request_modules(struct cx231xx *dev)
  674. {
  675. INIT_WORK(&dev->request_module_wk, request_module_async);
  676. schedule_work(&dev->request_module_wk);
  677. }
  678. #else
  679. #define request_modules(dev)
  680. #endif /* CONFIG_MODULES */
  681. /*
  682. * cx231xx_usb_probe()
  683. * checks for supported devices
  684. */
  685. static int cx231xx_usb_probe(struct usb_interface *interface,
  686. const struct usb_device_id *id)
  687. {
  688. struct usb_device *udev;
  689. struct usb_interface *uif;
  690. struct cx231xx *dev = NULL;
  691. int retval = -ENODEV;
  692. int nr = 0, ifnum;
  693. int i, isoc_pipe = 0;
  694. char *speed;
  695. char descr[255] = "";
  696. struct usb_interface *lif = NULL;
  697. struct usb_interface_assoc_descriptor *assoc_desc;
  698. udev = usb_get_dev(interface_to_usbdev(interface));
  699. ifnum = interface->altsetting[0].desc.bInterfaceNumber;
  700. if (ifnum == 1) {
  701. /*
  702. * Interface number 0 - IR interface
  703. */
  704. /* Check to see next free device and mark as used */
  705. nr = find_first_zero_bit(&cx231xx_devused, CX231XX_MAXBOARDS);
  706. cx231xx_devused |= 1 << nr;
  707. if (nr >= CX231XX_MAXBOARDS) {
  708. cx231xx_err(DRIVER_NAME
  709. ": Supports only %i cx231xx boards.\n", CX231XX_MAXBOARDS);
  710. cx231xx_devused &= ~(1 << nr);
  711. return -ENOMEM;
  712. }
  713. /* allocate memory for our device state and initialize it */
  714. dev = kzalloc(sizeof(*dev), GFP_KERNEL);
  715. if (dev == NULL) {
  716. cx231xx_err(DRIVER_NAME ": out of memory!\n");
  717. cx231xx_devused &= ~(1 << nr);
  718. return -ENOMEM;
  719. }
  720. snprintf(dev->name, 29, "cx231xx #%d", nr);
  721. dev->devno = nr;
  722. dev->model = id->driver_info;
  723. dev->video_mode.alt = -1;
  724. dev->interface_count++;
  725. /* reset gpio dir and value */
  726. dev->gpio_dir = 0;
  727. dev->gpio_val = 0;
  728. dev->xc_fw_load_done = 0;
  729. dev->has_alsa_audio = 1;
  730. dev->power_mode = -1;
  731. atomic_set(&dev->devlist_count, 0);
  732. /* 0 - vbi ; 1 -sliced cc mode */
  733. dev->vbi_or_sliced_cc_mode = 0;
  734. /* get maximum no.of IAD interfaces */
  735. assoc_desc = udev->actconfig->intf_assoc[0];
  736. dev->max_iad_interface_count = assoc_desc->bInterfaceCount;
  737. /* init CIR module TBD */
  738. /* store the current interface */
  739. lif = interface;
  740. /*mode_tv: digital=1 or analog=0*/
  741. dev->mode_tv = 0;
  742. dev->USE_ISO = transfer_mode;
  743. switch (udev->speed) {
  744. case USB_SPEED_LOW:
  745. speed = "1.5";
  746. break;
  747. case USB_SPEED_UNKNOWN:
  748. case USB_SPEED_FULL:
  749. speed = "12";
  750. break;
  751. case USB_SPEED_HIGH:
  752. speed = "480";
  753. break;
  754. default:
  755. speed = "unknown";
  756. }
  757. if (udev->manufacturer)
  758. strlcpy(descr, udev->manufacturer, sizeof(descr));
  759. if (udev->product) {
  760. if (*descr)
  761. strlcat(descr, " ", sizeof(descr));
  762. strlcat(descr, udev->product, sizeof(descr));
  763. }
  764. if (*descr)
  765. strlcat(descr, " ", sizeof(descr));
  766. cx231xx_info("New device %s@ %s Mbps "
  767. "(%04x:%04x) with %d interfaces\n",
  768. descr,
  769. speed,
  770. le16_to_cpu(udev->descriptor.idVendor),
  771. le16_to_cpu(udev->descriptor.idProduct),
  772. dev->max_iad_interface_count);
  773. /* store the interface 0 back */
  774. lif = udev->actconfig->interface[0];
  775. /* increment interface count */
  776. dev->interface_count++;
  777. /* get device number */
  778. nr = dev->devno;
  779. assoc_desc = udev->actconfig->intf_assoc[0];
  780. if (assoc_desc->bFirstInterface != ifnum) {
  781. cx231xx_err(DRIVER_NAME ": Not found "
  782. "matching IAD interface\n");
  783. return -ENODEV;
  784. }
  785. } else {
  786. return -ENODEV;
  787. }
  788. cx231xx_info("registering interface %d\n", ifnum);
  789. /* save our data pointer in this interface device */
  790. usb_set_intfdata(lif, dev);
  791. /*
  792. * AV device initialization - only done at the last interface
  793. */
  794. /* Create v4l2 device */
  795. retval = v4l2_device_register(&interface->dev, &dev->v4l2_dev);
  796. if (retval) {
  797. cx231xx_errdev("v4l2_device_register failed\n");
  798. cx231xx_devused &= ~(1 << nr);
  799. kfree(dev);
  800. dev = NULL;
  801. return -EIO;
  802. }
  803. /* allocate device struct */
  804. retval = cx231xx_init_dev(&dev, udev, nr);
  805. if (retval) {
  806. cx231xx_devused &= ~(1 << dev->devno);
  807. v4l2_device_unregister(&dev->v4l2_dev);
  808. kfree(dev);
  809. dev = NULL;
  810. usb_set_intfdata(lif, NULL);
  811. return retval;
  812. }
  813. /* compute alternate max packet sizes for video */
  814. uif = udev->actconfig->interface[dev->current_pcb_config.
  815. hs_config_info[0].interface_info.video_index + 1];
  816. dev->video_mode.end_point_addr = le16_to_cpu(uif->altsetting[0].
  817. endpoint[isoc_pipe].desc.bEndpointAddress);
  818. dev->video_mode.num_alt = uif->num_altsetting;
  819. cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
  820. dev->video_mode.end_point_addr,
  821. dev->video_mode.num_alt);
  822. dev->video_mode.alt_max_pkt_size =
  823. kmalloc(32 * dev->video_mode.num_alt, GFP_KERNEL);
  824. if (dev->video_mode.alt_max_pkt_size == NULL) {
  825. cx231xx_errdev("out of memory!\n");
  826. cx231xx_devused &= ~(1 << nr);
  827. v4l2_device_unregister(&dev->v4l2_dev);
  828. kfree(dev);
  829. dev = NULL;
  830. return -ENOMEM;
  831. }
  832. for (i = 0; i < dev->video_mode.num_alt; i++) {
  833. u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
  834. desc.wMaxPacketSize);
  835. dev->video_mode.alt_max_pkt_size[i] =
  836. (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
  837. cx231xx_info("Alternate setting %i, max size= %i\n", i,
  838. dev->video_mode.alt_max_pkt_size[i]);
  839. }
  840. /* compute alternate max packet sizes for vbi */
  841. uif = udev->actconfig->interface[dev->current_pcb_config.
  842. hs_config_info[0].interface_info.
  843. vanc_index + 1];
  844. dev->vbi_mode.end_point_addr =
  845. le16_to_cpu(uif->altsetting[0].endpoint[isoc_pipe].desc.
  846. bEndpointAddress);
  847. dev->vbi_mode.num_alt = uif->num_altsetting;
  848. cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
  849. dev->vbi_mode.end_point_addr,
  850. dev->vbi_mode.num_alt);
  851. dev->vbi_mode.alt_max_pkt_size =
  852. kmalloc(32 * dev->vbi_mode.num_alt, GFP_KERNEL);
  853. if (dev->vbi_mode.alt_max_pkt_size == NULL) {
  854. cx231xx_errdev("out of memory!\n");
  855. cx231xx_devused &= ~(1 << nr);
  856. v4l2_device_unregister(&dev->v4l2_dev);
  857. kfree(dev);
  858. dev = NULL;
  859. return -ENOMEM;
  860. }
  861. for (i = 0; i < dev->vbi_mode.num_alt; i++) {
  862. u16 tmp =
  863. le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
  864. desc.wMaxPacketSize);
  865. dev->vbi_mode.alt_max_pkt_size[i] =
  866. (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
  867. cx231xx_info("Alternate setting %i, max size= %i\n", i,
  868. dev->vbi_mode.alt_max_pkt_size[i]);
  869. }
  870. /* compute alternate max packet sizes for sliced CC */
  871. uif = udev->actconfig->interface[dev->current_pcb_config.
  872. hs_config_info[0].interface_info.
  873. hanc_index + 1];
  874. dev->sliced_cc_mode.end_point_addr =
  875. le16_to_cpu(uif->altsetting[0].endpoint[isoc_pipe].desc.
  876. bEndpointAddress);
  877. dev->sliced_cc_mode.num_alt = uif->num_altsetting;
  878. cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
  879. dev->sliced_cc_mode.end_point_addr,
  880. dev->sliced_cc_mode.num_alt);
  881. dev->sliced_cc_mode.alt_max_pkt_size =
  882. kmalloc(32 * dev->sliced_cc_mode.num_alt, GFP_KERNEL);
  883. if (dev->sliced_cc_mode.alt_max_pkt_size == NULL) {
  884. cx231xx_errdev("out of memory!\n");
  885. cx231xx_devused &= ~(1 << nr);
  886. v4l2_device_unregister(&dev->v4l2_dev);
  887. kfree(dev);
  888. dev = NULL;
  889. return -ENOMEM;
  890. }
  891. for (i = 0; i < dev->sliced_cc_mode.num_alt; i++) {
  892. u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].
  893. desc.wMaxPacketSize);
  894. dev->sliced_cc_mode.alt_max_pkt_size[i] =
  895. (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
  896. cx231xx_info("Alternate setting %i, max size= %i\n", i,
  897. dev->sliced_cc_mode.alt_max_pkt_size[i]);
  898. }
  899. if (dev->current_pcb_config.ts1_source != 0xff) {
  900. /* compute alternate max packet sizes for TS1 */
  901. uif = udev->actconfig->interface[dev->current_pcb_config.
  902. hs_config_info[0].
  903. interface_info.
  904. ts1_index + 1];
  905. dev->ts1_mode.end_point_addr =
  906. le16_to_cpu(uif->altsetting[0].endpoint[isoc_pipe].
  907. desc.bEndpointAddress);
  908. dev->ts1_mode.num_alt = uif->num_altsetting;
  909. cx231xx_info("EndPoint Addr 0x%x, Alternate settings: %i\n",
  910. dev->ts1_mode.end_point_addr,
  911. dev->ts1_mode.num_alt);
  912. dev->ts1_mode.alt_max_pkt_size =
  913. kmalloc(32 * dev->ts1_mode.num_alt, GFP_KERNEL);
  914. if (dev->ts1_mode.alt_max_pkt_size == NULL) {
  915. cx231xx_errdev("out of memory!\n");
  916. cx231xx_devused &= ~(1 << nr);
  917. v4l2_device_unregister(&dev->v4l2_dev);
  918. kfree(dev);
  919. dev = NULL;
  920. return -ENOMEM;
  921. }
  922. for (i = 0; i < dev->ts1_mode.num_alt; i++) {
  923. u16 tmp = le16_to_cpu(uif->altsetting[i].
  924. endpoint[isoc_pipe].desc.
  925. wMaxPacketSize);
  926. dev->ts1_mode.alt_max_pkt_size[i] =
  927. (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
  928. cx231xx_info("Alternate setting %i, max size= %i\n", i,
  929. dev->ts1_mode.alt_max_pkt_size[i]);
  930. }
  931. }
  932. if (dev->model == CX231XX_BOARD_CNXT_VIDEO_GRABBER) {
  933. cx231xx_enable_OSC(dev);
  934. cx231xx_reset_out(dev);
  935. cx231xx_set_alt_setting(dev, INDEX_VIDEO, 3);
  936. }
  937. if (dev->model == CX231XX_BOARD_CNXT_RDE_253S)
  938. cx231xx_sleep_s5h1432(dev);
  939. /* load other modules required */
  940. request_modules(dev);
  941. return 0;
  942. }
  943. /*
  944. * cx231xx_usb_disconnect()
  945. * called when the device gets diconencted
  946. * video device will be unregistered on v4l2_close in case it is still open
  947. */
  948. static void cx231xx_usb_disconnect(struct usb_interface *interface)
  949. {
  950. struct cx231xx *dev;
  951. dev = usb_get_intfdata(interface);
  952. usb_set_intfdata(interface, NULL);
  953. if (!dev)
  954. return;
  955. if (!dev->udev)
  956. return;
  957. /* delete v4l2 device */
  958. v4l2_device_unregister(&dev->v4l2_dev);
  959. /* wait until all current v4l2 io is finished then deallocate
  960. resources */
  961. mutex_lock(&dev->lock);
  962. wake_up_interruptible_all(&dev->open);
  963. if (dev->users) {
  964. cx231xx_warn
  965. ("device %s is open! Deregistration and memory "
  966. "deallocation are deferred on close.\n",
  967. video_device_node_name(dev->vdev));
  968. dev->state |= DEV_MISCONFIGURED;
  969. if (dev->USE_ISO)
  970. cx231xx_uninit_isoc(dev);
  971. else
  972. cx231xx_uninit_bulk(dev);
  973. dev->state |= DEV_DISCONNECTED;
  974. wake_up_interruptible(&dev->wait_frame);
  975. wake_up_interruptible(&dev->wait_stream);
  976. } else {
  977. dev->state |= DEV_DISCONNECTED;
  978. cx231xx_release_resources(dev);
  979. }
  980. cx231xx_close_extension(dev);
  981. mutex_unlock(&dev->lock);
  982. if (!dev->users) {
  983. kfree(dev->video_mode.alt_max_pkt_size);
  984. kfree(dev->vbi_mode.alt_max_pkt_size);
  985. kfree(dev->sliced_cc_mode.alt_max_pkt_size);
  986. kfree(dev->ts1_mode.alt_max_pkt_size);
  987. kfree(dev);
  988. dev = NULL;
  989. }
  990. }
  991. static struct usb_driver cx231xx_usb_driver = {
  992. .name = "cx231xx",
  993. .probe = cx231xx_usb_probe,
  994. .disconnect = cx231xx_usb_disconnect,
  995. .id_table = cx231xx_id_table,
  996. };
  997. static int __init cx231xx_module_init(void)
  998. {
  999. int result;
  1000. printk(KERN_INFO DRIVER_NAME " v4l2 driver loaded.\n");
  1001. /* register this driver with the USB subsystem */
  1002. result = usb_register(&cx231xx_usb_driver);
  1003. if (result)
  1004. cx231xx_err(DRIVER_NAME
  1005. " usb_register failed. Error number %d.\n", result);
  1006. return result;
  1007. }
  1008. static void __exit cx231xx_module_exit(void)
  1009. {
  1010. /* deregister this driver with the USB subsystem */
  1011. usb_deregister(&cx231xx_usb_driver);
  1012. }
  1013. module_init(cx231xx_module_init);
  1014. module_exit(cx231xx_module_exit);