greybus-dev September 2026

greybus-dev@lists.linaro.org

34 participants
40 discussions

[PATCH v3 0/3] Bring includes in linux/kmod.h up to date

by Petr Pavlu

The usermode helper declarations were previously provided by linux/kmod.h but commit c1f3fa2a4fde ("kmod: split off umh headers into its own file") moved them to linux/umh.h in 2017. Add explicit includes of linux/umh.h to files that use usermode helpers and remove linux/kmod.h where it is no longer needed. Also add a missing include of linux/sysctl.h to kernel/time/jiffies.c. Finally, clean up linux/kmod.h so that it includes only the headers that it actually requires, importantly removing the compat linux/umh.h include. This cleanup is motivated by trying to reduce the preprocessed size of linux/module.h, which includes linux/kmod.h. linux/module.h appears in roughly 15k #include directives across the kernel. This makes it a "hot" header, so it should avoid pulling in unnecessary definitions. Note that this series doesn't immediately improve the situation, since most of the files included by linux/kmod.h are, for now, also included by linux/module.h through other paths. Apologies for the wide distribution. Acked-bys are appreciated. --- Changes in v3: - Rebase on top of v7.3-rc2. - Clean up commit descriptions. - Link to v2: https://patch.msgid.link/20260721131207.803760-1-petr.pavlu@suse.com Changes in v2: - Remove the linux/kmod.h include from kernel/cgroup/cgroup-v1.c. - Add a missing include of linux/sysctl.h to kernel/time/jiffies.c. - Link to v1: https://patch.msgid.link/20260708154510.6794-1-petr.pavlu@suse.com --- Petr Pavlu (3): umh, treewide: Explicitly include linux/umh.h where needed time/jiffies: Include linux/sysctl.h for proc_int_u2k_conv_uop(), ... module: Bring includes in linux/kmod.h up to date arch/x86/kernel/cpu/mce/dev-mcelog.c | 2 +- drivers/block/drbd/drbd_nl.c | 1 + drivers/greybus/svc_watchdog.c | 1 + drivers/macintosh/windfarm_core.c | 1 + drivers/pnp/pnpbios/core.c | 2 +- drivers/video/fbdev/uvesafb.c | 1 + fs/coredump.c | 2 +- fs/nfs/cache_lib.c | 2 +- fs/nfsd/nfs4layouts.c | 2 +- fs/nfsd/nfs4recover.c | 1 + fs/ocfs2/stackglue.c | 1 + include/linux/kmod.h | 12 ++---------- kernel/cgroup/cgroup-v1.c | 2 +- kernel/module/kmod.c | 1 + kernel/power/process.c | 2 +- kernel/reboot.c | 2 +- kernel/time/jiffies.c | 1 + kernel/umh.c | 2 +- lib/kobject_uevent.c | 2 +- net/bridge/br_stp_if.c | 2 +- security/keys/request_key.c | 2 +- security/tomoyo/common.h | 2 +- 22 files changed, 23 insertions(+), 23 deletions(-) --- base-commit: df2908090cda368b01ff43709f51890076c56157 change-id: 20260816-module-include-kmod-14d1a0e19462

10 hours, 9 minutes

[PATCH] staging: greybus: gpio: add comment describing irq_lock mutex

by UgwuRhema

Add a description comment for irq_lock to clarify what the mutex protects and satisfy checkpatch checks. Signed-off-by: UgwuRhema <hikarialiyev(a)gmail.com> --- drivers/staging/greybus/gpio.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/staging/greybus/gpio.c b/drivers/staging/greybus/gpio.c index 12185f7a9..7f19b3275 100644 --- a/drivers/staging/greybus/gpio.c +++ b/drivers/staging/greybus/gpio.c @@ -39,7 +39,7 @@ struct gb_gpio_controller { struct gpio_chip chip; struct irq_chip irqc; - struct mutex irq_lock; + struct mutex irq_lock; /* protects IRQ configuration and hardware state */ }; static struct gpio_chip *irq_data_to_gpio_chip(struct irq_data *d) -- 2.55.0

1 day, 9 hours

[PATCH] staging: greybus: light: use sysfs_emit() instead of sprintf()

by ts930＠naver.com

From: Park Tae-sun <ts930(a)dgu.ac.kr> The sysfs documentation (Documentation/filesystems/sysfs.rst) recommends using sysfs_emit() instead of sprintf() in sysfs show() callbacks. Replace the remaining sprintf() calls in the fade_##__dir##_show() macro and color_show() callback with sysfs_emit(). This follows the standard kernel practice and existing use of sysfs_emit() in other Greybus sysfs show functions. No functional change. Signed-off-by: Park Tae-sun <ts930(a)dgu.ac.kr> --- drivers/staging/greybus/light.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/drivers/staging/greybus/light.c b/drivers/staging/greybus/light.c index cab02b5da867..2689f9a7524a 100644 --- a/drivers/staging/greybus/light.c +++ b/drivers/staging/greybus/light.c @@ -173,7 +173,7 @@ static ssize_t fade_##__dir##_show(struct device *dev, \ struct led_classdev *cdev = dev_get_drvdata(dev); \ struct gb_channel *channel = get_channel_from_cdev(cdev); \ \ - return sprintf(buf, "%u\n", channel->fade_##__dir); \ + return sysfs_emit(buf, "%u\n", channel->fade_##__dir); \ } \ \ static ssize_t fade_##__dir##_store(struct device *dev, \ @@ -220,7 +220,7 @@ static ssize_t color_show(struct device *dev, struct device_attribute *attr, struct led_classdev *cdev = dev_get_drvdata(dev); struct gb_channel *channel = get_channel_from_cdev(cdev); - return sprintf(buf, "0x%08x\n", channel->color); + return sysfs_emit(buf, "0x%08x\n", channel->color); } static ssize_t color_store(struct device *dev, struct device_attribute *attr, -- 2.43.0

1 day, 10 hours

[PATCH] staging: greybus: change mutexes to guard macros

by Omer PALA

