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

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'driver-core-6.6-rc1-2' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core

Pull driver symbol lookup fix from Greg KH:
"Here is one last fixup for your tree for 6.6-rc1. It resolves a
problem with the way that symbol_get was changed in the module tree
merge in your tree to fix up the DVB drivers which rely on this old
api to attach new devices.

As the changelog comment says:

In commit 9011e49d54dc ("modules: only allow symbol_get of
EXPORT_SYMBOL_GPL modules") the use of symbol_get is properly
restricted to GPL-only marked symbols. This interacts oddly with the
DVB logic which only uses dvb_attach() to load the dvb driver which
then uses symbol_get().

Fix this up by properly marking all of the dvb_attach attach symbols
as EXPORT_SYMBOL_GPL().

This has been acked by Hans from the V4L driver side, Luis from the
module side, Mauro on the media side, and Christoph said it was the
correct solution, and was tested by the original reporter of the
issue.

It has passed 0-day testing, but has not been in linux-next due to it
only being sent yesterday"

* tag 'driver-core-6.6-rc1-2' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core:
media: dvb: symbol fixup for dvb_attach()

Linus Torvalds 6b41fb27 474197a4

+113 -113
+1 -1
drivers/media/dvb-frontends/ascot2e.c
··· 533 533 priv->i2c_address, priv->i2c); 534 534 return fe; 535 535 } 536 - EXPORT_SYMBOL(ascot2e_attach); 536 + EXPORT_SYMBOL_GPL(ascot2e_attach); 537 537 538 538 MODULE_DESCRIPTION("Sony ASCOT2E terr/cab tuner driver"); 539 539 MODULE_AUTHOR("info@netup.ru");
+1 -1
drivers/media/dvb-frontends/atbm8830.c
··· 489 489 return NULL; 490 490 491 491 } 492 - EXPORT_SYMBOL(atbm8830_attach); 492 + EXPORT_SYMBOL_GPL(atbm8830_attach); 493 493 494 494 MODULE_DESCRIPTION("AltoBeam ATBM8830/8831 GB20600 demodulator driver"); 495 495 MODULE_AUTHOR("David T. L. Wong <davidtlwong@gmail.com>");
+1 -1
drivers/media/dvb-frontends/au8522_dig.c
··· 879 879 au8522_release_state(state); 880 880 return NULL; 881 881 } 882 - EXPORT_SYMBOL(au8522_attach); 882 + EXPORT_SYMBOL_GPL(au8522_attach); 883 883 884 884 static const struct dvb_frontend_ops au8522_ops = { 885 885 .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
+1 -1
drivers/media/dvb-frontends/bcm3510.c
··· 835 835 kfree(state); 836 836 return NULL; 837 837 } 838 - EXPORT_SYMBOL(bcm3510_attach); 838 + EXPORT_SYMBOL_GPL(bcm3510_attach); 839 839 840 840 static const struct dvb_frontend_ops bcm3510_ops = { 841 841 .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
+1 -1
drivers/media/dvb-frontends/cx22700.c
··· 432 432 MODULE_AUTHOR("Holger Waechtler"); 433 433 MODULE_LICENSE("GPL"); 434 434 435 - EXPORT_SYMBOL(cx22700_attach); 435 + EXPORT_SYMBOL_GPL(cx22700_attach);
+1 -1
drivers/media/dvb-frontends/cx22702.c
··· 604 604 kfree(state); 605 605 return NULL; 606 606 } 607 - EXPORT_SYMBOL(cx22702_attach); 607 + EXPORT_SYMBOL_GPL(cx22702_attach); 608 608 609 609 static const struct dvb_frontend_ops cx22702_ops = { 610 610 .delsys = { SYS_DVBT },
+1 -1
drivers/media/dvb-frontends/cx24110.c
··· 653 653 MODULE_AUTHOR("Peter Hettkamp"); 654 654 MODULE_LICENSE("GPL"); 655 655 656 - EXPORT_SYMBOL(cx24110_attach); 656 + EXPORT_SYMBOL_GPL(cx24110_attach);
+1 -1
drivers/media/dvb-frontends/cx24113.c
··· 590 590 591 591 return NULL; 592 592 } 593 - EXPORT_SYMBOL(cx24113_attach); 593 + EXPORT_SYMBOL_GPL(cx24113_attach); 594 594 595 595 module_param(debug, int, 0644); 596 596 MODULE_PARM_DESC(debug, "Activates frontend debugging (default:0)");
+1 -1
drivers/media/dvb-frontends/cx24116.c
··· 1133 1133 state->frontend.demodulator_priv = state; 1134 1134 return &state->frontend; 1135 1135 } 1136 - EXPORT_SYMBOL(cx24116_attach); 1136 + EXPORT_SYMBOL_GPL(cx24116_attach); 1137 1137 1138 1138 /* 1139 1139 * Initialise or wake up device
+1 -1
drivers/media/dvb-frontends/cx24120.c
··· 305 305 kfree(state); 306 306 return NULL; 307 307 } 308 - EXPORT_SYMBOL(cx24120_attach); 308 + EXPORT_SYMBOL_GPL(cx24120_attach); 309 309 310 310 static int cx24120_test_rom(struct cx24120_state *state) 311 311 {
+1 -1
drivers/media/dvb-frontends/cx24123.c
··· 1096 1096 1097 1097 return NULL; 1098 1098 } 1099 - EXPORT_SYMBOL(cx24123_attach); 1099 + EXPORT_SYMBOL_GPL(cx24123_attach); 1100 1100 1101 1101 static const struct dvb_frontend_ops cx24123_ops = { 1102 1102 .delsys = { SYS_DVBS },
+1 -1
drivers/media/dvb-frontends/cxd2820r_core.c
··· 536 536 537 537 return pdata.get_dvb_frontend(client); 538 538 } 539 - EXPORT_SYMBOL(cxd2820r_attach); 539 + EXPORT_SYMBOL_GPL(cxd2820r_attach); 540 540 541 541 static struct dvb_frontend *cxd2820r_get_dvb_frontend(struct i2c_client *client) 542 542 {
+2 -2
drivers/media/dvb-frontends/cxd2841er.c
··· 3930 3930 { 3931 3931 return cxd2841er_attach(cfg, i2c, SYS_DVBS); 3932 3932 } 3933 - EXPORT_SYMBOL(cxd2841er_attach_s); 3933 + EXPORT_SYMBOL_GPL(cxd2841er_attach_s); 3934 3934 3935 3935 struct dvb_frontend *cxd2841er_attach_t_c(struct cxd2841er_config *cfg, 3936 3936 struct i2c_adapter *i2c) 3937 3937 { 3938 3938 return cxd2841er_attach(cfg, i2c, 0); 3939 3939 } 3940 - EXPORT_SYMBOL(cxd2841er_attach_t_c); 3940 + EXPORT_SYMBOL_GPL(cxd2841er_attach_t_c); 3941 3941 3942 3942 static const struct dvb_frontend_ops cxd2841er_dvbs_s2_ops = { 3943 3943 .delsys = { SYS_DVBS, SYS_DVBS2 },
+1 -1
drivers/media/dvb-frontends/cxd2880/cxd2880_top.c
··· 1950 1950 1951 1951 return fe; 1952 1952 } 1953 - EXPORT_SYMBOL(cxd2880_attach); 1953 + EXPORT_SYMBOL_GPL(cxd2880_attach); 1954 1954 1955 1955 MODULE_DESCRIPTION("Sony CXD2880 DVB-T2/T tuner + demod driver"); 1956 1956 MODULE_AUTHOR("Sony Semiconductor Solutions Corporation");
+1 -1
drivers/media/dvb-frontends/dib0070.c
··· 762 762 fe->tuner_priv = NULL; 763 763 return NULL; 764 764 } 765 - EXPORT_SYMBOL(dib0070_attach); 765 + EXPORT_SYMBOL_GPL(dib0070_attach); 766 766 767 767 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>"); 768 768 MODULE_DESCRIPTION("Driver for the DiBcom 0070 base-band RF Tuner");
+2 -2
drivers/media/dvb-frontends/dib0090.c
··· 2634 2634 return NULL; 2635 2635 } 2636 2636 2637 - EXPORT_SYMBOL(dib0090_register); 2637 + EXPORT_SYMBOL_GPL(dib0090_register); 2638 2638 2639 2639 struct dvb_frontend *dib0090_fw_register(struct dvb_frontend *fe, struct i2c_adapter *i2c, const struct dib0090_config *config) 2640 2640 { ··· 2660 2660 fe->tuner_priv = NULL; 2661 2661 return NULL; 2662 2662 } 2663 - EXPORT_SYMBOL(dib0090_fw_register); 2663 + EXPORT_SYMBOL_GPL(dib0090_fw_register); 2664 2664 2665 2665 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>"); 2666 2666 MODULE_AUTHOR("Olivier Grenie <olivier.grenie@parrot.com>");
+1 -1
drivers/media/dvb-frontends/dib3000mb.c
··· 815 815 MODULE_DESCRIPTION(DRIVER_DESC); 816 816 MODULE_LICENSE("GPL"); 817 817 818 - EXPORT_SYMBOL(dib3000mb_attach); 818 + EXPORT_SYMBOL_GPL(dib3000mb_attach);
+1 -1
drivers/media/dvb-frontends/dib3000mc.c
··· 935 935 kfree(st); 936 936 return NULL; 937 937 } 938 - EXPORT_SYMBOL(dib3000mc_attach); 938 + EXPORT_SYMBOL_GPL(dib3000mc_attach); 939 939 940 940 static const struct dvb_frontend_ops dib3000mc_ops = { 941 941 .delsys = { SYS_DVBT },
+1 -1
drivers/media/dvb-frontends/dib7000m.c
··· 1434 1434 kfree(st); 1435 1435 return NULL; 1436 1436 } 1437 - EXPORT_SYMBOL(dib7000m_attach); 1437 + EXPORT_SYMBOL_GPL(dib7000m_attach); 1438 1438 1439 1439 static const struct dvb_frontend_ops dib7000m_ops = { 1440 1440 .delsys = { SYS_DVBT },
+1 -1
drivers/media/dvb-frontends/dib7000p.c
··· 2822 2822 2823 2823 return ops; 2824 2824 } 2825 - EXPORT_SYMBOL(dib7000p_attach); 2825 + EXPORT_SYMBOL_GPL(dib7000p_attach); 2826 2826 2827 2827 static const struct dvb_frontend_ops dib7000p_ops = { 2828 2828 .delsys = { SYS_DVBT },
+1 -1
drivers/media/dvb-frontends/dib8000.c
··· 4527 4527 4528 4528 return ops; 4529 4529 } 4530 - EXPORT_SYMBOL(dib8000_attach); 4530 + EXPORT_SYMBOL_GPL(dib8000_attach); 4531 4531 4532 4532 MODULE_AUTHOR("Olivier Grenie <Olivier.Grenie@parrot.com, Patrick Boettcher <patrick.boettcher@posteo.de>"); 4533 4533 MODULE_DESCRIPTION("Driver for the DiBcom 8000 ISDB-T demodulator");
+1 -1
drivers/media/dvb-frontends/dib9000.c
··· 2546 2546 kfree(st); 2547 2547 return NULL; 2548 2548 } 2549 - EXPORT_SYMBOL(dib9000_attach); 2549 + EXPORT_SYMBOL_GPL(dib9000_attach); 2550 2550 2551 2551 static const struct dvb_frontend_ops dib9000_ops = { 2552 2552 .delsys = { SYS_DVBT },
+1 -1
drivers/media/dvb-frontends/drx39xyj/drxj.c
··· 12372 12372 12373 12373 return NULL; 12374 12374 } 12375 - EXPORT_SYMBOL(drx39xxj_attach); 12375 + EXPORT_SYMBOL_GPL(drx39xxj_attach); 12376 12376 12377 12377 static const struct dvb_frontend_ops drx39xxj_ops = { 12378 12378 .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
+1 -1
drivers/media/dvb-frontends/drxd_hard.c
··· 2939 2939 kfree(state); 2940 2940 return NULL; 2941 2941 } 2942 - EXPORT_SYMBOL(drxd_attach); 2942 + EXPORT_SYMBOL_GPL(drxd_attach); 2943 2943 2944 2944 MODULE_DESCRIPTION("DRXD driver"); 2945 2945 MODULE_AUTHOR("Micronas");
+1 -1
drivers/media/dvb-frontends/drxk_hard.c
··· 6814 6814 kfree(state); 6815 6815 return NULL; 6816 6816 } 6817 - EXPORT_SYMBOL(drxk_attach); 6817 + EXPORT_SYMBOL_GPL(drxk_attach); 6818 6818 6819 6819 MODULE_DESCRIPTION("DRX-K driver"); 6820 6820 MODULE_AUTHOR("Ralph Metzler");
+1 -1
drivers/media/dvb-frontends/ds3000.c
··· 859 859 ds3000_set_voltage(&state->frontend, SEC_VOLTAGE_OFF); 860 860 return &state->frontend; 861 861 } 862 - EXPORT_SYMBOL(ds3000_attach); 862 + EXPORT_SYMBOL_GPL(ds3000_attach); 863 863 864 864 static int ds3000_set_carrier_offset(struct dvb_frontend *fe, 865 865 s32 carrier_offset_khz)
+1 -1
drivers/media/dvb-frontends/dvb-pll.c
··· 866 866 867 867 return NULL; 868 868 } 869 - EXPORT_SYMBOL(dvb_pll_attach); 869 + EXPORT_SYMBOL_GPL(dvb_pll_attach); 870 870 871 871 872 872 static int
+1 -1
drivers/media/dvb-frontends/ec100.c
··· 299 299 kfree(state); 300 300 return NULL; 301 301 } 302 - EXPORT_SYMBOL(ec100_attach); 302 + EXPORT_SYMBOL_GPL(ec100_attach); 303 303 304 304 static const struct dvb_frontend_ops ec100_ops = { 305 305 .delsys = { SYS_DVBT },
+2 -2
drivers/media/dvb-frontends/helene.c
··· 1025 1025 priv->i2c_address, priv->i2c); 1026 1026 return fe; 1027 1027 } 1028 - EXPORT_SYMBOL(helene_attach_s); 1028 + EXPORT_SYMBOL_GPL(helene_attach_s); 1029 1029 1030 1030 struct dvb_frontend *helene_attach(struct dvb_frontend *fe, 1031 1031 const struct helene_config *config, ··· 1061 1061 priv->i2c_address, priv->i2c); 1062 1062 return fe; 1063 1063 } 1064 - EXPORT_SYMBOL(helene_attach); 1064 + EXPORT_SYMBOL_GPL(helene_attach); 1065 1065 1066 1066 static int helene_probe(struct i2c_client *client) 1067 1067 {
+1 -1
drivers/media/dvb-frontends/horus3a.c
··· 395 395 priv->i2c_address, priv->i2c); 396 396 return fe; 397 397 } 398 - EXPORT_SYMBOL(horus3a_attach); 398 + EXPORT_SYMBOL_GPL(horus3a_attach); 399 399 400 400 MODULE_DESCRIPTION("Sony HORUS3A satellite tuner driver"); 401 401 MODULE_AUTHOR("Sergey Kozlov <serjk@netup.ru>");
+1 -1
drivers/media/dvb-frontends/isl6405.c
··· 141 141 142 142 return fe; 143 143 } 144 - EXPORT_SYMBOL(isl6405_attach); 144 + EXPORT_SYMBOL_GPL(isl6405_attach); 145 145 146 146 MODULE_DESCRIPTION("Driver for lnb supply and control ic isl6405"); 147 147 MODULE_AUTHOR("Hartmut Hackmann & Oliver Endriss");
+1 -1
drivers/media/dvb-frontends/isl6421.c
··· 213 213 214 214 return fe; 215 215 } 216 - EXPORT_SYMBOL(isl6421_attach); 216 + EXPORT_SYMBOL_GPL(isl6421_attach); 217 217 218 218 MODULE_DESCRIPTION("Driver for lnb supply and control ic isl6421"); 219 219 MODULE_AUTHOR("Andrew de Quincey & Oliver Endriss");
+1 -1
drivers/media/dvb-frontends/isl6423.c
··· 289 289 fe->sec_priv = NULL; 290 290 return NULL; 291 291 } 292 - EXPORT_SYMBOL(isl6423_attach); 292 + EXPORT_SYMBOL_GPL(isl6423_attach); 293 293 294 294 MODULE_DESCRIPTION("ISL6423 SEC"); 295 295 MODULE_AUTHOR("Manu Abraham");
+1 -1
drivers/media/dvb-frontends/itd1000.c
··· 389 389 390 390 return fe; 391 391 } 392 - EXPORT_SYMBOL(itd1000_attach); 392 + EXPORT_SYMBOL_GPL(itd1000_attach); 393 393 394 394 MODULE_AUTHOR("Patrick Boettcher <pb@linuxtv.org>"); 395 395 MODULE_DESCRIPTION("Integrant ITD1000 driver");
+1 -1
drivers/media/dvb-frontends/ix2505v.c
··· 302 302 kfree(state); 303 303 return NULL; 304 304 } 305 - EXPORT_SYMBOL(ix2505v_attach); 305 + EXPORT_SYMBOL_GPL(ix2505v_attach); 306 306 307 307 module_param_named(debug, ix2505v_debug, int, 0644); 308 308 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
+1 -1
drivers/media/dvb-frontends/l64781.c
··· 593 593 MODULE_AUTHOR("Holger Waechtler, Marko Kohtala"); 594 594 MODULE_LICENSE("GPL"); 595 595 596 - EXPORT_SYMBOL(l64781_attach); 596 + EXPORT_SYMBOL_GPL(l64781_attach);
+1 -1
drivers/media/dvb-frontends/lg2160.c
··· 1426 1426 1427 1427 return &state->frontend; 1428 1428 } 1429 - EXPORT_SYMBOL(lg2160_attach); 1429 + EXPORT_SYMBOL_GPL(lg2160_attach); 1430 1430 1431 1431 MODULE_DESCRIPTION("LG Electronics LG216x ATSC/MH Demodulator Driver"); 1432 1432 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
+1 -1
drivers/media/dvb-frontends/lgdt3305.c
··· 1148 1148 kfree(state); 1149 1149 return NULL; 1150 1150 } 1151 - EXPORT_SYMBOL(lgdt3305_attach); 1151 + EXPORT_SYMBOL_GPL(lgdt3305_attach); 1152 1152 1153 1153 static const struct dvb_frontend_ops lgdt3304_ops = { 1154 1154 .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
+1 -1
drivers/media/dvb-frontends/lgdt3306a.c
··· 1859 1859 kfree(state); 1860 1860 return NULL; 1861 1861 } 1862 - EXPORT_SYMBOL(lgdt3306a_attach); 1862 + EXPORT_SYMBOL_GPL(lgdt3306a_attach); 1863 1863 1864 1864 #ifdef DBG_DUMP 1865 1865
+1 -1
drivers/media/dvb-frontends/lgdt330x.c
··· 927 927 928 928 return lgdt330x_get_dvb_frontend(client); 929 929 } 930 - EXPORT_SYMBOL(lgdt330x_attach); 930 + EXPORT_SYMBOL_GPL(lgdt330x_attach); 931 931 932 932 static const struct dvb_frontend_ops lgdt3302_ops = { 933 933 .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
+1 -1
drivers/media/dvb-frontends/lgs8gxx.c
··· 1043 1043 return NULL; 1044 1044 1045 1045 } 1046 - EXPORT_SYMBOL(lgs8gxx_attach); 1046 + EXPORT_SYMBOL_GPL(lgs8gxx_attach); 1047 1047 1048 1048 MODULE_DESCRIPTION("Legend Silicon LGS8913/LGS8GXX DMB-TH demodulator driver"); 1049 1049 MODULE_AUTHOR("David T. L. Wong <davidtlwong@gmail.com>");
+1 -1
drivers/media/dvb-frontends/lnbh25.c
··· 173 173 __func__, priv->i2c_address); 174 174 return fe; 175 175 } 176 - EXPORT_SYMBOL(lnbh25_attach); 176 + EXPORT_SYMBOL_GPL(lnbh25_attach); 177 177 178 178 MODULE_DESCRIPTION("ST LNBH25 driver"); 179 179 MODULE_AUTHOR("info@netup.ru");
+2 -2
drivers/media/dvb-frontends/lnbp21.c
··· 155 155 return lnbx2x_attach(fe, i2c, override_set, override_clear, 156 156 i2c_addr, LNBH24_TTX); 157 157 } 158 - EXPORT_SYMBOL(lnbh24_attach); 158 + EXPORT_SYMBOL_GPL(lnbh24_attach); 159 159 160 160 struct dvb_frontend *lnbp21_attach(struct dvb_frontend *fe, 161 161 struct i2c_adapter *i2c, u8 override_set, ··· 164 164 return lnbx2x_attach(fe, i2c, override_set, override_clear, 165 165 0x08, LNBP21_ISEL); 166 166 } 167 - EXPORT_SYMBOL(lnbp21_attach); 167 + EXPORT_SYMBOL_GPL(lnbp21_attach); 168 168 169 169 MODULE_DESCRIPTION("Driver for lnb supply and control ic lnbp21, lnbh24"); 170 170 MODULE_AUTHOR("Oliver Endriss, Igor M. Liplianin");
+1 -1
drivers/media/dvb-frontends/lnbp22.c
··· 125 125 126 126 return fe; 127 127 } 128 - EXPORT_SYMBOL(lnbp22_attach); 128 + EXPORT_SYMBOL_GPL(lnbp22_attach); 129 129 130 130 MODULE_DESCRIPTION("Driver for lnb supply and control ic lnbp22"); 131 131 MODULE_AUTHOR("Dominik Kuhlen");
+1 -1
drivers/media/dvb-frontends/m88ds3103.c
··· 1695 1695 *tuner_i2c_adapter = pdata.get_i2c_adapter(client); 1696 1696 return pdata.get_dvb_frontend(client); 1697 1697 } 1698 - EXPORT_SYMBOL(m88ds3103_attach); 1698 + EXPORT_SYMBOL_GPL(m88ds3103_attach); 1699 1699 1700 1700 static const struct dvb_frontend_ops m88ds3103_ops = { 1701 1701 .delsys = {SYS_DVBS, SYS_DVBS2},
+1 -1
drivers/media/dvb-frontends/m88rs2000.c
··· 808 808 809 809 return NULL; 810 810 } 811 - EXPORT_SYMBOL(m88rs2000_attach); 811 + EXPORT_SYMBOL_GPL(m88rs2000_attach); 812 812 813 813 MODULE_DESCRIPTION("M88RS2000 DVB-S Demodulator driver"); 814 814 MODULE_AUTHOR("Malcolm Priestley tvboxspy@gmail.com");
+1 -1
drivers/media/dvb-frontends/mb86a16.c
··· 1853 1853 kfree(state); 1854 1854 return NULL; 1855 1855 } 1856 - EXPORT_SYMBOL(mb86a16_attach); 1856 + EXPORT_SYMBOL_GPL(mb86a16_attach); 1857 1857 MODULE_LICENSE("GPL"); 1858 1858 MODULE_AUTHOR("Manu Abraham");
+1 -1
drivers/media/dvb-frontends/mb86a20s.c
··· 2078 2078 dev_info(&i2c->dev, "Detected a Fujitsu mb86a20s frontend\n"); 2079 2079 return &state->frontend; 2080 2080 } 2081 - EXPORT_SYMBOL(mb86a20s_attach); 2081 + EXPORT_SYMBOL_GPL(mb86a20s_attach); 2082 2082 2083 2083 static const struct dvb_frontend_ops mb86a20s_ops = { 2084 2084 .delsys = { SYS_ISDBT },
+1 -1
drivers/media/dvb-frontends/mt312.c
··· 827 827 kfree(state); 828 828 return NULL; 829 829 } 830 - EXPORT_SYMBOL(mt312_attach); 830 + EXPORT_SYMBOL_GPL(mt312_attach); 831 831 832 832 module_param(debug, int, 0644); 833 833 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
+1 -1
drivers/media/dvb-frontends/mt352.c
··· 593 593 MODULE_AUTHOR("Holger Waechtler, Daniel Mack, Antonio Mancuso"); 594 594 MODULE_LICENSE("GPL"); 595 595 596 - EXPORT_SYMBOL(mt352_attach); 596 + EXPORT_SYMBOL_GPL(mt352_attach);
+1 -1
drivers/media/dvb-frontends/nxt200x.c
··· 1216 1216 MODULE_AUTHOR("Kirk Lapray, Michael Krufky, Jean-Francois Thibert, and Taylor Jacob"); 1217 1217 MODULE_LICENSE("GPL"); 1218 1218 1219 - EXPORT_SYMBOL(nxt200x_attach); 1219 + EXPORT_SYMBOL_GPL(nxt200x_attach); 1220 1220
+1 -1
drivers/media/dvb-frontends/nxt6000.c
··· 621 621 MODULE_AUTHOR("Florian Schirmer"); 622 622 MODULE_LICENSE("GPL"); 623 623 624 - EXPORT_SYMBOL(nxt6000_attach); 624 + EXPORT_SYMBOL_GPL(nxt6000_attach);
+1 -1
drivers/media/dvb-frontends/or51132.c
··· 605 605 MODULE_AUTHOR("Trent Piepho"); 606 606 MODULE_LICENSE("GPL"); 607 607 608 - EXPORT_SYMBOL(or51132_attach); 608 + EXPORT_SYMBOL_GPL(or51132_attach);
+1 -1
drivers/media/dvb-frontends/or51211.c
··· 551 551 MODULE_AUTHOR("Kirk Lapray"); 552 552 MODULE_LICENSE("GPL"); 553 553 554 - EXPORT_SYMBOL(or51211_attach); 554 + EXPORT_SYMBOL_GPL(or51211_attach); 555 555
+1 -1
drivers/media/dvb-frontends/s5h1409.c
··· 981 981 kfree(state); 982 982 return NULL; 983 983 } 984 - EXPORT_SYMBOL(s5h1409_attach); 984 + EXPORT_SYMBOL_GPL(s5h1409_attach); 985 985 986 986 static const struct dvb_frontend_ops s5h1409_ops = { 987 987 .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
+1 -1
drivers/media/dvb-frontends/s5h1411.c
··· 900 900 kfree(state); 901 901 return NULL; 902 902 } 903 - EXPORT_SYMBOL(s5h1411_attach); 903 + EXPORT_SYMBOL_GPL(s5h1411_attach); 904 904 905 905 static const struct dvb_frontend_ops s5h1411_ops = { 906 906 .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
+1 -1
drivers/media/dvb-frontends/s5h1420.c
··· 918 918 kfree(state); 919 919 return NULL; 920 920 } 921 - EXPORT_SYMBOL(s5h1420_attach); 921 + EXPORT_SYMBOL_GPL(s5h1420_attach); 922 922 923 923 static const struct dvb_frontend_ops s5h1420_ops = { 924 924 .delsys = { SYS_DVBS },
+1 -1
drivers/media/dvb-frontends/s5h1432.c
··· 355 355 356 356 return &state->frontend; 357 357 } 358 - EXPORT_SYMBOL(s5h1432_attach); 358 + EXPORT_SYMBOL_GPL(s5h1432_attach); 359 359 360 360 static const struct dvb_frontend_ops s5h1432_ops = { 361 361 .delsys = { SYS_DVBT },
+1 -1
drivers/media/dvb-frontends/s921.c
··· 495 495 496 496 return &state->frontend; 497 497 } 498 - EXPORT_SYMBOL(s921_attach); 498 + EXPORT_SYMBOL_GPL(s921_attach); 499 499 500 500 static const struct dvb_frontend_ops s921_ops = { 501 501 .delsys = { SYS_ISDBT },
+1 -1
drivers/media/dvb-frontends/si21xx.c
··· 937 937 kfree(state); 938 938 return NULL; 939 939 } 940 - EXPORT_SYMBOL(si21xx_attach); 940 + EXPORT_SYMBOL_GPL(si21xx_attach); 941 941 942 942 module_param(debug, int, 0644); 943 943 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
+1 -1
drivers/media/dvb-frontends/sp887x.c
··· 624 624 MODULE_DESCRIPTION("Spase sp887x DVB-T demodulator driver"); 625 625 MODULE_LICENSE("GPL"); 626 626 627 - EXPORT_SYMBOL(sp887x_attach); 627 + EXPORT_SYMBOL_GPL(sp887x_attach);
+1 -1
drivers/media/dvb-frontends/stb0899_drv.c
··· 1638 1638 kfree(state); 1639 1639 return NULL; 1640 1640 } 1641 - EXPORT_SYMBOL(stb0899_attach); 1641 + EXPORT_SYMBOL_GPL(stb0899_attach); 1642 1642 MODULE_PARM_DESC(verbose, "Set Verbosity level"); 1643 1643 MODULE_AUTHOR("Manu Abraham"); 1644 1644 MODULE_DESCRIPTION("STB0899 Multi-Std frontend");
+1 -1
drivers/media/dvb-frontends/stb6000.c
··· 232 232 233 233 return fe; 234 234 } 235 - EXPORT_SYMBOL(stb6000_attach); 235 + EXPORT_SYMBOL_GPL(stb6000_attach); 236 236 237 237 module_param(debug, int, 0644); 238 238 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
+1 -1
drivers/media/dvb-frontends/stb6100.c
··· 557 557 kfree(state); 558 558 } 559 559 560 - EXPORT_SYMBOL(stb6100_attach); 560 + EXPORT_SYMBOL_GPL(stb6100_attach); 561 561 MODULE_PARM_DESC(verbose, "Set Verbosity level"); 562 562 563 563 MODULE_AUTHOR("Manu Abraham");
+1 -1
drivers/media/dvb-frontends/stv0288.c
··· 590 590 591 591 return NULL; 592 592 } 593 - EXPORT_SYMBOL(stv0288_attach); 593 + EXPORT_SYMBOL_GPL(stv0288_attach); 594 594 595 595 module_param(debug_legacy_dish_switch, int, 0444); 596 596 MODULE_PARM_DESC(debug_legacy_dish_switch,
+1 -1
drivers/media/dvb-frontends/stv0297.c
··· 710 710 MODULE_AUTHOR("Dennis Noermann and Andrew de Quincey"); 711 711 MODULE_LICENSE("GPL"); 712 712 713 - EXPORT_SYMBOL(stv0297_attach); 713 + EXPORT_SYMBOL_GPL(stv0297_attach);
+1 -1
drivers/media/dvb-frontends/stv0299.c
··· 752 752 MODULE_AUTHOR("Ralph Metzler, Holger Waechtler, Peter Schildmann, Felix Domke, Andreas Oberritter, Andrew de Quincey, Kenneth Aafly"); 753 753 MODULE_LICENSE("GPL"); 754 754 755 - EXPORT_SYMBOL(stv0299_attach); 755 + EXPORT_SYMBOL_GPL(stv0299_attach);
+3 -3
drivers/media/dvb-frontends/stv0367.c
··· 1750 1750 kfree(state); 1751 1751 return NULL; 1752 1752 } 1753 - EXPORT_SYMBOL(stv0367ter_attach); 1753 + EXPORT_SYMBOL_GPL(stv0367ter_attach); 1754 1754 1755 1755 static int stv0367cab_gate_ctrl(struct dvb_frontend *fe, int enable) 1756 1756 { ··· 2919 2919 kfree(state); 2920 2920 return NULL; 2921 2921 } 2922 - EXPORT_SYMBOL(stv0367cab_attach); 2922 + EXPORT_SYMBOL_GPL(stv0367cab_attach); 2923 2923 2924 2924 /* 2925 2925 * Functions for operation on Digital Devices hardware ··· 3340 3340 kfree(state); 3341 3341 return NULL; 3342 3342 } 3343 - EXPORT_SYMBOL(stv0367ddb_attach); 3343 + EXPORT_SYMBOL_GPL(stv0367ddb_attach); 3344 3344 3345 3345 MODULE_PARM_DESC(debug, "Set debug"); 3346 3346 MODULE_PARM_DESC(i2c_debug, "Set i2c debug");
+1 -1
drivers/media/dvb-frontends/stv0900_core.c
··· 1957 1957 kfree(state); 1958 1958 return NULL; 1959 1959 } 1960 - EXPORT_SYMBOL(stv0900_attach); 1960 + EXPORT_SYMBOL_GPL(stv0900_attach); 1961 1961 1962 1962 MODULE_PARM_DESC(debug, "Set debug"); 1963 1963
+1 -1
drivers/media/dvb-frontends/stv090x.c
··· 5071 5071 kfree(state); 5072 5072 return NULL; 5073 5073 } 5074 - EXPORT_SYMBOL(stv090x_attach); 5074 + EXPORT_SYMBOL_GPL(stv090x_attach); 5075 5075 5076 5076 static const struct i2c_device_id stv090x_id_table[] = { 5077 5077 {"stv090x", 0},
+1 -1
drivers/media/dvb-frontends/stv6110.c
··· 427 427 428 428 return fe; 429 429 } 430 - EXPORT_SYMBOL(stv6110_attach); 430 + EXPORT_SYMBOL_GPL(stv6110_attach); 431 431 432 432 module_param(debug, int, 0644); 433 433 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
+1 -1
drivers/media/dvb-frontends/stv6110x.c
··· 467 467 dev_info(&stv6110x->i2c->dev, "Attaching STV6110x\n"); 468 468 return stv6110x->devctl; 469 469 } 470 - EXPORT_SYMBOL(stv6110x_attach); 470 + EXPORT_SYMBOL_GPL(stv6110x_attach); 471 471 472 472 static const struct i2c_device_id stv6110x_id_table[] = { 473 473 {"stv6110x", 0},
+1 -1
drivers/media/dvb-frontends/tda10021.c
··· 523 523 MODULE_AUTHOR("Ralph Metzler, Holger Waechtler, Markus Schulz"); 524 524 MODULE_LICENSE("GPL"); 525 525 526 - EXPORT_SYMBOL(tda10021_attach); 526 + EXPORT_SYMBOL_GPL(tda10021_attach);
+1 -1
drivers/media/dvb-frontends/tda10023.c
··· 594 594 MODULE_AUTHOR("Georg Acher, Hartmut Birr"); 595 595 MODULE_LICENSE("GPL"); 596 596 597 - EXPORT_SYMBOL(tda10023_attach); 597 + EXPORT_SYMBOL_GPL(tda10023_attach);
+1 -1
drivers/media/dvb-frontends/tda10048.c
··· 1138 1138 kfree(state); 1139 1139 return NULL; 1140 1140 } 1141 - EXPORT_SYMBOL(tda10048_attach); 1141 + EXPORT_SYMBOL_GPL(tda10048_attach); 1142 1142 1143 1143 static const struct dvb_frontend_ops tda10048_ops = { 1144 1144 .delsys = { SYS_DVBT },
+2 -2
drivers/media/dvb-frontends/tda1004x.c
··· 1378 1378 MODULE_AUTHOR("Andrew de Quincey & Robert Schlabbach"); 1379 1379 MODULE_LICENSE("GPL"); 1380 1380 1381 - EXPORT_SYMBOL(tda10045_attach); 1382 - EXPORT_SYMBOL(tda10046_attach); 1381 + EXPORT_SYMBOL_GPL(tda10045_attach); 1382 + EXPORT_SYMBOL_GPL(tda10046_attach);
+1 -1
drivers/media/dvb-frontends/tda10086.c
··· 764 764 MODULE_AUTHOR("Andrew de Quincey"); 765 765 MODULE_LICENSE("GPL"); 766 766 767 - EXPORT_SYMBOL(tda10086_attach); 767 + EXPORT_SYMBOL_GPL(tda10086_attach);
+1 -1
drivers/media/dvb-frontends/tda665x.c
··· 227 227 228 228 return fe; 229 229 } 230 - EXPORT_SYMBOL(tda665x_attach); 230 + EXPORT_SYMBOL_GPL(tda665x_attach); 231 231 232 232 MODULE_DESCRIPTION("TDA665x driver"); 233 233 MODULE_AUTHOR("Manu Abraham");
+1 -1
drivers/media/dvb-frontends/tda8083.c
··· 481 481 MODULE_AUTHOR("Ralph Metzler, Holger Waechtler"); 482 482 MODULE_LICENSE("GPL"); 483 483 484 - EXPORT_SYMBOL(tda8083_attach); 484 + EXPORT_SYMBOL_GPL(tda8083_attach);
+1 -1
drivers/media/dvb-frontends/tda8261.c
··· 188 188 return NULL; 189 189 } 190 190 191 - EXPORT_SYMBOL(tda8261_attach); 191 + EXPORT_SYMBOL_GPL(tda8261_attach); 192 192 193 193 MODULE_AUTHOR("Manu Abraham"); 194 194 MODULE_DESCRIPTION("TDA8261 8PSK/QPSK Tuner");
+1 -1
drivers/media/dvb-frontends/tda826x.c
··· 164 164 165 165 return fe; 166 166 } 167 - EXPORT_SYMBOL(tda826x_attach); 167 + EXPORT_SYMBOL_GPL(tda826x_attach); 168 168 169 169 module_param(debug, int, 0644); 170 170 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
+1 -1
drivers/media/dvb-frontends/ts2020.c
··· 525 525 526 526 return fe; 527 527 } 528 - EXPORT_SYMBOL(ts2020_attach); 528 + EXPORT_SYMBOL_GPL(ts2020_attach); 529 529 530 530 /* 531 531 * We implement own regmap locking due to legacy DVB attach which uses frontend
+1 -1
drivers/media/dvb-frontends/tua6100.c
··· 186 186 fe->tuner_priv = priv; 187 187 return fe; 188 188 } 189 - EXPORT_SYMBOL(tua6100_attach); 189 + EXPORT_SYMBOL_GPL(tua6100_attach); 190 190 191 191 MODULE_DESCRIPTION("DVB tua6100 driver"); 192 192 MODULE_AUTHOR("Andrew de Quincey");
+1 -1
drivers/media/dvb-frontends/ves1820.c
··· 434 434 MODULE_AUTHOR("Ralph Metzler, Holger Waechtler"); 435 435 MODULE_LICENSE("GPL"); 436 436 437 - EXPORT_SYMBOL(ves1820_attach); 437 + EXPORT_SYMBOL_GPL(ves1820_attach);
+1 -1
drivers/media/dvb-frontends/ves1x93.c
··· 540 540 MODULE_AUTHOR("Ralph Metzler"); 541 541 MODULE_LICENSE("GPL"); 542 542 543 - EXPORT_SYMBOL(ves1x93_attach); 543 + EXPORT_SYMBOL_GPL(ves1x93_attach);
+1 -1
drivers/media/dvb-frontends/zl10036.c
··· 496 496 kfree(state); 497 497 return NULL; 498 498 } 499 - EXPORT_SYMBOL(zl10036_attach); 499 + EXPORT_SYMBOL_GPL(zl10036_attach); 500 500 501 501 module_param_named(debug, zl10036_debug, int, 0644); 502 502 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
+1 -1
drivers/media/dvb-frontends/zl10039.c
··· 295 295 kfree(state); 296 296 return NULL; 297 297 } 298 - EXPORT_SYMBOL(zl10039_attach); 298 + EXPORT_SYMBOL_GPL(zl10039_attach); 299 299 300 300 module_param(debug, int, 0644); 301 301 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
+1 -1
drivers/media/dvb-frontends/zl10353.c
··· 665 665 MODULE_AUTHOR("Chris Pascoe"); 666 666 MODULE_LICENSE("GPL"); 667 667 668 - EXPORT_SYMBOL(zl10353_attach); 668 + EXPORT_SYMBOL_GPL(zl10353_attach);
+1 -1
drivers/media/pci/bt8xx/dst.c
··· 1722 1722 return state; /* Manu (DST is a card not a frontend) */ 1723 1723 } 1724 1724 1725 - EXPORT_SYMBOL(dst_attach); 1725 + EXPORT_SYMBOL_GPL(dst_attach); 1726 1726 1727 1727 static const struct dvb_frontend_ops dst_dvbt_ops = { 1728 1728 .delsys = { SYS_DVBT },
+1 -1
drivers/media/pci/bt8xx/dst_ca.c
··· 668 668 return NULL; 669 669 } 670 670 671 - EXPORT_SYMBOL(dst_ca_attach); 671 + EXPORT_SYMBOL_GPL(dst_ca_attach); 672 672 673 673 MODULE_DESCRIPTION("DST DVB-S/T/C Combo CA driver"); 674 674 MODULE_AUTHOR("Manu Abraham");
+1 -1
drivers/media/pci/ddbridge/ddbridge-dummy-fe.c
··· 112 112 state->frontend.demodulator_priv = state; 113 113 return &state->frontend; 114 114 } 115 - EXPORT_SYMBOL(ddbridge_dummy_fe_qam_attach); 115 + EXPORT_SYMBOL_GPL(ddbridge_dummy_fe_qam_attach); 116 116 117 117 static const struct dvb_frontend_ops ddbridge_dummy_fe_qam_ops = { 118 118 .delsys = { SYS_DVBC_ANNEX_A },
+1 -1
drivers/media/tuners/fc0011.c
··· 499 499 500 500 return fe; 501 501 } 502 - EXPORT_SYMBOL(fc0011_attach); 502 + EXPORT_SYMBOL_GPL(fc0011_attach); 503 503 504 504 MODULE_DESCRIPTION("Fitipower FC0011 silicon tuner driver"); 505 505 MODULE_AUTHOR("Michael Buesch <m@bues.ch>");
+1 -1
drivers/media/tuners/fc0012.c
··· 495 495 496 496 return fe; 497 497 } 498 - EXPORT_SYMBOL(fc0012_attach); 498 + EXPORT_SYMBOL_GPL(fc0012_attach); 499 499 500 500 MODULE_DESCRIPTION("Fitipower FC0012 silicon tuner driver"); 501 501 MODULE_AUTHOR("Hans-Frieder Vogt <hfvogt@gmx.net>");
+1 -1
drivers/media/tuners/fc0013.c
··· 608 608 609 609 return fe; 610 610 } 611 - EXPORT_SYMBOL(fc0013_attach); 611 + EXPORT_SYMBOL_GPL(fc0013_attach); 612 612 613 613 MODULE_DESCRIPTION("Fitipower FC0013 silicon tuner driver"); 614 614 MODULE_AUTHOR("Hans-Frieder Vogt <hfvogt@gmx.net>");
+1 -1
drivers/media/tuners/max2165.c
··· 410 410 411 411 return fe; 412 412 } 413 - EXPORT_SYMBOL(max2165_attach); 413 + EXPORT_SYMBOL_GPL(max2165_attach); 414 414 415 415 MODULE_AUTHOR("David T. L. Wong <davidtlwong@gmail.com>"); 416 416 MODULE_DESCRIPTION("Maxim MAX2165 silicon tuner driver");
+1 -1
drivers/media/tuners/mc44s803.c
··· 356 356 kfree(priv); 357 357 return NULL; 358 358 } 359 - EXPORT_SYMBOL(mc44s803_attach); 359 + EXPORT_SYMBOL_GPL(mc44s803_attach); 360 360 361 361 MODULE_AUTHOR("Jochen Friedrich"); 362 362 MODULE_DESCRIPTION("Freescale MC44S803 silicon tuner driver");
+1 -1
drivers/media/tuners/mt2060.c
··· 440 440 441 441 return fe; 442 442 } 443 - EXPORT_SYMBOL(mt2060_attach); 443 + EXPORT_SYMBOL_GPL(mt2060_attach); 444 444 445 445 static int mt2060_probe(struct i2c_client *client) 446 446 {
+1 -1
drivers/media/tuners/mt2131.c
··· 274 274 fe->tuner_priv = priv; 275 275 return fe; 276 276 } 277 - EXPORT_SYMBOL(mt2131_attach); 277 + EXPORT_SYMBOL_GPL(mt2131_attach); 278 278 279 279 MODULE_AUTHOR("Steven Toth"); 280 280 MODULE_DESCRIPTION("Microtune MT2131 silicon tuner driver");
+1 -1
drivers/media/tuners/mt2266.c
··· 336 336 mt2266_calibrate(priv); 337 337 return fe; 338 338 } 339 - EXPORT_SYMBOL(mt2266_attach); 339 + EXPORT_SYMBOL_GPL(mt2266_attach); 340 340 341 341 MODULE_AUTHOR("Olivier DANET"); 342 342 MODULE_DESCRIPTION("Microtune MT2266 silicon tuner driver");
+1 -1
drivers/media/tuners/mxl5005s.c
··· 4120 4120 fe->tuner_priv = state; 4121 4121 return fe; 4122 4122 } 4123 - EXPORT_SYMBOL(mxl5005s_attach); 4123 + EXPORT_SYMBOL_GPL(mxl5005s_attach); 4124 4124 4125 4125 MODULE_DESCRIPTION("MaxLinear MXL5005S silicon tuner driver"); 4126 4126 MODULE_AUTHOR("Steven Toth");
+1 -1
drivers/media/tuners/qt1010.c
··· 441 441 fe->tuner_priv = priv; 442 442 return fe; 443 443 } 444 - EXPORT_SYMBOL(qt1010_attach); 444 + EXPORT_SYMBOL_GPL(qt1010_attach); 445 445 446 446 MODULE_DESCRIPTION("Quantek QT1010 silicon tuner driver"); 447 447 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
+1 -1
drivers/media/tuners/tda18218.c
··· 336 336 337 337 return fe; 338 338 } 339 - EXPORT_SYMBOL(tda18218_attach); 339 + EXPORT_SYMBOL_GPL(tda18218_attach); 340 340 341 341 MODULE_DESCRIPTION("NXP TDA18218HN silicon tuner driver"); 342 342 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
+1 -1
drivers/media/tuners/xc2028.c
··· 1512 1512 return NULL; 1513 1513 } 1514 1514 1515 - EXPORT_SYMBOL(xc2028_attach); 1515 + EXPORT_SYMBOL_GPL(xc2028_attach); 1516 1516 1517 1517 MODULE_DESCRIPTION("Xceive xc2028/xc3028 tuner driver"); 1518 1518 MODULE_AUTHOR("Michel Ludwig <michel.ludwig@gmail.com>");
+1 -1
drivers/media/tuners/xc4000.c
··· 1742 1742 xc4000_release(fe); 1743 1743 return NULL; 1744 1744 } 1745 - EXPORT_SYMBOL(xc4000_attach); 1745 + EXPORT_SYMBOL_GPL(xc4000_attach); 1746 1746 1747 1747 MODULE_AUTHOR("Steven Toth, Davide Ferri"); 1748 1748 MODULE_DESCRIPTION("Xceive xc4000 silicon tuner driver");
+1 -1
drivers/media/tuners/xc5000.c
··· 1460 1460 xc5000_release(fe); 1461 1461 return NULL; 1462 1462 } 1463 - EXPORT_SYMBOL(xc5000_attach); 1463 + EXPORT_SYMBOL_GPL(xc5000_attach); 1464 1464 1465 1465 MODULE_AUTHOR("Steven Toth"); 1466 1466 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
+1 -1
drivers/staging/media/av7110/sp8870.c
··· 606 606 MODULE_AUTHOR("Juergen Peitz"); 607 607 MODULE_LICENSE("GPL"); 608 608 609 - EXPORT_SYMBOL(sp8870_attach); 609 + EXPORT_SYMBOL_GPL(sp8870_attach);