NoPaste

hikaru - diff dvbsky.c - Kernel 4.17 4.18

von hikaru

Dein Code:
  1. $ diff 4.17.17_dvbsky.c 4.18.20_dvbsky.c
  2. 293,305d292
  3. < static const struct m88ds3103_config dvbsky_s960_m88ds3103_config = {
  4. <       .i2c_addr = 0x68,
  5. <       .clock = 27000000,
  6. <       .i2c_wr_max = 33,
  7. <       .clock_out = 0,
  8. <       .ts_mode = M88DS3103_TS_CI,
  9. <       .ts_clk = 16000,
  10. <       .ts_clk_pol = 0,
  11. <       .agc = 0x99,
  12. <       .lnb_hv_pol = 1,
  13. <       .lnb_en_pol = 1,
  14. < };
  15. <
  16. 310,314c297,298
  17. <       int ret = 0;
  18. <       /* demod I2C adapter */
  19. <       struct i2c_adapter *i2c_adapter = NULL;
  20. <       struct i2c_client *client;
  21. <       struct i2c_board_info info;
  22. ---
  23. >       struct i2c_adapter *i2c_adapter;
  24. >       struct m88ds3103_platform_data m88ds3103_pdata = {};
  25. 316d299
  26. <       memset(&info, 0, sizeof(struct i2c_board_info));
  27. 319,327c302,319
  28. <       adap->fe[0] = dvb_attach(m88ds3103_attach,
  29. <                       &dvbsky_s960_m88ds3103_config,                                                                                                                                                                                                                        
  30. <                       &d->i2c_adap,                                                                                                                                                                                                                                          
  31. <                       &i2c_adapter);                                                                                                                                                                                                                                        
  32. <       if (!adap->fe[0]) {                                                                                                                                                                                                                                                    
  33. <               dev_err(&d->udev->dev, "dvbsky_s960_attach fail.\n");                                                                                                                                                                                                          
  34. <               ret = -ENODEV;                                                                                                                                                                                                                                                
  35. <               goto fail_attach;                                                                                                                                                                                                                                              
  36. <       }                                                                                                                                                                                                                                                                      
  37. ---                                                                                                                                                                                                                                                                            
  38. >       m88ds3103_pdata.clk = 27000000;                                                                                                                                                                                                                                        
  39. >       m88ds3103_pdata.i2c_wr_max = 33;                                                                                                                                                                                                                                      
  40. >       m88ds3103_pdata.clk_out = 0;                                                                                                                                                                                                                                          
  41. >       m88ds3103_pdata.ts_mode = M88DS3103_TS_CI;                                                                                                                                                                                                                            
  42. >       m88ds3103_pdata.ts_clk = 16000;                                                                                                                                                                                                                                        
  43. >       m88ds3103_pdata.ts_clk_pol = 0;                                                                                                                                                                                                                                        
  44. >       m88ds3103_pdata.agc = 0x99;                                                                                                                                                                                                                                            
  45. >       m88ds3103_pdata.lnb_hv_pol = 1,                                                                                                                                                                                                                                        
  46. >       m88ds3103_pdata.lnb_en_pol = 1,                                                                                                                                                                                                                                        
  47. >                                                                                                                                                                                                                                                                              
  48. >       state->i2c_client_demod = dvb_module_probe("m88ds3103", NULL,                                                                                                                                                                                                          
  49. >                                                  &d->i2c_adap,                                                                                                                                                                                                              
  50. >                                                  0x68, &m88ds3103_pdata);                                                                                                                                                                                                    
  51. >       if (!state->i2c_client_demod)                                                                                                                                                                                                                                          
  52. >               return -ENODEV;                                                                                                                                                                                                                                                
  53. >                                                                                                                                                                                                                                                                              
  54. >       adap->fe[0] = m88ds3103_pdata.get_dvb_frontend(state->i2c_client_demod);                                                                                                                                                                                              
  55. >       i2c_adapter = m88ds3103_pdata.get_i2c_adapter(state->i2c_client_demod);                                                                                                                                                                                                
  56. 332,341d323                                                                                                                                                                                                                                                                    
  57. <       strlcpy(info.type, "ts2020", I2C_NAME_SIZE);                                                                                                                                                                                                                          
  58. <       info.addr = 0x60;                                                                                                                                                                                                                                                      
  59. <       info.platform_data = &ts2020_config;                                                                                                                                                                                                                                  
  60. <       request_module("ts2020");                                                                                                                                                                                                                                              
  61. <       client = i2c_new_device(i2c_adapter, &info);                                                                                                                                                                                                                          
  62. <       if (client == NULL || client->dev.driver == NULL) {                                                                                                                                                                                                                    
  63. <               dvb_frontend_detach(adap->fe[0]);                                                                                                                                                                                                                              
  64. <               ret = -ENODEV;                                                                                                                                                                                                                                                
  65. <               goto fail_attach;                                                                                                                                                                                                                                              
  66. <       }                                                                                                                                                                                                                                                                      
  67. 343,347c325,330                                                                                                                                                                                                                                                                
  68. <       if (!try_module_get(client->dev.driver->owner)) {                                                                                                                                                                                                                      
  69. <               i2c_unregister_device(client);                                                                                                                                                                                                                                
  70. <               dvb_frontend_detach(adap->fe[0]);                                                                                                                                                                                                                              
  71. <               ret = -ENODEV;                                                                                                                                                                                                                                                
  72. <               goto fail_attach;                                                                                                                                                                                                                                              
  73. ---
  74. >       state->i2c_client_tuner = dvb_module_probe("ts2020", NULL,
  75. >                                                  i2c_adapter,
  76. >                                                  0x60, &ts2020_config);
  77. >       if (!state->i2c_client_tuner) {
  78. >               dvb_module_release(state->i2c_client_demod);
  79. >               return -ENODEV;
  80. 362,365c345
  81. <       state->i2c_client_tuner = client;
  82. <
  83. < fail_attach:
  84. <       return ret;
  85. ---
  86. >       return 0;
  87. 415,427d394
  88. < static const struct m88ds3103_config dvbsky_s960c_m88ds3103_config = {
  89. <       .i2c_addr = 0x68,
  90. <       .clock = 27000000,
  91. <       .i2c_wr_max = 33,
  92. <       .clock_out = 0,
  93. <       .ts_mode = M88DS3103_TS_CI,
  94. <       .ts_clk = 10000,
  95. <       .ts_clk_pol = 1,
  96. <       .agc = 0x99,
  97. <       .lnb_hv_pol = 0,
  98. <       .lnb_en_pol = 1,
  99. < };
  100. <
  101. 432,437c399,400
  102. <       int ret = 0;
  103. <       /* demod I2C adapter */
  104. <       struct i2c_adapter *i2c_adapter = NULL;
  105. <       struct i2c_client *client_tuner, *client_ci;
  106. <       struct i2c_board_info info;
  107. <       struct sp2_config sp2_config;
  108. ---
  109. >       struct i2c_adapter *i2c_adapter;
  110. >       struct m88ds3103_platform_data m88ds3103_pdata = {};
  111. 439c402
  112. <       memset(&info, 0, sizeof(struct i2c_board_info));
  113. ---
  114. >       struct sp2_config sp2_config = {};
  115. 442,450c405,422
  116. <       adap->fe[0] = dvb_attach(m88ds3103_attach,
  117. <                       &dvbsky_s960c_m88ds3103_config,
  118. <                       &d->i2c_adap,
  119. <                       &i2c_adapter);
  120. <       if (!adap->fe[0]) {
  121. <               dev_err(&d->udev->dev, "dvbsky_s960ci_attach fail.\n");
  122. <               ret = -ENODEV;
  123. <               goto fail_attach;
  124. <       }
  125. ---
  126. >       m88ds3103_pdata.clk = 27000000,
  127. >       m88ds3103_pdata.i2c_wr_max = 33,
  128. >       m88ds3103_pdata.clk_out = 0,
  129. >       m88ds3103_pdata.ts_mode = M88DS3103_TS_CI,
  130. >       m88ds3103_pdata.ts_clk = 10000,
  131. >       m88ds3103_pdata.ts_clk_pol = 1,
  132. >       m88ds3103_pdata.agc = 0x99,
  133. >       m88ds3103_pdata.lnb_hv_pol = 0,
  134. >       m88ds3103_pdata.lnb_en_pol = 1,
  135. >
  136. >       state->i2c_client_demod = dvb_module_probe("m88ds3103", NULL,
  137. >                                                  &d->i2c_adap,
  138. >                                                  0x68, &m88ds3103_pdata);
  139. >       if (!state->i2c_client_demod)
  140. >               return -ENODEV;
  141. >
  142. >       adap->fe[0] = m88ds3103_pdata.get_dvb_frontend(state->i2c_client_demod);
  143. >       i2c_adapter = m88ds3103_pdata.get_i2c_adapter(state->i2c_client_demod);
  144. 455,463d426
  145. <       strlcpy(info.type, "ts2020", I2C_NAME_SIZE);
  146. <       info.addr = 0x60;
  147. <       info.platform_data = &ts2020_config;
  148. <       request_module("ts2020");
  149. <       client_tuner = i2c_new_device(i2c_adapter, &info);
  150. <       if (client_tuner == NULL || client_tuner->dev.driver == NULL) {
  151. <               ret = -ENODEV;
  152. <               goto fail_tuner_device;
  153. <       }
  154. 465,467c428,433
  155. <       if (!try_module_get(client_tuner->dev.driver->owner)) {
  156. <               ret = -ENODEV;
  157. <               goto fail_tuner_module;
  158. ---
  159. >       state->i2c_client_tuner = dvb_module_probe("ts2020", NULL,
  160. >                                                  i2c_adapter,
  161. >                                                  0x60, &ts2020_config);
  162. >       if (!state->i2c_client_tuner) {
  163. >               dvb_module_release(state->i2c_client_demod);
  164. >               return -ENODEV;
  165. 471d436
  166. <       memset(&sp2_config, 0, sizeof(sp2_config));
  167. 475,484d439
  168. <       memset(&info, 0, sizeof(struct i2c_board_info));
  169. <       strlcpy(info.type, "sp2", I2C_NAME_SIZE);
  170. <       info.addr = 0x40;
  171. <       info.platform_data = &sp2_config;
  172. <       request_module("sp2");
  173. <       client_ci = i2c_new_device(&d->i2c_adap, &info);
  174. <       if (client_ci == NULL || client_ci->dev.driver == NULL) {
  175. <               ret = -ENODEV;
  176. <               goto fail_ci_device;
  177. <       }
  178. 486,488c441,448
  179. <       if (!try_module_get(client_ci->dev.driver->owner)) {
  180. <               ret = -ENODEV;
  181. <               goto fail_ci_module;
  182. ---
  183. >       state->i2c_client_ci = dvb_module_probe("sp2", NULL,
  184. >                                               &d->i2c_adap,
  185. >                                               0x40, &sp2_config);
  186. >
  187. >       if (!state->i2c_client_ci) {
  188. >               dvb_module_release(state->i2c_client_tuner);
  189. >               dvb_module_release(state->i2c_client_demod);
  190. >               return -ENODEV;
  191. 503,515c463
  192. <       state->i2c_client_tuner = client_tuner;
  193. <       state->i2c_client_ci = client_ci;
  194. <       return ret;
  195. < fail_ci_module:
  196. <       i2c_unregister_device(client_ci);
  197. < fail_ci_device:
  198. <       module_put(client_tuner->dev.driver->owner);
  199. < fail_tuner_module:
  200. <       i2c_unregister_device(client_tuner);
  201. < fail_tuner_device:
  202. <       dvb_frontend_detach(adap->fe[0]);
  203. < fail_attach:
  204. <       return ret;
  205. ---
  206. >       return 0;
  207. 522d469
  208. <       int ret = 0;
  209. 524,528c471,473
  210. <       struct i2c_client *client_demod, *client_tuner, *client_ci;
  211. <       struct i2c_board_info info;
  212. <       struct si2168_config si2168_config;
  213. <       struct si2157_config si2157_config;
  214. <       struct sp2_config sp2_config;
  215. ---
  216. >       struct si2168_config si2168_config = {};
  217. >       struct si2157_config si2157_config = {};
  218. >       struct sp2_config sp2_config = {};
  219. 531d475
  220. <       memset(&si2168_config, 0, sizeof(si2168_config));
  221. 535,546c479,484
  222. <       memset(&info, 0, sizeof(struct i2c_board_info));
  223. <       strlcpy(info.type, "si2168", I2C_NAME_SIZE);
  224. <       info.addr = 0x64;
  225. <       info.platform_data = &si2168_config;
  226. <
  227. <       request_module(info.type);
  228. <       client_demod = i2c_new_device(&d->i2c_adap, &info);
  229. <       if (client_demod == NULL ||
  230. <                       client_demod->dev.driver == NULL)
  231. <               goto fail_demod_device;
  232. <       if (!try_module_get(client_demod->dev.driver->owner))
  233. <               goto fail_demod_module;
  234. ---
  235. >
  236. >       state->i2c_client_demod = dvb_module_probe("si2168", NULL,
  237. >                                                  &d->i2c_adap,
  238. >                                                  0x64, &si2168_config);
  239. >       if (!state->i2c_client_demod)
  240. >               return -ENODEV;
  241. 549d486
  242. <       memset(&si2157_config, 0, sizeof(si2157_config));
  243. 552,563c489,496
  244. <       memset(&info, 0, sizeof(struct i2c_board_info));
  245. <       strlcpy(info.type, "si2157", I2C_NAME_SIZE);
  246. <       info.addr = 0x60;
  247. <       info.platform_data = &si2157_config;
  248. <
  249. <       request_module(info.type);
  250. <       client_tuner = i2c_new_device(i2c_adapter, &info);
  251. <       if (client_tuner == NULL ||
  252. <                       client_tuner->dev.driver == NULL)
  253. <               goto fail_tuner_device;
  254. <       if (!try_module_get(client_tuner->dev.driver->owner))
  255. <               goto fail_tuner_module;
  256. ---
  257. >
  258. >       state->i2c_client_tuner = dvb_module_probe("si2157", NULL,
  259. >                                                  i2c_adapter,
  260. >                                                  0x60, &si2157_config);
  261. >       if (!state->i2c_client_tuner) {
  262. >               dvb_module_release(state->i2c_client_demod);
  263. >               return -ENODEV;
  264. >       }
  265. 566d498
  266. <       memset(&sp2_config, 0, sizeof(sp2_config));
  267. 570,600c502,513
  268. <       memset(&info, 0, sizeof(struct i2c_board_info));
  269. <       strlcpy(info.type, "sp2", I2C_NAME_SIZE);
  270. <       info.addr = 0x40;
  271. <       info.platform_data = &sp2_config;
  272. <
  273. <       request_module(info.type);
  274. <       client_ci = i2c_new_device(&d->i2c_adap, &info);
  275. <
  276. <       if (client_ci == NULL || client_ci->dev.driver == NULL)
  277. <               goto fail_ci_device;
  278. <
  279. <       if (!try_module_get(client_ci->dev.driver->owner))
  280. <               goto fail_ci_module;
  281. <
  282. <       state->i2c_client_demod = client_demod;
  283. <       state->i2c_client_tuner = client_tuner;
  284. <       state->i2c_client_ci = client_ci;
  285. <       return ret;
  286. < fail_ci_module:
  287. <       i2c_unregister_device(client_ci);
  288. < fail_ci_device:
  289. <       module_put(client_tuner->dev.driver->owner);
  290. < fail_tuner_module:
  291. <       i2c_unregister_device(client_tuner);
  292. < fail_tuner_device:
  293. <       module_put(client_demod->dev.driver->owner);
  294. < fail_demod_module:
  295. <       i2c_unregister_device(client_demod);
  296. < fail_demod_device:
  297. <       ret = -ENODEV;
  298. <       return ret;
  299. ---
  300. >
  301. >       state->i2c_client_ci = dvb_module_probe("sp2", NULL,
  302. >                                               &d->i2c_adap,
  303. >                                               0x40, &sp2_config);
  304. >
  305. >       if (!state->i2c_client_ci) {
  306. >               dvb_module_release(state->i2c_client_tuner);
  307. >               dvb_module_release(state->i2c_client_demod);
  308. >               return -ENODEV;
  309. >       }
  310. >
  311. >       return 0;
  312. 607d519
  313. <       int ret = 0;
  314. 609,612c521,522
  315. <       struct i2c_client *client_demod, *client_tuner;
  316. <       struct i2c_board_info info;
  317. <       struct si2168_config si2168_config;
  318. <       struct si2157_config si2157_config;
  319. ---
  320. >       struct si2168_config si2168_config = {};
  321. >       struct si2157_config si2157_config = {};
  322. 615d524
  323. <       memset(&si2168_config, 0, sizeof(si2168_config));
  324. 620,631c529,534
  325. <       memset(&info, 0, sizeof(struct i2c_board_info));
  326. <       strlcpy(info.type, "si2168", I2C_NAME_SIZE);
  327. <       info.addr = 0x64;
  328. <       info.platform_data = &si2168_config;
  329. <
  330. <       request_module(info.type);
  331. <       client_demod = i2c_new_device(&d->i2c_adap, &info);
  332. <       if (client_demod == NULL ||
  333. <                       client_demod->dev.driver == NULL)
  334. <               goto fail_demod_device;
  335. <       if (!try_module_get(client_demod->dev.driver->owner))
  336. <               goto fail_demod_module;
  337. ---
  338. >
  339. >       state->i2c_client_demod = dvb_module_probe("si2168", NULL,
  340. >                                                  &d->i2c_adap,
  341. >                                                  0x64, &si2168_config);
  342. >       if (!state->i2c_client_demod)
  343. >               return -ENODEV;
  344. 634d536
  345. <       memset(&si2157_config, 0, sizeof(si2157_config));
  346. 637,648d538
  347. <       memset(&info, 0, sizeof(struct i2c_board_info));
  348. <       strlcpy(info.type, "si2157", I2C_NAME_SIZE);
  349. <       info.addr = 0x60;
  350. <       info.platform_data = &si2157_config;
  351. <
  352. <       request_module(info.type);
  353. <       client_tuner = i2c_new_device(i2c_adapter, &info);
  354. <       if (client_tuner == NULL ||
  355. <                       client_tuner->dev.driver == NULL)
  356. <               goto fail_tuner_device;
  357. <       if (!try_module_get(client_tuner->dev.driver->owner))
  358. <               goto fail_tuner_module;
  359. 650,661c540,548
  360. <       state->i2c_client_demod = client_demod;
  361. <       state->i2c_client_tuner = client_tuner;
  362. <       return ret;
  363. < fail_tuner_module:
  364. <       i2c_unregister_device(client_tuner);
  365. < fail_tuner_device:
  366. <       module_put(client_demod->dev.driver->owner);
  367. < fail_demod_module:
  368. <       i2c_unregister_device(client_demod);
  369. < fail_demod_device:
  370. <       ret = -ENODEV;
  371. <       return ret;
  372. ---
  373. >       state->i2c_client_tuner = dvb_module_probe("si2157", NULL,
  374. >                                                  i2c_adapter,
  375. >                                                  0x60, &si2157_config);
  376. >       if (!state->i2c_client_tuner) {
  377. >               dvb_module_release(state->i2c_client_demod);
  378. >               return -ENODEV;
  379. >       }
  380. >
  381. >       return 0;
  382. 669,672c556,557
  383. <       struct i2c_client *client_demod, *client_tuner;
  384. <       struct i2c_board_info info;
  385. <       struct si2168_config si2168_config;
  386. <       struct si2157_config si2157_config;
  387. ---
  388. >       struct si2168_config si2168_config = {};
  389. >       struct si2157_config si2157_config = {};
  390. 675d559
  391. <       memset(&si2168_config, 0, sizeof(si2168_config));
  392. 680,690c564,569
  393. <       memset(&info, 0, sizeof(struct i2c_board_info));
  394. <       strlcpy(info.type, "si2168", sizeof(info.type));
  395. <       info.addr = 0x64;
  396. <       info.platform_data = &si2168_config;
  397. <
  398. <       request_module("si2168");
  399. <       client_demod = i2c_new_device(&d->i2c_adap, &info);
  400. <       if (!client_demod || !client_demod->dev.driver)
  401. <               goto fail_demod_device;
  402. <       if (!try_module_get(client_demod->dev.driver->owner))
  403. <               goto fail_demod_module;
  404. ---
  405. >
  406. >       state->i2c_client_demod = dvb_module_probe("si2168", NULL,
  407. >                                                  &d->i2c_adap,
  408. >                                                  0x64, &si2168_config);
  409. >       if (!state->i2c_client_demod)
  410. >               return -ENODEV;
  411. 693d571
  412. <       memset(&si2157_config, 0, sizeof(si2157_config));
  413. 696,706d573
  414. <       memset(&info, 0, sizeof(struct i2c_board_info));
  415. <       strlcpy(info.type, "si2141", sizeof(info.type));
  416. <       info.addr = 0x60;
  417. <       info.platform_data = &si2157_config;
  418. <
  419. <       request_module("si2157");
  420. <       client_tuner = i2c_new_device(i2c_adapter, &info);
  421. <       if (!client_tuner || !client_tuner->dev.driver)
  422. <               goto fail_tuner_device;
  423. <       if (!try_module_get(client_tuner->dev.driver->owner))
  424. <               goto fail_tuner_module;
  425. 708,710c575,581
  426. <       state->i2c_client_demod = client_demod;
  427. <       state->i2c_client_tuner = client_tuner;
  428. <       return 0;
  429. ---
  430. >       state->i2c_client_tuner = dvb_module_probe("si2157", "si2141",
  431. >                                                  i2c_adapter,
  432. >                                                  0x60, &si2157_config);
  433. >       if (!state->i2c_client_tuner) {
  434. >               dvb_module_release(state->i2c_client_demod);
  435. >               return -ENODEV;
  436. >       }
  437. 712,719c583
  438. < fail_tuner_module:
  439. <       i2c_unregister_device(client_tuner);
  440. < fail_tuner_device:
  441. <       module_put(client_demod->dev.driver->owner);
  442. < fail_demod_module:
  443. <       i2c_unregister_device(client_demod);
  444. < fail_demod_device:
  445. <       return -ENODEV;
  446. ---
  447. >       return 0;
  448. 757c621
  449. <       struct i2c_client *client;
  450. ---
  451. >       struct dvb_usb_adapter *adap = &d->adapter[0];
  452. 759,776c623,627
  453. <       client = state->i2c_client_tuner;
  454. <       /* remove I2C tuner */
  455. <       if (client) {
  456. <               module_put(client->dev.driver->owner);
  457. <               i2c_unregister_device(client);
  458. <       }
  459. <       client = state->i2c_client_demod;
  460. <       /* remove I2C demod */
  461. <       if (client) {
  462. <               module_put(client->dev.driver->owner);
  463. <               i2c_unregister_device(client);
  464. <       }
  465. <       client = state->i2c_client_ci;
  466. <       /* remove I2C ci */
  467. <       if (client) {
  468. <               module_put(client->dev.driver->owner);
  469. <               i2c_unregister_device(client);
  470. <       }
  471. ---
  472. >       dvb_module_release(state->i2c_client_tuner);
  473. >       dvb_module_release(state->i2c_client_demod);
  474. >       dvb_module_release(state->i2c_client_ci);
  475. >
  476. >       adap->fe[0] = NULL;

Quellcode

Hier kannst du den Code kopieren und ihn in deinen bevorzugten Editor einfügen. Alternativ kannst du den gesamten Eintrag auch als Datei herunterladen.