Convert mutex_lock()/mutex_unlock() pairs to the guard() and scoped_guard() cleanup helpers where possible. This removes error-prone goto-based unlock paths and makes it harder to forget to release a mutex on an early return. Signed-off-by: Omer PALA <palaomer100(a)gmail.com> --- drivers/staging/greybus/arche-platform.c | 29 +++---- drivers/staging/greybus/audio_codec.c | 97 ++++++++++-------------- drivers/staging/greybus/audio_helper.c | 3 +- drivers/staging/greybus/audio_topology.c | 10 +-- drivers/staging/greybus/authentication.c | 34 ++++----- drivers/staging/greybus/bootrom.c | 11 ++- drivers/staging/greybus/camera.c | 60 +++++++-------- drivers/staging/greybus/fw-download.c | 31 ++++---- drivers/staging/greybus/fw-management.c | 38 ++++------ drivers/staging/greybus/light.c | 44 +++++------ drivers/staging/greybus/loopback.c | 39 +++++----- drivers/staging/greybus/power_supply.c | 42 ++++------ drivers/staging/greybus/raw.c | 25 +++--- drivers/staging/greybus/sdio.c | 25 +++--- drivers/staging/greybus/uart.c | 30 +++----- 15 files changed, 216 insertions(+), 302 deletions(-) diff --git a/drivers/staging/greybus/arche-platform.c b/drivers/staging/greybus/arche-platform.c index de5de59ea..02322fce0 100644 --- a/drivers/staging/greybus/arche-platform.c +++ b/drivers/staging/greybus/arche-platform.c @@ -310,20 +310,19 @@ static ssize_t state_store(struct device *dev, struct arche_platform_drvdata *arche_pdata = dev_get_drvdata(dev); int ret = 0; - mutex_lock(&arche_pdata->platform_state_mutex); + guard(mutex)(&arche_pdata->platform_state_mutex); if (sysfs_streq(buf, "off")) { if (arche_pdata->state == ARCHE_PLATFORM_STATE_OFF) - goto exit; + return count; /* If SVC goes down, bring down APB's as well */ device_for_each_child(arche_pdata->dev, NULL, apb_poweroff); arche_platform_poweroff_seq(arche_pdata); - } else if (sysfs_streq(buf, "active")) { if (arche_pdata->state == ARCHE_PLATFORM_STATE_ACTIVE) - goto exit; + return count; /* First we want to make sure we power off everything * and then activate back again @@ -334,16 +333,15 @@ static ssize_t state_store(struct device *dev, arche_platform_wd_irq_en(arche_pdata); ret = arche_platform_coldboot_seq(arche_pdata); if (ret) - goto exit; - + return ret; } else if (sysfs_streq(buf, "standby")) { if (arche_pdata->state == ARCHE_PLATFORM_STATE_STANDBY) - goto exit; + return count; dev_warn(arche_pdata->dev, "standby state not supported\n"); } else if (sysfs_streq(buf, "fw_flashing")) { if (arche_pdata->state == ARCHE_PLATFORM_STATE_FW_FLASHING) - goto exit; + return count; /* * Here we only control SVC. @@ -356,15 +354,11 @@ static ssize_t state_store(struct device *dev, ret = arche_platform_fw_flashing_seq(arche_pdata); if (ret) - goto exit; + return ret ? ret : count; } else { dev_err(arche_pdata->dev, "unknown state\n"); - ret = -EINVAL; + return -EINVAL; } - -exit: - mutex_unlock(&arche_pdata->platform_state_mutex); - return ret ? ret : count; } static ssize_t state_show(struct device *dev, @@ -396,7 +390,7 @@ static int arche_platform_pm_notifier(struct notifier_block *notifier, pm_notifier); int ret = NOTIFY_DONE; - mutex_lock(&arche_pdata->platform_state_mutex); + guard(mutex)(&arche_pdata->platform_state_mutex); switch (pm_event) { case PM_SUSPEND_PREPARE: if (arche_pdata->state != ARCHE_PLATFORM_STATE_ACTIVE) { @@ -416,7 +410,6 @@ static int arche_platform_pm_notifier(struct notifier_block *notifier, default: break; } - mutex_unlock(&arche_pdata->platform_state_mutex); return ret; } @@ -530,15 +523,13 @@ static int arche_platform_probe(struct platform_device *pdev) /* Explicitly power off if requested */ if (!of_property_read_bool(pdev->dev.of_node, "arche,init-off")) { - mutex_lock(&arche_pdata->platform_state_mutex); + guard(mutex)(&arche_pdata->platform_state_mutex); ret = arche_platform_coldboot_seq(arche_pdata); if (ret) { - mutex_unlock(&arche_pdata->platform_state_mutex); dev_err(dev, "Failed to cold boot svc %d\n", ret); goto err_unregister_pm_notifier; } arche_platform_wd_irq_en(arche_pdata); - mutex_unlock(&arche_pdata->platform_state_mutex); } dev_info(dev, "Device registered successfully\n"); diff --git a/drivers/staging/greybus/audio_codec.c b/drivers/staging/greybus/audio_codec.c index 6daa4e706..92d3cd4ae 100644 --- a/drivers/staging/greybus/audio_codec.c +++ b/drivers/staging/greybus/audio_codec.c @@ -316,7 +316,7 @@ int gbaudio_module_update(struct gbaudio_codec_info *codec, return -EINVAL; } - mutex_lock(&codec->lock); + guard(mutex)(&codec->lock); if (w->id == snd_soc_dapm_aif_in) { if (enable) ret = gbaudio_module_enable_tx(codec, module, dai_id); @@ -329,8 +329,6 @@ int gbaudio_module_update(struct gbaudio_codec_info *codec, ret = gbaudio_module_disable_rx(module, dai_id); } - mutex_unlock(&codec->lock); - return ret; } EXPORT_SYMBOL(gbaudio_module_update); @@ -344,22 +342,19 @@ static int gbcodec_startup(struct snd_pcm_substream *substream, struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev); struct gbaudio_stream_params *params; - mutex_lock(&codec->lock); - - if (list_empty(&codec->module_list)) { - dev_err(codec->dev, "No codec module available\n"); - mutex_unlock(&codec->lock); - return -ENODEV; - } + scoped_guard(mutex, &codec->lock) { + if (list_empty(&codec->module_list)) { + dev_err(codec->dev, "No codec module available\n"); + return -ENODEV; + } - params = find_dai_stream_params(codec, dai->id, substream->stream); - if (!params) { - dev_err(codec->dev, "Failed to fetch dai_stream pointer\n"); - mutex_unlock(&codec->lock); - return -EINVAL; + params = find_dai_stream_params(codec, dai->id, substream->stream); + if (!params) { + dev_err(codec->dev, "Failed to fetch dai_stream pointer\n"); + return -EINVAL; + } + params->state = GBAUDIO_CODEC_STARTUP; } - params->state = GBAUDIO_CODEC_STARTUP; - mutex_unlock(&codec->lock); /* to prevent suspend in case of active audio */ pm_stay_awake(dai->dev); @@ -372,19 +367,19 @@ static void gbcodec_shutdown(struct snd_pcm_substream *substream, struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev); struct gbaudio_stream_params *params; - mutex_lock(&codec->lock); - if (list_empty(&codec->module_list)) - dev_info(codec->dev, "No codec module available during shutdown\n"); + scoped_guard(mutex, &codec->lock) { + if (list_empty(&codec->module_list)) + dev_info(codec->dev, "No codec module available during shutdown\n"); - params = find_dai_stream_params(codec, dai->id, substream->stream); - if (!params) { - dev_err(codec->dev, "Failed to fetch dai_stream pointer\n"); - mutex_unlock(&codec->lock); - return; + params = find_dai_stream_params(codec, dai->id, substream->stream); + if (!params) { + dev_err(codec->dev, "Failed to fetch dai_stream pointer\n"); + return; + } + params->state = GBAUDIO_CODEC_SHUTDOWN; } - params->state = GBAUDIO_CODEC_SHUTDOWN; - mutex_unlock(&codec->lock); + pm_relax(dai->dev); } @@ -401,11 +396,10 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream, struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev); struct gbaudio_stream_params *params; - mutex_lock(&codec->lock); + guard(mutex)(&codec->lock); if (list_empty(&codec->module_list)) { dev_err(codec->dev, "No codec module available\n"); - mutex_unlock(&codec->lock); return -ENODEV; } @@ -416,7 +410,6 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream, if (params_channels(hwparams) != 2) { dev_err(dai->dev, "Invalid channel count:%d\n", params_channels(hwparams)); - mutex_unlock(&codec->lock); return -EINVAL; } channels = params_channels(hwparams); @@ -424,14 +417,12 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream, if (params_rate(hwparams) != 48000) { dev_err(dai->dev, "Invalid sampling rate:%d\n", params_rate(hwparams)); - mutex_unlock(&codec->lock); return -EINVAL; } rate = GB_AUDIO_PCM_RATE_48000; if (params_format(hwparams) != SNDRV_PCM_FORMAT_S16_LE) { dev_err(dai->dev, "Invalid format:%d\n", params_format(hwparams)); - mutex_unlock(&codec->lock); return -EINVAL; } format = GB_AUDIO_PCM_FMT_S16_LE; @@ -445,21 +436,18 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream, if (!data) { dev_err(dai->dev, "DATA connection missing\n"); - mutex_unlock(&codec->lock); return -EINVAL; } params = find_dai_stream_params(codec, dai->id, substream->stream); if (!params) { dev_err(codec->dev, "Failed to fetch dai_stream pointer\n"); - mutex_unlock(&codec->lock); return -EINVAL; } bundle = to_gb_bundle(module->dev); ret = gb_pm_runtime_get_sync(bundle); if (ret) { - mutex_unlock(&codec->lock); return ret; } @@ -471,7 +459,6 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream, dev_err_ratelimited(dai->dev, "%d: Error during set_config\n", ret); gb_pm_runtime_put_noidle(bundle); - mutex_unlock(&codec->lock); return ret; } @@ -488,13 +475,17 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream, params->channels = channels; params->sig_bits = sig_bits; - mutex_unlock(&codec->lock); return 0; } static int gbcodec_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { + /* + * Keep explicit mutex_lock/unlock here instead of guard(mutex) + * to release the lock before calling dev_err_ratelimited() and PM calls. + */ + int ret; struct gbaudio_module_info *module = NULL, *iter; struct gbaudio_data_connection *data; @@ -572,12 +563,11 @@ static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream) dev_dbg(dai->dev, "Mute:%d, Direction:%s\n", mute, stream ? "CAPTURE" : "PLAYBACK"); - mutex_lock(&codec->lock); + guard(mutex)(&codec->lock); params = find_dai_stream_params(codec, dai->id, stream); if (!params) { dev_err(codec->dev, "Failed to fetch dai_stream pointer\n"); - mutex_unlock(&codec->lock); return -EINVAL; } @@ -589,7 +579,6 @@ static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream) } else { ret = -ENODEV; } - mutex_unlock(&codec->lock); return ret; } @@ -604,14 +593,12 @@ static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream) if (!data) { dev_err(dai->dev, "%s DATA connection missing\n", dai->name); - mutex_unlock(&codec->lock); return -ENODEV; } bundle = to_gb_bundle(module->dev); ret = gb_pm_runtime_get_sync(bundle); if (ret) { - mutex_unlock(&codec->lock); return ret; } @@ -646,7 +633,6 @@ static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream) stream ? "Capture" : "Playback", ret); gb_pm_runtime_put_noidle(bundle); - mutex_unlock(&codec->lock); return ret; } @@ -817,19 +803,17 @@ int gbaudio_register_module(struct gbaudio_module_info *module) comp = gbcodec->component; dapm = snd_soc_component_to_dapm(comp); - mutex_lock(&gbcodec->register_mutex); + guard(mutex)(&gbcodec->register_mutex); if (module->num_dais) { dev_err(gbcodec->dev, "%d:DAIs not supported via gbcodec driver\n", module->num_dais); - mutex_unlock(&gbcodec->register_mutex); return -EINVAL; } ret = gbaudio_init_jack(module, comp->card); if (ret) { - mutex_unlock(&gbcodec->register_mutex); return ret; } @@ -858,15 +842,14 @@ int gbaudio_register_module(struct gbaudio_module_info *module) #endif } - mutex_lock(&gbcodec->lock); - list_add(&module->list, &gbcodec->module_list); - mutex_unlock(&gbcodec->lock); + scoped_guard(mutex, &gbcodec->lock) { + list_add(&module->list, &gbcodec->module_list); + } if (comp->card->instantiated) ret = snd_soc_dapm_new_widgets(comp->card); dev_dbg(comp->dev, "Registered %s module\n", module->name); - mutex_unlock(&gbcodec->register_mutex); return ret; } EXPORT_SYMBOL(gbaudio_register_module); @@ -939,12 +922,12 @@ void gbaudio_unregister_module(struct gbaudio_module_info *module) dev_dbg(comp->dev, "Unregister %s module\n", module->name); - mutex_lock(&gbcodec->register_mutex); - mutex_lock(&gbcodec->lock); - gbaudio_codec_cleanup(module); - list_del(&module->list); - dev_dbg(comp->dev, "Process Unregister %s module\n", module->name); - mutex_unlock(&gbcodec->lock); + guard(mutex)(&gbcodec->register_mutex); + scoped_guard(mutex, &gbcodec->lock) { + gbaudio_codec_cleanup(module); + list_del(&module->list); + dev_dbg(comp->dev, "Process Unregister %s module\n", module->name); + } #ifdef CONFIG_SND_JACK /* free jack devices for this module jack_list */ @@ -991,8 +974,6 @@ void gbaudio_unregister_module(struct gbaudio_module_info *module) } dev_dbg(comp->dev, "Unregistered %s module\n", module->name); - - mutex_unlock(&gbcodec->register_mutex); } EXPORT_SYMBOL(gbaudio_unregister_module); diff --git a/drivers/staging/greybus/audio_helper.c b/drivers/staging/greybus/audio_helper.c index b4873c6d6..eeb2ca7a5 100644 --- a/drivers/staging/greybus/audio_helper.c +++ b/drivers/staging/greybus/audio_helper.c @@ -117,7 +117,7 @@ int gbaudio_dapm_free_controls(struct snd_soc_dapm_context *dapm, struct snd_soc_dapm_widget *w, *tmp_w; struct snd_soc_card *card = snd_soc_dapm_to_card(dapm); - mutex_lock(&card->dapm_mutex); + guard(mutex)(&card->dapm_mutex); for (i = 0; i < num; i++) { /* below logic can be optimized to identify widget pointer */ w = NULL; @@ -137,7 +137,6 @@ int gbaudio_dapm_free_controls(struct snd_soc_dapm_context *dapm, widget++; gbaudio_dapm_free_widget(w); } - mutex_unlock(&card->dapm_mutex); return 0; } diff --git a/drivers/staging/greybus/audio_topology.c b/drivers/staging/greybus/audio_topology.c index 76146f91c..295625a48 100644 --- a/drivers/staging/greybus/audio_topology.c +++ b/drivers/staging/greybus/audio_topology.c @@ -33,14 +33,12 @@ static struct gbaudio_module_info *find_gb_module(struct gbaudio_codec_info *cod dev_dbg(codec->dev, "%s:Find module#%d\n", __func__, dev_id); - mutex_lock(&codec->lock); - list_for_each_entry(module, &codec->module_list, list) { - if (module->dev_id == dev_id) { - mutex_unlock(&codec->lock); - return module; + scoped_guard(mutex, &codec->lock) { + list_for_each_entry(module, &codec->module_list, list) { + if (module->dev_id == dev_id) + return module; } } - mutex_unlock(&codec->lock); dev_warn(codec->dev, "%s: module#%d missing in codec list\n", name, dev_id); return NULL; diff --git a/drivers/staging/greybus/authentication.c b/drivers/staging/greybus/authentication.c index d8f2cd432..5c0bfc9b0 100644 --- a/drivers/staging/greybus/authentication.c +++ b/drivers/staging/greybus/authentication.c @@ -65,20 +65,17 @@ static struct gb_cap *get_cap(struct cdev *cdev) { struct gb_cap *cap; - mutex_lock(&list_mutex); + guard(mutex)(&list_mutex); list_for_each_entry(cap, &cap_list, node) { if (&cap->cdev == cdev) { kref_get(&cap->kref); - goto unlock; + return cap; } } cap = NULL; -unlock: - mutex_unlock(&list_mutex); - return cap; } @@ -276,7 +273,7 @@ static long cap_ioctl_unlocked(struct file *file, unsigned int cmd, * the connection is getting disconnected, so that we don't start any * new operations. */ - mutex_lock(&cap->mutex); + guard(mutex)(&cap->mutex); if (!cap->disabled) { ret = gb_pm_runtime_get_sync(bundle); if (!ret) { @@ -284,7 +281,6 @@ static long cap_ioctl_unlocked(struct file *file, unsigned int cmd, gb_pm_runtime_put_autosuspend(bundle); } } - mutex_unlock(&cap->mutex); return ret; } @@ -314,9 +310,9 @@ int gb_cap_connection_init(struct gb_connection *connection) gb_connection_set_data(connection, cap); kref_init(&cap->kref); - mutex_lock(&list_mutex); - list_add(&cap->node, &cap_list); - mutex_unlock(&list_mutex); + scoped_guard(mutex, &list_mutex) { + list_add(&cap->node, &cap_list); + } ret = gb_connection_enable(connection); if (ret) @@ -353,9 +349,9 @@ int gb_cap_connection_init(struct gb_connection *connection) err_connection_disable: gb_connection_disable(connection); err_list_del: - mutex_lock(&list_mutex); - list_del(&cap->node); - mutex_unlock(&list_mutex); + scoped_guard(mutex, &list_mutex) { + list_del(&cap->node); + } put_cap(cap); @@ -379,17 +375,17 @@ void gb_cap_connection_exit(struct gb_connection *connection) * Disallow any new ioctl operations on the char device and wait for * existing ones to finish. */ - mutex_lock(&cap->mutex); - cap->disabled = true; - mutex_unlock(&cap->mutex); + scoped_guard(mutex, &cap->mutex) { + cap->disabled = true; + } /* All pending greybus operations should have finished by now */ gb_connection_disable(cap->connection); /* Disallow new users to get access to the cap structure */ - mutex_lock(&list_mutex); - list_del(&cap->node); - mutex_unlock(&list_mutex); + scoped_guard(mutex, &list_mutex) { + list_del(&cap->node); + } /* * All current users of cap would have taken a reference to it by diff --git a/drivers/staging/greybus/bootrom.c b/drivers/staging/greybus/bootrom.c index 83921d90c..923456d6c 100644 --- a/drivers/staging/greybus/bootrom.c +++ b/drivers/staging/greybus/bootrom.c @@ -78,9 +78,9 @@ static void gb_bootrom_timedout(struct work_struct *work) dev_err(dev, "Timed out waiting for %s from the Module\n", reason); - mutex_lock(&bootrom->mutex); - free_firmware(bootrom); - mutex_unlock(&bootrom->mutex); + scoped_guard(mutex, &bootrom->mutex) { + free_firmware(bootrom); + } /* TODO: Power-off Module ? */ } @@ -240,6 +240,11 @@ static int gb_bootrom_firmware_size_request(struct gb_operation *op) static int gb_bootrom_get_firmware(struct gb_operation *op) { + /* + * Keep explicit mutex_lock/unlock here instead of guard(mutex) + * to release the lock before queue_work. + */ + struct gb_bootrom *bootrom = gb_connection_get_data(op->connection); const struct firmware *fw; struct gb_bootrom_get_firmware_request *firmware_request; diff --git a/drivers/staging/greybus/camera.c b/drivers/staging/greybus/camera.c index 62b55bb28..2edb02a75 100644 --- a/drivers/staging/greybus/camera.c +++ b/drivers/staging/greybus/camera.c @@ -490,24 +490,21 @@ static int gb_camera_capabilities(struct gb_camera *gcam, if (ret) return ret; - mutex_lock(&gcam->mutex); + scoped_guard(mutex, &gcam->mutex) { + if (!gcam->connection) { + ret = -EINVAL; + goto done; + } - if (!gcam->connection) { - ret = -EINVAL; - goto done; + ret = gb_camera_operation_sync_flags(gcam->connection, + GB_CAMERA_TYPE_CAPABILITIES, + GB_OPERATION_FLAG_SHORT_RESPONSE, + NULL, 0, + (void *)capabilities, size); + if (ret) + dev_err(&gcam->bundle->dev, "failed to retrieve capabilities: %d\n", ret); } - - ret = gb_camera_operation_sync_flags(gcam->connection, - GB_CAMERA_TYPE_CAPABILITIES, - GB_OPERATION_FLAG_SHORT_RESPONSE, - NULL, 0, - (void *)capabilities, size); - if (ret) - dev_err(&gcam->bundle->dev, "failed to retrieve capabilities: %d\n", ret); - done: - mutex_unlock(&gcam->mutex); - gb_pm_runtime_put_autosuspend(gcam->bundle); return ret; @@ -519,6 +516,11 @@ static int gb_camera_configure_streams(struct gb_camera *gcam, struct gb_camera_stream_config *streams, struct gb_camera_csi_params *csi_params) { + /* + * Keep explicit mutex_lock/unlock here instead of guard(mutex) + * to release the lock before freeing req and resp. + */ + struct gb_camera_configure_streams_request *req; struct gb_camera_configure_streams_response *resp; unsigned int nstreams = *num_streams; @@ -668,18 +670,17 @@ static int gb_camera_capture(struct gb_camera *gcam, u32 request_id, req->num_frames = cpu_to_le16(num_frames); memcpy(req->settings, settings, settings_size); - mutex_lock(&gcam->mutex); + scoped_guard(mutex, &gcam->mutex) { + if (!gcam->connection) { + ret = -EINVAL; + goto done; + } - if (!gcam->connection) { - ret = -EINVAL; - goto done; + ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_CAPTURE, + req, req_size, NULL, 0); } - ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_CAPTURE, - req, req_size, NULL, 0); done: - mutex_unlock(&gcam->mutex); - kfree(req); return ret; @@ -690,25 +691,21 @@ static int gb_camera_flush(struct gb_camera *gcam, u32 *request_id) struct gb_camera_flush_response resp; int ret; - mutex_lock(&gcam->mutex); + guard(mutex)(&gcam->mutex); if (!gcam->connection) { - ret = -EINVAL; - goto done; + return -EINVAL; } ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_FLUSH, NULL, 0, &resp, sizeof(resp)); if (ret < 0) - goto done; + return ret; if (request_id) *request_id = le32_to_cpu(resp.request_id); -done: - mutex_unlock(&gcam->mutex); - return ret; } @@ -1187,7 +1184,7 @@ static void gb_camera_cleanup(struct gb_camera *gcam) { gb_camera_debugfs_cleanup(gcam); - mutex_lock(&gcam->mutex); + guard(mutex)(&gcam->mutex); if (gcam->data_connection) { gb_connection_disable(gcam->data_connection); gb_connection_destroy(gcam->data_connection); @@ -1199,7 +1196,6 @@ static void gb_camera_cleanup(struct gb_camera *gcam) gb_connection_destroy(gcam->connection); gcam->connection = NULL; } - mutex_unlock(&gcam->mutex); } static void gb_camera_release_module(struct kref *ref) diff --git a/drivers/staging/greybus/fw-download.c b/drivers/staging/greybus/fw-download.c index a0a683447..a4e2e2361 100644 --- a/drivers/staging/greybus/fw-download.c +++ b/drivers/staging/greybus/fw-download.c @@ -93,21 +93,16 @@ static struct fw_request *get_fw_req(struct fw_download *fw_download, { struct fw_request *fw_req; - mutex_lock(&fw_download->mutex); + guard(mutex)(&fw_download->mutex); list_for_each_entry(fw_req, &fw_download->fw_requests, node) { if (fw_req->firmware_id == firmware_id) { kref_get(&fw_req->kref); - goto unlock; + return fw_req; } } - fw_req = NULL; - -unlock: - mutex_unlock(&fw_download->mutex); - - return fw_req; + return NULL; } static void free_firmware(struct fw_download *fw_download, @@ -117,9 +112,9 @@ static void free_firmware(struct fw_download *fw_download, if (fw_req->disabled) return; - mutex_lock(&fw_download->mutex); - list_del(&fw_req->node); - mutex_unlock(&fw_download->mutex); + scoped_guard(mutex, &fw_download->mutex) { + list_del(&fw_req->node); + } fw_req->disabled = true; put_fw_req(fw_req); @@ -197,9 +192,9 @@ static struct fw_request *find_firmware(struct fw_download *fw_download, fw_req->fw_download = fw_download; kref_init(&fw_req->kref); - mutex_lock(&fw_download->mutex); - list_add(&fw_req->node, &fw_download->fw_requests); - mutex_unlock(&fw_download->mutex); + scoped_guard(mutex, &fw_download->mutex) { + list_add(&fw_req->node, &fw_download->fw_requests); + } /* Timeout, in jiffies, within which firmware should get loaded */ req_count = DIV_ROUND_UP(fw_req->fw->size, MIN_FETCH_SIZE); @@ -448,10 +443,10 @@ void gb_fw_download_connection_exit(struct gb_connection *connection) * Make sure we have a reference to the pending requests, before they * are freed from the timeout handler. */ - mutex_lock(&fw_download->mutex); - list_for_each_entry(fw_req, &fw_download->fw_requests, node) - kref_get(&fw_req->kref); - mutex_unlock(&fw_download->mutex); + scoped_guard(mutex, &fw_download->mutex) { + list_for_each_entry(fw_req, &fw_download->fw_requests, node) + kref_get(&fw_req->kref); + } /* Release pending firmware packages */ list_for_each_entry_safe(fw_req, tmp, &fw_download->fw_requests, node) { diff --git a/drivers/staging/greybus/fw-management.c b/drivers/staging/greybus/fw-management.c index 5d01da6b6..c48bea217 100644 --- a/drivers/staging/greybus/fw-management.c +++ b/drivers/staging/greybus/fw-management.c @@ -87,21 +87,16 @@ static struct fw_mgmt *get_fw_mgmt(struct cdev *cdev) { struct fw_mgmt *fw_mgmt; - mutex_lock(&list_mutex); + guard(mutex)(&list_mutex); list_for_each_entry(fw_mgmt, &fw_mgmt_list, node) { if (&fw_mgmt->cdev == cdev) { kref_get(&fw_mgmt->kref); - goto unlock; + return fw_mgmt; } } - fw_mgmt = NULL; - -unlock: - mutex_unlock(&list_mutex); - - return fw_mgmt; + return NULL; } static int fw_mgmt_interface_fw_version_operation(struct fw_mgmt *fw_mgmt, @@ -533,7 +528,7 @@ static long fw_mgmt_ioctl_unlocked(struct file *file, unsigned int cmd, * the connection is getting disconnected, so that we don't start any * new operations. */ - mutex_lock(&fw_mgmt->mutex); + guard(mutex)(&fw_mgmt->mutex); if (!fw_mgmt->disabled) { ret = gb_pm_runtime_get_sync(bundle); if (!ret) { @@ -541,7 +536,6 @@ static long fw_mgmt_ioctl_unlocked(struct file *file, unsigned int cmd, gb_pm_runtime_put_autosuspend(bundle); } } - mutex_unlock(&fw_mgmt->mutex); return ret; } @@ -591,9 +585,9 @@ int gb_fw_mgmt_connection_init(struct gb_connection *connection) mutex_init(&fw_mgmt->mutex); kref_init(&fw_mgmt->kref); - mutex_lock(&list_mutex); - list_add(&fw_mgmt->node, &fw_mgmt_list); - mutex_unlock(&list_mutex); + scoped_guard(mutex, &list_mutex) { + list_add(&fw_mgmt->node, &fw_mgmt_list); + } ret = gb_connection_enable(connection); if (ret) @@ -631,9 +625,9 @@ int gb_fw_mgmt_connection_init(struct gb_connection *connection) err_connection_disable: gb_connection_disable(connection); err_list_del: - mutex_lock(&list_mutex); - list_del(&fw_mgmt->node); - mutex_unlock(&list_mutex); + scoped_guard(mutex, &list_mutex) { + list_del(&fw_mgmt->node); + } put_fw_mgmt(fw_mgmt); @@ -657,17 +651,17 @@ void gb_fw_mgmt_connection_exit(struct gb_connection *connection) * Disallow any new ioctl operations on the char device and wait for * existing ones to finish. */ - mutex_lock(&fw_mgmt->mutex); - fw_mgmt->disabled = true; - mutex_unlock(&fw_mgmt->mutex); + scoped_guard(mutex, &fw_mgmt->mutex) { + fw_mgmt->disabled = true; + } /* All pending greybus operations should have finished by now */ gb_connection_disable(fw_mgmt->connection); /* Disallow new users to get access to the fw_mgmt structure */ - mutex_lock(&list_mutex); - list_del(&fw_mgmt->node); - mutex_unlock(&list_mutex); + scoped_guard(mutex, &list_mutex) { + list_del(&fw_mgmt->node); + } /* * All current users of fw_mgmt would have taken a reference to it by diff --git a/drivers/staging/greybus/light.c b/drivers/staging/greybus/light.c index cab02b5da..83df32aa2 100644 --- a/drivers/staging/greybus/light.c +++ b/drivers/staging/greybus/light.c @@ -354,10 +354,10 @@ static int __gb_lights_led_brightness_set(struct gb_channel *channel) bool old_active; int ret; - mutex_lock(&channel->lock); + guard(mutex)(&channel->lock); ret = gb_pm_runtime_get_sync(bundle); if (ret < 0) - goto out_unlock; + return ret; old_active = channel->active; @@ -377,7 +377,7 @@ static int __gb_lights_led_brightness_set(struct gb_channel *channel) /* we need to keep module alive when turning to active state */ if (!old_active && channel->active) - goto out_unlock; + return ret; /* * on the other hand if going to inactive we still hold a reference and @@ -388,8 +388,6 @@ static int __gb_lights_led_brightness_set(struct gb_channel *channel) out_pm_put: gb_pm_runtime_put_autosuspend(bundle); -out_unlock: - mutex_unlock(&channel->lock); return ret; } @@ -443,10 +441,10 @@ static int gb_blink_set(struct led_classdev *cdev, unsigned long *delay_on, if (!delay_on || !delay_off) return -EINVAL; - mutex_lock(&channel->lock); + guard(mutex)(&channel->lock); ret = gb_pm_runtime_get_sync(bundle); if (ret < 0) - goto out_unlock; + return ret; old_active = channel->active; @@ -467,7 +465,7 @@ static int gb_blink_set(struct led_classdev *cdev, unsigned long *delay_on, /* we need to keep module alive when turning to active state */ if (!old_active && channel->active) - goto out_unlock; + return ret; /* * on the other hand if going to inactive we still hold a reference and @@ -478,8 +476,6 @@ static int gb_blink_set(struct led_classdev *cdev, unsigned long *delay_on, out_pm_put: gb_pm_runtime_put_autosuspend(bundle); -out_unlock: - mutex_unlock(&channel->lock); return ret; } @@ -1146,15 +1142,14 @@ static int gb_lights_create_all(struct gb_lights *glights) int ret; int i; - mutex_lock(&glights->lights_lock); + guard(mutex)(&glights->lights_lock); ret = gb_lights_get_count(glights); if (ret < 0) - goto out; + return ret; glights->lights = kzalloc_objs(struct gb_light, glights->lights_count); if (!glights->lights) { - ret = -ENOMEM; - goto out; + return -ENOMEM; } for (i = 0; i < glights->lights_count; i++) { @@ -1162,12 +1157,10 @@ static int gb_lights_create_all(struct gb_lights *glights) if (ret < 0) { dev_err(&connection->bundle->dev, "Fail to configure lights device\n"); - goto out; + return ret; } } -out: - mutex_unlock(&glights->lights_lock); return ret; } @@ -1177,7 +1170,7 @@ static int gb_lights_register_all(struct gb_lights *glights) int ret = 0; int i; - mutex_lock(&glights->lights_lock); + guard(mutex)(&glights->lights_lock); for (i = 0; i < glights->lights_count; i++) { ret = gb_lights_light_register(&glights->lights[i]); if (ret < 0) { @@ -1187,7 +1180,6 @@ static int gb_lights_register_all(struct gb_lights *glights) } } - mutex_unlock(&glights->lights_lock); return ret; } @@ -1231,14 +1223,14 @@ static int gb_lights_request_handler(struct gb_operation *op) if (event & GB_LIGHTS_LIGHT_CONFIG) { light = &glights->lights[light_id]; - mutex_lock(&glights->lights_lock); - gb_lights_light_release(light); - ret = gb_lights_light_config(glights, light_id); - if (!ret) - ret = gb_lights_light_register(light); - if (ret < 0) + scoped_guard(mutex, &glights->lights_lock) { gb_lights_light_release(light); - mutex_unlock(&glights->lights_lock); + ret = gb_lights_light_config(glights, light_id); + if (!ret) + ret = gb_lights_light_register(light); + if (ret < 0) + gb_lights_light_release(light); + } } return ret; diff --git a/drivers/staging/greybus/loopback.c b/drivers/staging/greybus/loopback.c index 2a623fc2e..2ca6d5c5f 100644 --- a/drivers/staging/greybus/loopback.c +++ b/drivers/staging/greybus/loopback.c @@ -406,24 +406,22 @@ static void gb_loopback_async_operation_callback(struct gb_operation *operation) op_async = gb_operation_get_data(operation); gb = op_async->gb; - mutex_lock(&gb->mutex); + scoped_guard(mutex, &gb->mutex) { + if (!result && op_async->completion) + result = op_async->completion(op_async); - if (!result && op_async->completion) - result = op_async->completion(op_async); + if (!result) { + gb->elapsed_nsecs = gb_loopback_calc_latency(op_async->ts, te); + } else { + gb->error++; + if (result == -ETIMEDOUT) + gb->requests_timedout++; + } - if (!result) { - gb->elapsed_nsecs = gb_loopback_calc_latency(op_async->ts, te); - } else { - gb->error++; - if (result == -ETIMEDOUT) - gb->requests_timedout++; + gb->iteration_count++; + gb_loopback_calculate_stats(gb, result); } - gb->iteration_count++; - gb_loopback_calculate_stats(gb, result); - - mutex_unlock(&gb->mutex); - dev_dbg(&gb->connection->bundle->dev, "complete operation %d\n", operation->id); @@ -848,7 +846,7 @@ static int gb_loopback_fn(void *data) gb_loopback_async_wait_all(gb); /* Mark complete unless user-space has poked us */ - mutex_lock(&gb->mutex); + guard(mutex)(&gb->mutex); if (gb->iteration_count == gb->iteration_max) { gb->type = 0; gb->send_count = 0; @@ -859,7 +857,6 @@ static int gb_loopback_fn(void *data) dev_dbg(&bundle->dev, "continuing on with new test set\n"); } - mutex_unlock(&gb->mutex); continue; } size = gb->size; @@ -919,18 +916,16 @@ static int gb_loopback_dbgfs_latency_show_common(struct seq_file *s, int retval; if (kfifo_len(kfifo) == 0) { - retval = -EAGAIN; - goto done; + return -EAGAIN; } - mutex_lock(mutex); + guard(mutex)(mutex); retval = kfifo_out(kfifo, &latency, sizeof(latency)); if (retval > 0) { seq_printf(s, "%u", latency); - retval = 0; + return 0; } - mutex_unlock(mutex); -done: + return retval; } diff --git a/drivers/staging/greybus/power_supply.c b/drivers/staging/greybus/power_supply.c index 44bd8a72f..5df14315f 100644 --- a/drivers/staging/greybus/power_supply.c +++ b/drivers/staging/greybus/power_supply.c @@ -365,7 +365,7 @@ static void gb_power_supply_state_change(struct gb_power_supply *gbpsy, * Check gbpsy->pm_acquired to make sure only one pair of 'get_sync' * and 'put_autosuspend' runtime pm call for state property change. */ - mutex_lock(&gbpsy->supply_lock); + guard(mutex)(&gbpsy->supply_lock); if ((prop->val == GB_POWER_SUPPLY_STATUS_CHARGING) && !gbpsy->pm_acquired) { @@ -385,8 +385,6 @@ static void gb_power_supply_state_change(struct gb_power_supply *gbpsy, gbpsy->pm_acquired = false; } } - - mutex_unlock(&gbpsy->supply_lock); } static void check_changed(struct gb_power_supply *gbpsy, @@ -861,11 +859,11 @@ static void _gb_power_supplies_release(struct gb_power_supplies *supplies) if (!supplies->supply) return; - mutex_lock(&supplies->supplies_lock); - for (i = 0; i < supplies->supplies_count; i++) - _gb_power_supply_release(&supplies->supply[i]); - kfree(supplies->supply); - mutex_unlock(&supplies->supplies_lock); + scoped_guard(mutex, &supplies->supplies_lock) { + for (i = 0; i < supplies->supplies_count; i++) + _gb_power_supply_release(&supplies->supply[i]); + kfree(supplies->supply); + } kfree(supplies); } @@ -935,18 +933,17 @@ static int gb_power_supplies_setup(struct gb_power_supplies *supplies) int ret; int i; - mutex_lock(&supplies->supplies_lock); + guard(mutex)(&supplies->supplies_lock); ret = gb_power_supplies_get_count(supplies); if (ret < 0) - goto out; + return ret; supplies->supply = kzalloc_objs(struct gb_power_supply, supplies->supplies_count); if (!supplies->supply) { - ret = -ENOMEM; - goto out; + return -ENOMEM; } for (i = 0; i < supplies->supplies_count; i++) { @@ -954,11 +951,10 @@ static int gb_power_supplies_setup(struct gb_power_supplies *supplies) if (ret < 0) { dev_err(&connection->bundle->dev, "Fail to configure supplies devices\n"); - goto out; + return ret; } } -out: - mutex_unlock(&supplies->supplies_lock); + return ret; } @@ -968,7 +964,7 @@ static int gb_power_supplies_register(struct gb_power_supplies *supplies) int ret = 0; int i; - mutex_lock(&supplies->supplies_lock); + guard(mutex)(&supplies->supplies_lock); for (i = 0; i < supplies->supplies_count; i++) { ret = gb_power_supply_enable(&supplies->supply[i]); @@ -979,7 +975,6 @@ static int gb_power_supplies_register(struct gb_power_supplies *supplies) } } - mutex_unlock(&supplies->supplies_lock); return ret; } @@ -992,7 +987,6 @@ static int gb_supplies_request_handler(struct gb_operation *op) struct gb_power_supply_event_request *payload; u8 psy_id; u8 event; - int ret = 0; if (op->type != GB_POWER_SUPPLY_TYPE_EVENT) { dev_err(&connection->bundle->dev, @@ -1011,14 +1005,13 @@ static int gb_supplies_request_handler(struct gb_operation *op) payload = request->payload; psy_id = payload->psy_id; - mutex_lock(&supplies->supplies_lock); + guard(mutex)(&supplies->supplies_lock); if (psy_id >= supplies->supplies_count || !supplies->supply[psy_id].registered) { dev_err(&connection->bundle->dev, "Event received for unconfigured power_supply id: %d\n", psy_id); - ret = -EINVAL; - goto out_unlock; + return -EINVAL; } event = payload->event; @@ -1028,8 +1021,7 @@ static int gb_supplies_request_handler(struct gb_operation *op) */ gbpsy = &supplies->supply[psy_id]; if (!gbpsy->update_interval) { - ret = -ESHUTDOWN; - goto out_unlock; + return -ESHUTDOWN; } if (event & GB_POWER_SUPPLY_UPDATE) { @@ -1042,9 +1034,7 @@ static int gb_supplies_request_handler(struct gb_operation *op) gb_power_supply_status_update(gbpsy); } -out_unlock: - mutex_unlock(&supplies->supplies_lock); - return ret; + return 0; } static int gb_power_supply_probe(struct gb_bundle *bundle, diff --git a/drivers/staging/greybus/raw.c b/drivers/staging/greybus/raw.c index 4f1b3f4db..b280b5b75 100644 --- a/drivers/staging/greybus/raw.c +++ b/drivers/staging/greybus/raw.c @@ -246,12 +246,12 @@ static void gb_raw_disconnect(struct gb_bundle *bundle) gb_connection_disable(connection); gb_connection_destroy(connection); - mutex_lock(&raw->list_lock); - list_for_each_entry_safe(raw_data, temp, &raw->list, entry) { - list_del(&raw_data->entry); - kfree(raw_data); + scoped_guard(mutex, &raw->list_lock) { + list_for_each_entry_safe(raw_data, temp, &raw->list, entry) { + list_del(&raw_data->entry); + kfree(raw_data); + } } - mutex_unlock(&raw->list_lock); put_device(&raw->dev); } @@ -310,19 +310,16 @@ static ssize_t raw_read(struct file *file, char __user *buf, size_t count, int retval = 0; struct raw_data *raw_data; - mutex_lock(&raw->list_lock); + guard(mutex)(&raw->list_lock); if (list_empty(&raw->list)) - goto exit; + return 0; raw_data = list_first_entry(&raw->list, struct raw_data, entry); - if (raw_data->len > count) { - retval = -ENOSPC; - goto exit; - } + if (raw_data->len > count) + return -ENOSPC; if (copy_to_user(buf, &raw_data->data[0], raw_data->len)) { - retval = -EFAULT; - goto exit; + return -EFAULT; } list_del(&raw_data->entry); @@ -330,8 +327,6 @@ static ssize_t raw_read(struct file *file, char __user *buf, size_t count, retval = raw_data->len; kfree(raw_data); -exit: - mutex_unlock(&raw->list_lock); return retval; } diff --git a/drivers/staging/greybus/sdio.c b/drivers/staging/greybus/sdio.c index 3952f3d22..316aaeb15 100644 --- a/drivers/staging/greybus/sdio.c +++ b/drivers/staging/greybus/sdio.c @@ -597,7 +597,7 @@ static void gb_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) u8 drv_type; u32 vdd = 0; - mutex_lock(&host->lock); + guard(mutex)(&host->lock); request.clock = cpu_to_le32(ios->clock); if (ios->vdd) @@ -710,24 +710,19 @@ static void gb_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) ret = gb_sdio_set_ios(host, &request); if (ret < 0) - goto out; + return; memcpy(&mmc->ios, ios, sizeof(mmc->ios)); - -out: - mutex_unlock(&host->lock); } static int gb_mmc_get_ro(struct mmc_host *mmc) { struct gb_sdio_host *host = mmc_priv(mmc); - mutex_lock(&host->lock); + guard(mutex)(&host->lock); if (host->removed) { - mutex_unlock(&host->lock); return -ESHUTDOWN; } - mutex_unlock(&host->lock); return host->read_only; } @@ -736,12 +731,10 @@ static int gb_mmc_get_cd(struct mmc_host *mmc) { struct gb_sdio_host *host = mmc_priv(mmc); - mutex_lock(&host->lock); + guard(mutex)(&host->lock); if (host->removed) { - mutex_unlock(&host->lock); return -ESHUTDOWN; } - mutex_unlock(&host->lock); return host->card_present; } @@ -852,11 +845,11 @@ static void gb_sdio_remove(struct gbphy_device *gbphy_dev) if (ret) gbphy_runtime_get_noresume(gbphy_dev); - mutex_lock(&host->lock); - host->removed = true; - mmc = host->mmc; - gb_connection_set_data(connection, NULL); - mutex_unlock(&host->lock); + scoped_guard(mutex, &host->lock) { + host->removed = true; + mmc = host->mmc; + gb_connection_set_data(connection, NULL); + } destroy_workqueue(host->mrq_workqueue); gb_connection_disable_rx(connection); diff --git a/drivers/staging/greybus/uart.c b/drivers/staging/greybus/uart.c index 24b4dab06..e1aa12966 100644 --- a/drivers/staging/greybus/uart.c +++ b/drivers/staging/greybus/uart.c @@ -341,19 +341,16 @@ static struct gb_tty *get_gb_by_minor(unsigned int minor) { struct gb_tty *gb_tty; - mutex_lock(&table_lock); + guard(mutex)(&table_lock); gb_tty = idr_find(&tty_minors, minor); if (gb_tty) { - mutex_lock(&gb_tty->mutex); + guard(mutex)(&gb_tty->mutex); if (gb_tty->disconnected) { - mutex_unlock(&gb_tty->mutex); gb_tty = NULL; } else { tty_port_get(&gb_tty->port); - mutex_unlock(&gb_tty->mutex); } } - mutex_unlock(&table_lock); return gb_tty; } @@ -361,9 +358,9 @@ static int alloc_minor(struct gb_tty *gb_tty) { int minor; - mutex_lock(&table_lock); - minor = idr_alloc(&tty_minors, gb_tty, 0, GB_NUM_MINORS, GFP_KERNEL); - mutex_unlock(&table_lock); + scoped_guard(mutex, &table_lock) { + minor = idr_alloc(&tty_minors, gb_tty, 0, GB_NUM_MINORS, GFP_KERNEL); + } if (minor >= 0) gb_tty->minor = minor; return minor; @@ -374,9 +371,8 @@ static void release_minor(struct gb_tty *gb_tty) int minor = gb_tty->minor; gb_tty->minor = 0; /* Maybe should use an invalid value instead */ - mutex_lock(&table_lock); + guard(mutex)(&table_lock); idr_remove(&tty_minors, minor); - mutex_unlock(&table_lock); } static int gb_tty_install(struct tty_driver *driver, struct tty_struct *tty) @@ -596,13 +592,12 @@ static int get_serial_info(struct tty_struct *tty, struct gb_tty *gb_tty = tty->driver_data; ss->line = gb_tty->minor; - mutex_lock(&gb_tty->port.mutex); + guard(mutex)(&gb_tty->port.mutex); ss->close_delay = jiffies_to_msecs(gb_tty->port.close_delay) / 10; ss->closing_wait = gb_tty->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ? ASYNC_CLOSING_WAIT_NONE : jiffies_to_msecs(gb_tty->port.closing_wait) / 10; - mutex_unlock(&gb_tty->port.mutex); return 0; } @@ -620,7 +615,7 @@ static int set_serial_info(struct tty_struct *tty, ASYNC_CLOSING_WAIT_NONE : msecs_to_jiffies(ss->closing_wait * 10); - mutex_lock(&gb_tty->port.mutex); + guard(mutex)(&gb_tty->port.mutex); if (!capable(CAP_SYS_ADMIN)) { if ((close_delay != gb_tty->port.close_delay) || (closing_wait != gb_tty->port.closing_wait)) @@ -629,7 +624,6 @@ static int set_serial_info(struct tty_struct *tty, gb_tty->port.close_delay = close_delay; gb_tty->port.closing_wait = closing_wait; } - mutex_unlock(&gb_tty->port.mutex); return retval; } @@ -926,11 +920,11 @@ static void gb_uart_remove(struct gbphy_device *gbphy_dev) if (ret) gbphy_runtime_get_noresume(gbphy_dev); - mutex_lock(&gb_tty->mutex); - gb_tty->disconnected = true; + scoped_guard(mutex, &gb_tty->mutex) { + gb_tty->disconnected = true; - wake_up_all(&gb_tty->wioctl); - mutex_unlock(&gb_tty->mutex); + wake_up_all(&gb_tty->wioctl); + } tty_port_tty_vhangup(&gb_tty->port); -- 2.55.0

