Problems loading firmware using built-in drivers with kernels that use initramfs.
A message that is not in the archive (sent off-list or not yet received): 1440449403.2469.35.camel@loki
A message that is not in the archive (sent off-list or not yet received): 1440489900.2419.4.camel@loki
A message that is not in the archive (sent off-list or not yet received): [email protected]
Quoted 2 lines · David Woodhouse
Luis, did you tell me the other day that you made the kernel get firmware directly from the file system? This regression would be yours then?
I didn't implement that, Linus did in 2012 (see commit abb139e75c2c titled "firmware: teach the kernel to load firmware files directly from the filesystem"). But we used to fallback to a userspace helper when the fw was not present and then Takashi made this optional via commit 7b1269f778782d titled "firmware: Make user-mode helper optional". Takashi noted in the Kconfig "The user-mode helper is no longer required unless you have a special firmware file that resides in a non-standard path". It was not clarified why that's true though, or what you'd need to do to ensure that the fw would be available. It would be good for us to elaborate on that.
Quoted 1 line
I can also take a look next week when I'm home from vacation.
No worries, I'll look at it.
Quoted 13 lines
From:Liam Girdwood <[email protected]>
Sent:Tue, 25 Aug 2015 09:05:00 +0100
To:"Jie, Yang" <[email protected]>,[email protected],"joonas.lahtinen " <[email protected]>
Subject:Re: Problems loading firmware using built-in drivers with kernels that use initramfs.Quoted 8 lines · Liam Girdwood
Quoted 7 lines
Currently firmware loading with built-in drivers is failing on systems that mount an initramfs before the root FS is mounted (that contains the firmware file). Modular drivers work fine.
Keyon (Jie, Yang) has done some testing with the Intel audio DSP driver and found that the built-in firmware loading only works if the firmware is included as part of the initramfs.
Note that works.
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
The same has been seen with other
Intel drivers that use firmware.In this case it looks like userspace (udevd ?) is checking initramfs for pending firmware requests and returning not found if it cant find the files, but it's not re-checking for any pending firmware requests once the real FS is mounted. Is it possible to have udevd re-check the pending firmware requests after the real FS is mounted ?
We are phasing out CONFIG_FW_LOADER_USER_HELPER support in the kernel, support for udev helper firmware loading was removed from systemd, the only requirement for it now is the dell rbu driver.
Without CONFIG_FW_LOADER_USER_HELPER it its up to userspace or system integrators to do the right thing and you have a few options if you are enabling drivers as built-in:
* stuff firmware in initramfs
* built firmware into the kernel
We don't do anything special for pivot_root for built-in, I am not sure if we should, I don't think we should... can you not do any of the above two options?
Since folks can stuff firmware into initramfs and that's outside the scope of how we build the kernel we can't always ensure folks will do one of the above two options at build time for built-in drivers. If we don't want to do something for pivot_root the only thing I think we can do is document the expecations clearly, unless there are other ideas of course.
Luis
Quoted 5 lines · Luis R. Rodriguez
Quoted 2 lines · David Woodhouse
Luis, did you tell me the other day that you made the kernel get firmware directly from the file system? This regression would be yours then?
Quoted 10 lines
I didn't implement that, Linus did in 2012 (see commit
abb139e75c2ctitled "firmware: teach the kernel to load firmware files directly from the filesystem"). But we used to fallback to a userspace helper when the fw was not present and then Takashi made this optional via commit7b1269f778782dtitled "firmware: Make user-mode helper optional". Takashi noted in theKconfig"The user-mode helper is no longer required unless you have a special firmware file that resides in a non-standard path". It was not clarified why that's true though, or what you'd need to do to ensure that the fw would be available. It would be good for us to elaborate on that.
The recent udev already dropped the firmware loading feature.
Takashi
Quoted 18 lines · Takashi Iwai
Quoted 5 lines · Luis R. Rodriguez
Quoted 2 lines · David Woodhouse
Luis, did you tell me the other day that you made the kernel get firmware directly from the file system? This regression would be yours then?
Quoted 10 lines
I didn't implement that, Linus did in 2012 (see commit
abb139e75c2ctitled "firmware: teach the kernel to load firmware files directly from the filesystem"). But we used to fallback to a userspace helper when the fw was not present and then Takashi made this optional via commit7b1269f778782dtitled "firmware: Make user-mode helper optional". Takashi noted in theKconfig"The user-mode helper is no longer required unless you have a special firmware file that resides in a non-standard path". It was not clarified why that's true though, or what you'd need to do to ensure that the fw would be available. It would be good for us to elaborate on that.
Quoted 1 line
The recent udev already dropped the firmware loading feature.
Note that even when we had udev helper to load the firmware it was not always reliable depending on the exact point where we requested firmware. If request happened in probe() path before we mounted root fs then we'd never get it loaded because we'd be waiting for devices settle before mounting rootfs.
Either build firmware in the kernel or ramdisk (so it is always available), or make sure request_firmware() calls are not in driver's probe() paths.
Thanks.
Signature · 1 line
Dmitry
Quoted 4 lines · Dmitry Torokhov
Either build firmware in the kernel or ramdisk (so it is always available), or make sure
request_firmware()calls are not in driver'sprobe()paths.
The correct answer is almost always that second one.
Drivers that load firmware in their probe parts are generally doign things wrong.
It's very occasionally the right thing to do - there are a few pieces of hardware where just about _everything_ about the device is in the firmware, and you simply can't even problem them before that, because you don't know what they *are* before the firmware has been loaded. The extreme case of that might be something like the base hardware being an FPGA that has a USB interface, but before the FPGA has been loaded, it basically has no identity. So there are probably valid cases in theory for loading firmware at probe time, but pretty much every single case I've ever actually seen, the probe knows what the actual hardware is from some identifiable piece, and the actual firmware loading should be delayed until the piece of hardware is actually opened.
So the "load firmware in probe routine" happens, and we shouldn't disallow it, but it should be considered a "last resort" kind of thing.
In general, things like sound drivers should *not* need to have their firmware in the initrd, even if you build them into the kernel. A disk driver? Yes. Maybe the root filesystem is on that disk, and you need the firmware for the disk driver to load it. But a sound device? Please just make sure that you load the firmware as late as possible.
Linus
Quoted 32 lines · Linus Torvalds
Quoted 4 lines · Dmitry Torokhov
Either build firmware in the kernel or ramdisk (so it is always available), or make sure
request_firmware()calls are not in driver'sprobe()paths.The correct answer is almost always that second one.
Drivers that load firmware in their probe parts are generally doign things wrong.
It's very occasionally the right thing to do - there are a few pieces of hardware where just about _everything_ about the device is in the firmware, and you simply can't even problem them before that, because you don't know what they *are* before the firmware has been loaded. The extreme case of that might be something like the base hardware being an FPGA that has a USB interface, but before the FPGA has been loaded, it basically has no identity. So there are probably valid cases in theory for loading firmware at probe time, but pretty much every single case I've ever actually seen, the probe knows what the actual hardware is from some identifiable piece, and the actual firmware loading should be delayed until the piece of hardware is actually opened.
So the "load firmware in probe routine" happens, and we shouldn't disallow it, but it should be considered a "last resort" kind of thing.
Quoted 6 lines
In general, things like sound drivers should *not* need to have their firmware in the initrd, even if you build them into the kernel. A disk driver? Yes. Maybe the root filesystem is on that disk, and you need the firmware for the disk driver to load it. But a sound device? Please just make sure that you load the firmware as late as possible.
i remember lots of drivers load their firmware when some user space process open the device node, that is to say, they load the firmware in ->open() function, at this time , you can make sure the real filesystem is ready in most time.
i think your dsp firmware can also do like this.
you can refer to msm gnu driver:
static void load_gpu(struct drm_device *dev)
{
static DEFINE_MUTEX(init_lock);
struct msm_drm_private *priv = dev->dev_private;
mutex_lock(&init_lock);
if (!priv->gpu)
priv->gpu = adreno_load_gpu(dev);
mutex_unlock(&init_lock);
}static int msm_open(struct drm_device *dev, struct drm_file *file)
{
struct msm_file_private *ctx;
/* For now, load gpu on open.. to avoid the requirement of having
* firmware in the initrd.
*/
load_gpu(dev);
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
if (!ctx)
return -ENOMEM;
file->driver_priv = ctx;
return 0;
}it load the firmware in open() function.
Thanks
Quoted 32 lines
-----Original Message-----
From: Dmitry Torokhov [mailto:[email protected]]
Sent: Wednesday, August 26, 2015 3:58 AM
To: Takashi Iwai
Cc: Luis R. Rodriguez; Girdwood, Liam R; Jie, Yang; [email protected]; Tom Gundersen; Ming Lei; Al Viro; Greg Kroah-Hartman; Kay Sievers; Linus Torvalds; David Woodhouse; Luis Rodriguez; lkml
Subject: Re: Problems loading firmware using built-in drivers with kernels that use initramfs.Quoted 6 lines · Takashi Iwai
Quoted 4 lines · Luis R. Rodriguez
Quoted 2 lines · David Woodhouse
Luis, did you tell me the other day that you made the kernel get firmware directly from the file system? This regression would be yours
then?
Quoted 13 lines
Quoted 12 lines
I didn't implement that, Linus did in 2012 (see commit
abb139e75c2ctitled
"firmware: teach the kernel to load firmware files directly from the filesystem"). But we used to fallback to a userspace helper when the fw was not present and then Takashi made this optional via commit7b1269f778782dtitled "firmware: Make user-mode helper optional". Takashi noted in theKconfig"The user-mode helper is no longer required unless you have a special firmware file that resides in a non-standard path". It was not clarified why that's true though, or what you'd need to do to ensure that the fw would be available. It would be good for us to elaborate on that.
Quoted 7 lines
Quoted 1 line
The recent udev already dropped the firmware loading feature.
Note that even when we had udev helper to load the firmware it was not always reliable depending on the exact point where we requested firmware. If request happened in
probe()path before we mounted root fs then we'd never get it loaded because we'd be waiting for devices settle before mounting rootfs.
For request in probe(), is it possible to use request_firmware_nowait() to wait rootfs mounted or timeout in another thread?
It looks usermodehelper_disabled is 0(at probe()) at this case then no waiting occurs here in our testing.
Thanks,
~Keyon
Quoted 9 lines
Either build firmware in the kernel or ramdisk (so it is always available), or make sure
request_firmware()calls are not in driver'sprobe()paths.Thanks.
--
Dmitry
���{.n�+�������+%�����ݶ��w��{.n�+����{��G�����{ay�ʇڙ�,j��f���h��������z_�(�階�ݢj"���m������G������?����&���~��iO��z��v�^�m����������?�I�
Quoted 41 lines · Yang
Quoted 33 lines
-----Original Message-----
From: Dmitry Torokhov [mailto:[email protected]]
Sent: Wednesday, August 26, 2015 3:58 AM
To: Takashi Iwai
Cc: Luis R. Rodriguez; Girdwood, Liam R; Jie, Yang; [email protected]; Tom Gundersen; Ming Lei; Al Viro; Greg Kroah-Hartman; Kay Sievers; Linus Torvalds; David Woodhouse; Luis Rodriguez; lkml
Subject: Re: Problems loading firmware using built-in drivers with kernels that use initramfs.Quoted 6 lines · Takashi Iwai
Quoted 4 lines · Luis R. Rodriguez
Quoted 2 lines · David Woodhouse
Luis, did you tell me the other day that you made the kernel get firmware directly from the file system? This regression would be yours
then?
Quoted 13 lines
Quoted 12 lines
I didn't implement that, Linus did in 2012 (see commit
abb139e75c2ctitled
"firmware: teach the kernel to load firmware files directly from the filesystem"). But we used to fallback to a userspace helper when the fw was not present and then Takashi made this optional via commit7b1269f778782dtitled "firmware: Make user-mode helper optional". Takashi noted in theKconfig"The user-mode helper is no longer required unless you have a special firmware file that resides in a non-standard path". It was not clarified why that's true though, or what you'd need to do to ensure that the fw would be available. It would be good for us to elaborate on that.Quoted 7 lines
Quoted 1 line
The recent udev already dropped the firmware loading feature.
Note that even when we had udev helper to load the firmware it was not always reliable depending on the exact point where we requested firmware. If request happened in
probe()path before we mounted root fs then we'd never get it loaded because we'd be waiting for devices settle before mounting rootfs.
Quoted 5 lines
For request in
probe(), is it possible to userequest_firmware_nowait()to wait rootfs mounted or timeout in another thread?It looks
usermodehelper_disabledis 0(atprobe()) at this case then no waiting occurs here in our testing.
It's possible -- and even with the normal request_firmware(), in theory. The missing piece is that you need to inform the helper to retry the f/w loading. Currently the direct f/w loader assumes that the file is there and returns error if not present.
If we implement a retry, another question is how to trigger it, i.e. how the helper can know when a fs is mounted a new file is present.
Takashi
Quoted 63 lines
-----Original Message-----
From: Takashi Iwai [mailto:[email protected]]
Sent: Wednesday, August 26, 2015 1:33 PM
To: Jie, Yang
Cc: Dmitry Torokhov; Luis R. Rodriguez; Girdwood, Liam R; [email protected]; Tom Gundersen; Ming Lei; Al Viro; Greg Kroah-Hartman; Kay Sievers; Linus Torvalds; David Woodhouse; Luis Rodriguez; lkml
Subject: Re: Problems loading firmware using built-in drivers with kernels that use initramfs.Quoted 19 lines · Yang
Quoted 19 lines
-----Original Message-----
From: Dmitry Torokhov [mailto:[email protected]]
Sent: Wednesday, August 26, 2015 3:58 AM
To: Takashi Iwai
Cc: Luis R. Rodriguez; Girdwood, Liam R; Jie, Yang; [email protected]; Tom Gundersen; Ming Lei; Al Viro; Greg Kroah-Hartman; Kay Sievers; Linus Torvalds; David Woodhouse; Luis Rodriguez; lkml
Subject: Re: Problems loading firmware using built-in drivers with kernels that use initramfs.Quoted 6 lines · Takashi Iwai
Quoted 5 lines · Luis R. Rodriguez
Quoted 3 lines · David Woodhouse
Luis, did you tell me the other day that you made the kernel get firmware directly from the file system? This regression would be yours
Quoted 8 lines
Quoted 8 lines
then?
Quoted 7 lines
Quoted 7 lines
I didn't implement that, Linus did in 2012 (see commit
abb139e75c2ctitled
"firmware: teach the kernel to load firmware files directly from the filesystem"). But we used to fallback to a userspace helper when the fw was not present and then Takashi made this optional via commit7b1269f778782dtitled "firmware: Make user-mode helperoptional".
Quoted 10 lines
Quoted 10 lines
Quoted 7 lines
Quoted 5 lines
Takashi noted in the
Kconfig"The user-mode helper is no longer required unless you have a special firmware file that resides in a non-standard path". It was not clarified why that's true though, or what you'd need to do to ensure that the fw would be available. It would be good for us to elaborate on that.The recent udev already dropped the firmware loading feature.
Note that even when we had udev helper to load the firmware it was not always reliable depending on the exact point where we requested
firmware.
Quoted 6 lines
Quoted 3 lines
If request happened in
probe()path before we mounted root fs then we'd never get it loaded because we'd be waiting for devices settle before mounting rootfs.For request in
probe(), is it possible to userequest_firmware_nowait()to wait rootfs mounted or timeout in anotherthread?
Quoted 3 lines
It looks
usermodehelper_disabledis 0(atprobe()) at this case then no waiting occurs here in our testing.
Quoted 7 lines
It's possible -- and even with the normal
request_firmware(), in theory. The missing piece is that you need to inform the helper to retry the f/w loading. Currently the direct f/w loader assumes that the file is there and returns error if not present.If we implement a retry, another question is how to trigger it, i.e. how the helper can know when a fs is mounted a new file is present.
Got it, thanks Takashi and all.
So looks we should(and already done for most audio firmware) implement it as Dmitry and Linus proposed, that is to make sure request_firmware() calls are not in driver's probe() paths.
Yalin help posted sample code for this implementation(to request firmware in device node open) and actually I also did similar for Broadwell ADSP driver and will send out later, thank you all.
Thanks,
~Keyon
Quoted 3 lines
Takashi
Quoted 73 lines · Yang
Quoted 63 lines
-----Original Message-----
From: Takashi Iwai [mailto:[email protected]]
Sent: Wednesday, August 26, 2015 1:33 PM
To: Jie, Yang
Cc: Dmitry Torokhov; Luis R. Rodriguez; Girdwood, Liam R; [email protected]; Tom Gundersen; Ming Lei; Al Viro; Greg Kroah-Hartman; Kay Sievers; Linus Torvalds; David Woodhouse; Luis Rodriguez; lkml
Subject: Re: Problems loading firmware using built-in drivers with kernels that use initramfs.Quoted 19 lines · Yang
Quoted 19 lines
-----Original Message-----
From: Dmitry Torokhov [mailto:[email protected]]
Sent: Wednesday, August 26, 2015 3:58 AM
To: Takashi Iwai
Cc: Luis R. Rodriguez; Girdwood, Liam R; Jie, Yang; [email protected]; Tom Gundersen; Ming Lei; Al Viro; Greg Kroah-Hartman; Kay Sievers; Linus Torvalds; David Woodhouse; Luis Rodriguez; lkml
Subject: Re: Problems loading firmware using built-in drivers with kernels that use initramfs.Quoted 6 lines · Takashi Iwai
Quoted 5 lines · Luis R. Rodriguez
Quoted 3 lines · David Woodhouse
Luis, did you tell me the other day that you made the kernel get firmware directly from the file system? This regression would be yours
Quoted 8 lines
Quoted 8 lines
then?
Quoted 7 lines
Quoted 7 lines
I didn't implement that, Linus did in 2012 (see commit
abb139e75c2ctitled
"firmware: teach the kernel to load firmware files directly from the filesystem"). But we used to fallback to a userspace helper when the fw was not present and then Takashi made this optional via commit7b1269f778782dtitled "firmware: Make user-mode helperoptional".
Quoted 10 lines
Quoted 10 lines
Quoted 7 lines
Quoted 5 lines
Takashi noted in the
Kconfig"The user-mode helper is no longer required unless you have a special firmware file that resides in a non-standard path". It was not clarified why that's true though, or what you'd need to do to ensure that the fw would be available. It would be good for us to elaborate on that.The recent udev already dropped the firmware loading feature.
Note that even when we had udev helper to load the firmware it was not always reliable depending on the exact point where we requested
firmware.
Quoted 6 lines
Quoted 3 lines
If request happened in
probe()path before we mounted root fs then we'd never get it loaded because we'd be waiting for devices settle before mounting rootfs.For request in
probe(), is it possible to userequest_firmware_nowait()to wait rootfs mounted or timeout in anotherthread?
Quoted 3 lines
It looks
usermodehelper_disabledis 0(atprobe()) at this case then no waiting occurs here in our testing.Quoted 7 lines
It's possible -- and even with the normal
request_firmware(), in theory. The missing piece is that you need to inform the helper to retry the f/w loading. Currently the direct f/w loader assumes that the file is there and returns error if not present.If we implement a retry, another question is how to trigger it, i.e. how the helper can know when a fs is mounted a new file is present.
Got it, thanks Takashi and all.
Quoted 7 lines
So looks we should(and already done for most audio firmware) implement it as Dmitry and Linus proposed, that is to make sure
request_firmware()calls are not in driver'sprobe()paths.Yalin help posted sample code for this implementation(to request firmware in device node open) and actually I also did similar for Broadwell ADSP driver and will send out later, thank you all.
Keyon, we have a similar situation to that of the FPGA example that Linus described when the DSP driver uses topology data. i.e. the audio driver will have no PCM devices that can be opened (to initiate the FW loading) until after the FW is loaded. The topology data is part of the FW and contains the PCMs, kcontrols, graphs etc. i.e. a PCM device is created for every PCM description found in the FW topology data.
I think the options are to either :-
1) Don not support audio DSP drivers using topology data as built-in drivers. Audio is not really a critical system required for booting anyway.
2) Create a default PCM for every driver that has topology data on the assumption that every sound card will at least 1 PCM. This PCM can then be re-configured when the FW is loaded.
Liam
Quoted 49 lines
-----Original Message-----
From: Liam Girdwood [mailto:[email protected]]
Sent: Wednesday, August 26, 2015 4:07 PM
To: Jie, Yang
Cc: Takashi Iwai; Dmitry Torokhov; Luis R. Rodriguez; [email protected]; Tom Gundersen; Ming Lei; Al Viro; Greg Kroah-Hartman; Kay Sievers; Linus Torvalds; David Woodhouse; Luis Rodriguez; lkml; yalin wang
Subject: Re: Problems loading firmware using built-in drivers with kernels that use initramfs.Quoted 11 lines · Yang
Quoted 11 lines
-----Original Message-----
From: Takashi Iwai [mailto:[email protected]]
Sent: Wednesday, August 26, 2015 1:33 PM
To: Jie, Yang
Cc: Dmitry Torokhov; Luis R. Rodriguez; Girdwood, Liam R; [email protected]; Tom Gundersen; Ming Lei; Al Viro; Greg Kroah-Hartman; Kay Sievers; Linus Torvalds; David Woodhouse; Luis Rodriguez; lkml
Subject: Re: Problems loading firmware using built-in drivers with kernels that use initramfs.Quoted 2 lines
Quoted 2 lines
It's possible -- and even with the normal
request_firmware(), in theory. The missing piece is that you need to inform the helper to retrythe f/w loading.
Quoted 8 lines
Quoted 5 lines
Currently the direct f/w loader assumes that the file is there and returns error if not present.
If we implement a retry, another question is how to trigger it, i.e. how the helper can know when a fs is mounted a new file is present.
Got it, thanks Takashi and all.
Quoted 7 lines
So looks we should(and already done for most audio firmware) implement it as Dmitry and Linus proposed, that is to make sure
request_firmware()calls are not in driver'sprobe()paths.Yalin help posted sample code for this implementation(to request firmware in device node open) and actually I also did similar for Broadwell ADSP driver and will send out later, thank you all.
Keyon, we have a similar situation to that of the FPGA example that Linus described when the DSP driver uses topology data. i.e. the audio driver will have no PCM devices that can be opened (to initiate the FW loading) until after the FW is loaded. The topology data is part of the FW and contains the PCMs, kcontrols, graphs etc. i.e. a PCM device is created for every PCM description found in the FW topology data.
Quoted 8 lines
I think the options are to either :-
1) Don not support audio DSP drivers using topology data as built-in drivers. Audio is not really a critical system required for booting anyway.
2) Create a default PCM for every driver that has topology data on the assumption that every sound card will at least 1 PCM. This PCM can then be re-configured when the FW is loaded.
Yep, this case is quite similar with what Linus described.
Is it possible that we can probe pcm device after firmware is loaded for this case?
What I am thinking about is postponing all firmware related(e.g. pcm probing, dma/dsp/ipc initialization, ...) code to that rootfs is ready and FW is loaded.
~Keyon
Quoted 3 lines
Liam
���{.n�+�������+%�����ݶ��w��{.n�+����{��G�����{ay�ʇڙ�,j��f���h��������z_�(�階�ݢj"���m������G������?����&���~��iO��z��v�^�m����������?�I�
Quoted 8 lines · Yang
Quoted 8 lines
-----Original Message-----
From: Liam Girdwood [mailto:[email protected]]I think the options are to either :-
1) Don not support audio DSP drivers using topology data as built-in drivers. Audio is not really a critical system required for booting anyway.
Quoted 9 lines
Quoted 3 lines
2) Create a default PCM for every driver that has topology data on the assumption that every sound card will at least 1 PCM. This PCM can then be re-configured when the FW is loaded.
Yep, this case is quite similar with what Linus described.
Is it possible that we can probe pcm device after firmware is loaded for this case?
The PCM devices are defined in the topology data so it is only possible to create the PCM device *after* the firmware is loaded in these drivers.
Liam
Quoted 27 lines
-----Original Message-----
From: Liam Girdwood [mailto:[email protected]]
Sent: Wednesday, August 26, 2015 5:01 PM
To: Jie, Yang
Cc: Takashi Iwai; Dmitry Torokhov; Luis R. Rodriguez; [email protected]; Tom Gundersen; Ming Lei; Al Viro; Greg Kroah-Hartman; Kay Sievers; Linus Torvalds; David Woodhouse; Luis Rodriguez; lkml; yalin wang; Lin, Mengdong
Subject: Re: Problems loading firmware using built-in drivers with kernels that use initramfs.Quoted 6 lines · Yang
Quoted 6 lines
-----Original Message-----
From: Liam Girdwood [mailto:[email protected]]I think the options are to either :-
1) Don not support audio DSP drivers using topology data as built-in
drivers.
Quoted 8 lines
Quoted 5 lines
Audio is not really a critical system required for booting anyway.
2) Create a default PCM for every driver that has topology data on the assumption that every sound card will at least 1 PCM. This PCM can then be re-configured when the FW is loaded.
Yep, this case is quite similar with what Linus described.
Quoted 8 lines
Quoted 3 lines
Is it possible that we can probe pcm device after firmware is loaded for this case?
The PCM devices are defined in the topology data so it is only possible to create the PCM device *after* the firmware is loaded in these drivers.
Liam
It seems this can prevent audio device driver in built-in mode to use topology drivers.
If topology is present, the vendor driver also uses request_firmware() to load the topology data file in the probe phase. Then ASoC core will create the sound card and its PCM devices.
Shall we force the device drivers that depends on topology to be configured as modules?
Thanks
Mengdong
���{.n�+�������+%�����ݶ��w��{.n�+����{��G�����{ay�ʇڙ�,j��f���h��������z_�(�階�ݢj"���m������G������?����&���~��iO��z��v�^�m����������?�I�
Quoted 34 lines · Mengdong
Quoted 34 lines
-----Original Message-----
From: Liam Girdwood [mailto:[email protected]]
Sent: Wednesday, August 26, 2015 5:01 PM
To: Jie, Yang
Cc: Takashi Iwai; Dmitry Torokhov; Luis R. Rodriguez; [email protected]; Tom Gundersen; Ming Lei; Al Viro; Greg Kroah-Hartman; Kay Sievers; Linus Torvalds; David Woodhouse; Luis Rodriguez; lkml; yalin wang; Lin, Mengdong
Subject: Re: Problems loading firmware using built-in drivers with kernels that use initramfs.Quoted 6 lines · Yang
Quoted 6 lines
-----Original Message-----
From: Liam Girdwood [mailto:[email protected]]I think the options are to either :-
1) Don not support audio DSP drivers using topology data as built-in
drivers.
Quoted 11 lines
Quoted 5 lines
Audio is not really a critical system required for booting anyway.
2) Create a default PCM for every driver that has topology data on the assumption that every sound card will at least 1 PCM. This PCM can then be re-configured when the FW is loaded.
Yep, this case is quite similar with what Linus described.
Is it possible that we can probe pcm device after firmware is loaded for this case?
The PCM devices are defined in the topology data so it is only possible to create the PCM device *after* the firmware is loaded in these drivers.
Quoted 7 lines
Quoted 1 line
Liam
It seems this can prevent audio device driver in built-in mode to use topology drivers.
If topology is present, the vendor driver also uses
request_firmware()to load the topology data file in the probe phase. Then ASoC core will create the sound card and its PCM devices.Shall we force the device drivers that depends on topology to be configured as modules?
Yes, this is probably the best/quickest solution for the short term until we can implement and test option 2.
Liam
Quoted 6 lines · Liam Girdwood
I think the options are to either :-
1) Don not support audio DSP drivers using topology data as built-in drivers. Audio is not really a critical system required for booting anyway.
Yes, forcing it to be a module and not letting people compile it in by mistake (and then not have it work) is an option.
That said, there are situations where people don't want to use modules. I used to eschew them for security reasons, for example - now I instead just do a one-time temporary key. But others may have other reasons to try to avoid modules.
Quoted 3 lines
2) Create a default PCM for every driver that has topology data on the assumption that every sound card will at least 1 PCM. This PCM can then be re-configured when the FW is loaded.
That would seem to be the better option if it is reasonably implementable.
Of course, some kind of timer-based retry (limited *somehow*) of the fw loading could work too, but smells really really hacky.
Linus
Quoted 17 lines · Linus Torvalds
Quoted 6 lines · Liam Girdwood
I think the options are to either :-
1) Don not support audio DSP drivers using topology data as built-in drivers. Audio is not really a critical system required for booting anyway.
Yes, forcing it to be a module and not letting people compile it in by mistake (and then not have it work) is an option.
That said, there are situations where people don't want to use modules. I used to eschew them for security reasons, for example - now I instead just do a one-time temporary key. But others may have other reasons to try to avoid modules.
Quoted 8 lines
Quoted 3 lines
2) Create a default PCM for every driver that has topology data on the assumption that every sound card will at least 1 PCM. This PCM can then be re-configured when the FW is loaded.
That would seem to be the better option if it is reasonably implementable.
Of course, some kind of timer-based retry (limited *somehow*) of the fw loading could work too, but smells really really hacky.
Yeah, years ago, we discussed to use -EPROBE_DEFER for the situation, which should be one kind of fix, but looks there were objections at that time.
thanks,
Quoted 23 lines · Ming Lei
Quoted 21 lines · Linus Torvalds
Quoted 6 lines · Liam Girdwood
I think the options are to either :-
1) Don not support audio DSP drivers using topology data as built-in drivers. Audio is not really a critical system required for booting anyway.
Yes, forcing it to be a module and not letting people compile it in by mistake (and then not have it work) is an option.
That said, there are situations where people don't want to use modules. I used to eschew them for security reasons, for example - now I instead just do a one-time temporary key. But others may have other reasons to try to avoid modules.
Quoted 3 lines
2) Create a default PCM for every driver that has topology data on the assumption that every sound card will at least 1 PCM. This PCM can then be re-configured when the FW is loaded.
Quoted 7 lines
Quoted 4 lines
That would seem to be the better option if it is reasonably implementable.
Of course, some kind of timer-based retry (limited *somehow*) of the fw loading could work too, but smells really really hacky.
Yeah, years ago, we discussed to use -EPROBE_DEFER for the situation, which should be one kind of fix, but looks there were objections at that time.
That would still be a hack. I'll note there is also asynchronous probe support now but to use that would also be a hack for this issue. We don't want to encourage folks to go down that road. They'd be hacks for this issue as you are simply delaying the driver probe for a later time and there is no guarantee that any pivot_root() might have already been completed later to ensure your driver's fw file is present. So it may work or it may not.
We should instead strive to be clear about expectations and requirements both through documentation and when possible through APIs. I'll send out an RFC which adds some grammar rules which can help us police this. I currently only spot two drivers that require fixing.
Luis
Quoted 26 lines · Luis R. Rodriguez
Quoted 25 lines · Ming Lei
Quoted 23 lines · Linus Torvalds
Quoted 6 lines · Liam Girdwood
I think the options are to either :-
1) Don not support audio DSP drivers using topology data as built-in drivers. Audio is not really a critical system required for booting anyway.
Yes, forcing it to be a module and not letting people compile it in by mistake (and then not have it work) is an option.
That said, there are situations where people don't want to use modules. I used to eschew them for security reasons, for example - now I instead just do a one-time temporary key. But others may have other reasons to try to avoid modules.
Quoted 3 lines
2) Create a default PCM for every driver that has topology data on the assumption that every sound card will at least 1 PCM. This PCM can then be re-configured when the FW is loaded.
That would seem to be the better option if it is reasonably implementable.
Quoted 8 lines
Quoted 5 lines
Quoted 2 lines
Of course, some kind of timer-based retry (limited *somehow*) of the fw loading could work too, but smells really really hacky.
Yeah, years ago, we discussed to use -EPROBE_DEFER for the situation, which should be one kind of fix, but looks there were objections at that time.
That would still be a hack. I'll note there is also asynchronous probe support now but to use that would also be a hack for this issue. We don't want to
If we think firmware as one kind of resources like regulators, gpio and others, PROBE_DEFER is one good match for firmware loading case, and
it has been used by lots of drivers, so why can't it be used for firmware loading?
One problem is that we need to convert drivers into returning -EPROBE_DEFER in case of request failure, and that may involve some work, but which should be mechanical.
Quoted 4 lines
encourage folks to go down that road. They'd be hacks for this issue as you are simply delaying the driver probe for a later time and there is no guarantee that any
pivot_root()might have already been completed later to ensure your driver's fw file is present. So it may work or it may not.
We can trigger defer probe explicitly once root fs is setup or other condition is met.
Quoted 7 lines
We should instead strive to be clear about expectations and requirements both through documentation and when possible through APIs. I'll send out an RFC which adds some grammar rules which can help us police this. I currently only spot two drivers that require fixing.
Luis
Quoted 37 lines · Ming Lei
Quoted 26 lines · Luis R. Rodriguez
Quoted 25 lines · Ming Lei
Quoted 23 lines · Linus Torvalds
Quoted 6 lines · Liam Girdwood
I think the options are to either :-
1) Don not support audio DSP drivers using topology data as built-in drivers. Audio is not really a critical system required for booting anyway.
Yes, forcing it to be a module and not letting people compile it in by mistake (and then not have it work) is an option.
That said, there are situations where people don't want to use modules. I used to eschew them for security reasons, for example - now I instead just do a one-time temporary key. But others may have other reasons to try to avoid modules.
Quoted 3 lines
2) Create a default PCM for every driver that has topology data on the assumption that every sound card will at least 1 PCM. This PCM can then be re-configured when the FW is loaded.
That would seem to be the better option if it is reasonably implementable.
Quoted 8 lines
Quoted 5 lines
Quoted 2 lines
Of course, some kind of timer-based retry (limited *somehow*) of the fw loading could work too, but smells really really hacky.
Yeah, years ago, we discussed to use -EPROBE_DEFER for the situation, which should be one kind of fix, but looks there were objections at that time.
That would still be a hack. I'll note there is also asynchronous probe support now but to use that would also be a hack for this issue. We don't want to
Quoted 8 lines
If we think firmware as one kind of resources like regulators, gpio and others,
PROBE_DEFERis one good match for firmware loading case, and
it has been used by lots of drivers, so why can't it be used for firmware loading?One problem is that we need to convert drivers into returning -EPROBE_DEFER in case of request failure, and that may involve some work, but which should be mechanical.
I find such a delaying mechanism not so bad, too. It's very straightforward, at least, no big pain in the transition in the driver side.
Quoted 7 lines
Quoted 4 lines
encourage folks to go down that road. They'd be hacks for this issue as you are simply delaying the driver probe for a later time and there is no guarantee that any
pivot_root()might have already been completed later to ensure your driver's fw file is present. So it may work or it may not.We can trigger defer probe explicitly once root fs is setup or other condition is met.
Right, how to trigger the reprobe (and relevant optimization) needs to be considered on top of the current mechanism.
Takashi
Quoted 44 lines · Takashi Iwai
Quoted 42 lines · Ming Lei
Quoted 26 lines · Luis R. Rodriguez
Quoted 25 lines · Ming Lei
Quoted 23 lines · Linus Torvalds
Quoted 6 lines · Liam Girdwood
I think the options are to either :-
1) Don not support audio DSP drivers using topology data as built-in drivers. Audio is not really a critical system required for booting anyway.
Yes, forcing it to be a module and not letting people compile it in by mistake (and then not have it work) is an option.
That said, there are situations where people don't want to use modules. I used to eschew them for security reasons, for example - now I instead just do a one-time temporary key. But others may have other reasons to try to avoid modules.
Quoted 3 lines
2) Create a default PCM for every driver that has topology data on the assumption that every sound card will at least 1 PCM. This PCM can then be re-configured when the FW is loaded.
That would seem to be the better option if it is reasonably implementable.
Quoted 8 lines
Quoted 5 lines
Quoted 2 lines
Of course, some kind of timer-based retry (limited *somehow*) of the fw loading could work too, but smells really really hacky.
Yeah, years ago, we discussed to use -EPROBE_DEFER for the situation, which should be one kind of fix, but looks there were objections at that time.
That would still be a hack. I'll note there is also asynchronous probe support now but to use that would also be a hack for this issue. We don't want to
If we think firmware as one kind of resources like regulators, gpio and others,
PROBE_DEFERis one good match for firmware loading case, and
it has been used by lots of drivers, so why can't it be used for firmware loading?
Quoted 7 lines
Quoted 3 lines
One problem is that we need to convert drivers into returning -EPROBE_DEFER in case of request failure, and that may involve some work, but which should be mechanical.
I find such a delaying mechanism not so bad, too. It's very straightforward, at least, no big pain in the transition in the driver side.
Not sure how this is going to work with request_firmware_nowait(). We use that in our drivers to get rid of ~60 sec. delay in probe and consequently boot time when built-in. So basically we return 0 on probe lacking better knowledge. Guess we can always move back to request_firmware calls when defer_probe support is available.
Regards,
Arend
Quoted 19 lines
Quoted 7 lines
Quoted 4 lines
encourage folks to go down that road. They'd be hacks for this issue as you are simply delaying the driver probe for a later time and there is no guarantee that any
pivot_root()might have already been completed later to ensure your driver's fw file is present. So it may work or it may not.We can trigger defer probe explicitly once root fs is setup or other condition is met.
Right, how to trigger the reprobe (and relevant optimization) needs to be considered on top of the current mechanism.
Takashi
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Quoted 53 lines · On Sat, 29 Aug 2015 10:50:22 +0200 Arend van Spriel <[email protected]> wrote:
Quoted 44 lines · Takashi Iwai
Quoted 42 lines · Ming Lei
Quoted 26 lines · Luis R. Rodriguez
Quoted 25 lines · Ming Lei
Quoted 23 lines · Linus Torvalds
Quoted 6 lines · Liam Girdwood
I think the options are to either :-
1) Don not support audio DSP drivers using topology data as built-in drivers. Audio is not really a critical system required for booting anyway.
Yes, forcing it to be a module and not letting people compile it in by mistake (and then not have it work) is an option.
That said, there are situations where people don't want to use modules. I used to eschew them for security reasons, for example - now I instead just do a one-time temporary key. But others may have other reasons to try to avoid modules.
Quoted 3 lines
2) Create a default PCM for every driver that has topology data on the assumption that every sound card will at least 1 PCM. This PCM can then be re-configured when the FW is loaded.
That would seem to be the better option if it is reasonably implementable.
Quoted 8 lines
Quoted 5 lines
Quoted 2 lines
Of course, some kind of timer-based retry (limited *somehow*) of the fw loading could work too, but smells really really hacky.
Yeah, years ago, we discussed to use -EPROBE_DEFER for the situation, which should be one kind of fix, but looks there were objections at that time.
That would still be a hack. I'll note there is also asynchronous probe support now but to use that would also be a hack for this issue. We don't want to
If we think firmware as one kind of resources like regulators, gpio and others,
PROBE_DEFERis one good match for firmware loading case, and
it has been used by lots of drivers, so why can't it be used for firmware loading?Quoted 7 lines
Quoted 3 lines
One problem is that we need to convert drivers into returning -EPROBE_DEFER in case of request failure, and that may involve some work, but which should be mechanical.
I find such a delaying mechanism not so bad, too. It's very straightforward, at least, no big pain in the transition in the driver side.
Quoted 5 lines
Not sure how this is going to work with
request_firmware_nowait(). We use that in our drivers to get rid of ~60 sec. delay in probe and consequently boot time when built-in. So basically we return 0 on probe lacking better knowledge. Guess we can always move back torequest_firmwarecalls whendefer_probesupport is available.
How about the following untested draft patch?
drivers/base/dd.c +6 -0
@@ -171,6 +171,12 @@ static void driver_deferred_probe_trigger(void)queue_work (deferred_wq, &deferred_probe_work); } +void driver_trigger_fw_load () +{ +driver_deferred_probe_trigger (); +} +EXPORT_SYMBOL_GPL (driver_trigger_fw_load); +/** * deferred_probe_initcall() - Enable probing of deferred devices *
drivers/base/firmware_class.c +8 -0
@@ -1132,6 +1132,11 @@ _request_firmware(const struct firmware **firmware_p, const char *name,if (ret <=0 )/* error or already assigned */ goto out; +if (system_state ==SYSTEM_BOOTING ) { + ret = -EPROBE_DEFER ; + goto out; + } + ret =0 ; timeout =firmware_loading_timeout ();if (opt_flags &FW_OPT_NOWAIT ) {
@@ -1311,6 +1316,9 @@ request_firmware_nowait( {struct firmware_work *fw_work; +if (system_state ==SYSTEM_BOOTING ) +return -EPROBE_DEFER ; + fw_work =kzalloc (sizeof (struct firmware_work ), gfp);if (!fw_work)return -ENOMEM ;
include/linux/device.h +1 -0
@@ -289,6 +289,7 @@ extern struct device_driver *driver_find(const char *name, struct bus_type *bus);extern int driver_probe_done (void );extern void wait_for_device_probe (void ); +extern void driver_trigger_fw_load (void );/* sysfs interface for exporting driver attributes */
init/main.c +3 -0
@@ -943,6 +943,9 @@ static int __ref kernel_init(void *unused)flush_delayed_fput (); +/* trigger probe for request_firmware and its no_wait pair */ +driver_trigger_fw_load (); +if (ramdisk_execute_command) { ret =run_init_process (ramdisk_execute_command);if (!ret)
Thanks,
Quoted 98 lines · Ming Lei
Quoted 53 lines · On Sat, 29 Aug 2015 10:50:22 +0200 Arend van Spriel <[email protected]> wrote:
Quoted 44 lines · Takashi Iwai
Quoted 42 lines · Ming Lei
Quoted 26 lines · Luis R. Rodriguez
Quoted 25 lines · Ming Lei
Quoted 23 lines · Linus Torvalds
Quoted 6 lines · Liam Girdwood
I think the options are to either :-
1) Don not support audio DSP drivers using topology data as built-in drivers. Audio is not really a critical system required for booting anyway.
Yes, forcing it to be a module and not letting people compile it in by mistake (and then not have it work) is an option.
That said, there are situations where people don't want to use modules. I used to eschew them for security reasons, for example - now I instead just do a one-time temporary key. But others may have other reasons to try to avoid modules.
Quoted 3 lines
2) Create a default PCM for every driver that has topology data on the assumption that every sound card will at least 1 PCM. This PCM can then be re-configured when the FW is loaded.
That would seem to be the better option if it is reasonably implementable.
Quoted 8 lines
Quoted 5 lines
Quoted 2 lines
Of course, some kind of timer-based retry (limited *somehow*) of the fw loading could work too, but smells really really hacky.
Yeah, years ago, we discussed to use -EPROBE_DEFER for the situation, which should be one kind of fix, but looks there were objections at that time.
That would still be a hack. I'll note there is also asynchronous probe support now but to use that would also be a hack for this issue. We don't want to
If we think firmware as one kind of resources like regulators, gpio and others,
PROBE_DEFERis one good match for firmware loading case, and
it has been used by lots of drivers, so why can't it be used for firmware loading?Quoted 7 lines
Quoted 3 lines
One problem is that we need to convert drivers into returning -EPROBE_DEFER in case of request failure, and that may involve some work, but which should be mechanical.
I find such a delaying mechanism not so bad, too. It's very straightforward, at least, no big pain in the transition in the driver side.
Quoted 5 lines
Not sure how this is going to work with
request_firmware_nowait(). We use that in our drivers to get rid of ~60 sec. delay in probe and consequently boot time when built-in. So basically we return 0 on probe lacking better knowledge. Guess we can always move back torequest_firmwarecalls whendefer_probesupport is available.How about the following untested draft patch?
drivers/base/dd.c +6
-0@@ -171,6 +171,12 @@ static void driver_deferred_probe_trigger(void)queue_work (deferred_wq, &deferred_probe_work); } +void driver_trigger_fw_load () +{ +driver_deferred_probe_trigger (); +} +EXPORT_SYMBOL_GPL (driver_trigger_fw_load); +/** * deferred_probe_initcall() - Enable probing of deferred devices * drivers/base/firmware_class.c +5
-0@@ -1132,6 +1132,11 @@ _request_firmware(const struct firmware **firmware_p, const char *name,if (ret <=0 )/* error or already assigned */ goto out; +if (system_state ==SYSTEM_BOOTING ) { + ret = -EPROBE_DEFER ; + goto out; + } + ret =0 ; timeout =firmware_loading_timeout ();if (opt_flags &FW_OPT_NOWAIT ) {
drivers/base/firmware_class.c request_firmware_nowait( · line 1321
Quoted 6 lines
drivers/base/firmware_class.c +3
-0@@ -1311,6 +1316,9 @@ request_firmware_nowait( {struct firmware_work *fw_work; +if (system_state ==SYSTEM_BOOTING ) +return -EPROBE_DEFER ; +
Does this mean a built-in driver can not get firmware from initramfs or built in the kernel early. Seems a bit too aggressive. The problem stated in this thread is when the firmware is not on initramfs but only on the rootfs.
Regards,
Arend
Quoted 34 lines
drivers/base/firmware_class.c +0
-0fw_work =kzalloc (sizeof (struct firmware_work ), gfp);if (!fw_work)return -ENOMEM ;include/linux/device.h +1
-0@@ -289,6 +289,7 @@ extern struct device_driver *driver_find(const char *name, struct bus_type *bus);extern int driver_probe_done (void );extern void wait_for_device_probe (void ); +extern void driver_trigger_fw_load (void );/* sysfs interface for exporting driver attributes */ init/main.c +3
-0@@ -943,6 +943,9 @@ static int __ref kernel_init(void *unused)flush_delayed_fput (); +/* trigger probe for request_firmware and its no_wait pair */ +driver_trigger_fw_load (); +if (ramdisk_execute_command) { ret =run_init_process (ramdisk_execute_command);if (!ret)Thanks,
Quoted 4 lines · Arend van Spriel
On 08/29/2015 12:38 PM, Ming Lei wrote:
Does this mean a built-in driver can not get firmware from initramfs or built in the kernel early. Seems a bit too aggressive.
Yeah, that seems wrong. Loading firmware from initramfs is required for some things, like disk drivers. Of course, depending on how it's done, it's all after the SYSTEM_BOOTING phase, but ..
What we *might* do is to not allow it for the user-mode helper fallback, but I think it's more likely that we'll just deprecate the usermode helper fw loader entirely, so adding new error cases for it seems pointless.
Linus
Quoted 6 lines · Linus Torvalds
Quoted 4 lines · Arend van Spriel
On 08/29/2015 12:38 PM, Ming Lei wrote:
Does this mean a built-in driver can not get firmware from initramfs or built in the kernel early. Seems a bit too aggressive.
Quoted 6 lines
Yeah, that seems wrong. Loading firmware from initramfs is required for some things, like disk drivers. Of course, depending on how it's done, it's all after the
SYSTEM_BOOTINGphase, but ..What we *might* do is to not allow it for the user-mode helper fallback,
FWIW, that's what we did, request_firmware_direct() now skips the silly usermode helper. I'll note that Greg pointed out to me that Daniel (was this right?) might have some use cases for the usermode helper in the future on graphics though. Daniel is that right? Can you clarify the use case, I'd just like to document this and keep it in mind for future design changes on firmware_class. Also, it occurs to me that if you have a need for it, perhaps others might and if we can avoid *others* from coming up with their own solution that'd be best, specifically as this is related to file loading -- more on this later generalized possible use cases in another thread I'll Cc you folks on.
Quoted 3 lines
but I think it's more likely that we'll just deprecate the usermode helper fw loader entirely, so adding new error cases for it seems pointless.
I was shooting hard to deprecate the usermodehelper, Greg has noted that we can only phase it out though, so that is what I will be shooting for: a sysdata API, what will have firmware signing support later will *not* make use of the usermode helper. The old APIs will still use it.
[0] http://lkml.kernel.org/r/[email protected]
Luis
Quoted 131 lines · Arend van Spriel
Quoted 130 lines · Ming Lei
Quoted 79 lines · On Sat, 29 Aug 2015 10:50:22 +0200 Arend van Spriel <[email protected]> wrote:
Quoted 73 lines · Takashi Iwai
Quoted 64 lines · Ming Lei
Quoted 48 lines · Luis R. Rodriguez
Quoted 37 lines · Ming Lei
Quoted 34 lines · Linus Torvalds
Quoted 8 lines · Liam Girdwood
I think the options are to either :-
1) Don not support audio DSP drivers using topology data as built-in
drivers. Audio is not really a critical system required for booting anyway.Yes, forcing it to be a module and not letting people compile it in by
mistake (and then not have it work) is an option.That said, there are situations where people don't want to use modules. I used to eschew them for security reasons, for example - now
I instead just do a one-time temporary key. But others may have other
reasons to try to avoid modules.Quoted 5 lines
2) Create a default PCM for every driver that has topology data on the
assumption that every sound card will at least 1 PCM. This PCM can then
be re-configured when the FW is loaded.That would seem to be the better option if it is reasonably implementable.
Quoted 7 lines
Quoted 2 lines
Of course, some kind of timer-based retry (limited *somehow*) of the fw loading could work too, but smells really really hacky.
Yeah, years ago, we discussed to use -EPROBE_DEFER for the situation, which should be one kind of fix, but looks there were objections at that time.
Quoted 4 lines
That would still be a hack. I'll note there is also asynchronous probe support
now but to use that would also be a hack for this issue. We don't want toIf we think firmware as one kind of resources like regulators, gpio and others,
PROBE_DEFERis one good match for firmware loading case, and it has been used by lots of drivers, so why can't it be used for firmware loading?Quoted 4 lines
One problem is that we need to convert drivers into returning -EPROBE_DEFER
in case of request failure, and that may involve some work, but which should be mechanical.Quoted 3 lines
I find such a delaying mechanism not so bad, too. It's very straightforward, at least, no big pain in the transition in the driver side.
Quoted 5 lines
Not sure how this is going to work with
request_firmware_nowait(). We use that in our drivers to get rid of ~60 sec. delay in probe and consequently boot time when built-in. So basically we return 0 on probe lacking better knowledge. Guess we can always move back torequest_firmwarecalls whendefer_probesupport is available.How about the following untested draft patch?
drivers/base/dd.c +6
-0@@ -171,6 +171,12 @@ static void driver_deferred_probe_trigger(void)queue_work (deferred_wq, &deferred_probe_work); } +void driver_trigger_fw_load () +{ +driver_deferred_probe_trigger (); +} +EXPORT_SYMBOL_GPL (driver_trigger_fw_load); +/** * deferred_probe_initcall() - Enable probing of deferred devices * drivers/base/firmware_class.c +5
-0@@ -1132,6 +1132,11 @@ _request_firmware(const struct firmware **firmware_p, const char *name, if (ret <= 0) /* error or already assigned */ goto out; +if (system_state ==SYSTEM_BOOTING ) { + ret = -EPROBE_DEFER ; + goto out; + } + ret =0 ; timeout =firmware_loading_timeout ();if (opt_flags & FW_OPT_NOWAIT) {drivers/base/firmware_class.c +0
-0@@ -1311,6 +1316,9 @@ request_firmware_nowait( {struct firmware_work *fw_work;
Quoted 8 lines
drivers/base/firmware_class.c request_firmware_nowait( · line 1321
Quoted 3 lines
drivers/base/firmware_class.c +3
-0+if (system_state ==SYSTEM_BOOTING ) +return -EPROBE_DEFER ; +Does this mean a built-in driver can not get firmware from initramfs or built in the kernel early. Seems a bit too aggressive. The problem stated in this thread is when the firmware is not on initramfs but only on the rootfs.
Yes, strictly speaking, user mode request can't be handled with defer probe during booting because we don't know how the user helper handles the request, that said even checking if the firmware exists in current path doesn't make sense for user mode request.
So the patch should have used defer proble for direct load only during booting.
Quoted 41 lines
Regards,
ArendQuoted 35 lines
drivers/base/firmware_class.c +0
-0fw_work =kzalloc (sizeof (struct firmware_work ), gfp);if (!fw_work)return -ENOMEM ;include/linux/device.h +1
-0@@ -289,6 +289,7 @@ extern struct device_driver *driver_find(const char *name, struct bus_type *bus);extern int driver_probe_done (void );extern void wait_for_device_probe (void ); +extern void driver_trigger_fw_load (void );/* sysfs interface for exporting driver attributes */
init/main.c +3
-0@@ -943,6 +943,9 @@ static int __ref kernel_init(void *unused)flush_delayed_fput (); +/* trigger probe for request_firmware and its no_wait pair */ +driver_trigger_fw_load (); +if (ramdisk_execute_command) { ret =run_init_process (ramdisk_execute_command);if (!ret)Thanks,
Quoted 8 lines · Ming Lei
Quoted 3 lines · Arend van Spriel
Does this mean a built-in driver can not get firmware from initramfs or built in the kernel early. Seems a bit too aggressive. The problem stated in this thread is when the firmware is not on initramfs but only on the rootfs.
Yes, strictly speaking, user mode request can't be handled with defer probe during booting because we don't know how the user helper handles the request,
FWIW I have a strategy in mind to help us compartamentalize the user mode helper only to the dell-rbu driver, and as such phase out that code eventually completely. Its part of the goals I have with the extensible firmware API I've been proposing.
Quoted 5 lines
that said even checking if the firmware exists in current path doesn't make sense for user mode request.
So the patch should have used defer proble for direct load only during booting.
What exact guarantees would we be giving to callers if they follow up on probe with -EDEFER_PROBE ? I'd much prefer to try to avoid such uses in init / probe (note that unless you're using async probe since we batch both so it doesn't really matter where you place your code) all together and then for the few remaining stragglers understand the requirements and provide an interface that lets them claim their requirements and try to meets them.
A grammatical hunt for drivers who call fw API on init / probe can be completed, although I know the hunt needs a bit more fine tuning it surely can be completed. If we don't have many callers the compexity added for only a few callers with rather loose criteria seems rather unnecessary, specially if we can change the drivers and make these driver sthe exception rather than a norm.
Then as for drivers *needing* the fw at probe why not have a proper interface that does guarantee they get the requirements they ask for first ? For instance a new probe type specified by the driver could enable the core to wait for say an event and then tirgger a probe, kind of how we ended up defining the async probe type preference:
static struct some_bus_driver some_driver = {
.probe = some_probe,
.id_table = some_id,
.driver = {
.name = DEVICE_NAME,
.pm = &some_pm_ops, .probe_type = PROBE_PREFER_POST_FOO,
},
};
Then we just don't try just hoping for completion but rather can do something about the criteria passed.
Luis
Quoted 51 lines · Luis R. Rodriguez
Quoted 8 lines · Ming Lei
Quoted 3 lines · Arend van Spriel
Does this mean a built-in driver can not get firmware from initramfs or built in the kernel early. Seems a bit too aggressive. The problem stated in this thread is when the firmware is not on initramfs but only on the rootfs.
Yes, strictly speaking, user mode request can't be handled with defer probe during booting because we don't know how the user helper handles the request,
FWIW I have a strategy in mind to help us compartamentalize the user mode helper only to the dell-rbu driver, and as such phase out that code eventually completely. Its part of the goals I have with the extensible firmware API I've been proposing.
Quoted 5 lines
that said even checking if the firmware exists in current path doesn't make sense for user mode request.
So the patch should have used defer proble for direct load only during booting.
What exact guarantees would we be giving to callers if they follow up on probe with -EDEFER_PROBE ? I'd much prefer to try to avoid such uses in init / probe (note that unless you're using async probe since we batch both so it doesn't really matter where you place your code) all together and then for the few remaining stragglers understand the requirements and provide an interface that lets them claim their requirements and try to meets them.
A grammatical hunt for drivers who call fw API on init / probe can be completed, although I know the hunt needs a bit more fine tuning it surely can be completed. If we don't have many callers the compexity added for only a few callers with rather loose criteria seems rather unnecessary, specially if we can change the drivers and make these driver sthe exception rather than a norm.
Then as for drivers *needing* the fw at probe why not have a proper interface that does guarantee they get the requirements they ask for first ? For instance a new probe type specified by the driver could enable the core to wait for say an event and then tirgger a probe, kind of how we ended up defining the async probe type preference:
static struct
some_bus_driversome_driver= {
.probe =some_probe,
.id_table =some_id,
.driver = {
.name =DEVICE_NAME,
.pm =&some_pm_ops, .probe_type =PROBE_PREFER_POST_FOO,
},
};
Quoted 2 lines
Then we just don't try just hoping for completion but rather can do something about the criteria passed.
That sounds good to me and learning about the async probe type. We do a schedule work in our module_init to avoid the probe being done in init context. Guess we can change that using the async probe type :-p
Regards,
Arend
Quoted 71 lines · Arend van Spriel
Quoted 70 lines · Luis R. Rodriguez
Quoted 8 lines · Ming Lei
Quoted 5 lines · Arend van Spriel
Does this mean a built-in driver can not get firmware from initramfs or built in the kernel early. Seems a bit too aggressive. The problem stated in
this thread is when the firmware is not on initramfs but only on the rootfs.Quoted 4 lines
Yes, strictly speaking, user mode request can't be handled with defer probe
during booting because we don't know how the user helper handles the request,FWIW I have a strategy in mind to help us compartamentalize the user mode helper only to the dell-rbu driver, and as such phase out that code eventually
completely. Its part of the goals I have with the extensible firmware API I've
been proposing.Quoted 5 lines
that said even checking if the firmware exists in current path doesn't make sense for user mode request.
So the patch should have used defer proble for direct load only during booting.
What exact guarantees would we be giving to callers if they follow up on probe
with -EDEFER_PROBE ? I'd much prefer to try to avoid such uses in init / probe
(note that unless you're using async probe since we batch both so it doesn't really
matter where you place your code) all together and then for the few remaining
stragglers understand the requirements and provide an interface that lets them
claim their requirements and try to meets them.A grammatical hunt for drivers who call fw API on init / probe can be completed, although I know the hunt needs a bit more fine tuning it surely can
be completed. If we don't have many callers the compexity added for only a
few callers with rather loose criteria seems rather unnecessary, specially if
we can change the drivers and make these driver sthe exception rather than
a norm.Then as for drivers *needing* the fw at probe why not have a proper interface
that does guarantee they get the requirements they ask for first ? For instance
a new probe type specified by the driver could enable the core to wait for say
an event and then tirgger a probe, kind of how we ended up defining the async
probe type preference:static struct
some_bus_driversome_driver= {
.probe =some_probe,
.id_table =some_id,
.driver = {
.name =DEVICE_NAME,
.pm =&some_pm_ops, .probe_type =PROBE_PREFER_POST_FOO,
},
};
Quoted 3 lines
Quoted 3 lines
Then we just don't try just hoping for completion but rather can do something
about the criteria passed.
So should the probe type indicate some event or should it just indicate what the driver needs, ie. .probe_type = PROBE_TYPE_NEED_FW.
Regards,
Arend
Quoted 11 lines
That sounds good to me and learning about the async probe type. We do a schedule work in our
module_initto avoid the probe being done in init context. Guess we can change that using the async probe type :-pRegards,
Arend
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Quoted 72 lines · Arend van Spriel
Quoted 71 lines · Arend van Spriel
Quoted 70 lines · Luis R. Rodriguez
Quoted 8 lines · Ming Lei
Quoted 5 lines · Arend van Spriel
Does this mean a built-in driver can not get firmware from initramfs or built in the kernel early. Seems a bit too aggressive. The problem stated in
this thread is when the firmware is not on initramfs but only on the rootfs.Quoted 4 lines
Yes, strictly speaking, user mode request can't be handled with defer probe
during booting because we don't know how the user helper handles the request,FWIW I have a strategy in mind to help us compartamentalize the user mode helper only to the dell-rbu driver, and as such phase out that code eventually
completely. Its part of the goals I have with the extensible firmware API I've
been proposing.Quoted 5 lines
that said even checking if the firmware exists in current path doesn't make sense for user mode request.
So the patch should have used defer proble for direct load only during booting.
What exact guarantees would we be giving to callers if they follow up on probe
with -EDEFER_PROBE ? I'd much prefer to try to avoid such uses in init / probe
(note that unless you're using async probe since we batch both so it doesn't really
matter where you place your code) all together and then for the few remaining
stragglers understand the requirements and provide an interface that lets them
claim their requirements and try to meets them.A grammatical hunt for drivers who call fw API on init / probe can be completed, although I know the hunt needs a bit more fine tuning it surely can
be completed. If we don't have many callers the compexity added for only a
few callers with rather loose criteria seems rather unnecessary, specially if
we can change the drivers and make these driver sthe exception rather than
a norm.Then as for drivers *needing* the fw at probe why not have a proper interface
that does guarantee they get the requirements they ask for first ? For instance
a new probe type specified by the driver could enable the core to wait for say
an event and then tirgger a probe, kind of how we ended up defining the async
probe type preference:static struct
some_bus_driversome_driver= {
.probe =some_probe,
.id_table =some_id,
.driver = {
.name =DEVICE_NAME,
.pm =&some_pm_ops, .probe_type =PROBE_PREFER_POST_FOO,
},
};
Quoted 7 lines
Quoted 3 lines
Quoted 3 lines
Then we just don't try just hoping for completion but rather can do something
about the criteria passed.So should the probe type indicate some event or should it just indicate what the driver needs, ie. .probe_type =
PROBE_TYPE_NEED_FW.
Right so this is an open question. I suggested something like the above since the deferred probe documentation on drivers/base/dd.c states:
* Sometimes driver probe order matters, but the kernel doesn't always have
* dependency information
I'm alluding that we consider *avoiding* -EPROBE_DEFER for areas of the kernel where some work can be done to not only list the dependency the information from the driver but also we know we can get it from the kernel. In this case I do believe we could not only express the requirement but also wait for it in the kernel. Before we do that though I think it'd be good to do a grammar hunt to determine exactly how popular all this fw on probe needed really is.
Greg, provided we find sufficient drivers that really do need firmware on probe, any thoughts on this line of approach to address this?
Luis
Quoted 87 lines · Luis R. Rodriguez
Quoted 72 lines · Arend van Spriel
Quoted 71 lines · Arend van Spriel
Quoted 70 lines · Luis R. Rodriguez
Quoted 8 lines · Ming Lei
Quoted 5 lines · Arend van Spriel
Does this mean a built-in driver can not get firmware from initramfs or built in the kernel early. Seems a bit too aggressive. The problem stated in
this thread is when the firmware is not on initramfs but only on the rootfs.Quoted 4 lines
Yes, strictly speaking, user mode request can't be handled with defer probe
during booting because we don't know how the user helper handles the request,FWIW I have a strategy in mind to help us compartamentalize the user mode helper only to the dell-rbu driver, and as such phase out that code eventually
completely. Its part of the goals I have with the extensible firmware API I've
been proposing.Quoted 5 lines
that said even checking if the firmware exists in current path doesn't make sense for user mode request.
So the patch should have used defer proble for direct load only during booting.
What exact guarantees would we be giving to callers if they follow up on probe
with -EDEFER_PROBE ? I'd much prefer to try to avoid such uses in init / probe
(note that unless you're using async probe since we batch both so it doesn't really
matter where you place your code) all together and then for the few remaining
stragglers understand the requirements and provide an interface that lets them
claim their requirements and try to meets them.A grammatical hunt for drivers who call fw API on init / probe can be completed, although I know the hunt needs a bit more fine tuning it surely can
be completed. If we don't have many callers the compexity added for only a
few callers with rather loose criteria seems rather unnecessary, specially if
we can change the drivers and make these driver sthe exception rather than
a norm.Then as for drivers *needing* the fw at probe why not have a proper interface
that does guarantee they get the requirements they ask for first ? For instance
a new probe type specified by the driver could enable the core to wait for say
an event and then tirgger a probe, kind of how we ended up defining the async
probe type preference:static struct
some_bus_driversome_driver= {
.probe =some_probe,
.id_table =some_id,
.driver = {
.name =DEVICE_NAME,
.pm =&some_pm_ops, .probe_type =PROBE_PREFER_POST_FOO,
},
};Quoted 7 lines
Quoted 3 lines
Quoted 3 lines
Then we just don't try just hoping for completion but rather can do something
about the criteria passed.So should the probe type indicate some event or should it just indicate what the driver needs, ie. .probe_type =
PROBE_TYPE_NEED_FW.Right so this is an open question. I suggested something like the above since the deferred probe documentation on
drivers/base/dd.cstates:* Sometimes driver probe order matters, but the kernel doesn't always have
* dependency information
Quoted 7 lines
I'm alluding that we consider *avoiding* -EPROBE_DEFER for areas of the kernel where some work can be done to not only list the dependency the information from the driver but also we know we can get it from the kernel. In this case I do believe we could not only express the requirement but also wait for it in the kernel. Before we do that though I think it'd be good to do a grammar hunt to determine exactly how popular all this fw on probe needed really is.
Ok. So some background why we need it in brcm80211 drivers. So as a wireless network device driver the answer we got when asking for an event to load firware is upon IF_UP for a registered net device. Because we try to do things smart we query the firmware running on the device for capabilities before we can register the net device hence we request the firmware during probe. This may be specific to wireless drivers (Intel has same approach if not mistaken) but I suspect there may be more.
Regards,
Arend
Quoted 5 lines
Greg, provided we find sufficient drivers that really do need firmware on probe, any thoughts on this line of approach to address this?
Luis
Quoted 111 lines · Arend van Spriel
Quoted 101 lines · Luis R. Rodriguez
Quoted 82 lines · Arend van Spriel
Quoted 80 lines · Arend van Spriel
Quoted 78 lines · Luis R. Rodriguez
Quoted 12 lines · Ming Lei
Quoted 7 lines · Arend van Spriel
Does this mean a built-in driver can not get firmware from initramfs or
built in the kernel early. Seems a bit too aggressive. The problem stated in
this thread is when the firmware is not on initramfs but only on the rootfs.Quoted 4 lines
Yes, strictly speaking, user mode request can't be handled with defer probe
during booting because we don't know how the user helper handles the request,FWIW I have a strategy in mind to help us compartamentalize the user mode
helper only to the dell-rbu driver, and as such phase out that code eventually
completely. Its part of the goals I have with the extensible firmware API I've
been proposing.Quoted 5 lines
that said even checking if the firmware exists in current path doesn't make sense for user mode request.
So the patch should have used defer proble for direct load only during booting.
What exact guarantees would we be giving to callers if they follow up on probe
with -EDEFER_PROBE ? I'd much prefer to try to avoid such uses in init / probe
(note that unless you're using async probe since we batch both so it doesn't really
matter where you place your code) all together and then for the few remaining
stragglers understand the requirements and provide an interface that lets them
claim their requirements and try to meets them.A grammatical hunt for drivers who call fw API on init / probe can be completed, although I know the hunt needs a bit more fine tuning it surely can
be completed. If we don't have many callers the compexity added for only a
few callers with rather loose criteria seems rather unnecessary, specially if
we can change the drivers and make these driver sthe exception rather than
a norm.Then as for drivers *needing* the fw at probe why not have a proper interface
that does guarantee they get the requirements they ask for first ? For instance
a new probe type specified by the driver could enable the core to wait for say
an event and then tirgger a probe, kind of how we ended up defining the async
probe type preference:static struct
some_bus_driversome_driver= {
.probe =some_probe,
.id_table =some_id,
.driver = {
.name =DEVICE_NAME,
.pm =&some_pm_ops, .probe_type =PROBE_PREFER_POST_FOO,
},
};Quoted 8 lines
Quoted 3 lines
Quoted 3 lines
Then we just don't try just hoping for completion but rather can do something
about the criteria passed.So should the probe type indicate some event or should it just indicate what the driver needs, ie. .probe_type =
PROBE_TYPE_NEED_FW.Right so this is an open question. I suggested something like the above since the deferred probe documentation on
drivers/base/dd.cstates:* Sometimes driver probe order matters, but the kernel doesn't always
have
* dependency informationQuoted 7 lines
I'm alluding that we consider *avoiding* -EPROBE_DEFER for areas of the kernel where some work can be done to not only list the dependency the information from the driver but also we know we can get it from the kernel. In this case I do believe we could not only express the requirement but also wait for it in the kernel. Before we do that though I think it'd be good to do a grammar hunt to determine exactly how popular all this fw on probe needed really is.
Quoted 7 lines
Ok. So some background why we need it in brcm80211 drivers. So as a wireless network device driver the answer we got when asking for an event to load firware is upon
IF_UPfor a registered net device. Because we try to do things smart we query the firmware running on the device for capabilities before we can register the net device hence we request the firmware during probe. This may be specific to wireless drivers (Intel has same approach if not mistaken) but I suspect there may be more.
We have the same issue with input devices: before we can register one we need to set their capabilities and to know their capabilities we quite often need to load their firmware/config and query the device.
Thanks.
Signature · 1 line
Dmitry
Quoted 120 lines · Dmitry Torokhov
Quoted 111 lines · Arend van Spriel
Quoted 101 lines · Luis R. Rodriguez
Quoted 82 lines · Arend van Spriel
Quoted 80 lines · Arend van Spriel
Quoted 78 lines · Luis R. Rodriguez
Quoted 12 lines · Ming Lei
Quoted 7 lines · Arend van Spriel
Does this mean a built-in driver can not get firmware from initramfs or
built in the kernel early. Seems a bit too aggressive. The problem stated in
this thread is when the firmware is not on initramfs but only on the rootfs.Quoted 4 lines
Yes, strictly speaking, user mode request can't be handled with defer probe
during booting because we don't know how the user helper handles the request,FWIW I have a strategy in mind to help us compartamentalize the user mode
helper only to the dell-rbu driver, and as such phase out that code eventually
completely. Its part of the goals I have with the extensible firmware API I've
been proposing.Quoted 5 lines
that said even checking if the firmware exists in current path doesn't make sense for user mode request.
So the patch should have used defer proble for direct load only during booting.
What exact guarantees would we be giving to callers if they follow up on probe
with -EDEFER_PROBE ? I'd much prefer to try to avoid such uses in init / probe
(note that unless you're using async probe since we batch both so it doesn't really
matter where you place your code) all together and then for the few remaining
stragglers understand the requirements and provide an interface that lets them
claim their requirements and try to meets them.A grammatical hunt for drivers who call fw API on init / probe can be completed, although I know the hunt needs a bit more fine tuning it surely can
be completed. If we don't have many callers the compexity added for only a
few callers with rather loose criteria seems rather unnecessary, specially if
we can change the drivers and make these driver sthe exception rather than
a norm.Then as for drivers *needing* the fw at probe why not have a proper interface
that does guarantee they get the requirements they ask for first ? For instance
a new probe type specified by the driver could enable the core to wait for say
an event and then tirgger a probe, kind of how we ended up defining the async
probe type preference:static struct
some_bus_driversome_driver= {
.probe =some_probe,
.id_table =some_id,
.driver = {
.name =DEVICE_NAME,
.pm =&some_pm_ops, .probe_type =PROBE_PREFER_POST_FOO,
},
};Quoted 8 lines
Quoted 3 lines
Quoted 3 lines
Then we just don't try just hoping for completion but rather can do something
about the criteria passed.So should the probe type indicate some event or should it just indicate what the driver needs, ie. .probe_type =
PROBE_TYPE_NEED_FW.Right so this is an open question. I suggested something like the above since the deferred probe documentation on
drivers/base/dd.cstates:* Sometimes driver probe order matters, but the kernel doesn't always
have
* dependency informationQuoted 7 lines
I'm alluding that we consider *avoiding* -EPROBE_DEFER for areas of the kernel where some work can be done to not only list the dependency the information from the driver but also we know we can get it from the kernel. In this case I do believe we could not only express the requirement but also wait for it in the kernel. Before we do that though I think it'd be good to do a grammar hunt to determine exactly how popular all this fw on probe needed really is.
Quoted 7 lines
Ok. So some background why we need it in brcm80211 drivers. So as a wireless network device driver the answer we got when asking for an event to load firware is upon
IF_UPfor a registered net device. Because we try to do things smart we query the firmware running on the device for capabilities before we can register the net device hence we request the firmware during probe. This may be specific to wireless drivers (Intel has same approach if not mistaken) but I suspect there may be more.
Quoted 3 lines
We have the same issue with input devices: before we can register one we need to set their capabilities and to know their capabilities we quite often need to load their
firmware/configand query the device.
Should Arend's driver use async probe then?
IMHO its just as hacky as using -EPROBE_DEFER too, but its at least preemptively hacky. Sadly I can't think of clear and clever way for the kernel to know when firmware will be ready either... Would userspace know? Should the kernel learn this from userspace ?
For instance, if init is going to use initramfs it can pivot_root() and later send us a smoke signal when done, and it it doesn't it can also send us a smoke signal. In the absence of such a hint being implemented I suppose -EPROBE_DEFER, async probe or a notifier on pivot_root() is best effort we can do, but again *eh*.
Luis
Quoted 121 lines · Luis R. Rodriguez
Quoted 120 lines · Dmitry Torokhov
Quoted 118 lines · Arend van Spriel
Quoted 101 lines · Luis R. Rodriguez
Quoted 82 lines · Arend van Spriel
Quoted 80 lines · Arend van Spriel
Quoted 78 lines · Luis R. Rodriguez
Quoted 12 lines · Ming Lei
Quoted 7 lines · Arend van Spriel
Does this mean a built-in driver can not get firmware from initramfs or
built in the kernel early. Seems a bit too aggressive. The problem stated in
this thread is when the firmware is not on initramfs but only on the rootfs.Quoted 4 lines
Yes, strictly speaking, user mode request can't be handled with defer probe
during booting because we don't know how the user helper handles the request,FWIW I have a strategy in mind to help us compartamentalize the user mode
helper only to the dell-rbu driver, and as such phase out that code eventually
completely. Its part of the goals I have with the extensible firmware API I've
been proposing.Quoted 5 lines
that said even checking if the firmware exists in current path doesn't make sense for user mode request.
So the patch should have used defer proble for direct load only during booting.
What exact guarantees would we be giving to callers if they follow up on probe
with -EDEFER_PROBE ? I'd much prefer to try to avoid such uses in init / probe
(note that unless you're using async probe since we batch both so it doesn't really
matter where you place your code) all together and then for the few remaining
stragglers understand the requirements and provide an interface that lets them
claim their requirements and try to meets them.A grammatical hunt for drivers who call fw API on init / probe can be completed, although I know the hunt needs a bit more fine tuning it surely can
be completed. If we don't have many callers the compexity added for only a
few callers with rather loose criteria seems rather unnecessary, specially if
we can change the drivers and make these driver sthe exception rather than
a norm.Then as for drivers *needing* the fw at probe why not have a proper interface
that does guarantee they get the requirements they ask for first ? For instance
a new probe type specified by the driver could enable the core to wait for say
an event and then tirgger a probe, kind of how we ended up defining the async
probe type preference:static struct
some_bus_driversome_driver= {
.probe =some_probe,
.id_table =some_id,
.driver = {
.name =DEVICE_NAME,
.pm =&some_pm_ops, .probe_type =PROBE_PREFER_POST_FOO,
},
};Quoted 8 lines
Quoted 3 lines
Quoted 3 lines
Then we just don't try just hoping for completion but rather can do something
about the criteria passed.So should the probe type indicate some event or should it just indicate what the driver needs, ie. .probe_type =
PROBE_TYPE_NEED_FW.Right so this is an open question. I suggested something like the above since the deferred probe documentation on
drivers/base/dd.cstates:* Sometimes driver probe order matters, but the kernel doesn't always
have
* dependency informationQuoted 7 lines
I'm alluding that we consider *avoiding* -EPROBE_DEFER for areas of the kernel where some work can be done to not only list the dependency the information from the driver but also we know we can get it from the kernel. In this case I do believe we could not only express the requirement but also wait for it in the kernel. Before we do that though I think it'd be good to do a grammar hunt to determine exactly how popular all this fw on probe needed really is.
Ok. So some background why we need it in brcm80211 drivers. So as a wireless network device driver the answer we got when asking for an event to load firware is upon
IF_UPfor a registered net device. Because we try to do things smart we query the firmware running on the device for capabilities before we can register the net device hence we request the firmware during probe. This may be specific to wireless drivers (Intel has same approach if not mistaken) but I suspect there may be more.
Quoted 5 lines
Quoted 3 lines
We have the same issue with input devices: before we can register one we need to set their capabilities and to know their capabilities we quite often need to load their
firmware/configand query the device.Should Arend's driver use async probe then?
What has async probe have to do with anything? We will still be waiting for async probes to finish before we mount rootfs so it will not change absolutely anything.
Quoted 5 lines
IMHO its just as hacky as using -EPROBE_DEFER too, but its at least preemptively hacky. Sadly I can't think of clear and clever way for the kernel to know when firmware will be ready either... Would userspace know? Should the kernel learn this from userspace ?
Yes. Given only userspace knows when firmware is available (I could have it on a separate device and mount it at some time). So maybe userpsace should simply try and scan busses for unbound devices and tell them to re-probe when it decides that firmware is finally available.
Thanks.
Signature · 1 line
Dmitry
Quoted 15 lines · Dmitry Torokhov
Quoted 14 lines · Luis R. Rodriguez
Quoted 12 lines · Dmitry Torokhov
Quoted 7 lines · Arend van Spriel
Ok. So some background why we need it in brcm80211 drivers. So as a wireless network device driver the answer we got when asking for an event to load firware is upon
IF_UPfor a registered net device. Because we try to do things smart we query the firmware running on the device for capabilities before we can register the net device hence we request the firmware during probe. This may be specific to wireless drivers (Intel has same approach if not mistaken) but I suspect there may be more.We have the same issue with input devices: before we can register one we need to set their capabilities and to know their capabilities we quite often need to load their
firmware/configand query the device.
Quoted 5 lines
Quoted 1 line
Should Arend's driver use async probe then?
What has async probe have to do with anything? We will still be waiting for async probes to finish before we mount rootfs so it will not change absolutely anything.
:) Right, its what I was alluding to as well.
Quoted 10 lines
Quoted 4 lines
IMHO its just as hacky as using -EPROBE_DEFER too, but its at least preemptively hacky. Sadly I can't think of clear and clever way for the kernel to know when firmware will be ready either... Would userspace know? Should the kernel learn this from userspace ?
Yes. Given only userspace knows when firmware is available (I could have it on a separate device and mount it at some time). So maybe userpsace should simply try and scan busses for unbound devices and tell them to re-probe when it decides that firmware is finally available.
OK, the folks wanting this mechanism can implement it then. Short of that we only have hacks.
Luis
Quoted 17 lines · Luis R. Rodriguez
Quoted 15 lines · Dmitry Torokhov
Quoted 14 lines · Luis R. Rodriguez
Quoted 12 lines · Dmitry Torokhov
Quoted 7 lines · Arend van Spriel
Ok. So some background why we need it in brcm80211 drivers. So as a wireless network device driver the answer we got when asking for an event to load firware is upon
IF_UPfor a registered net device. Because we try to do things smart we query the firmware running on the device for capabilities before we can register the net device hence we request the firmware during probe. This may be specific to wireless drivers (Intel has same approach if not mistaken) but I suspect there may be more.We have the same issue with input devices: before we can register one we need to set their capabilities and to know their capabilities we quite often need to load their
firmware/configand query the device.
Quoted 7 lines
Quoted 5 lines
Quoted 1 line
Should Arend's driver use async probe then?
What has async probe have to do with anything? We will still be waiting for async probes to finish before we mount rootfs so it will not change absolutely anything.
:) Right, its what I was alluding to as well.
Indeed. However, upon module_init we schedule a worker in which the driver are registered. We do that to make sure the probe is not done within module_init context. That could now be done with async probe. This is not the problem discussed here so let's not spend more time on this.
Quoted 5 lines
Quoted 5 lines
Quoted 4 lines
IMHO its just as hacky as using -EPROBE_DEFER too, but its at least preemptively hacky. Sadly I can't think of clear and clever way for the kernel to know when firmware will be ready either... Would userspace know? Should the kernel learn this from userspace ?
Quoted 8 lines
Quoted 5 lines
Yes. Given only userspace knows when firmware is available (I could have it on a separate device and mount it at some time). So maybe userpsace should simply try and scan busses for unbound devices and tell them to re-probe when it decides that firmware is finally available.
OK, the folks wanting this mechanism can implement it then. Short of that we only have hacks.
So what does "userspace knows when firmware is available" mean here. The specific firmware file the driver wants or the collection of firmware files which may or may not have the specific firmware file the driver wants. I assume the latter and re-probe will fail as expected.
Regards,
Arend
Quoted 22 lines · Arend van Spriel
Quoted 21 lines · Luis R. Rodriguez
Quoted 16 lines · Dmitry Torokhov
Quoted 6 lines · Luis R. Rodriguez
IMHO its just as hacky as using -EPROBE_DEFER too, but its at least preemptively hacky. Sadly I can't think of clear and clever way for the kernel
to know when firmware will be ready either... Would userspace know? Should the
kernel learn this from userspace ?Yes. Given only userspace knows when firmware is available (I could have it on a separate device and mount it at some time). So maybe userpsace should simply try and scan busses for unbound devices and tell them to re-probe when it decides that firmware is finally available.
Quoted 8 lines
Quoted 2 lines
OK, the folks wanting this mechanism can implement it then. Short of that we only have hacks.
So what does "userspace knows when firmware is available" mean here. The specific firmware file the driver wants or the collection of firmware files which may or may not have the specific firmware file the driver wants. I assume the latter and re-probe will fail as expected.
Right, the latter.
Signature · 1 line
Dmitry
Quoted 27 lines · Dmitry Torokhov
Quoted 26 lines · Arend van Spriel
Quoted 23 lines · Luis R. Rodriguez
Quoted 11 lines · Dmitry Torokhov
Quoted 6 lines · Luis R. Rodriguez
IMHO its just as hacky as using -EPROBE_DEFER too, but its at least preemptively hacky. Sadly I can't think of clear and clever way for the kernel
to know when firmware will be ready either... Would userspace know? Should the
kernel learn this from userspace ?Quoted 5 lines
Yes. Given only userspace knows when firmware is available (I could have it on a separate device and mount it at some time). So maybe userpsace should simply try and scan busses for unbound devices and tell them to re-probe when it decides that firmware is finally available.
OK, the folks wanting this mechanism can implement it then. Short of that we only have hacks.
Quoted 6 lines
Quoted 4 lines
So what does "userspace knows when firmware is available" mean here. The specific firmware file the driver wants or the collection of firmware files which may or may not have the specific firmware file the driver wants. I assume the latter and re-probe will fail as expected.
Right, the latter.
Arend, curious are you working on this? Me and Julia did some hunting and have found quite a bit of users that could use this. I'll provide results in another thread but figured I'd follow up to see if anyone is working to address this. Otherwise we just have hacks for now.
Luis
Quoted 4 lines · Luis R. Rodriguez
Arend, curious are you working on this? Me and Julia did some hunting and have found quite a bit of users that could use this. I'll provide results in another thread but figured I'd follow up to see if anyone is working to address this. Otherwise we just have hacks for now.
A lot of things are going on with firmware_class enhancements so lets jot things down here:
http://kernelnewbies.org/KernelProjects/firmware-class-enhancements
Luis
Quoted 33 lines · Luis R. Rodriguez
Quoted 32 lines · Dmitry Torokhov
Quoted 30 lines · Arend van Spriel
Quoted 21 lines · Luis R. Rodriguez
Quoted 11 lines · Dmitry Torokhov
Quoted 6 lines · Luis R. Rodriguez
IMHO its just as hacky as using -EPROBE_DEFER too, but its at least preemptively hacky. Sadly I can't think of clear and clever way for the kernel
to know when firmware will be ready either... Would userspace know? Should the
kernel learn this from userspace ?Quoted 5 lines
Yes. Given only userspace knows when firmware is available (I could have it on a separate device and mount it at some time). So maybe userpsace should simply try and scan busses for unbound devices and tell them to re-probe when it decides that firmware is finally available.
Quoted 2 lines
OK, the folks wanting this mechanism can implement it then. Short of that we only have hacks.
So what does "userspace knows when firmware is available" mean here. The specific firmware file the driver wants or the collection of firmware files which may or may not have the specific firmware file the driver wants. I assume the latter and re-probe will fail as expected.
Quoted 6 lines
Quoted 1 line
Right, the latter.
Arend, curious are you working on this? Me and Julia did some hunting and have found quite a bit of users that could use this. I'll provide results in another thread but figured I'd follow up to see if anyone is working to address this. Otherwise we just have hacks for now.
Not doing much else than diaper changes these days. Seems to me based on the above that from kernel perspective we can not do much when firmware mounts are controlled by user-space.
Regards,
Arend
Quoted 79 lines · Arend van Spriel
Quoted 78 lines · Arend van Spriel
Quoted 76 lines · Luis R. Rodriguez
Quoted 11 lines · Ming Lei
Quoted 6 lines · Arend van Spriel
Does this mean a built-in driver can not get firmware from initramfs or built in the kernel early. Seems a bit too aggressive. The problem stated in
this thread is when the firmware is not on initramfs but only on the rootfs.Quoted 4 lines
Yes, strictly speaking, user mode request can't be handled with defer probe
during booting because we don't know how the user helper handles the request,FWIW I have a strategy in mind to help us compartamentalize the user mode helper only to the dell-rbu driver, and as such phase out that code eventually
completely. Its part of the goals I have with the extensible firmware API I've
been proposing.Quoted 5 lines
that said even checking if the firmware exists in current path doesn't make sense for user mode request.
So the patch should have used defer proble for direct load only during booting.
What exact guarantees would we be giving to callers if they follow up on probe
with -EDEFER_PROBE ? I'd much prefer to try to avoid such uses in init / probe
(note that unless you're using async probe since we batch both so it doesn't really
matter where you place your code) all together and then for the few remaining
stragglers understand the requirements and provide an interface that lets them
claim their requirements and try to meets them.A grammatical hunt for drivers who call fw API on init / probe can be completed, although I know the hunt needs a bit more fine tuning it surely can
be completed. If we don't have many callers the compexity added for only a
few callers with rather loose criteria seems rather unnecessary, specially if
we can change the drivers and make these driver sthe exception rather than
a norm.Then as for drivers *needing* the fw at probe why not have a proper interface
that does guarantee they get the requirements they ask for first ? For instance
a new probe type specified by the driver could enable the core to wait for say
an event and then tirgger a probe, kind of how we ended up defining the async
probe type preference:static struct
some_bus_driversome_driver= {
.probe =some_probe,
.id_table =some_id,
.driver = {
.name =DEVICE_NAME,
.pm =&some_pm_ops, .probe_type =PROBE_PREFER_POST_FOO,
},
};
Quoted 7 lines
Quoted 3 lines
Quoted 3 lines
Then we just don't try just hoping for completion but rather can do something
about the criteria passed.So should the probe type indicate some event or should it just indicate what the driver needs, ie. .probe_type =
PROBE_TYPE_NEED_FW.
What will kernel do when it sees such an option? It does not know when firmware will become available (if ever). We can only try and fail and then userspace may try re-probing devices once firmware is available. I guess the question is how to let userspace know what devices failed to probe because of the lack of firmware.
Thanks.
Signature · 1 line
Dmitry
Quoted 33 lines · Ming Lei
Quoted 32 lines · Luis R. Rodriguez
Quoted 30 lines · Ming Lei
Quoted 17 lines · Linus Torvalds
Quoted 6 lines · Liam Girdwood
I think the options are to either :-
1) Don not support audio DSP drivers using topology data as built-in drivers. Audio is not really a critical system required for booting anyway.
Yes, forcing it to be a module and not letting people compile it in by mistake (and then not have it work) is an option.
That said, there are situations where people don't want to use modules. I used to eschew them for security reasons, for example - now I instead just do a one-time temporary key. But others may have other reasons to try to avoid modules.
Quoted 8 lines
Quoted 3 lines
2) Create a default PCM for every driver that has topology data on the assumption that every sound card will at least 1 PCM. This PCM can then be re-configured when the FW is loaded.
That would seem to be the better option if it is reasonably implementable.
Of course, some kind of timer-based retry (limited *somehow*) of the fw loading could work too, but smells really really hacky.
Yeah, years ago, we discussed to use -EPROBE_DEFER for the situation, which should be one kind of fix, but looks there were objections at that time.
Quoted 7 lines
Quoted 2 lines
That would still be a hack. I'll note there is also asynchronous probe support now but to use that would also be a hack for this issue. We don't want to
If we think firmware as one kind of resources like regulators, gpio and others,
PROBE_DEFERis one good match for firmware loading case, and
it has been used by lots of drivers, so why can't it be used for firmware loading?
I'm glad you asked, it begs the question if we could have done something better for these other components. In short its a matter of if we have an interface that would let devices coming up ask: are my requirements available yet? Reason we kick -EPROBE_DEFER is we can't answer this as we have no way to map some of these requirements pricely so -EPROBE_DEFER is the best we can do at times.
It doesn't mean we shouldn't think harder, and for firmware I think we can and should try harder to answer these questions.
I'm arguing that its a viable solution to use -EPROBE_DEFER but I don't think its the best we can do but also I worry about the lack of semantics that would be implied by user if they start doing this all over. In terms of semantics I'd want at least some undestanding by the caller over certain guarantees of what we are going to try to do for them by using -EPROBE_DEFER.
Quoted 3 lines
One problem is that we need to convert drivers into returning -EPROBE_DEFER in case of request failure, and that may involve some work, but which should be mechanical.
And there may be cases where the fs might already be available, so it would be pointless to retry if the error was true. To me that's a bit sloppy, and part of the sloppiness comes from the lack of clear semantics. Its why we are having this discussion. Its also not the first of its case and its why I'm kind of trying to be a bit pedantic. I would prefer to avoid just a bandaid.
Quoted 7 lines
Quoted 4 lines
encourage folks to go down that road. They'd be hacks for this issue as you are simply delaying the driver probe for a later time and there is no guarantee that any
pivot_root()might have already been completed later to ensure your driver's fw file is present. So it may work or it may not.We can trigger defer probe explicitly once root fs is setup or other condition is met.
Now we're talking, that's the sort of line of solution I'd much prefer, but again that's building on top of a use case that I think we should try to avoid. I think the strategy is sound but not the way we're deferring probe. I think that's prone to error and the solution lacks clarity.
Luis