tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

media: em28xx-dvb: simplify DVB module probing logic

The module probing logic there is a way more complex than
it should be, and requires some special magic to avoid
stack overflows when KASAN is enabled.

Solve it by creating ancillary functions to setup the
platform data and request module.

Now, the probing functions are cleaner and easier to understand.

As a side effect, the size of the module was reduced by
about 9.7% on x86_64:

Before this patch:
text data bss dec hex filename
51090 14192 96 65378 ff62 drivers/media/usb/em28xx/em28xx-dvb.o

After this patch:
text data bss dec hex filename
44743 14192 96 59031 e697 drivers/media/usb/em28xx/em28xx-dvb.o

Tested with a PCTV 461e device.

Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>

Mauro Carvalho Chehab ad32495b 8f569c0b

+146 -402
+146 -402
drivers/media/usb/em28xx/em28xx-dvb.c
··· 1124 1124 dvb_unregister_adapter(&dvb->adapter); 1125 1125 } 1126 1126 1127 - static noinline_for_stack int em28174_dvb_init_pctv_460e(struct em28xx *dev) 1127 + static int em28174_dvb_init_pctv_460e(struct em28xx *dev) 1128 1128 { 1129 1129 struct em28xx_dvb *dvb = dev->dvb; 1130 - struct i2c_client *client; 1131 - struct i2c_board_info board_info; 1132 1130 struct tda10071_platform_data tda10071_pdata = {}; 1133 1131 struct a8293_platform_data a8293_pdata = {}; 1134 - int result; 1135 1132 1136 1133 /* attach demod + tuner combo */ 1137 - tda10071_pdata.clk = 40444000, /* 40.444 MHz */ 1138 - tda10071_pdata.i2c_wr_max = 64, 1139 - tda10071_pdata.ts_mode = TDA10071_TS_SERIAL, 1140 - tda10071_pdata.pll_multiplier = 20, 1141 - tda10071_pdata.tuner_i2c_addr = 0x14, 1142 - memset(&board_info, 0, sizeof(board_info)); 1143 - strlcpy(board_info.type, "tda10071_cx24118", I2C_NAME_SIZE); 1144 - board_info.addr = 0x55; 1145 - board_info.platform_data = &tda10071_pdata; 1146 - request_module("tda10071"); 1147 - client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &board_info); 1148 - if (client == NULL || client->dev.driver == NULL) { 1149 - result = -ENODEV; 1150 - goto out_free; 1151 - } 1152 - if (!try_module_get(client->dev.driver->owner)) { 1153 - i2c_unregister_device(client); 1154 - result = -ENODEV; 1155 - goto out_free; 1156 - } 1157 - dvb->fe[0] = tda10071_pdata.get_dvb_frontend(client); 1158 - dvb->i2c_client_demod = client; 1134 + tda10071_pdata.clk = 40444000; /* 40.444 MHz */ 1135 + tda10071_pdata.i2c_wr_max = 64; 1136 + tda10071_pdata.ts_mode = TDA10071_TS_SERIAL; 1137 + tda10071_pdata.pll_multiplier = 20; 1138 + tda10071_pdata.tuner_i2c_addr = 0x14; 1139 + 1140 + dvb->i2c_client_demod = dvb_module_probe("tda10071", "tda10071_cx24118", 1141 + &dev->i2c_adap[dev->def_i2c_bus], 1142 + 0x55, &tda10071_pdata); 1143 + if (!dvb->i2c_client_demod) 1144 + return -ENODEV; 1145 + 1146 + dvb->fe[0] = tda10071_pdata.get_dvb_frontend(dvb->i2c_client_demod); 1159 1147 1160 1148 /* attach SEC */ 1161 1149 a8293_pdata.dvb_frontend = dvb->fe[0]; 1162 - memset(&board_info, 0, sizeof(board_info)); 1163 - strlcpy(board_info.type, "a8293", I2C_NAME_SIZE); 1164 - board_info.addr = 0x08; 1165 - board_info.platform_data = &a8293_pdata; 1166 - request_module("a8293"); 1167 - client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &board_info); 1168 - if (client == NULL || client->dev.driver == NULL) { 1169 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1170 - i2c_unregister_device(dvb->i2c_client_demod); 1171 - result = -ENODEV; 1172 - goto out_free; 1150 + 1151 + dvb->i2c_client_sec = dvb_module_probe("a8293", NULL, 1152 + &dev->i2c_adap[dev->def_i2c_bus], 1153 + 0x08, &a8293_pdata); 1154 + if (!dvb->i2c_client_sec) { 1155 + dvb_module_release(dvb->i2c_client_demod); 1156 + return -ENODEV; 1173 1157 } 1174 - if (!try_module_get(client->dev.driver->owner)) { 1175 - i2c_unregister_device(client); 1176 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1177 - i2c_unregister_device(dvb->i2c_client_demod); 1178 - result = -ENODEV; 1179 - goto out_free; 1180 - } 1181 - dvb->i2c_client_sec = client; 1182 - result = 0; 1183 - out_free: 1184 - return result; 1158 + 1159 + return 0; 1185 1160 } 1186 1161 1187 - static noinline_for_stack int em28178_dvb_init_pctv_461e(struct em28xx *dev) 1162 + static int em28178_dvb_init_pctv_461e(struct em28xx *dev) 1188 1163 { 1189 1164 struct em28xx_dvb *dvb = dev->dvb; 1190 - struct i2c_client *client; 1191 1165 struct i2c_adapter *i2c_adapter; 1192 - struct i2c_board_info board_info; 1193 1166 struct m88ds3103_platform_data m88ds3103_pdata = {}; 1194 1167 struct ts2020_config ts2020_config = {}; 1195 1168 struct a8293_platform_data a8293_pdata = {}; 1196 - int result; 1197 1169 1198 1170 /* attach demod */ 1199 1171 m88ds3103_pdata.clk = 27000000; ··· 1174 1202 m88ds3103_pdata.ts_clk = 16000; 1175 1203 m88ds3103_pdata.ts_clk_pol = 1; 1176 1204 m88ds3103_pdata.agc = 0x99; 1177 - memset(&board_info, 0, sizeof(board_info)); 1178 - strlcpy(board_info.type, "m88ds3103", I2C_NAME_SIZE); 1179 - board_info.addr = 0x68; 1180 - board_info.platform_data = &m88ds3103_pdata; 1181 - request_module("m88ds3103"); 1182 - client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &board_info); 1183 - if (client == NULL || client->dev.driver == NULL) { 1184 - result = -ENODEV; 1185 - goto out_free; 1186 - } 1187 - if (!try_module_get(client->dev.driver->owner)) { 1188 - i2c_unregister_device(client); 1189 - result = -ENODEV; 1190 - goto out_free; 1191 - } 1192 - dvb->fe[0] = m88ds3103_pdata.get_dvb_frontend(client); 1193 - i2c_adapter = m88ds3103_pdata.get_i2c_adapter(client); 1194 - dvb->i2c_client_demod = client; 1205 + 1206 + dvb->i2c_client_demod = dvb_module_probe("m88ds3103", NULL, 1207 + &dev->i2c_adap[dev->def_i2c_bus], 1208 + 0x68, &m88ds3103_pdata); 1209 + if (!dvb->i2c_client_demod) 1210 + return -ENODEV; 1211 + 1212 + dvb->fe[0] = m88ds3103_pdata.get_dvb_frontend(dvb->i2c_client_demod); 1213 + i2c_adapter = m88ds3103_pdata.get_i2c_adapter(dvb->i2c_client_demod); 1195 1214 1196 1215 /* attach tuner */ 1197 1216 ts2020_config.fe = dvb->fe[0]; 1198 - memset(&board_info, 0, sizeof(board_info)); 1199 - strlcpy(board_info.type, "ts2022", I2C_NAME_SIZE); 1200 - board_info.addr = 0x60; 1201 - board_info.platform_data = &ts2020_config; 1202 - request_module("ts2020"); 1203 - client = i2c_new_device(i2c_adapter, &board_info); 1204 - if (client == NULL || client->dev.driver == NULL) { 1205 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1206 - i2c_unregister_device(dvb->i2c_client_demod); 1207 - result = -ENODEV; 1208 - goto out_free; 1217 + 1218 + dvb->i2c_client_tuner = dvb_module_probe("ts2020", "ts2022", 1219 + i2c_adapter, 1220 + 0x60, &ts2020_config); 1221 + if (!dvb->i2c_client_tuner) { 1222 + dvb_module_release(dvb->i2c_client_demod); 1223 + return -ENODEV; 1209 1224 } 1210 - if (!try_module_get(client->dev.driver->owner)) { 1211 - i2c_unregister_device(client); 1212 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1213 - i2c_unregister_device(dvb->i2c_client_demod); 1214 - result = -ENODEV; 1215 - goto out_free; 1216 - } 1217 - dvb->i2c_client_tuner = client; 1225 + 1218 1226 /* delegate signal strength measurement to tuner */ 1219 1227 dvb->fe[0]->ops.read_signal_strength = 1220 1228 dvb->fe[0]->ops.tuner_ops.get_rf_strength; 1221 1229 1222 1230 /* attach SEC */ 1223 1231 a8293_pdata.dvb_frontend = dvb->fe[0]; 1224 - memset(&board_info, 0, sizeof(board_info)); 1225 - strlcpy(board_info.type, "a8293", I2C_NAME_SIZE); 1226 - board_info.addr = 0x08; 1227 - board_info.platform_data = &a8293_pdata; 1228 - request_module("a8293"); 1229 - client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &board_info); 1230 - if (client == NULL || client->dev.driver == NULL) { 1231 - module_put(dvb->i2c_client_tuner->dev.driver->owner); 1232 - i2c_unregister_device(dvb->i2c_client_tuner); 1233 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1234 - i2c_unregister_device(dvb->i2c_client_demod); 1235 - result = -ENODEV; 1236 - goto out_free; 1232 + dvb->i2c_client_sec = dvb_module_probe("a8293", NULL, 1233 + &dev->i2c_adap[dev->def_i2c_bus], 1234 + 0x08, &a8293_pdata); 1235 + if (!dvb->i2c_client_sec) { 1236 + dvb_module_release(dvb->i2c_client_tuner); 1237 + dvb_module_release(dvb->i2c_client_demod); 1238 + return -ENODEV; 1237 1239 } 1238 - if (!try_module_get(client->dev.driver->owner)) { 1239 - i2c_unregister_device(client); 1240 - module_put(dvb->i2c_client_tuner->dev.driver->owner); 1241 - i2c_unregister_device(dvb->i2c_client_tuner); 1242 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1243 - i2c_unregister_device(dvb->i2c_client_demod); 1244 - result = -ENODEV; 1245 - goto out_free; 1246 - } 1247 - dvb->i2c_client_sec = client; 1248 - result = 0; 1249 - out_free: 1250 - return result; 1240 + 1241 + return 0; 1251 1242 } 1252 1243 1253 - static noinline_for_stack int em28178_dvb_init_pctv_292e(struct em28xx *dev) 1244 + static int em28178_dvb_init_pctv_292e(struct em28xx *dev) 1254 1245 { 1255 1246 struct em28xx_dvb *dvb = dev->dvb; 1256 1247 struct i2c_adapter *adapter; 1257 - struct i2c_client *client; 1258 - struct i2c_board_info info; 1259 - struct si2168_config si2168_config; 1260 - struct si2157_config si2157_config; 1261 - int result; 1248 + struct si2168_config si2168_config = {}; 1249 + struct si2157_config si2157_config = {}; 1262 1250 1263 1251 /* attach demod */ 1264 - memset(&si2168_config, 0, sizeof(si2168_config)); 1265 1252 si2168_config.i2c_adapter = &adapter; 1266 1253 si2168_config.fe = &dvb->fe[0]; 1267 1254 si2168_config.ts_mode = SI2168_TS_PARALLEL; 1268 - memset(&info, 0, sizeof(struct i2c_board_info)); 1269 - strlcpy(info.type, "si2168", I2C_NAME_SIZE); 1270 - info.addr = 0x64; 1271 - info.platform_data = &si2168_config; 1272 - request_module(info.type); 1273 - client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &info); 1274 - if (client == NULL || client->dev.driver == NULL) { 1275 - result = -ENODEV; 1276 - goto out_free; 1277 - } 1278 1255 1279 - if (!try_module_get(client->dev.driver->owner)) { 1280 - i2c_unregister_device(client); 1281 - result = -ENODEV; 1282 - goto out_free; 1283 - } 1284 - 1285 - dvb->i2c_client_demod = client; 1256 + dvb->i2c_client_demod = dvb_module_probe("si2168", NULL, 1257 + &dev->i2c_adap[dev->def_i2c_bus], 1258 + 0x64, &si2168_config); 1259 + if (!dvb->i2c_client_demod) 1260 + return -ENODEV; 1286 1261 1287 1262 /* attach tuner */ 1288 - memset(&si2157_config, 0, sizeof(si2157_config)); 1289 1263 si2157_config.fe = dvb->fe[0]; 1290 1264 si2157_config.if_port = 1; 1291 1265 #ifdef CONFIG_MEDIA_CONTROLLER_DVB 1292 1266 si2157_config.mdev = dev->media_dev; 1293 1267 #endif 1294 - memset(&info, 0, sizeof(struct i2c_board_info)); 1295 - strlcpy(info.type, "si2157", I2C_NAME_SIZE); 1296 - info.addr = 0x60; 1297 - info.platform_data = &si2157_config; 1298 - request_module(info.type); 1299 - client = i2c_new_device(adapter, &info); 1300 - if (client == NULL || client->dev.driver == NULL) { 1301 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1302 - i2c_unregister_device(dvb->i2c_client_demod); 1303 - result = -ENODEV; 1304 - goto out_free; 1268 + dvb->i2c_client_tuner = dvb_module_probe("si2157", NULL, 1269 + adapter, 1270 + 0x60, &si2157_config); 1271 + if (!dvb->i2c_client_tuner) { 1272 + dvb_module_release(dvb->i2c_client_demod); 1273 + return -ENODEV; 1305 1274 } 1306 - 1307 - if (!try_module_get(client->dev.driver->owner)) { 1308 - i2c_unregister_device(client); 1309 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1310 - i2c_unregister_device(dvb->i2c_client_demod); 1311 - result = -ENODEV; 1312 - goto out_free; 1313 - } 1314 - 1315 - dvb->i2c_client_tuner = client; 1316 1275 dvb->fe[0]->ops.set_lna = em28xx_pctv_292e_set_lna; 1317 - result = 0; 1318 - out_free: 1319 - return result; 1276 + 1277 + return 0; 1320 1278 } 1321 1279 1322 - static noinline_for_stack int em28178_dvb_init_terratec_t2_stick_hd(struct em28xx *dev) 1280 + static int em28178_dvb_init_terratec_t2_stick_hd(struct em28xx *dev) 1323 1281 { 1324 1282 struct em28xx_dvb *dvb = dev->dvb; 1325 1283 struct i2c_adapter *adapter; 1326 - struct i2c_client *client; 1327 - struct i2c_board_info info; 1328 - struct si2168_config si2168_config; 1329 - struct si2157_config si2157_config; 1330 - int result; 1284 + struct si2168_config si2168_config = {}; 1285 + struct si2157_config si2157_config = {}; 1331 1286 1332 1287 /* attach demod */ 1333 - memset(&si2168_config, 0, sizeof(si2168_config)); 1334 1288 si2168_config.i2c_adapter = &adapter; 1335 1289 si2168_config.fe = &dvb->fe[0]; 1336 1290 si2168_config.ts_mode = SI2168_TS_PARALLEL; 1337 - memset(&info, 0, sizeof(struct i2c_board_info)); 1338 - strlcpy(info.type, "si2168", I2C_NAME_SIZE); 1339 - info.addr = 0x64; 1340 - info.platform_data = &si2168_config; 1341 - request_module(info.type); 1342 - client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &info); 1343 - if (client == NULL || client->dev.driver == NULL) { 1344 - result = -ENODEV; 1345 - goto out_free; 1346 - } 1347 1291 1348 - if (!try_module_get(client->dev.driver->owner)) { 1349 - i2c_unregister_device(client); 1350 - result = -ENODEV; 1351 - goto out_free; 1352 - } 1353 - 1354 - dvb->i2c_client_demod = client; 1292 + dvb->i2c_client_demod = dvb_module_probe("si2168", NULL, 1293 + &dev->i2c_adap[dev->def_i2c_bus], 1294 + 0x64, &si2168_config); 1295 + if (!dvb->i2c_client_demod) 1296 + return -ENODEV; 1355 1297 1356 1298 /* attach tuner */ 1357 1299 memset(&si2157_config, 0, sizeof(si2157_config)); ··· 1274 1388 #ifdef CONFIG_MEDIA_CONTROLLER_DVB 1275 1389 si2157_config.mdev = dev->media_dev; 1276 1390 #endif 1277 - memset(&info, 0, sizeof(struct i2c_board_info)); 1278 - strlcpy(info.type, "si2146", I2C_NAME_SIZE); 1279 - info.addr = 0x60; 1280 - info.platform_data = &si2157_config; 1281 - request_module("si2157"); 1282 - client = i2c_new_device(adapter, &info); 1283 - if (client == NULL || client->dev.driver == NULL) { 1284 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1285 - i2c_unregister_device(dvb->i2c_client_demod); 1286 - result = -ENODEV; 1287 - goto out_free; 1391 + dvb->i2c_client_tuner = dvb_module_probe("si2157", "si2146", 1392 + adapter, 1393 + 0x60, &si2157_config); 1394 + if (!dvb->i2c_client_tuner) { 1395 + dvb_module_release(dvb->i2c_client_demod); 1396 + return -ENODEV; 1288 1397 } 1289 1398 1290 - if (!try_module_get(client->dev.driver->owner)) { 1291 - i2c_unregister_device(client); 1292 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1293 - i2c_unregister_device(dvb->i2c_client_demod); 1294 - result = -ENODEV; 1295 - goto out_free; 1296 - } 1297 - 1298 - dvb->i2c_client_tuner = client; 1299 - result = 0; 1300 - out_free: 1301 - return result; 1399 + return 0; 1302 1400 } 1303 1401 1304 - static noinline_for_stack int em28178_dvb_init_plex_px_bcud(struct em28xx *dev) 1402 + static int em28178_dvb_init_plex_px_bcud(struct em28xx *dev) 1305 1403 { 1306 1404 struct em28xx_dvb *dvb = dev->dvb; 1307 - struct i2c_client *client; 1308 - struct i2c_board_info info; 1309 - struct tc90522_config tc90522_config; 1310 - struct qm1d1c0042_config qm1d1c0042_config; 1311 - int result; 1405 + struct tc90522_config tc90522_config = {}; 1406 + struct qm1d1c0042_config qm1d1c0042_config = {}; 1312 1407 1313 1408 /* attach demod */ 1314 - memset(&tc90522_config, 0, sizeof(tc90522_config)); 1315 - memset(&info, 0, sizeof(struct i2c_board_info)); 1316 - strlcpy(info.type, "tc90522sat", I2C_NAME_SIZE); 1317 - info.addr = 0x15; 1318 - info.platform_data = &tc90522_config; 1319 - request_module("tc90522"); 1320 - client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &info); 1321 - if (client == NULL || client->dev.driver == NULL) { 1322 - result = -ENODEV; 1323 - goto out_free; 1324 - } 1325 - dvb->i2c_client_demod = client; 1326 - if (!try_module_get(client->dev.driver->owner)) { 1327 - i2c_unregister_device(client); 1328 - result = -ENODEV; 1329 - goto out_free; 1330 - } 1409 + dvb->i2c_client_demod = dvb_module_probe("tc90522", "tc90522sat", 1410 + &dev->i2c_adap[dev->def_i2c_bus], 1411 + 0x15, &tc90522_config); 1412 + if (!dvb->i2c_client_demod) 1413 + return -ENODEV; 1331 1414 1332 1415 /* attach tuner */ 1333 - memset(&qm1d1c0042_config, 0, 1334 - sizeof(qm1d1c0042_config)); 1335 1416 qm1d1c0042_config.fe = tc90522_config.fe; 1336 1417 qm1d1c0042_config.lpf = 1; 1337 - memset(&info, 0, sizeof(struct i2c_board_info)); 1338 - strlcpy(info.type, "qm1d1c0042", I2C_NAME_SIZE); 1339 - info.addr = 0x61; 1340 - info.platform_data = &qm1d1c0042_config; 1341 - request_module(info.type); 1342 - client = i2c_new_device(tc90522_config.tuner_i2c, 1343 - &info); 1344 - if (client == NULL || client->dev.driver == NULL) { 1345 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1346 - i2c_unregister_device(dvb->i2c_client_demod); 1347 - result = -ENODEV; 1348 - goto out_free; 1418 + 1419 + dvb->i2c_client_tuner = dvb_module_probe("qm1d1c0042", NULL, 1420 + tc90522_config.tuner_i2c, 1421 + 0x61, &qm1d1c0042_config); 1422 + if (!dvb->i2c_client_tuner) { 1423 + dvb_module_release(dvb->i2c_client_demod); 1424 + return -ENODEV; 1349 1425 } 1350 - dvb->i2c_client_tuner = client; 1351 - if (!try_module_get(client->dev.driver->owner)) { 1352 - i2c_unregister_device(client); 1353 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1354 - i2c_unregister_device(dvb->i2c_client_demod); 1355 - result = -ENODEV; 1356 - goto out_free; 1357 - } 1426 + 1358 1427 dvb->fe[0] = tc90522_config.fe; 1359 1428 px_bcud_init(dev); 1360 - result = 0; 1361 - out_free: 1362 - return result; 1429 + 1430 + return 0; 1363 1431 } 1364 1432 1365 - static noinline_for_stack int em28174_dvb_init_hauppauge_wintv_dualhd_dvb(struct em28xx *dev) 1433 + static int em28174_dvb_init_hauppauge_wintv_dualhd_dvb(struct em28xx *dev) 1366 1434 { 1367 1435 struct em28xx_dvb *dvb = dev->dvb; 1368 1436 struct i2c_adapter *adapter; 1369 - struct i2c_client *client; 1370 - struct i2c_board_info info; 1371 - struct si2168_config si2168_config; 1372 - struct si2157_config si2157_config; 1373 - int result; 1437 + struct si2168_config si2168_config = {}; 1438 + struct si2157_config si2157_config = {}; 1439 + unsigned char addr; 1374 1440 1375 1441 /* attach demod */ 1376 - memset(&si2168_config, 0, sizeof(si2168_config)); 1377 1442 si2168_config.i2c_adapter = &adapter; 1378 1443 si2168_config.fe = &dvb->fe[0]; 1379 1444 si2168_config.ts_mode = SI2168_TS_SERIAL; 1380 - memset(&info, 0, sizeof(struct i2c_board_info)); 1381 - strlcpy(info.type, "si2168", I2C_NAME_SIZE); 1382 - if (dev->ts == PRIMARY_TS) 1383 - info.addr = 0x64; 1384 - else 1385 - info.addr = 0x67; 1386 - info.platform_data = &si2168_config; 1387 - request_module(info.type); 1388 - client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &info); 1389 - if (client == NULL || client->dev.driver == NULL) { 1390 - result = -ENODEV; 1391 - goto out_free; 1392 - } 1445 + addr = (dev->ts == PRIMARY_TS) ? 0x64 : 0x67; 1393 1446 1394 - if (!try_module_get(client->dev.driver->owner)) { 1395 - i2c_unregister_device(client); 1396 - result = -ENODEV; 1397 - goto out_free; 1398 - } 1399 - 1400 - dvb->i2c_client_demod = client; 1447 + dvb->i2c_client_demod = dvb_module_probe("si2168", NULL, 1448 + &dev->i2c_adap[dev->def_i2c_bus], 1449 + addr, &si2168_config); 1450 + if (!dvb->i2c_client_demod) 1451 + return -ENODEV; 1401 1452 1402 1453 /* attach tuner */ 1403 1454 memset(&si2157_config, 0, sizeof(si2157_config)); ··· 1343 1520 #ifdef CONFIG_MEDIA_CONTROLLER_DVB 1344 1521 si2157_config.mdev = dev->media_dev; 1345 1522 #endif 1346 - memset(&info, 0, sizeof(struct i2c_board_info)); 1347 - strlcpy(info.type, "si2157", I2C_NAME_SIZE); 1348 - if (dev->ts == PRIMARY_TS) 1349 - info.addr = 0x60; 1350 - else 1351 - info.addr = 0x63; 1352 - info.platform_data = &si2157_config; 1353 - request_module(info.type); 1354 - client = i2c_new_device(adapter, &info); 1355 - if (client == NULL || client->dev.driver == NULL) { 1356 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1357 - i2c_unregister_device(dvb->i2c_client_demod); 1358 - result = -ENODEV; 1359 - goto out_free; 1523 + addr = (dev->ts == PRIMARY_TS) ? 0x60 : 0x63; 1524 + 1525 + dvb->i2c_client_tuner = dvb_module_probe("si2157", NULL, 1526 + adapter, 1527 + addr, &si2157_config); 1528 + if (!dvb->i2c_client_tuner) { 1529 + dvb_module_release(dvb->i2c_client_demod); 1530 + return -ENODEV; 1360 1531 } 1361 1532 1362 - if (!try_module_get(client->dev.driver->owner)) { 1363 - i2c_unregister_device(client); 1364 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1365 - i2c_unregister_device(dvb->i2c_client_demod); 1366 - result = -ENODEV; 1367 - goto out_free; 1368 - } 1369 - 1370 - dvb->i2c_client_tuner = client; 1371 - result = 0; 1372 - out_free: 1373 - return result; 1533 + return 0; 1374 1534 } 1375 1535 1376 1536 static int em28174_dvb_init_hauppauge_wintv_dualhd_01595(struct em28xx *dev) 1377 1537 { 1378 1538 struct em28xx_dvb *dvb = dev->dvb; 1379 1539 struct i2c_adapter *adapter; 1380 - struct i2c_client *client; 1381 - struct i2c_board_info info = {}; 1382 - struct lgdt3306a_config lgdt3306a_config; 1540 + struct lgdt3306a_config lgdt3306a_config = {}; 1383 1541 struct si2157_config si2157_config = {}; 1384 - int result; 1542 + unsigned char addr; 1385 1543 1386 1544 /* attach demod */ 1387 1545 lgdt3306a_config = hauppauge_01595_lgdt3306a_config; 1388 1546 lgdt3306a_config.fe = &dvb->fe[0]; 1389 1547 lgdt3306a_config.i2c_adapter = &adapter; 1390 - strlcpy(info.type, "lgdt3306a", sizeof(info.type)); 1391 - if (dev->ts == PRIMARY_TS) 1392 - info.addr = 0x59; 1393 - else 1394 - info.addr = 0x0e; 1395 - info.platform_data = &lgdt3306a_config; 1396 - request_module(info.type); 1397 - client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], 1398 - &info); 1399 - if (client == NULL || client->dev.driver == NULL) { 1400 - result = -ENODEV; 1401 - goto out_free; 1402 - } 1548 + addr = (dev->ts == PRIMARY_TS) ? 0x59 : 0x0e; 1403 1549 1404 - if (!try_module_get(client->dev.driver->owner)) { 1405 - i2c_unregister_device(client); 1406 - result = -ENODEV; 1407 - goto out_free; 1408 - } 1409 - 1410 - dvb->i2c_client_demod = client; 1550 + dvb->i2c_client_demod = dvb_module_probe("lgdt3306a", NULL, 1551 + &dev->i2c_adap[dev->def_i2c_bus], 1552 + addr, &lgdt3306a_config); 1553 + if (!dvb->i2c_client_demod) 1554 + return -ENODEV; 1411 1555 1412 1556 /* attach tuner */ 1413 1557 si2157_config.fe = dvb->fe[0]; ··· 1383 1593 #ifdef CONFIG_MEDIA_CONTROLLER_DVB 1384 1594 si2157_config.mdev = dev->media_dev; 1385 1595 #endif 1386 - memset(&info, 0, sizeof(struct i2c_board_info)); 1387 - strlcpy(info.type, "si2157", sizeof(info.type)); 1388 - if (dev->ts == PRIMARY_TS) 1389 - info.addr = 0x60; 1390 - else 1391 - info.addr = 0x62; 1392 - info.platform_data = &si2157_config; 1393 - request_module(info.type); 1596 + addr = (dev->ts == PRIMARY_TS) ? 0x60 : 0x62; 1394 1597 1395 - client = i2c_new_device(adapter, &info); 1396 - if (client == NULL || client->dev.driver == NULL) { 1397 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1398 - i2c_unregister_device(dvb->i2c_client_demod); 1399 - result = -ENODEV; 1400 - goto out_free; 1401 - } 1402 - if (!try_module_get(client->dev.driver->owner)) { 1403 - i2c_unregister_device(client); 1404 - module_put(dvb->i2c_client_demod->dev.driver->owner); 1405 - i2c_unregister_device(dvb->i2c_client_demod); 1406 - result = -ENODEV; 1407 - goto out_free; 1598 + dvb->i2c_client_tuner = dvb_module_probe("si2157", NULL, 1599 + adapter, 1600 + 0x60, &si2157_config); 1601 + if (!dvb->i2c_client_tuner) { 1602 + dvb_module_release(dvb->i2c_client_demod); 1603 + return -ENODEV; 1408 1604 } 1409 1605 1410 - dvb->i2c_client_tuner = client; 1411 - result = 0; 1412 - out_free: 1413 - return result; 1606 + return 0; 1414 1607 } 1608 + 1415 1609 static int em28xx_dvb_init(struct em28xx *dev) 1416 1610 { 1417 1611 int result = 0, dvb_alt = 0; ··· 1631 1857 break; 1632 1858 case EM2884_BOARD_HAUPPAUGE_WINTV_HVR_930C: 1633 1859 { 1634 - struct xc5000_config cfg; 1860 + struct xc5000_config cfg = {}; 1635 1861 1636 1862 hauppauge_hvr930c_init(dev); 1637 1863 ··· 1648 1874 dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl; 1649 1875 1650 1876 /* Attach xc5000 */ 1651 - memset(&cfg, 0, sizeof(cfg)); 1652 1877 cfg.i2c_address = 0x61; 1653 1878 cfg.if_khz = 4000; 1654 1879 ··· 1800 2027 break; 1801 2028 case EM2874_BOARD_KWORLD_UB435Q_V3: 1802 2029 { 1803 - struct i2c_client *client; 1804 2030 struct i2c_adapter *adapter = &dev->i2c_adap[dev->def_i2c_bus]; 1805 - struct i2c_board_info board_info = { 1806 - .type = "tda18212", 1807 - .addr = 0x60, 1808 - .platform_data = &kworld_ub435q_v3_config, 1809 - }; 1810 2031 1811 2032 dvb->fe[0] = dvb_attach(lgdt3305_attach, 1812 2033 &em2874_lgdt3305_nogate_dev, ··· 1812 2045 1813 2046 /* attach tuner */ 1814 2047 kworld_ub435q_v3_config.fe = dvb->fe[0]; 1815 - request_module("tda18212"); 1816 - client = i2c_new_device(adapter, &board_info); 1817 - if (client == NULL || client->dev.driver == NULL) { 2048 + 2049 + dvb->i2c_client_tuner = dvb_module_probe("tda18212", NULL, 2050 + adapter, 2051 + 0x60, 2052 + &kworld_ub435q_v3_config); 2053 + if (!dvb->i2c_client_tuner) { 1818 2054 dvb_frontend_detach(dvb->fe[0]); 1819 2055 result = -ENODEV; 1820 2056 goto out_free; 1821 2057 } 1822 - 1823 - if (!try_module_get(client->dev.driver->owner)) { 1824 - i2c_unregister_device(client); 1825 - dvb_frontend_detach(dvb->fe[0]); 1826 - result = -ENODEV; 1827 - goto out_free; 1828 - } 1829 - 1830 - dvb->i2c_client_tuner = client; 1831 2058 break; 1832 2059 } 1833 2060 case EM2874_BOARD_PCTV_HD_MINI_80E: ··· 1920 2159 static int em28xx_dvb_fini(struct em28xx *dev) 1921 2160 { 1922 2161 struct em28xx_dvb *dvb; 1923 - struct i2c_client *client; 1924 2162 1925 2163 if (dev->is_audio_only) { 1926 2164 /* Shouldn't initialize IR for this interface */ ··· 1955 2195 1956 2196 em28xx_unregister_dvb(dvb); 1957 2197 1958 - /* remove I2C SEC */ 1959 - client = dvb->i2c_client_sec; 1960 - if (client) { 1961 - module_put(client->dev.driver->owner); 1962 - i2c_unregister_device(client); 1963 - } 1964 - 1965 - /* remove I2C tuner */ 1966 - client = dvb->i2c_client_tuner; 1967 - if (client) { 1968 - module_put(client->dev.driver->owner); 1969 - i2c_unregister_device(client); 1970 - } 1971 - 1972 - /* remove I2C demod */ 1973 - client = dvb->i2c_client_demod; 1974 - if (client) { 1975 - module_put(client->dev.driver->owner); 1976 - i2c_unregister_device(client); 1977 - } 2198 + /* release I2C module bindings */ 2199 + dvb_module_release(dvb->i2c_client_sec); 2200 + dvb_module_release(dvb->i2c_client_tuner); 2201 + dvb_module_release(dvb->i2c_client_demod); 1978 2202 1979 2203 kfree(dvb); 1980 2204 dev->dvb = NULL;