2 days, 4 hours

[PATCH v2 0/3] rust: serdev: Refactor

by Markus Probst

The following has been changed: - introduce a new C serdev API to fix race conditions and simplify rust code. Should also be useful on the C side. - fix race conditions - simplify rust code Signed-off-by: Markus Probst <markus.probst(a)posteo.de> --- Changes in v2: - fix missing memory barriers in serdev apis - use `tty_buffer_restart_work` instead of `tty_flip_buffer_push` - use `tty_buffer_flush_work` instead of exclusively locking the mutex - add `#[inline]` to `PrivateData::driver_data` - remove patches for mutable references - Link to v1: https://patch.msgid.link/20260906-rust_serdev_probe_refactor-v1-0-69cdae007… --- Markus Probst (3): tty: serdev: Export functions to pause receive_buf callback calls rust: serdev: Replace `active` mutex with receive pause rust: serdev: Simplify callbacks drivers/tty/serdev/core.c | 50 ++++++++++- drivers/tty/serdev/serdev-ttyport.c | 38 ++++++++ include/linux/serdev.h | 6 ++ rust/kernel/serdev.rs | 167 ++++++++++++------------------------ 4 files changed, 147 insertions(+), 114 deletions(-) --- base-commit: c2cd463d6ee7d55a3ec0719d93c49ff99022d58f change-id: 20260905-rust_serdev_probe_refactor-0e2b044354a7

