Am 20.04.22 um 10:52 schrieb Javier Martinez Canillas:

This function just returned 0 on success or an errno code on error, but it could be useful for sysfb_init() callers to have a pointer to the device.

Signed-off-by: Javier Martinez Canillas javierm@redhat.com Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch

Reviewed-by: Thomas Zimmermann tzimmermann@suse.de

---

(no changes since v2)

Changes in v2:

• Rebase on top of latest drm-misc-next and fix conflicts (Daniel Vetter).

  drivers/firmware/sysfb.c | 4 ++-- drivers/firmware/sysfb_simplefb.c | 16 ++++++++-------- include/linux/sysfb.h | 10 +++++----- 3 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/drivers/firmware/sysfb.c b/drivers/firmware/sysfb.c index 2bfbb05f7d89..b032f40a92de 100644 --- a/drivers/firmware/sysfb.c +++ b/drivers/firmware/sysfb.c @@ -46,8 +46,8 @@ static __init int sysfb_init(void) /* try to create a simple-framebuffer device */ compatible = sysfb_parse_mode(si, &mode); if (compatible) {

• ret = sysfb_create_simplefb(si, &mode);
  

• if (!ret)
  

• pd = sysfb_create_simplefb(si, &mode);
  

• if (!IS_ERR(pd))
  return 0;
  

  }

diff --git a/drivers/firmware/sysfb_simplefb.c b/drivers/firmware/sysfb_simplefb.c index bda8712bfd8c..a353e27f83f5 100644 --- a/drivers/firmware/sysfb_simplefb.c +++ b/drivers/firmware/sysfb_simplefb.c @@ -57,8 +57,8 @@ __init bool sysfb_parse_mode(const struct screen_info *si, return false; }

-__init int sysfb_create_simplefb(const struct screen_info *si,

• 		 const struct simplefb_platform_data *mode)
  

