greybus-dev

greybus-dev@lists.linaro.org

35 participants
856 discussions

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

18 hours, 39 minutes

[PATCH] staging: greybus: avoid snprintf truncation in audio topology

by Eduard Zateev

Building with W=1 reports format truncation warnings when prefixing the Greybus device id to widget and control names. The destination buffers are NAME_SIZE bytes, while the copied topology names may already take most of that space. Split the operation into writing the prefix first and then copying the remaining name into the space left in the destination buffer. This avoids the -Wformat-truncation warnings while preserving bounded string handling. Signed-off-by: Eduard Zateev <hackerowskiy(a)gmail.com> --- drivers/staging/greybus/audio_topology.c | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/drivers/staging/greybus/audio_topology.c b/drivers/staging/greybus/audio_topology.c index 76146f91cddc..72a71fd38312 100644 --- a/drivers/staging/greybus/audio_topology.c +++ b/drivers/staging/greybus/audio_topology.c @@ -1019,6 +1019,7 @@ static int gbaudio_tplg_create_widget(struct gbaudio_module_info *module, struct gbaudio_control *control, *_control; size_t size; char temp_name[NAME_SIZE]; + int name_len; ret = gbaudio_validate_kcontrol_count(w); if (ret) { @@ -1087,7 +1088,8 @@ static int gbaudio_tplg_create_widget(struct gbaudio_module_info *module, /* Prefix dev_id to widget control_name */ strscpy(temp_name, w->name, sizeof(temp_name)); - snprintf(w->name, sizeof(w->name), "GB %d %s", module->dev_id, temp_name); + name_len = scnprintf(w->name, sizeof(w->name), "GB %d ", module->dev_id); + strscpy(w->name + name_len, temp_name, sizeof(w->name) - name_len); switch (w->type) { case snd_soc_dapm_spk: @@ -1144,6 +1146,7 @@ static int gbaudio_tplg_process_kcontrols(struct gbaudio_module_info *module, struct gbaudio_control *control, *_control; size_t size; char temp_name[NAME_SIZE]; + int name_len; size = sizeof(struct snd_kcontrol_new) * module->num_controls; dapm_kctls = devm_kzalloc(module->dev, size, GFP_KERNEL); @@ -1169,8 +1172,10 @@ static int gbaudio_tplg_process_kcontrols(struct gbaudio_module_info *module, control->id = curr->id; /* Prefix dev_id to widget_name */ strscpy(temp_name, curr->name, sizeof(temp_name)); - snprintf(curr->name, sizeof(curr->name), "GB %d %s", module->dev_id, - temp_name); + name_len = scnprintf(curr->name, sizeof(curr->name), "GB %d ", + module->dev_id); + strscpy(curr->name + name_len, temp_name, + sizeof(curr->name) - name_len); control->name = curr->name; if (curr->info.type == GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED) { struct gb_audio_enumerated *gbenum = -- 2.55.0

1 day, 1 hour

[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

1 day, 21 hours

[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

2 days, 20 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

2 days, 21 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

3 days, 15 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

3 days, 20 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

5 days, 21 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

5 days, 21 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

6 days, 20 hours

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

greybus-dev