2 days, 8 hours

[PATCH] staging: greybus: gbphy: use sysfs_emit() instead of sprintf()

by ts930＠naver.com

From: Park Tae-sun <ts930(a)dgu.ac.kr> The sysfs documentation (Documentation/filesystems/sysfs.rst) recommends using sysfs_emit() instead of sprintf() in sysfs show() callbacks. Replace sprintf() with sysfs_emit() in the protocol_id_show() callback. This follows the standard kernel practice and existing use of sysfs_emit() in other Greybus sysfs show functions. No functional change. Signed-off-by: Park Tae-sun <ts930(a)dgu.ac.kr> --- drivers/staging/greybus/gbphy.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/staging/greybus/gbphy.c b/drivers/staging/greybus/gbphy.c index bdb0f5164a6f..bb9a5b538e6e 100644 --- a/drivers/staging/greybus/gbphy.c +++ b/drivers/staging/greybus/gbphy.c @@ -31,7 +31,7 @@ static ssize_t protocol_id_show(struct device *dev, { struct gbphy_device *gbphy_dev = to_gbphy_dev(dev); - return sprintf(buf, "0x%02x\n", gbphy_dev->cport_desc->protocol_id); + return sysfs_emit(buf, "0x%02x\n", gbphy_dev->cport_desc->protocol_id); } static DEVICE_ATTR_RO(protocol_id); -- 2.43.0

2 days, 9 hours

[PATCH] staging: greybus: remove camera driver marked as broken since 2016

by Ethan Nelson-Moore

The Greybus camera driver has been marked as BROKEN since commit d4f56b47a8fa ("staging: greybus: Add drivers/staging/greybus to the build"). It has not been able to compile since at least commit ec0ad868173d ("staging: greybus: move core include files to include/linux/greybus/") because it includes greybus_protocols.h from its own directory. These two facts make it very clear there is no demand for this driver. Remove it from the kernel. Signed-off-by: Ethan Nelson-Moore <enelsonmoore(a)gmail.com> --- drivers/staging/greybus/Kconfig | 10 - drivers/staging/greybus/Makefile | 2 - drivers/staging/greybus/camera.c | 1367 --------------------------- drivers/staging/greybus/gb-camera.h | 127 --- 4 files changed, 1506 deletions(-) delete mode 100644 drivers/staging/greybus/camera.c delete mode 100644 drivers/staging/greybus/gb-camera.h diff --git a/drivers/staging/greybus/Kconfig b/drivers/staging/greybus/Kconfig index c25da61570eb..e1d7ffdf4a6f 100644 --- a/drivers/staging/greybus/Kconfig +++ b/drivers/staging/greybus/Kconfig @@ -32,16 +32,6 @@ config GREYBUS_BOOTROM To compile this code as a module, chose M here: the module will be called gb-bootrom.ko -config GREYBUS_CAMERA - tristate "Greybus Camera Class driver" - depends on MEDIA_SUPPORT && LEDS_CLASS_FLASH && BROKEN - help - Select this option if you have a device that follows the - Greybus Camera Class specification. - - To compile this code as a module, chose M here: the module - will be called gb-camera.ko - config GREYBUS_FIRMWARE tristate "Greybus Firmware Download Class driver" depends on SPI diff --git a/drivers/staging/greybus/Makefile b/drivers/staging/greybus/Makefile index 7b9807f8a1a3..01a372e9833e 100644 --- a/drivers/staging/greybus/Makefile +++ b/drivers/staging/greybus/Makefile @@ -4,7 +4,6 @@ ccflags-y += -I$(src) # Greybus class drivers gb-bootrom-y := bootrom.o -gb-camera-y := camera.o gb-firmware-y := fw-core.o fw-download.o fw-management.o authentication.o gb-spilib-y := spilib.o gb-hid-y := hid.o @@ -16,7 +15,6 @@ gb-raw-y := raw.o gb-vibrator-y := vibrator.o obj-$(CONFIG_GREYBUS_BOOTROM) += gb-bootrom.o -obj-$(CONFIG_GREYBUS_CAMERA) += gb-camera.o obj-$(CONFIG_GREYBUS_FIRMWARE) += gb-firmware.o gb-spilib.o obj-$(CONFIG_GREYBUS_HID) += gb-hid.o obj-$(CONFIG_GREYBUS_LIGHT) += gb-light.o diff --git a/drivers/staging/greybus/camera.c b/drivers/staging/greybus/camera.c deleted file mode 100644 index 62b55bb28408..000000000000 --- a/drivers/staging/greybus/camera.c +++ /dev/null @@ -1,1367 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0 -/* - * Greybus Camera protocol driver. - * - * Copyright 2015 Google Inc. - * Copyright 2015 Linaro Ltd. - */ - -#include <linux/debugfs.h> -#include <linux/fs.h> -#include <linux/kernel.h> -#include <linux/module.h> -#include <linux/slab.h> -#include <linux/string.h> -#include <linux/uaccess.h> -#include <linux/vmalloc.h> -#include <linux/greybus.h> - -#include "gb-camera.h" -#include "greybus_protocols.h" - -enum gb_camera_debugs_buffer_id { - GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES, - GB_CAMERA_DEBUGFS_BUFFER_STREAMS, - GB_CAMERA_DEBUGFS_BUFFER_CAPTURE, - GB_CAMERA_DEBUGFS_BUFFER_FLUSH, - GB_CAMERA_DEBUGFS_BUFFER_MAX, -}; - -struct gb_camera_debugfs_buffer { - char data[PAGE_SIZE]; - size_t length; -}; - -enum gb_camera_state { - GB_CAMERA_STATE_UNCONFIGURED, - GB_CAMERA_STATE_CONFIGURED, -}; - -/** - * struct gb_camera - A Greybus Camera Device - * @connection: the greybus connection for camera management - * @data_connection: the greybus connection for camera data - * @data_cport_id: the data CPort ID on the module side - * @mutex: protects the connection and state fields - * @state: the current module state - * @debugfs: debugfs entries for camera protocol operations testing - * @module: Greybus camera module registered to HOST processor. - */ -struct gb_camera { - struct gb_bundle *bundle; - struct gb_connection *connection; - struct gb_connection *data_connection; - u16 data_cport_id; - - struct mutex mutex; - enum gb_camera_state state; - - struct { - struct dentry *root; - struct gb_camera_debugfs_buffer *buffers; - } debugfs; - - struct gb_camera_module module; -}; - -struct gb_camera_stream_config { - unsigned int width; - unsigned int height; - unsigned int format; - unsigned int vc; - unsigned int dt[2]; - unsigned int max_size; -}; - -struct gb_camera_fmt_info { - enum v4l2_mbus_pixelcode mbus_code; - unsigned int gb_format; - unsigned int bpp; -}; - -/* GB format to media code map */ -static const struct gb_camera_fmt_info gb_fmt_info[] = { - { - .mbus_code = V4L2_MBUS_FMT_UYVY8_1X16, - .gb_format = 0x01, - .bpp = 16, - }, - { - .mbus_code = V4L2_MBUS_FMT_NV12_1x8, - .gb_format = 0x12, - .bpp = 12, - }, - { - .mbus_code = V4L2_MBUS_FMT_NV21_1x8, - .gb_format = 0x13, - .bpp = 12, - }, - { - .mbus_code = V4L2_MBUS_FMT_YU12_1x8, - .gb_format = 0x16, - .bpp = 12, - }, - { - .mbus_code = V4L2_MBUS_FMT_YV12_1x8, - .gb_format = 0x17, - .bpp = 12, - }, - { - .mbus_code = V4L2_MBUS_FMT_JPEG_1X8, - .gb_format = 0x40, - .bpp = 0, - }, - { - .mbus_code = V4L2_MBUS_FMT_GB_CAM_METADATA_1X8, - .gb_format = 0x41, - .bpp = 0, - }, - { - .mbus_code = V4L2_MBUS_FMT_GB_CAM_DEBUG_DATA_1X8, - .gb_format = 0x42, - .bpp = 0, - }, - { - .mbus_code = V4L2_MBUS_FMT_SBGGR10_1X10, - .gb_format = 0x80, - .bpp = 10, - }, - { - .mbus_code = V4L2_MBUS_FMT_SGBRG10_1X10, - .gb_format = 0x81, - .bpp = 10, - }, - { - .mbus_code = V4L2_MBUS_FMT_SGRBG10_1X10, - .gb_format = 0x82, - .bpp = 10, - }, - { - .mbus_code = V4L2_MBUS_FMT_SRGGB10_1X10, - .gb_format = 0x83, - .bpp = 10, - }, - { - .mbus_code = V4L2_MBUS_FMT_SBGGR12_1X12, - .gb_format = 0x84, - .bpp = 12, - }, - { - .mbus_code = V4L2_MBUS_FMT_SGBRG12_1X12, - .gb_format = 0x85, - .bpp = 12, - }, - { - .mbus_code = V4L2_MBUS_FMT_SGRBG12_1X12, - .gb_format = 0x86, - .bpp = 12, - }, - { - .mbus_code = V4L2_MBUS_FMT_SRGGB12_1X12, - .gb_format = 0x87, - .bpp = 12, - }, -}; - -static const struct gb_camera_fmt_info *gb_camera_get_format_info(u16 gb_fmt) -{ - unsigned int i; - - for (i = 0; i < ARRAY_SIZE(gb_fmt_info); i++) { - if (gb_fmt_info[i].gb_format == gb_fmt) - return &gb_fmt_info[i]; - } - - return NULL; -} - -#define ES2_APB_CDSI0_CPORT 16 -#define ES2_APB_CDSI1_CPORT 17 - -#define GB_CAMERA_MAX_SETTINGS_SIZE 8192 - -static int gb_camera_operation_sync_flags(struct gb_connection *connection, - int type, unsigned int flags, - void *request, size_t request_size, - void *response, size_t *response_size) -{ - struct gb_operation *operation; - int ret; - - operation = gb_operation_create_flags(connection, type, request_size, - *response_size, flags, - GFP_KERNEL); - if (!operation) - return -ENOMEM; - - if (request_size) - memcpy(operation->request->payload, request, request_size); - - ret = gb_operation_request_send_sync(operation); - if (ret) { - dev_err(&connection->hd->dev, - "%s: synchronous operation of type 0x%02x failed: %d\n", - connection->name, type, ret); - } else { - *response_size = operation->response->payload_size; - - if (operation->response->payload_size) - memcpy(response, operation->response->payload, - operation->response->payload_size); - } - - gb_operation_put(operation); - - return ret; -} - -static int gb_camera_get_max_pkt_size(struct gb_camera *gcam, - struct gb_camera_configure_streams_response *resp) -{ - unsigned int max_pkt_size = 0; - unsigned int i; - - for (i = 0; i < resp->num_streams; i++) { - struct gb_camera_stream_config_response *cfg = &resp->config[i]; - const struct gb_camera_fmt_info *fmt_info; - unsigned int pkt_size; - - fmt_info = gb_camera_get_format_info(cfg->format); - if (!fmt_info) { - dev_err(&gcam->bundle->dev, "unsupported greybus image format: %d\n", - cfg->format); - return -EIO; - } - - if (fmt_info->bpp == 0) { - pkt_size = le32_to_cpu(cfg->max_pkt_size); - - if (pkt_size == 0) { - dev_err(&gcam->bundle->dev, - "Stream %u: invalid zero maximum packet size\n", - i); - return -EIO; - } - } else { - pkt_size = le16_to_cpu(cfg->width) * fmt_info->bpp / 8; - - if (pkt_size != le32_to_cpu(cfg->max_pkt_size)) { - dev_err(&gcam->bundle->dev, - "Stream %u: maximum packet size mismatch (%u/%u)\n", - i, pkt_size, cfg->max_pkt_size); - return -EIO; - } - } - - max_pkt_size = max(pkt_size, max_pkt_size); - } - - return max_pkt_size; -} - -/* - * Validate the stream configuration response verifying padding is correctly - * set and the returned number of streams is supported - */ -static const int gb_camera_configure_streams_validate_response(struct gb_camera *gcam, - struct gb_camera_configure_streams_response *resp, - unsigned int nstreams) -{ - unsigned int i; - - /* Validate the returned response structure */ - if (resp->padding[0] || resp->padding[1]) { - dev_err(&gcam->bundle->dev, "response padding != 0\n"); - return -EIO; - } - - if (resp->num_streams > nstreams) { - dev_err(&gcam->bundle->dev, "got #streams %u > request %u\n", - resp->num_streams, nstreams); - return -EIO; - } - - for (i = 0; i < resp->num_streams; i++) { - struct gb_camera_stream_config_response *cfg = &resp->config[i]; - - if (cfg->padding) { - dev_err(&gcam->bundle->dev, "stream #%u padding != 0\n", i); - return -EIO; - } - } - - return 0; -} - -/* ----------------------------------------------------------------------------- - * Hardware Configuration - */ - -static int gb_camera_set_intf_power_mode(struct gb_camera *gcam, u8 intf_id, - bool hs) -{ - struct gb_svc *svc = gcam->connection->hd->svc; - int ret; - - if (hs) - ret = gb_svc_intf_set_power_mode(svc, intf_id, - GB_SVC_UNIPRO_HS_SERIES_A, - GB_SVC_UNIPRO_FAST_MODE, 2, 2, - GB_SVC_SMALL_AMPLITUDE, - GB_SVC_NO_DE_EMPHASIS, - GB_SVC_UNIPRO_FAST_MODE, 2, 2, - GB_SVC_PWRM_RXTERMINATION | - GB_SVC_PWRM_TXTERMINATION, 0, - NULL, NULL); - else - ret = gb_svc_intf_set_power_mode(svc, intf_id, - GB_SVC_UNIPRO_HS_SERIES_A, - GB_SVC_UNIPRO_SLOW_AUTO_MODE, - 2, 1, - GB_SVC_SMALL_AMPLITUDE, - GB_SVC_NO_DE_EMPHASIS, - GB_SVC_UNIPRO_SLOW_AUTO_MODE, - 2, 1, - 0, 0, - NULL, NULL); - - return ret; -} - -static int gb_camera_set_power_mode(struct gb_camera *gcam, bool hs) -{ - struct gb_interface *intf = gcam->connection->intf; - struct gb_svc *svc = gcam->connection->hd->svc; - int ret; - - ret = gb_camera_set_intf_power_mode(gcam, intf->interface_id, hs); - if (ret < 0) { - dev_err(&gcam->bundle->dev, "failed to set module interface to %s (%d)\n", - hs ? "HS" : "PWM", ret); - return ret; - } - - ret = gb_camera_set_intf_power_mode(gcam, svc->ap_intf_id, hs); - if (ret < 0) { - gb_camera_set_intf_power_mode(gcam, intf->interface_id, !hs); - dev_err(&gcam->bundle->dev, "failed to set AP interface to %s (%d)\n", - hs ? "HS" : "PWM", ret); - return ret; - } - - return 0; -} - -struct ap_csi_config_request { - __u8 csi_id; - __u8 flags; -#define GB_CAMERA_CSI_FLAG_CLOCK_CONTINUOUS 0x01 - __u8 num_lanes; - __u8 padding; - __le32 csi_clk_freq; - __le32 max_pkt_size; -} __packed; - -/* - * TODO: Compute the number of lanes dynamically based on bandwidth - * requirements. - */ -#define GB_CAMERA_CSI_NUM_DATA_LANES 4 - -#define GB_CAMERA_CSI_CLK_FREQ_MAX 999000000U -#define GB_CAMERA_CSI_CLK_FREQ_MIN 100000000U -#define GB_CAMERA_CSI_CLK_FREQ_MARGIN 150000000U - -static int gb_camera_setup_data_connection(struct gb_camera *gcam, - struct gb_camera_configure_streams_response *resp, - struct gb_camera_csi_params *csi_params) -{ - struct ap_csi_config_request csi_cfg; - struct gb_connection *conn; - unsigned int clk_freq; - int ret; - - /* - * Create the data connection between the camera module data CPort and - * APB CDSI1. The CDSI1 CPort ID is hardcoded by the ES2 bridge. - */ - conn = gb_connection_create_offloaded(gcam->bundle, gcam->data_cport_id, - GB_CONNECTION_FLAG_NO_FLOWCTRL | - GB_CONNECTION_FLAG_CDSI1); - if (IS_ERR(conn)) - return PTR_ERR(conn); - - gcam->data_connection = conn; - gb_connection_set_data(conn, gcam); - - ret = gb_connection_enable(conn); - if (ret) - goto error_conn_destroy; - - /* Set the UniPro link to high speed mode. */ - ret = gb_camera_set_power_mode(gcam, true); - if (ret < 0) - goto error_conn_disable; - - /* - * Configure the APB-A CSI-2 transmitter. - * - * Hardcode the number of lanes to 4 and compute the bus clock frequency - * based on the module bandwidth requirements with a safety margin. - */ - memset(&csi_cfg, 0, sizeof(csi_cfg)); - csi_cfg.csi_id = 1; - csi_cfg.flags = 0; - csi_cfg.num_lanes = GB_CAMERA_CSI_NUM_DATA_LANES; - - clk_freq = resp->data_rate / 2 / GB_CAMERA_CSI_NUM_DATA_LANES; - clk_freq = clamp(clk_freq + GB_CAMERA_CSI_CLK_FREQ_MARGIN, - GB_CAMERA_CSI_CLK_FREQ_MIN, - GB_CAMERA_CSI_CLK_FREQ_MAX); - csi_cfg.csi_clk_freq = clk_freq; - - ret = gb_camera_get_max_pkt_size(gcam, resp); - if (ret < 0) { - ret = -EIO; - goto error_power; - } - csi_cfg.max_pkt_size = ret; - - ret = gb_hd_output(gcam->connection->hd, &csi_cfg, - sizeof(csi_cfg), - GB_APB_REQUEST_CSI_TX_CONTROL, false); - if (ret < 0) { - dev_err(&gcam->bundle->dev, "failed to start the CSI transmitter\n"); - goto error_power; - } - - if (csi_params) { - csi_params->clk_freq = csi_cfg.csi_clk_freq; - csi_params->num_lanes = csi_cfg.num_lanes; - } - - return 0; - -error_power: - gb_camera_set_power_mode(gcam, false); -error_conn_disable: - gb_connection_disable(gcam->data_connection); -error_conn_destroy: - gb_connection_destroy(gcam->data_connection); - gcam->data_connection = NULL; - return ret; -} - -static void gb_camera_teardown_data_connection(struct gb_camera *gcam) -{ - struct ap_csi_config_request csi_cfg; - int ret; - - /* Stop the APB1 CSI transmitter. */ - memset(&csi_cfg, 0, sizeof(csi_cfg)); - csi_cfg.csi_id = 1; - - ret = gb_hd_output(gcam->connection->hd, &csi_cfg, - sizeof(csi_cfg), - GB_APB_REQUEST_CSI_TX_CONTROL, false); - - if (ret < 0) - dev_err(&gcam->bundle->dev, "failed to stop the CSI transmitter\n"); - - /* Set the UniPro link to low speed mode. */ - gb_camera_set_power_mode(gcam, false); - - /* Destroy the data connection. */ - gb_connection_disable(gcam->data_connection); - gb_connection_destroy(gcam->data_connection); - gcam->data_connection = NULL; -} - -/* ----------------------------------------------------------------------------- - * Camera Protocol Operations - */ - -static int gb_camera_capabilities(struct gb_camera *gcam, - u8 *capabilities, size_t *size) -{ - int ret; - - ret = gb_pm_runtime_get_sync(gcam->bundle); - if (ret) - return ret; - - mutex_lock(&gcam->mutex); - - if (!gcam->connection) { - ret = -EINVAL; - goto done; - } - - ret = gb_camera_operation_sync_flags(gcam->connection, - GB_CAMERA_TYPE_CAPABILITIES, - GB_OPERATION_FLAG_SHORT_RESPONSE, - NULL, 0, - (void *)capabilities, size); - if (ret) - dev_err(&gcam->bundle->dev, "failed to retrieve capabilities: %d\n", ret); - -done: - mutex_unlock(&gcam->mutex); - - gb_pm_runtime_put_autosuspend(gcam->bundle); - - return ret; -} - -static int gb_camera_configure_streams(struct gb_camera *gcam, - unsigned int *num_streams, - unsigned int *flags, - struct gb_camera_stream_config *streams, - struct gb_camera_csi_params *csi_params) -{ - struct gb_camera_configure_streams_request *req; - struct gb_camera_configure_streams_response *resp; - unsigned int nstreams = *num_streams; - unsigned int i; - size_t req_size; - size_t resp_size; - int ret; - - if (nstreams > GB_CAMERA_MAX_STREAMS) - return -EINVAL; - - req_size = sizeof(*req) + nstreams * sizeof(req->config[0]); - resp_size = sizeof(*resp) + nstreams * sizeof(resp->config[0]); - - req = kmalloc(req_size, GFP_KERNEL); - resp = kmalloc(resp_size, GFP_KERNEL); - if (!req || !resp) { - kfree(req); - kfree(resp); - return -ENOMEM; - } - - req->num_streams = nstreams; - req->flags = *flags; - req->padding = 0; - - for (i = 0; i < nstreams; ++i) { - struct gb_camera_stream_config_request *cfg = &req->config[i]; - - cfg->width = cpu_to_le16(streams[i].width); - cfg->height = cpu_to_le16(streams[i].height); - cfg->format = cpu_to_le16(streams[i].format); - cfg->padding = 0; - } - - mutex_lock(&gcam->mutex); - - ret = gb_pm_runtime_get_sync(gcam->bundle); - if (ret) - goto done_skip_pm_put; - - if (!gcam->connection) { - ret = -EINVAL; - goto done; - } - - ret = gb_camera_operation_sync_flags(gcam->connection, - GB_CAMERA_TYPE_CONFIGURE_STREAMS, - GB_OPERATION_FLAG_SHORT_RESPONSE, - req, req_size, - resp, &resp_size); - if (ret < 0) - goto done; - - ret = gb_camera_configure_streams_validate_response(gcam, resp, - nstreams); - if (ret < 0) - goto done; - - *flags = resp->flags; - *num_streams = resp->num_streams; - - for (i = 0; i < resp->num_streams; ++i) { - struct gb_camera_stream_config_response *cfg = &resp->config[i]; - - streams[i].width = le16_to_cpu(cfg->width); - streams[i].height = le16_to_cpu(cfg->height); - streams[i].format = le16_to_cpu(cfg->format); - streams[i].vc = cfg->virtual_channel; - streams[i].dt[0] = cfg->data_type[0]; - streams[i].dt[1] = cfg->data_type[1]; - streams[i].max_size = le32_to_cpu(cfg->max_size); - } - - if ((resp->flags & GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED) || - (req->flags & GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY)) - goto done; - - if (gcam->state == GB_CAMERA_STATE_CONFIGURED) { - gb_camera_teardown_data_connection(gcam); - gcam->state = GB_CAMERA_STATE_UNCONFIGURED; - - /* - * When unconfiguring streams release the PM runtime reference - * that was acquired when streams were configured. The bundle - * won't be suspended until the PM runtime reference acquired at - * the beginning of this function gets released right before - * returning. - */ - gb_pm_runtime_put_noidle(gcam->bundle); - } - - if (resp->num_streams == 0) - goto done; - - /* - * Make sure the bundle won't be suspended until streams get - * unconfigured after the stream is configured successfully - */ - gb_pm_runtime_get_noresume(gcam->bundle); - - /* Setup CSI-2 connection from APB-A to AP */ - ret = gb_camera_setup_data_connection(gcam, resp, csi_params); - if (ret < 0) { - memset(req, 0, sizeof(*req)); - gb_operation_sync(gcam->connection, - GB_CAMERA_TYPE_CONFIGURE_STREAMS, - req, sizeof(*req), - resp, sizeof(*resp)); - *flags = 0; - *num_streams = 0; - gb_pm_runtime_put_noidle(gcam->bundle); - goto done; - } - - gcam->state = GB_CAMERA_STATE_CONFIGURED; - -done: - gb_pm_runtime_put_autosuspend(gcam->bundle); - -done_skip_pm_put: - mutex_unlock(&gcam->mutex); - kfree(req); - kfree(resp); - return ret; -} - -static int gb_camera_capture(struct gb_camera *gcam, u32 request_id, - unsigned int streams, unsigned int num_frames, - size_t settings_size, const void *settings) -{ - struct gb_camera_capture_request *req; - size_t req_size; - int ret; - - if (settings_size > GB_CAMERA_MAX_SETTINGS_SIZE) - return -EINVAL; - - req_size = sizeof(*req) + settings_size; - req = kmalloc(req_size, GFP_KERNEL); - if (!req) - return -ENOMEM; - - req->request_id = cpu_to_le32(request_id); - req->streams = streams; - req->padding = 0; - req->num_frames = cpu_to_le16(num_frames); - memcpy(req->settings, settings, settings_size); - - mutex_lock(&gcam->mutex); - - if (!gcam->connection) { - ret = -EINVAL; - goto done; - } - - ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_CAPTURE, - req, req_size, NULL, 0); -done: - mutex_unlock(&gcam->mutex); - - kfree(req); - - return ret; -} - -static int gb_camera_flush(struct gb_camera *gcam, u32 *request_id) -{ - struct gb_camera_flush_response resp; - int ret; - - mutex_lock(&gcam->mutex); - - if (!gcam->connection) { - ret = -EINVAL; - goto done; - } - - ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_FLUSH, NULL, 0, - &resp, sizeof(resp)); - - if (ret < 0) - goto done; - - if (request_id) - *request_id = le32_to_cpu(resp.request_id); - -done: - mutex_unlock(&gcam->mutex); - - return ret; -} - -static int gb_camera_request_handler(struct gb_operation *op) -{ - struct gb_camera *gcam = gb_connection_get_data(op->connection); - struct gb_camera_metadata_request *payload; - struct gb_message *request; - - if (op->type != GB_CAMERA_TYPE_METADATA) { - dev_err(&gcam->bundle->dev, "Unsupported unsolicited event: %u\n", op->type); - return -EINVAL; - } - - request = op->request; - - if (request->payload_size < sizeof(*payload)) { - dev_err(&gcam->bundle->dev, "Wrong event size received (%zu < %zu)\n", - request->payload_size, sizeof(*payload)); - return -EINVAL; - } - - payload = request->payload; - - dev_dbg(&gcam->bundle->dev, "received metadata for request %u, frame %u, stream %u\n", - payload->request_id, payload->frame_number, payload->stream); - - return 0; -} - -/* ----------------------------------------------------------------------------- - * Interface with HOST gmp camera. - */ -static unsigned int gb_camera_mbus_to_gb(enum v4l2_mbus_pixelcode mbus_code) -{ - unsigned int i; - - for (i = 0; i < ARRAY_SIZE(gb_fmt_info); i++) { - if (gb_fmt_info[i].mbus_code == mbus_code) - return gb_fmt_info[i].gb_format; - } - return gb_fmt_info[0].gb_format; -} - -static enum v4l2_mbus_pixelcode gb_camera_gb_to_mbus(u16 gb_fmt) -{ - unsigned int i; - - for (i = 0; i < ARRAY_SIZE(gb_fmt_info); i++) { - if (gb_fmt_info[i].gb_format == gb_fmt) - return gb_fmt_info[i].mbus_code; - } - return gb_fmt_info[0].mbus_code; -} - -static ssize_t gb_camera_op_capabilities(void *priv, char *data, size_t len) -{ - struct gb_camera *gcam = priv; - size_t capabilities_len = len; - int ret; - - ret = gb_camera_capabilities(gcam, data, &capabilities_len); - if (ret) - return ret; - - return capabilities_len; -} - -static int gb_camera_op_configure_streams(void *priv, unsigned int *nstreams, - unsigned int *flags, struct gb_camera_stream *streams, - struct gb_camera_csi_params *csi_params) -{ - struct gb_camera *gcam = priv; - struct gb_camera_stream_config *gb_streams; - unsigned int gb_flags = 0; - unsigned int gb_nstreams = *nstreams; - unsigned int i; - int ret; - - if (gb_nstreams > GB_CAMERA_MAX_STREAMS) - return -EINVAL; - - gb_streams = kzalloc_objs(*gb_streams, gb_nstreams); - if (!gb_streams) - return -ENOMEM; - - for (i = 0; i < gb_nstreams; i++) { - gb_streams[i].width = streams[i].width; - gb_streams[i].height = streams[i].height; - gb_streams[i].format = - gb_camera_mbus_to_gb(streams[i].pixel_code); - } - - if (*flags & GB_CAMERA_IN_FLAG_TEST) - gb_flags |= GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY; - - ret = gb_camera_configure_streams(gcam, &gb_nstreams, - &gb_flags, gb_streams, csi_params); - if (ret < 0) - goto done; - if (gb_nstreams > *nstreams) { - ret = -EINVAL; - goto done; - } - - *flags = 0; - if (gb_flags & GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED) - *flags |= GB_CAMERA_OUT_FLAG_ADJUSTED; - - for (i = 0; i < gb_nstreams; i++) { - streams[i].width = gb_streams[i].width; - streams[i].height = gb_streams[i].height; - streams[i].vc = gb_streams[i].vc; - streams[i].dt[0] = gb_streams[i].dt[0]; - streams[i].dt[1] = gb_streams[i].dt[1]; - streams[i].max_size = gb_streams[i].max_size; - streams[i].pixel_code = - gb_camera_gb_to_mbus(gb_streams[i].format); - } - *nstreams = gb_nstreams; - -done: - kfree(gb_streams); - return ret; -} - -static int gb_camera_op_capture(void *priv, u32 request_id, - unsigned int streams, unsigned int num_frames, - size_t settings_size, const void *settings) -{ - struct gb_camera *gcam = priv; - - return gb_camera_capture(gcam, request_id, streams, num_frames, - settings_size, settings); -} - -static int gb_camera_op_flush(void *priv, u32 *request_id) -{ - struct gb_camera *gcam = priv; - - return gb_camera_flush(gcam, request_id); -} - -static const struct gb_camera_ops gb_cam_ops = { - .capabilities = gb_camera_op_capabilities, - .configure_streams = gb_camera_op_configure_streams, - .capture = gb_camera_op_capture, - .flush = gb_camera_op_flush, -}; - -/* ----------------------------------------------------------------------------- - * DebugFS - */ - -static ssize_t gb_camera_debugfs_capabilities(struct gb_camera *gcam, - char *buf, size_t len) -{ - struct gb_camera_debugfs_buffer *buffer = - &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES]; - size_t size = 1024; - unsigned int i; - u8 *caps; - int ret; - - caps = kmalloc(size, GFP_KERNEL); - if (!caps) - return -ENOMEM; - - ret = gb_camera_capabilities(gcam, caps, &size); - if (ret < 0) - goto done; - - /* - * hex_dump_to_buffer() doesn't return the number of bytes dumped prior - * to v4.0, we need our own implementation :-( - */ - buffer->length = 0; - - for (i = 0; i < size; i += 16) { - unsigned int nbytes = min_t(unsigned int, size - i, 16); - - buffer->length += sprintf(buffer->data + buffer->length, - "%*ph\n", nbytes, caps + i); - } - -done: - kfree(caps); - return ret; -} - -static ssize_t gb_camera_debugfs_configure_streams(struct gb_camera *gcam, - char *buf, size_t len) -{ - struct gb_camera_debugfs_buffer *buffer = - &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_STREAMS]; - struct gb_camera_stream_config *streams; - unsigned int nstreams; - unsigned int flags; - unsigned int i; - char *token; - int ret; - - /* Retrieve number of streams to configure */ - token = strsep(&buf, ";"); - if (!token) - return -EINVAL; - - ret = kstrtouint(token, 10, &nstreams); - if (ret < 0) - return ret; - - if (nstreams > GB_CAMERA_MAX_STREAMS) - return -EINVAL; - - token = strsep(&buf, ";"); - if (!token) - return -EINVAL; - - ret = kstrtouint(token, 10, &flags); - if (ret < 0) - return ret; - - /* For each stream to configure parse width, height and format */ - streams = kzalloc_objs(*streams, nstreams); - if (!streams) - return -ENOMEM; - - for (i = 0; i < nstreams; ++i) { - struct gb_camera_stream_config *stream = &streams[i]; - - /* width */ - token = strsep(&buf, ";"); - if (!token) { - ret = -EINVAL; - goto done; - } - ret = kstrtouint(token, 10, &stream->width); - if (ret < 0) - goto done; - - /* height */ - token = strsep(&buf, ";"); - if (!token) - goto done; - - ret = kstrtouint(token, 10, &stream->height); - if (ret < 0) - goto done; - - /* Image format code */ - token = strsep(&buf, ";"); - if (!token) - goto done; - - ret = kstrtouint(token, 16, &stream->format); - if (ret < 0) - goto done; - } - - ret = gb_camera_configure_streams(gcam, &nstreams, &flags, streams, - NULL); - if (ret < 0) - goto done; - - buffer->length = sprintf(buffer->data, "%u;%u;", nstreams, flags); - - for (i = 0; i < nstreams; ++i) { - struct gb_camera_stream_config *stream = &streams[i]; - - buffer->length += sprintf(buffer->data + buffer->length, - "%u;%u;%u;%u;%u;%u;%u;", - stream->width, stream->height, - stream->format, stream->vc, - stream->dt[0], stream->dt[1], - stream->max_size); - } - - ret = len; - -done: - kfree(streams); - return ret; -}; - -static ssize_t gb_camera_debugfs_capture(struct gb_camera *gcam, - char *buf, size_t len) -{ - unsigned int request_id; - unsigned int streams_mask; - unsigned int num_frames; - char *token; - int ret; - - /* Request id */ - token = strsep(&buf, ";"); - if (!token) - return -EINVAL; - ret = kstrtouint(token, 10, &request_id); - if (ret < 0) - return ret; - - /* Stream mask */ - token = strsep(&buf, ";"); - if (!token) - return -EINVAL; - ret = kstrtouint(token, 16, &streams_mask); - if (ret < 0) - return ret; - - /* number of frames */ - token = strsep(&buf, ";"); - if (!token) - return -EINVAL; - ret = kstrtouint(token, 10, &num_frames); - if (ret < 0) - return ret; - - ret = gb_camera_capture(gcam, request_id, streams_mask, num_frames, 0, - NULL); - if (ret < 0) - return ret; - - return len; -} - -static ssize_t gb_camera_debugfs_flush(struct gb_camera *gcam, - char *buf, size_t len) -{ - struct gb_camera_debugfs_buffer *buffer = - &gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_FLUSH]; - unsigned int req_id; - int ret; - - ret = gb_camera_flush(gcam, &req_id); - if (ret < 0) - return ret; - - buffer->length = sprintf(buffer->data, "%u", req_id); - - return len; -} - -struct gb_camera_debugfs_entry { - const char *name; - unsigned int mask; - unsigned int buffer; - ssize_t (*execute)(struct gb_camera *gcam, char *buf, size_t len); -}; - -static const struct gb_camera_debugfs_entry gb_camera_debugfs_entries[] = { - { - .name = "capabilities", - .mask = S_IFREG | 0444, - .buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES, - .execute = gb_camera_debugfs_capabilities, - }, { - .name = "configure_streams", - .mask = S_IFREG | 0666, - .buffer = GB_CAMERA_DEBUGFS_BUFFER_STREAMS, - .execute = gb_camera_debugfs_configure_streams, - }, { - .name = "capture", - .mask = S_IFREG | 0666, - .buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPTURE, - .execute = gb_camera_debugfs_capture, - }, { - .name = "flush", - .mask = S_IFREG | 0666, - .buffer = GB_CAMERA_DEBUGFS_BUFFER_FLUSH, - .execute = gb_camera_debugfs_flush, - }, -}; - -static ssize_t gb_camera_debugfs_read(struct file *file, char __user *buf, - size_t len, loff_t *offset) -{ - const struct gb_camera_debugfs_entry *op = file->private_data; - struct gb_camera *gcam = file_inode(file)->i_private; - struct gb_camera_debugfs_buffer *buffer; - ssize_t ret; - - /* For read-only entries the operation is triggered by a read. */ - if (!(op->mask & 0222)) { - ret = op->execute(gcam, NULL, 0); - if (ret < 0) - return ret; - } - - buffer = &gcam->debugfs.buffers[op->buffer]; - - return simple_read_from_buffer(buf, len, offset, buffer->data, - buffer->length); -} - -static ssize_t gb_camera_debugfs_write(struct file *file, - const char __user *buf, size_t len, - loff_t *offset) -{ - const struct gb_camera_debugfs_entry *op = file->private_data; - struct gb_camera *gcam = file_inode(file)->i_private; - ssize_t ret; - char *kbuf; - - if (len > 1024) - return -EINVAL; - - kbuf = memdup_user_nul(buf, len); - if (IS_ERR(kbuf)) - return PTR_ERR(kbuf); - - ret = op->execute(gcam, kbuf, len); - -done: - kfree(kbuf); - return ret; -} - -static int gb_camera_debugfs_open(struct inode *inode, struct file *file) -{ - file->private_data = debugfs_get_aux(file); - return 0; -} - -static const struct file_operations gb_camera_debugfs_ops = { - .open = gb_camera_debugfs_open, - .read = gb_camera_debugfs_read, - .write = gb_camera_debugfs_write, -}; - -static int gb_camera_debugfs_init(struct gb_camera *gcam) -{ - struct gb_connection *connection = gcam->connection; - char dirname[27]; - unsigned int i; - - /* - * Create root debugfs entry and a file entry for each camera operation. - */ - snprintf(dirname, 27, "camera-%u.%u", connection->intf->interface_id, - gcam->bundle->id); - - gcam->debugfs.root = debugfs_create_dir(dirname, gb_debugfs_get()); - - gcam->debugfs.buffers = - vmalloc(array_size(GB_CAMERA_DEBUGFS_BUFFER_MAX, - sizeof(*gcam->debugfs.buffers))); - if (!gcam->debugfs.buffers) - return -ENOMEM; - - for (i = 0; i < ARRAY_SIZE(gb_camera_debugfs_entries); ++i) { - const struct gb_camera_debugfs_entry *entry = - &gb_camera_debugfs_entries[i]; - - gcam->debugfs.buffers[i].length = 0; - - debugfs_create_file_aux(entry->name, entry->mask, - gcam->debugfs.root, gcam, entry, - &gb_camera_debugfs_ops); - } - - return 0; -} - -static void gb_camera_debugfs_cleanup(struct gb_camera *gcam) -{ - debugfs_remove_recursive(gcam->debugfs.root); - - vfree(gcam->debugfs.buffers); -} - -/* ----------------------------------------------------------------------------- - * Init & Cleanup - */ - -static void gb_camera_cleanup(struct gb_camera *gcam) -{ - gb_camera_debugfs_cleanup(gcam); - - mutex_lock(&gcam->mutex); - if (gcam->data_connection) { - gb_connection_disable(gcam->data_connection); - gb_connection_destroy(gcam->data_connection); - gcam->data_connection = NULL; - } - - if (gcam->connection) { - gb_connection_disable(gcam->connection); - gb_connection_destroy(gcam->connection); - gcam->connection = NULL; - } - mutex_unlock(&gcam->mutex); -} - -static void gb_camera_release_module(struct kref *ref) -{ - struct gb_camera_module *cam_mod = - container_of(ref, struct gb_camera_module, refcount); - kfree(cam_mod->priv); -} - -static int gb_camera_probe(struct gb_bundle *bundle, - const struct greybus_bundle_id *id) -{ - struct gb_connection *conn; - struct gb_camera *gcam; - u16 mgmt_cport_id = 0; - u16 data_cport_id = 0; - unsigned int i; - int ret; - - /* - * The camera bundle must contain exactly two CPorts, one for the - * camera management protocol and one for the camera data protocol. - */ - if (bundle->num_cports != 2) - return -ENODEV; - - for (i = 0; i < bundle->num_cports; ++i) { - struct greybus_descriptor_cport *desc = &bundle->cport_desc[i]; - - switch (desc->protocol_id) { - case GREYBUS_PROTOCOL_CAMERA_MGMT: - mgmt_cport_id = le16_to_cpu(desc->id); - break; - case GREYBUS_PROTOCOL_CAMERA_DATA: - data_cport_id = le16_to_cpu(desc->id); - break; - default: - return -ENODEV; - } - } - - if (!mgmt_cport_id || !data_cport_id) - return -ENODEV; - - gcam = kzalloc_obj(*gcam); - if (!gcam) - return -ENOMEM; - - mutex_init(&gcam->mutex); - - gcam->bundle = bundle; - gcam->state = GB_CAMERA_STATE_UNCONFIGURED; - gcam->data_cport_id = data_cport_id; - - conn = gb_connection_create(bundle, mgmt_cport_id, - gb_camera_request_handler); - if (IS_ERR(conn)) { - ret = PTR_ERR(conn); - goto error; - } - - gcam->connection = conn; - gb_connection_set_data(conn, gcam); - - ret = gb_connection_enable(conn); - if (ret) - goto error; - - ret = gb_camera_debugfs_init(gcam); - if (ret < 0) - goto error; - - gcam->module.priv = gcam; - gcam->module.ops = &gb_cam_ops; - gcam->module.interface_id = gcam->connection->intf->interface_id; - gcam->module.release = gb_camera_release_module; - ret = gb_camera_register(&gcam->module); - if (ret < 0) - goto error; - - greybus_set_drvdata(bundle, gcam); - - gb_pm_runtime_put_autosuspend(gcam->bundle); - - return 0; - -error: - gb_camera_cleanup(gcam); - kfree(gcam); - return ret; -} - -static void gb_camera_disconnect(struct gb_bundle *bundle) -{ - struct gb_camera *gcam = greybus_get_drvdata(bundle); - int ret; - - ret = gb_pm_runtime_get_sync(bundle); - if (ret) - gb_pm_runtime_get_noresume(bundle); - - gb_camera_cleanup(gcam); - gb_camera_unregister(&gcam->module); -} - -static const struct greybus_bundle_id gb_camera_id_table[] = { - { GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_CAMERA) }, - { }, -}; - -#ifdef CONFIG_PM -static int gb_camera_suspend(struct device *dev) -{ - struct gb_bundle *bundle = to_gb_bundle(dev); - struct gb_camera *gcam = greybus_get_drvdata(bundle); - - if (gcam->data_connection) - gb_connection_disable(gcam->data_connection); - - gb_connection_disable(gcam->connection); - - return 0; -} - -static int gb_camera_resume(struct device *dev) -{ - struct gb_bundle *bundle = to_gb_bundle(dev); - struct gb_camera *gcam = greybus_get_drvdata(bundle); - int ret; - - ret = gb_connection_enable(gcam->connection); - if (ret) { - dev_err(&gcam->bundle->dev, "failed to enable connection: %d\n", ret); - return ret; - } - - if (gcam->data_connection) { - ret = gb_connection_enable(gcam->data_connection); - if (ret) { - dev_err(&gcam->bundle->dev, - "failed to enable data connection: %d\n", ret); - return ret; - } - } - - return 0; -} -#endif - -static const struct dev_pm_ops gb_camera_pm_ops = { - SET_RUNTIME_PM_OPS(gb_camera_suspend, gb_camera_resume, NULL) -}; - -static struct greybus_driver gb_camera_driver = { - .name = "camera", - .probe = gb_camera_probe, - .disconnect = gb_camera_disconnect, - .id_table = gb_camera_id_table, - .driver.pm = &gb_camera_pm_ops, -}; - -module_greybus_driver(gb_camera_driver); - -MODULE_DESCRIPTION("Greybus Camera protocol driver."); -MODULE_LICENSE("GPL v2"); diff --git a/drivers/staging/greybus/gb-camera.h b/drivers/staging/greybus/gb-camera.h deleted file mode 100644 index d5a33a13f2a4..000000000000 --- a/drivers/staging/greybus/gb-camera.h +++ /dev/null @@ -1,127 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0 */ -/* - * Greybus Camera protocol driver. - * - * Copyright 2015 Google Inc. - */ -#ifndef __GB_CAMERA_H -#define __GB_CAMERA_H - -#include <linux/v4l2-mediabus.h> - -/* Input flags need to be set from the caller */ -#define GB_CAMERA_IN_FLAG_TEST BIT(0) -/* Output flags returned */ -#define GB_CAMERA_OUT_FLAG_ADJUSTED BIT(0) - -/** - * struct gb_camera_stream - Represents greybus camera stream. - * @width: Stream width in pixels. - * @height: Stream height in pixels. - * @pixel_code: Media bus pixel code. - * @vc: MIPI CSI virtual channel. - * @dt: MIPI CSI data types. Most formats use a single data type, in which case - * the second element will be ignored. - * @max_size: Maximum size of a frame in bytes. The camera module guarantees - * that all data between the Frame Start and Frame End packet for - * the associated virtual channel and data type(s) will not exceed - * this size. - */ -struct gb_camera_stream { - unsigned int width; - unsigned int height; - enum v4l2_mbus_pixelcode pixel_code; - unsigned int vc; - unsigned int dt[2]; - unsigned int max_size; -}; - -/** - * struct gb_camera_csi_params - CSI configuration parameters - * @num_lanes: number of CSI data lanes - * @clk_freq: CSI clock frequency in Hz - */ -struct gb_camera_csi_params { - unsigned int num_lanes; - unsigned int clk_freq; -}; - -/** - * struct gb_camera_ops - Greybus camera operations, used by the Greybus camera - * driver to expose operations to the host camera driver. - * @capabilities: Retrieve camera capabilities and store them in the buffer - * 'buf' capabilities. The buffer maximum size is specified by - * the caller in the 'size' parameter, and the effective - * capabilities size is returned from the function. If the buffer - * size is too small to hold the capabilities an error is - * returned and the buffer is left untouched. - * - * @configure_streams: Negotiate configuration and prepare the module for video - * capture. The caller specifies the number of streams it - * requests in the 'nstreams' argument and the associated - * streams configurations in the 'streams' argument. The - * GB_CAMERA_IN_FLAG_TEST 'flag' can be set to test a - * configuration without applying it, otherwise the - * configuration is applied by the module. The module can - * decide to modify the requested configuration, including - * using a different number of streams. In that case the - * modified configuration won't be applied, the - * GB_CAMERA_OUT_FLAG_ADJUSTED 'flag' will be set upon - * return, and the modified configuration and number of - * streams stored in 'streams' and 'array'. The module - * returns its CSI-2 bus parameters in the 'csi_params' - * structure in all cases. - * - * @capture: Submit a capture request. The supplied 'request_id' must be unique - * and higher than the IDs of all the previously submitted requests. - * The 'streams' argument specifies which streams are affected by the - * request in the form of a bitmask, with bits corresponding to the - * configured streams indexes. If the request contains settings, the - * 'settings' argument points to the settings buffer and its size is - * specified by the 'settings_size' argument. Otherwise the 'settings' - * argument should be set to NULL and 'settings_size' to 0. - * - * @flush: Flush the capture requests queue. Return the ID of the last request - * that will processed by the device before it stops transmitting video - * frames. All queued capture requests with IDs higher than the returned - * ID will be dropped without being processed. - */ -struct gb_camera_ops { - ssize_t (*capabilities)(void *priv, char *buf, size_t len); - int (*configure_streams)(void *priv, unsigned int *nstreams, - unsigned int *flags, - struct gb_camera_stream *streams, - struct gb_camera_csi_params *csi_params); - int (*capture)(void *priv, u32 request_id, - unsigned int streams, unsigned int num_frames, - size_t settings_size, const void *settings); - int (*flush)(void *priv, u32 *request_id); -}; - -/** - * struct gb_camera_module - Represents greybus camera module. - * @priv: Module private data, passed to all camera operations. - * @ops: Greybus camera operation callbacks. - * @interface_id: Interface id of the module. - * @refcount: Reference counting object. - * @release: Module release function. - * @list: List entry in the camera modules list. - */ -struct gb_camera_module { - void *priv; - const struct gb_camera_ops *ops; - - unsigned int interface_id; - struct kref refcount; - void (*release)(struct kref *kref); - struct list_head list; /* Global list */ -}; - -#define gb_camera_call(f, op, args...) \ - (!(f) ? -ENODEV : (((f)->ops->op) ? \ - (f)->ops->op((f)->priv, ##args) : -ENOIOCTLCMD)) - -int gb_camera_register(struct gb_camera_module *module); -int gb_camera_unregister(struct gb_camera_module *module); - -#endif /* __GB_CAMERA_H */ -- 2.43.0

4 days, 10 hours

[PATCH] staging: greybus: remove empty TODO file

by Ethan Nelson-Moore

drivers/staging/greybus/TODO has been empty since commit d85bef159923 ("staging: greybus: remove completed GPIO conversion task from TODO"). Remove it. Signed-off-by: Ethan Nelson-Moore <enelsonmoore(a)gmail.com> --- drivers/staging/greybus/TODO | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 drivers/staging/greybus/TODO diff --git a/drivers/staging/greybus/TODO b/drivers/staging/greybus/TODO deleted file mode 100644 index e69de29bb2d1..000000000000 -- 2.43.0

4 days, 10 hours

[PATCH 0/2] mmc: core: Avoid export of mmc_alloc|free_host()

by Ulf Hansson

From: Ulf Hansson <ulfh(a)kernel.org> The only remaining user of mmc_alloc|free_host() is the greybus sdio driver. Let's convert it into using the resource managed variant so we can drop the export of mmc_alloc|free_host(). Ulf Hansson (2): staging: greybus: sdio: Convert to devm_mmc_alloc_host() mmc: core: Turn mmc_alloc|free_host() into static functions drivers/mmc/core/host.c | 35 +++++++++------------------------- drivers/staging/greybus/sdio.c | 11 +++-------- include/linux/mmc/host.h | 2 -- 3 files changed, 12 insertions(+), 36 deletions(-) -- 2.43.0

5 days, 9 hours

[PATCH] staging: greybus: add newline to sysfs_emit return

by Omer PALA

Add a terminating newline character to sysfs_emit() format strings in audio_manager_module.c. Without a trailing newline, reading sysfs attributes directly from user space (e.g., using `cat`) appends the command prompt to the output string, leading to broken formatting. Including '\n' ensures compliance with sysfs single-value formatting standards and prevents parsing issues in user space tools and scripts. Signed-off-by: Omer PALA <palaomer100(a)gmail.com> --- drivers/staging/greybus/audio_manager_module.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/drivers/staging/greybus/audio_manager_module.c b/drivers/staging/greybus/audio_manager_module.c index dc90cc2d2..5737f2a32 100644 --- a/drivers/staging/greybus/audio_manager_module.c +++ b/drivers/staging/greybus/audio_manager_module.c @@ -75,7 +75,7 @@ static void gb_audio_module_release(struct kobject *kobj) static ssize_t gb_audio_module_name_show(struct gb_audio_manager_module *module, struct gb_audio_manager_module_attribute *attr, char *buf) { - return sysfs_emit(buf, "%s", module->desc.name); + return sysfs_emit(buf, "%s\n", module->desc.name); } static struct gb_audio_manager_module_attribute gb_audio_module_name_attribute = @@ -84,7 +84,7 @@ static struct gb_audio_manager_module_attribute gb_audio_module_name_attribute = static ssize_t gb_audio_module_vid_show(struct gb_audio_manager_module *module, struct gb_audio_manager_module_attribute *attr, char *buf) { - return sysfs_emit(buf, "%d", module->desc.vid); + return sysfs_emit(buf, "%d\n", module->desc.vid); } static struct gb_audio_manager_module_attribute gb_audio_module_vid_attribute = @@ -93,7 +93,7 @@ static struct gb_audio_manager_module_attribute gb_audio_module_vid_attribute = static ssize_t gb_audio_module_pid_show(struct gb_audio_manager_module *module, struct gb_audio_manager_module_attribute *attr, char *buf) { - return sysfs_emit(buf, "%d", module->desc.pid); + return sysfs_emit(buf, "%d\n", module->desc.pid); } static struct gb_audio_manager_module_attribute gb_audio_module_pid_attribute = @@ -103,7 +103,7 @@ static ssize_t gb_audio_module_intf_id_show(struct gb_audio_manager_module *modu struct gb_audio_manager_module_attribute *attr, char *buf) { - return sysfs_emit(buf, "%d", module->desc.intf_id); + return sysfs_emit(buf, "%d\n", module->desc.intf_id); } static struct gb_audio_manager_module_attribute @@ -114,7 +114,7 @@ static ssize_t gb_audio_module_ip_devices_show(struct gb_audio_manager_module *m struct gb_audio_manager_module_attribute *attr, char *buf) { - return sysfs_emit(buf, "0x%X", module->desc.ip_devices); + return sysfs_emit(buf, "0x%X\n", module->desc.ip_devices); } static struct gb_audio_manager_module_attribute @@ -125,7 +125,7 @@ static ssize_t gb_audio_module_op_devices_show(struct gb_audio_manager_module *m struct gb_audio_manager_module_attribute *attr, char *buf) { - return sysfs_emit(buf, "0x%X", module->desc.op_devices); + return sysfs_emit(buf, "0x%X\n", module->desc.op_devices); } static struct gb_audio_manager_module_attribute -- 2.55.0

5 days, 17 hours

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

greybus-dev September 2026