+__init struct platform_device *sysfb_create_simplefb(const struct screen_info *si,

• 				     const struct simplefb_platform_data *mode)
  

  { struct platform_device *pd; struct resource res;

@@ -76,7 +76,7 @@ __init int sysfb_create_simplefb(const struct screen_info *si, base |= (u64)si->ext_lfb_base << 32; if (!base || (u64)(resource_size_t)base != base) { printk(KERN_DEBUG "sysfb: inaccessible VRAM base\n");

• return -EINVAL;
  

• return ERR_PTR(-EINVAL);
  

  }

  /*

@@ -93,7 +93,7 @@ __init int sysfb_create_simplefb(const struct screen_info *si, length = mode->height * mode->stride; if (length > size) { printk(KERN_WARNING "sysfb: VRAM smaller than advertised\n");

• return -EINVAL;
  

• return ERR_PTR(-EINVAL);
  

  } length = PAGE_ALIGN(length);

@@ -104,11 +104,11 @@ __init int sysfb_create_simplefb(const struct screen_info *si, res.start = base; res.end = res.start + length - 1; if (res.end <= res.start)

• return -EINVAL;
  

• return ERR_PTR(-EINVAL);
  
  

  pd = platform_device_alloc("simple-framebuffer", 0); if (!pd)

• return -ENOMEM;
  

• return ERR_PTR(-ENOMEM);
  
  

  sysfb_apply_efi_quirks(pd);

@@ -124,10 +124,10 @@ __init int sysfb_create_simplefb(const struct screen_info *si, if (ret) goto err_put_device;

• return 0;

• return pd;

  err_put_device: platform_device_put(pd);

• return ret;

• return ERR_PTR(ret); }

diff --git a/include/linux/sysfb.h b/include/linux/sysfb.h index b0dcfa26d07b..708152e9037b 100644 --- a/include/linux/sysfb.h +++ b/include/linux/sysfb.h @@ -72,8 +72,8 @@ static inline void sysfb_apply_efi_quirks(struct platform_device *pd)

bool sysfb_parse_mode(const struct screen_info *si, struct simplefb_platform_data *mode); -int sysfb_create_simplefb(const struct screen_info *si,

• 	  const struct simplefb_platform_data *mode);
  

+struct platform_device *sysfb_create_simplefb(const struct screen_info *si,

• 			      const struct simplefb_platform_data *mode);
  
  

  #else /* CONFIG_SYSFB_SIMPLE */

@@ -83,10 +83,10 @@ static inline bool sysfb_parse_mode(const struct screen_info *si, return false; }

-static inline int sysfb_create_simplefb(const struct screen_info *si,

• 			 const struct simplefb_platform_data *mode)
  

+static inline struct platform_device *sysfb_create_simplefb(const struct screen_info *si,

• 					    const struct simplefb_platform_data *mode)
  

  {

• return -EINVAL;

• return ERR_PTR(-EINVAL); }

  #endif /* CONFIG_SYSFB_SIMPLE */

Hi

Am 20.04.22 um 10:53 schrieb Javier Martinez Canillas:

These can be used by subsystems to unregister a platform device registered by sysfb and also to disable future platform device registration in sysfb.

Suggested-by: Daniel Vetter daniel.vetter@ffwll.ch Signed-off-by: Javier Martinez Canillas javierm@redhat.com Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch

---

(no changes since v2)

Changes in v2:

• Add kernel-doc comments and include in other_interfaces.rst (Daniel Vetter).

  .../driver-api/firmware/other_interfaces.rst | 6 ++ drivers/firmware/sysfb.c | 73 +++++++++++++++++-- include/linux/sysfb.h | 19 +++++ 3 files changed, 92 insertions(+), 6 deletions(-)

diff --git a/Documentation/driver-api/firmware/other_interfaces.rst b/Documentation/driver-api/firmware/other_interfaces.rst index b81794e0cfbb..06ac89adaafb 100644 --- a/Documentation/driver-api/firmware/other_interfaces.rst +++ b/Documentation/driver-api/firmware/other_interfaces.rst @@ -13,6 +13,12 @@ EDD Interfaces .. kernel-doc:: drivers/firmware/edd.c :internal:

+Generic System Framebuffers Interface +-------------------------------------

+.. kernel-doc:: drivers/firmware/sysfb.c

• :export:

• Intel Stratix10 SoC Service Layer

  Some features of the Intel Stratix10 SoC require a level of privilege

diff --git a/drivers/firmware/sysfb.c b/drivers/firmware/sysfb.c index b032f40a92de..a50d2858ce4d 100644 --- a/drivers/firmware/sysfb.c +++ b/drivers/firmware/sysfb.c @@ -34,21 +34,78 @@ #include <linux/screen_info.h> #include <linux/sysfb.h>

+static struct platform_device *pd;

You could have multiple instances of simple-framebuffer because you don't know what the firmware set up. It originated from DT and EFI/VESA is really just an afterthought. If there is more than 1 instance, your entire unregistering breaks down.

(I've been told that such multi-output cases exist in the context of OF framebuffers. Something similar could exist for simple-frambuffer as well.)

Best regards Thomas

+static DEFINE_MUTEX(load_lock); +static bool disabled;

+/**

• • sysfb_disable() - disable the Generic System Framebuffers support
• • This disables the registration of system framebuffer devices that match the
• • generic drivers that make use of the system framebuffer set up by firmware.
• • Context: The function can sleep. A @load_lock mutex is acquired to serialize

• •      against sysfb_init(), that registers a system framebuffer device and
    

• •      sysfb_try_unregister(), that tries to unregister framebuffer devices.
    

• */

+void sysfb_disable(void) +{

• mutex_lock(&load_lock);
• disabled = true;
• mutex_unlock(&load_lock);

+} +EXPORT_SYMBOL_GPL(sysfb_disable);

+/**

• • sysfb_try_unregister() - attempt to unregister a system framebuffer device
• • @dev: device to unregister
• • This tries to unregister a system framebuffer device if this was registered
• • by the Generic System Framebuffers. The device will only be unregistered if
• • it was registered by sysfb_init(), otherwise it will not be unregistered.
• • Context: The function can sleep. a @load_lock mutex is acquired to serialize

• •      against sysfb_init(), that registers a simple framebuffer device and
    

• •      sysfb_disable(), that disables the Generic System Framebuffers support.
    

• • Return:
• • • true - the device was unregistered successfully
• • • false - the device was not unregistered
• */

+bool sysfb_try_unregister(struct device *dev) +{

• bool ret = true;
• mutex_lock(&load_lock);
• if (!pd || pd != to_platform_device(dev))

• return false;
  

• platform_device_unregister(to_platform_device(dev));
• pd = NULL;
• mutex_unlock(&load_lock);
• return ret;

+} +EXPORT_SYMBOL_GPL(sysfb_try_unregister);

• static __init int sysfb_init(void) { struct screen_info *si = &screen_info; struct simplefb_platform_data mode;

• struct platform_device *pd; const char *name; bool compatible;
• int ret;

• int ret = 0;

• mutex_lock(&load_lock);

• if (disabled)

• goto unlock_mutex;
  
  

  /* try to create a simple-framebuffer device */ compatible = sysfb_parse_mode(si, &mode); if (compatible) { pd = sysfb_create_simplefb(si, &mode); if (!IS_ERR(pd))

• 	return 0;
  

• 	goto unlock_mutex;
  

  }

  /* if the FB is incompatible, create a legacy framebuffer device */

@@ -60,8 +117,10 @@ static __init int sysfb_init(void) name = "platform-framebuffer";

pd = platform_device_alloc(name, 0);

• if (!pd)

• return -ENOMEM;
  

• if (!pd) {

• ret = -ENOMEM;
  

• goto unlock_mutex;
  

• }

  sysfb_apply_efi_quirks(pd);

@@ -73,9 +132,11 @@ static __init int sysfb_init(void) if (ret) goto err;

• return 0;

• goto unlock_mutex; err: platform_device_put(pd);

+unlock_mutex:

• mutex_unlock(&load_lock); return ret; }

diff --git a/include/linux/sysfb.h b/include/linux/sysfb.h index 708152e9037b..e8c0313fac8f 100644 --- a/include/linux/sysfb.h +++ b/include/linux/sysfb.h @@ -55,6 +55,25 @@ struct efifb_dmi_info { int flags; };

+#ifdef CONFIG_SYSFB

+void sysfb_disable(void); +bool sysfb_try_unregister(struct device *dev);

+#else /* CONFIG_SYSFB */

+static inline void sysfb_disable(void) +{

+}

+static inline bool sysfb_try_unregister(struct device *dev) +{

• return false;

+}

+#endif /* CONFIG_SYSFB */

• #ifdef CONFIG_EFI

  extern struct efifb_dmi_info efifb_dmi_list[];

Hi

Am 20.04.22 um 10:53 schrieb Javier Martinez Canillas:

Drivers that want to remove registered conflicting framebuffers prior to register their own framebuffer, calls remove_conflicting_framebuffers().

This function takes the registration_lock mutex, to prevent a races when drivers register framebuffer devices. But if a conflicting framebuffer device is found, the underlaying platform device is unregistered and this will lead to the platform driver .remove callback to be called, which in turn will call to the unregister_framebuffer() that takes the same lock.

To prevent this, a struct fb_info.forced_out field was used as indication to unregister_framebuffer() whether the mutex has to be grabbed or not.

A cleaner solution is to drop the lock before platform_device_unregister() so unregister_framebuffer() can take it when called from the fbdev driver, and just grab the lock again after the device has been registered and do a removal loop restart.

I don't see how this patch improves the situation. So far, do_remove_conflicting_framebuffers() had no business in maintaining locks. And now it's doing this in in a goto-loop where it keeps getting/dropping locks. That's asking for bugs IMHO.

Best regards Thomas

Since the framebuffer devices will already be removed, the loop would just finish when no more conflicting framebuffers are found.

Suggested-by: Daniel Vetter daniel.vetter@ffwll.ch Signed-off-by: Javier Martinez Canillas javierm@redhat.com Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch

---

(no changes since v1)

drivers/video/fbdev/core/fbmem.c | 22 +++++++++++++++------- include/linux/fb.h | 1 - 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c index 84427470367b..0bb459258df3 100644 --- a/drivers/video/fbdev/core/fbmem.c +++ b/drivers/video/fbdev/core/fbmem.c @@ -1553,6 +1553,7 @@ static void do_remove_conflicting_framebuffers(struct apertures_struct *a, { int i;

+restart_removal: /* check all firmware fbs and kick off if the base addr overlaps */ for_each_registered_fb(i) { struct apertures_struct *gen_aper; @@ -1585,12 +1586,23 @@ static void do_remove_conflicting_framebuffers(struct apertures_struct *a, pr_warn("fb%d: no device set\n", i); do_unregister_framebuffer(registered_fb[i]); } else if (dev_is_platform(device)) {

• 		registered_fb[i]->forced_out = true;
  

• 		/*
  

• 		 * Drop the lock because if the device is unregistered, its
  

• 		 * driver will call to unregister_framebuffer(), that takes
  

• 		 * this lock.
  

• 		 */
  

• 		mutex_unlock(&registration_lock);
  	platform_device_unregister(to_platform_device(device));
  

• 		mutex_lock(&registration_lock);
  } else {
  	pr_warn("fb%d: cannot remove device\n", i);
  	do_unregister_framebuffer(registered_fb[i]);
  }
  

• 	/*
  

• 	 * Restart the removal loop now that the device has been
  

• 	 * unregistered and its associated framebuffer gone.
  

• 	 */
  

• 	goto restart_removal;
  

  } } }

@@ -1897,13 +1909,9 @@ EXPORT_SYMBOL(register_framebuffer); void unregister_framebuffer(struct fb_info *fb_info) {

• bool forced_out = fb_info->forced_out;
• if (!forced_out)

• mutex_lock(&registration_lock);
  

• mutex_lock(&registration_lock); do_unregister_framebuffer(fb_info);

• if (!forced_out)

• mutex_unlock(&registration_lock);
  

• mutex_unlock(&registration_lock); } EXPORT_SYMBOL(unregister_framebuffer);

diff --git a/include/linux/fb.h b/include/linux/fb.h index f95da1af9ff6..b781bc721113 100644 --- a/include/linux/fb.h +++ b/include/linux/fb.h @@ -502,7 +502,6 @@ struct fb_info { } *apertures;

bool skip_vt_switch; /* no VT switch on suspend/resume required */

• bool forced_out; /* set when being removed by another driver */ };

  static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {