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

Configure Feed

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

ASoC: SOF: Use guard()/scoped_guard() for locks when

Merge series from Peter Ujfalusi <peter.ujfalusi@linux.intel.com>:

Only code refactoring, and no behavior change.

Replace most of the manual *lock/*unlock handling with guard use.

Mark Brown 28e5a3de dd808d6b

+95 -220
+1 -3
sound/soc/sof/amd/acp-ipc.c
··· 190 190 dsp_ack = snd_sof_dsp_read(sdev, ACP_DSP_BAR, ACP_SCRATCH_REG_0 + dsp_ack_write); 191 191 if (dsp_ack) { 192 192 if (likely(sdev->fw_state == SOF_FW_BOOT_COMPLETE)) { 193 - spin_lock_irq(&sdev->ipc_lock); 193 + guard(spinlock_irq)(&sdev->ipc_lock); 194 194 195 195 /* handle immediate reply from DSP core */ 196 196 acp_dsp_ipc_get_reply(sdev); 197 197 snd_sof_ipc_reply(sdev, 0); 198 198 /* set the done bit */ 199 199 acp_dsp_ipc_dsp_done(sdev); 200 - 201 - spin_unlock_irq(&sdev->ipc_lock); 202 200 } else { 203 201 dev_dbg_ratelimited(sdev->dev, "IPC reply before FW_BOOT_COMPLETE: %#x\n", 204 202 dsp_ack);
+2 -6
sound/soc/sof/imx/imx-common.c
··· 81 81 82 82 static void imx_handle_reply(struct imx_dsp_ipc *ipc) 83 83 { 84 - struct snd_sof_dev *sdev; 85 - unsigned long flags; 84 + struct snd_sof_dev *sdev = imx_dsp_get_data(ipc); 86 85 87 - sdev = imx_dsp_get_data(ipc); 88 - 89 - spin_lock_irqsave(&sdev->ipc_lock, flags); 86 + guard(spinlock_irqsave)(&sdev->ipc_lock); 90 87 snd_sof_ipc_process_reply(sdev, 0); 91 - spin_unlock_irqrestore(&sdev->ipc_lock, flags); 92 88 } 93 89 94 90 static void imx_handle_request(struct imx_dsp_ipc *ipc)
+1 -6
sound/soc/sof/intel/atom.c
··· 143 143 144 144 /* reply message from DSP */ 145 145 if (ipcx & SHIM_BYT_IPCX_DONE) { 146 - 147 - spin_lock_irq(&sdev->ipc_lock); 148 - 149 146 /* 150 147 * handle immediate reply from DSP core. If the msg is 151 148 * found, set done bit in cmd_done which is called at the ··· 150 153 * because the done bit can't be set in cmd_done function 151 154 * which is triggered by msg 152 155 */ 156 + guard(spinlock_irq)(&sdev->ipc_lock); 153 157 snd_sof_ipc_process_reply(sdev, ipcx); 154 - 155 158 atom_dsp_done(sdev); 156 - 157 - spin_unlock_irq(&sdev->ipc_lock); 158 159 } 159 160 160 161 /* new message from DSP */
+1 -6
sound/soc/sof/intel/bdw.c
··· 315 315 snd_sof_dsp_update_bits_unlocked(sdev, BDW_DSP_BAR, 316 316 SHIM_IMRX, SHIM_IMRX_DONE, 317 317 SHIM_IMRX_DONE); 318 - 319 - spin_lock_irq(&sdev->ipc_lock); 320 - 321 318 /* 322 319 * handle immediate reply from DSP core. If the msg is 323 320 * found, set done bit in cmd_done which is called at the ··· 322 325 * because the done bit can't be set in cmd_done function 323 326 * which is triggered by msg 324 327 */ 328 + guard(spinlock_irq)(&sdev->ipc_lock); 325 329 snd_sof_ipc_process_reply(sdev, ipcx); 326 - 327 330 bdw_dsp_done(sdev); 328 - 329 - spin_unlock_irq(&sdev->ipc_lock); 330 331 } 331 332 332 333 ipcd = snd_sof_dsp_read(sdev, BDW_DSP_BAR, SHIM_IPCD);
+2 -9
sound/soc/sof/intel/cnl.c
··· 69 69 data->primary = primary; 70 70 data->extension = extension; 71 71 72 - spin_lock_irq(&sdev->ipc_lock); 73 - 72 + guard(spinlock_irq)(&sdev->ipc_lock); 74 73 snd_sof_ipc_get_reply(sdev); 75 74 cnl_ipc_host_done(sdev); 76 75 snd_sof_ipc_reply(sdev, data->primary); 77 - 78 - spin_unlock_irq(&sdev->ipc_lock); 79 76 } else { 80 77 dev_dbg_ratelimited(sdev->dev, 81 78 "IPC reply before FW_READY: %#x|%#x\n", ··· 138 141 CNL_DSP_REG_HIPCCTL_DONE, 0); 139 142 140 143 if (likely(sdev->fw_state == SOF_FW_BOOT_COMPLETE)) { 141 - spin_lock_irq(&sdev->ipc_lock); 142 - 143 144 /* handle immediate reply from DSP core */ 145 + guard(spinlock_irq)(&sdev->ipc_lock); 144 146 hda_dsp_ipc_get_reply(sdev); 145 147 snd_sof_ipc_reply(sdev, msg); 146 - 147 148 cnl_ipc_dsp_done(sdev); 148 - 149 - spin_unlock_irq(&sdev->ipc_lock); 150 149 } else { 151 150 dev_dbg_ratelimited(sdev->dev, "IPC reply before FW_READY: %#x\n", 152 151 msg);
+13 -12
sound/soc/sof/intel/hda-dai-ops.c
··· 58 58 return NULL; 59 59 } 60 60 61 - spin_lock_irq(&bus->reg_lock); 61 + guard(spinlock_irq)(&bus->reg_lock); 62 62 list_for_each_entry(hstream, &bus->stream_list, list) { 63 63 struct hdac_ext_stream *hext_stream = 64 64 stream_to_hdac_ext_stream(hstream); ··· 110 110 res->link_locked = 1; 111 111 res->link_substream = substream; 112 112 } 113 - spin_unlock_irq(&bus->reg_lock); 114 113 115 114 return res; 116 115 } ··· 310 311 if (pipe_widget->instance_id < 0) 311 312 return 0; 312 313 313 - mutex_lock(&ipc4_data->pipeline_state_mutex); 314 + guard(mutex)(&ipc4_data->pipeline_state_mutex); 314 315 315 316 switch (cmd) { 316 317 case SNDRV_PCM_TRIGGER_START: ··· 322 323 ret = sof_ipc4_set_pipeline_state(sdev, pipe_widget->instance_id, 323 324 SOF_IPC4_PIPE_PAUSED); 324 325 if (ret < 0) 325 - goto out; 326 + return ret; 326 327 327 328 pipeline->state = SOF_IPC4_PIPE_PAUSED; 329 + 328 330 break; 329 331 default: 330 332 dev_err(sdev->dev, "unknown trigger command %d\n", cmd); 331 333 ret = -EINVAL; 332 334 } 333 - out: 334 - mutex_unlock(&ipc4_data->pipeline_state_mutex); 335 + 335 336 return ret; 336 337 } 337 338 ··· 387 388 if (pipe_widget->instance_id < 0) 388 389 return 0; 389 390 390 - mutex_lock(&ipc4_data->pipeline_state_mutex); 391 + guard(mutex)(&ipc4_data->pipeline_state_mutex); 391 392 392 393 switch (cmd) { 393 394 case SNDRV_PCM_TRIGGER_START: ··· 395 396 ret = sof_ipc4_set_pipeline_state(sdev, pipe_widget->instance_id, 396 397 SOF_IPC4_PIPE_PAUSED); 397 398 if (ret < 0) 398 - goto out; 399 + return ret; 400 + 399 401 pipeline->state = SOF_IPC4_PIPE_PAUSED; 400 402 } 401 403 402 404 ret = sof_ipc4_set_pipeline_state(sdev, pipe_widget->instance_id, 403 405 SOF_IPC4_PIPE_RUNNING); 404 406 if (ret < 0) 405 - goto out; 407 + return ret; 408 + 406 409 pipeline->state = SOF_IPC4_PIPE_RUNNING; 407 410 swidget->spipe->started_count++; 408 411 break; ··· 412 411 ret = sof_ipc4_set_pipeline_state(sdev, pipe_widget->instance_id, 413 412 SOF_IPC4_PIPE_RUNNING); 414 413 if (ret < 0) 415 - goto out; 414 + return ret; 415 + 416 416 pipeline->state = SOF_IPC4_PIPE_RUNNING; 417 417 break; 418 418 case SNDRV_PCM_TRIGGER_SUSPEND: ··· 431 429 ret = -EINVAL; 432 430 break; 433 431 } 434 - out: 435 - mutex_unlock(&ipc4_data->pipeline_state_mutex); 432 + 436 433 return ret; 437 434 } 438 435
+2 -9
sound/soc/sof/intel/hda-ipc.c
··· 204 204 data->primary = primary; 205 205 data->extension = extension; 206 206 207 - spin_lock_irq(&sdev->ipc_lock); 208 - 207 + guard(spinlock_irq)(&sdev->ipc_lock); 209 208 snd_sof_ipc_get_reply(sdev); 210 209 hda_dsp_ipc_host_done(sdev); 211 210 snd_sof_ipc_reply(sdev, data->primary); 212 - 213 - spin_unlock_irq(&sdev->ipc_lock); 214 211 } else { 215 212 dev_dbg_ratelimited(sdev->dev, 216 213 "IPC reply before FW_READY: %#x|%#x\n", ··· 286 289 * reply. 287 290 */ 288 291 if (likely(sdev->fw_state == SOF_FW_BOOT_COMPLETE)) { 289 - spin_lock_irq(&sdev->ipc_lock); 290 - 291 292 /* handle immediate reply from DSP core */ 293 + guard(spinlock_irq)(&sdev->ipc_lock); 292 294 hda_dsp_ipc_get_reply(sdev); 293 295 snd_sof_ipc_reply(sdev, msg); 294 - 295 296 /* set the done bit */ 296 297 hda_dsp_ipc_dsp_done(sdev); 297 - 298 - spin_unlock_irq(&sdev->ipc_lock); 299 298 } else { 300 299 dev_dbg_ratelimited(sdev->dev, "IPC reply before FW_READY: %#x\n", 301 300 msg);
+8 -21
sound/soc/sof/intel/hda-mlink.c
··· 524 524 525 525 hlink = &h2link->hext_link; 526 526 527 - mutex_lock(&h2link->eml_lock); 528 - 529 - hdaml_link_enable_interrupt(hlink->ml_addr + AZX_REG_ML_LCTL, enable); 530 - 531 - mutex_unlock(&h2link->eml_lock); 527 + scoped_guard(mutex, &h2link->eml_lock) 528 + hdaml_link_enable_interrupt(hlink->ml_addr + AZX_REG_ML_LCTL, enable); 532 529 } 533 530 EXPORT_SYMBOL_NS(hdac_bus_eml_enable_interrupt, "SND_SOC_SOF_HDA_MLINK"); 534 531 ··· 834 837 835 838 hlink = &h2link->hext_link; 836 839 837 - mutex_lock(&h2link->eml_lock); 838 - 839 - hdaml_link_set_lsdiid(hlink->ml_addr + AZX_REG_ML_LSDIID_OFFSET(sublink), dev_num); 840 - 841 - mutex_unlock(&h2link->eml_lock); 840 + scoped_guard(mutex, &h2link->eml_lock) 841 + hdaml_link_set_lsdiid(hlink->ml_addr + AZX_REG_ML_LSDIID_OFFSET(sublink), dev_num); 842 842 843 843 return 0; 844 844 } EXPORT_SYMBOL_NS(hdac_bus_eml_sdw_set_lsdiid, "SND_SOC_SOF_HDA_MLINK"); ··· 869 875 lchan = 0; 870 876 } 871 877 872 - mutex_lock(&h2link->eml_lock); 873 - 874 - hdaml_shim_map_stream_ch(pcmsycm, lchan, hchan, 875 - stream_id, dir); 876 - 877 - mutex_unlock(&h2link->eml_lock); 878 + scoped_guard(mutex, &h2link->eml_lock) 879 + hdaml_shim_map_stream_ch(pcmsycm, lchan, hchan, stream_id, dir); 878 880 879 881 val = readw(pcmsycm); 880 882 ··· 1002 1012 1003 1013 hlink = &h2link->hext_link; 1004 1014 1005 - mutex_lock(&h2link->eml_lock); 1006 - 1007 - hdaml_lctl_offload_enable(hlink->ml_addr + AZX_REG_ML_LCTL, enable); 1008 - 1009 - mutex_unlock(&h2link->eml_lock); 1015 + scoped_guard(mutex, &h2link->eml_lock) 1016 + hdaml_lctl_offload_enable(hlink->ml_addr + AZX_REG_ML_LCTL, enable); 1010 1017 1011 1018 return 0; 1012 1019 }
+4 -7
sound/soc/sof/intel/hda-stream.c
··· 724 724 struct hdac_bus *bus = sof_to_bus(sdev); 725 725 u32 mask = BIT(hstream->index); 726 726 727 - spin_lock_irq(&bus->reg_lock); 727 + guard(spinlock_irq)(&bus->reg_lock); 728 + 728 729 /* couple host and link DMA if link DMA channel is idle */ 729 730 if (!hext_stream->link_locked) 730 731 snd_sof_dsp_update_bits(sdev, HDA_DSP_PP_BAR, 731 732 SOF_HDA_REG_PP_PPCTL, mask, 0); 732 - spin_unlock_irq(&bus->reg_lock); 733 733 } 734 734 735 735 hda_dsp_stream_spib_config(sdev, hext_stream, HDA_DSP_SPIB_DISABLE, 0); ··· 747 747 u32 status; 748 748 749 749 /* The function can be called at irq thread, so use spin_lock_irq */ 750 - spin_lock_irq(&bus->reg_lock); 750 + guard(spinlock_irq)(&bus->reg_lock); 751 751 752 752 status = snd_sof_dsp_read(sdev, HDA_DSP_HDA_BAR, SOF_HDA_INTSTS); 753 753 ··· 756 756 /* if Register inaccessible, ignore it.*/ 757 757 if (status != 0xffffffff) 758 758 ret = true; 759 - 760 - spin_unlock_irq(&bus->reg_lock); 761 759 762 760 return ret; 763 761 } ··· 840 842 * unsolicited responses from the codec 841 843 */ 842 844 for (i = 0, active = true; i < 10 && active; i++) { 843 - spin_lock_irq(&bus->reg_lock); 845 + guard(spinlock_irq)(&bus->reg_lock); 844 846 845 847 status = snd_sof_dsp_read(sdev, HDA_DSP_HDA_BAR, SOF_HDA_INTSTS); 846 848 ··· 851 853 if (status & AZX_INT_CTRL_EN) { 852 854 active |= hda_codec_check_rirb_status(sdev); 853 855 } 854 - spin_unlock_irq(&bus->reg_lock); 855 856 } 856 857 857 858 return IRQ_HANDLED;
+1 -4
sound/soc/sof/intel/mtl.c
··· 596 596 data->primary = primary; 597 597 data->extension = extension; 598 598 599 - spin_lock_irq(&sdev->ipc_lock); 600 - 599 + guard(spinlock_irq)(&sdev->ipc_lock); 601 600 snd_sof_ipc_get_reply(sdev); 602 601 mtl_ipc_host_done(sdev); 603 602 snd_sof_ipc_reply(sdev, data->primary); 604 - 605 - spin_unlock_irq(&sdev->ipc_lock); 606 603 } else { 607 604 dev_dbg_ratelimited(sdev->dev, 608 605 "IPC reply before FW_READY: %#x|%#x\n",
+3 -6
sound/soc/sof/ipc.c
··· 47 47 * The spin-lock is needed to protect message objects against other 48 48 * atomic contexts. 49 49 */ 50 - spin_lock_irq(&sdev->ipc_lock); 50 + guard(spinlock_irq)(&sdev->ipc_lock); 51 51 52 52 /* initialise the message */ 53 53 msg = &ipc->msg; ··· 65 65 /* Next reply that we receive will be related to this message */ 66 66 if (!ret) 67 67 msg->ipc_complete = false; 68 - 69 - spin_unlock_irq(&sdev->ipc_lock); 70 68 71 69 return ret; 72 70 } ··· 223 225 return; 224 226 225 227 /* disable sending of ipc's */ 226 - mutex_lock(&ipc->tx_mutex); 227 - ipc->disable_ipc_tx = true; 228 - mutex_unlock(&ipc->tx_mutex); 228 + scoped_guard(mutex, &ipc->tx_mutex) 229 + ipc->disable_ipc_tx = true; 229 230 230 231 if (ipc->ops->exit) 231 232 ipc->ops->exit(sdev);
+3 -3
sound/soc/sof/ipc3-topology.c
··· 2427 2427 /* Do not free widgets for static pipelines with FW older than SOF2.2 */ 2428 2428 if (!verify && !swidget->dynamic_pipeline_widget && 2429 2429 SOF_FW_VER(v->major, v->minor, v->micro) < SOF_FW_VER(2, 2, 0)) { 2430 - mutex_lock(&swidget->setup_mutex); 2431 - swidget->use_count = 0; 2432 - mutex_unlock(&swidget->setup_mutex); 2430 + scoped_guard(mutex, &swidget->setup_mutex) 2431 + swidget->use_count = 0; 2432 + 2433 2433 if (swidget->spipe) 2434 2434 swidget->spipe->complete = 0; 2435 2435 continue;
+2 -6
sound/soc/sof/ipc3.c
··· 378 378 } 379 379 380 380 /* Serialise IPC TX */ 381 - mutex_lock(&ipc->tx_mutex); 381 + guard(mutex)(&ipc->tx_mutex); 382 382 383 383 ret = ipc3_tx_msg_unlocked(ipc, msg_data, msg_bytes, reply_data, reply_bytes); 384 384 ··· 404 404 sof_ipc3_dump_payload(sdev, payload, payload_bytes); 405 405 } 406 406 } 407 - 408 - mutex_unlock(&ipc->tx_mutex); 409 407 410 408 return ret; 411 409 } ··· 475 477 memcpy(cdata_chunk, cdata, hdr_bytes); 476 478 477 479 /* Serialise IPC TX */ 478 - mutex_lock(&sdev->ipc->tx_mutex); 480 + guard(mutex)(&ipc->tx_mutex); 479 481 480 482 /* copy the payload data in a loop */ 481 483 for (i = 0; i < num_msg; i++) { ··· 508 510 payload += header_bytes; 509 511 sof_ipc3_dump_payload(sdev, payload, data_bytes - header_bytes); 510 512 } 511 - 512 - mutex_unlock(&sdev->ipc->tx_mutex); 513 513 514 514 kfree(cdata_chunk); 515 515
+9 -15
sound/soc/sof/ipc4-mtrace.c
··· 118 118 struct sof_mtrace_core_data *core_data = inode->i_private; 119 119 int ret; 120 120 121 - mutex_lock(&core_data->buffer_lock); 121 + guard(mutex)(&core_data->buffer_lock); 122 122 123 - if (core_data->log_buffer) { 124 - ret = -EBUSY; 125 - goto out; 126 - } 123 + if (core_data->log_buffer) 124 + return -EBUSY; 127 125 128 126 ret = debugfs_file_get(file->f_path.dentry); 129 127 if (unlikely(ret)) 130 - goto out; 128 + return ret; 131 129 132 130 core_data->log_buffer = kmalloc(SOF_IPC4_DEBUG_SLOT_SIZE, GFP_KERNEL); 133 131 if (!core_data->log_buffer) { 134 132 debugfs_file_put(file->f_path.dentry); 135 - ret = -ENOMEM; 136 - goto out; 133 + return -ENOMEM; 137 134 } 138 135 139 136 ret = simple_open(inode, file); ··· 138 141 kfree(core_data->log_buffer); 139 142 debugfs_file_put(file->f_path.dentry); 140 143 } 141 - 142 - out: 143 - mutex_unlock(&core_data->buffer_lock); 144 144 145 145 return ret; 146 146 } ··· 275 281 276 282 debugfs_file_put(file->f_path.dentry); 277 283 278 - mutex_lock(&core_data->buffer_lock); 279 - kfree(core_data->log_buffer); 280 - core_data->log_buffer = NULL; 281 - mutex_unlock(&core_data->buffer_lock); 284 + scoped_guard(mutex, &core_data->buffer_lock) { 285 + kfree(core_data->log_buffer); 286 + core_data->log_buffer = NULL; 287 + } 282 288 283 289 return 0; 284 290 }
+1 -2
sound/soc/sof/ipc4-pcm.c
··· 487 487 return -ENOMEM; 488 488 } 489 489 490 - mutex_lock(&ipc4_data->pipeline_state_mutex); 490 + guard(mutex)(&ipc4_data->pipeline_state_mutex); 491 491 492 492 /* 493 493 * IPC4 requires pipelines to be triggered in order starting at the sink and ··· 580 580 } 581 581 582 582 free: 583 - mutex_unlock(&ipc4_data->pipeline_state_mutex); 584 583 kfree(trigger_list); 585 584 kfree(pipe_priority); 586 585 return ret;
+1 -4
sound/soc/sof/ipc4-topology.c
··· 3241 3241 struct sof_ipc4_fw_data *ipc4_data = sdev->private; 3242 3242 int ret = 0; 3243 3243 3244 - mutex_lock(&ipc4_data->pipeline_state_mutex); 3244 + guard(mutex)(&ipc4_data->pipeline_state_mutex); 3245 3245 3246 3246 /* freeing a pipeline frees all the widgets associated with it */ 3247 3247 if (swidget->id == snd_soc_dapm_scheduler) { ··· 3252 3252 if (pipeline->use_chain_dma) { 3253 3253 dev_warn(sdev->dev, "use_chain_dma set for scheduler %s", 3254 3254 swidget->widget->name); 3255 - mutex_unlock(&ipc4_data->pipeline_state_mutex); 3256 3255 return 0; 3257 3256 } 3258 3257 ··· 3278 3279 if (!pipeline->use_chain_dma) 3279 3280 ida_free(&fw_module->m_ida, swidget->instance_id); 3280 3281 } 3281 - 3282 - mutex_unlock(&ipc4_data->pipeline_state_mutex); 3283 3282 3284 3283 return ret; 3285 3284 }
+2 -6
sound/soc/sof/ipc4.c
··· 412 412 } 413 413 414 414 /* Serialise IPC TX */ 415 - mutex_lock(&ipc->tx_mutex); 415 + guard(mutex)(&ipc->tx_mutex); 416 416 417 417 ret = ipc4_tx_msg_unlocked(ipc, msg_data, msg_bytes, reply_data, reply_bytes); 418 418 ··· 428 428 if (msg) 429 429 sof_ipc4_dump_payload(sdev, msg->data_ptr, msg->data_size); 430 430 } 431 - 432 - mutex_unlock(&ipc->tx_mutex); 433 431 434 432 return ret; 435 433 } ··· 504 506 } 505 507 506 508 /* Serialise IPC TX */ 507 - mutex_lock(&sdev->ipc->tx_mutex); 509 + guard(mutex)(&sdev->ipc->tx_mutex); 508 510 509 511 do { 510 512 size_t tx_size, rx_size; ··· 587 589 out: 588 590 if (sof_debug_check_flag(SOF_DBG_DUMP_IPC_MESSAGE_PAYLOAD)) 589 591 sof_ipc4_dump_payload(sdev, ipc4_msg->data_ptr, ipc4_msg->data_size); 590 - 591 - mutex_unlock(&sdev->ipc->tx_mutex); 592 592 593 593 kfree(tx_payload_for_get); 594 594
+1 -3
sound/soc/sof/mediatek/mtk-adsp-common.c
··· 107 107 void mtk_adsp_handle_reply(struct mtk_adsp_ipc *ipc) 108 108 { 109 109 struct adsp_priv *priv = mtk_adsp_ipc_get_data(ipc); 110 - unsigned long flags; 111 110 112 - spin_lock_irqsave(&priv->sdev->ipc_lock, flags); 111 + guard(spinlock_irqsave)(&priv->sdev->ipc_lock); 113 112 snd_sof_ipc_process_reply(priv->sdev, 0); 114 - spin_unlock_irqrestore(&priv->sdev->ipc_lock, flags); 115 113 } 116 114 EXPORT_SYMBOL(mtk_adsp_handle_reply); 117 115
+7 -27
sound/soc/sof/ops.c
··· 38 38 bool snd_sof_pci_update_bits(struct snd_sof_dev *sdev, u32 offset, 39 39 u32 mask, u32 value) 40 40 { 41 - unsigned long flags; 42 - bool change; 43 - 44 - spin_lock_irqsave(&sdev->hw_lock, flags); 45 - change = snd_sof_pci_update_bits_unlocked(sdev, offset, mask, value); 46 - spin_unlock_irqrestore(&sdev->hw_lock, flags); 47 - return change; 41 + guard(spinlock_irqsave)(&sdev->hw_lock); 42 + return snd_sof_pci_update_bits_unlocked(sdev, offset, mask, value); 48 43 } 49 44 EXPORT_SYMBOL(snd_sof_pci_update_bits); 50 45 ··· 85 90 bool snd_sof_dsp_update_bits(struct snd_sof_dev *sdev, u32 bar, u32 offset, 86 91 u32 mask, u32 value) 87 92 { 88 - unsigned long flags; 89 - bool change; 90 - 91 - spin_lock_irqsave(&sdev->hw_lock, flags); 92 - change = snd_sof_dsp_update_bits_unlocked(sdev, bar, offset, mask, 93 - value); 94 - spin_unlock_irqrestore(&sdev->hw_lock, flags); 95 - return change; 93 + guard(spinlock_irqsave)(&sdev->hw_lock); 94 + return snd_sof_dsp_update_bits_unlocked(sdev, bar, offset, mask, value); 96 95 } 97 96 EXPORT_SYMBOL(snd_sof_dsp_update_bits); 98 97 99 98 bool snd_sof_dsp_update_bits64(struct snd_sof_dev *sdev, u32 bar, u32 offset, 100 99 u64 mask, u64 value) 101 100 { 102 - unsigned long flags; 103 - bool change; 104 - 105 - spin_lock_irqsave(&sdev->hw_lock, flags); 106 - change = snd_sof_dsp_update_bits64_unlocked(sdev, bar, offset, mask, 107 - value); 108 - spin_unlock_irqrestore(&sdev->hw_lock, flags); 109 - return change; 101 + guard(spinlock_irqsave)(&sdev->hw_lock); 102 + return snd_sof_dsp_update_bits64_unlocked(sdev, bar, offset, mask, value); 110 103 } 111 104 EXPORT_SYMBOL(snd_sof_dsp_update_bits64); 112 105 ··· 117 134 void snd_sof_dsp_update_bits_forced(struct snd_sof_dev *sdev, u32 bar, 118 135 u32 offset, u32 mask, u32 value) 119 136 { 120 - unsigned long flags; 121 - 122 - spin_lock_irqsave(&sdev->hw_lock, flags); 137 + guard(spinlock_irqsave)(&sdev->hw_lock); 123 138 snd_sof_dsp_update_bits_forced_unlocked(sdev, bar, offset, mask, value); 124 - spin_unlock_irqrestore(&sdev->hw_lock, flags); 125 139 } 126 140 EXPORT_SYMBOL(snd_sof_dsp_update_bits_forced); 127 141
+3 -7
sound/soc/sof/ops.h
··· 287 287 snd_sof_dsp_set_power_state(struct snd_sof_dev *sdev, 288 288 const struct sof_dsp_power_state *target_state) 289 289 { 290 - int ret = 0; 291 - 292 - mutex_lock(&sdev->power_state_access); 290 + guard(mutex)(&sdev->power_state_access); 293 291 294 292 if (sof_ops(sdev)->set_power_state) 295 - ret = sof_ops(sdev)->set_power_state(sdev, target_state); 293 + return sof_ops(sdev)->set_power_state(sdev, target_state); 296 294 297 - mutex_unlock(&sdev->power_state_access); 298 - 299 - return ret; 295 + return 0; 300 296 } 301 297 302 298 /* debug */
+17 -29
sound/soc/sof/sof-audio.c
··· 121 121 122 122 int sof_widget_free(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget) 123 123 { 124 - int ret; 125 - 126 - mutex_lock(&swidget->setup_mutex); 127 - ret = sof_widget_free_unlocked(sdev, swidget); 128 - mutex_unlock(&swidget->setup_mutex); 129 - 130 - return ret; 124 + guard(mutex)(&swidget->setup_mutex); 125 + return sof_widget_free_unlocked(sdev, swidget); 131 126 } 132 127 EXPORT_SYMBOL(sof_widget_free); 133 128 ··· 235 240 236 241 int sof_widget_setup(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget) 237 242 { 238 - int ret; 239 - 240 - mutex_lock(&swidget->setup_mutex); 241 - ret = sof_widget_setup_unlocked(sdev, swidget); 242 - mutex_unlock(&swidget->setup_mutex); 243 - 244 - return ret; 243 + guard(mutex)(&swidget->setup_mutex); 244 + return sof_widget_setup_unlocked(sdev, swidget); 245 245 } 246 246 EXPORT_SYMBOL(sof_widget_setup); 247 247 ··· 367 377 else 368 378 swidget = sroute->src_widget; 369 379 370 - mutex_lock(&swidget->setup_mutex); 371 - if (!swidget->use_count) { 372 - mutex_unlock(&swidget->setup_mutex); 373 - continue; 374 - } 380 + scoped_guard(mutex, &swidget->setup_mutex) { 381 + if (!swidget->use_count) 382 + continue; 375 383 376 - if (tplg_ops && tplg_ops->route_setup) { 377 - /* 378 - * this route will get freed when either the source widget or the sink 379 - * widget is freed during hw_free 380 - */ 381 - ret = tplg_ops->route_setup(sdev, sroute); 382 - if (!ret) 383 - sroute->setup = true; 384 + if (tplg_ops && tplg_ops->route_setup) { 385 + /* 386 + * this route will get freed when either the 387 + * source widget or the sink widget is freed 388 + * during hw_free 389 + */ 390 + ret = tplg_ops->route_setup(sdev, sroute); 391 + if (!ret) 392 + sroute->setup = true; 393 + } 384 394 } 385 - 386 - mutex_unlock(&swidget->setup_mutex); 387 395 388 396 if (ret < 0) 389 397 return ret;
+11 -29
sound/soc/sof/sof-client.c
··· 265 265 } 266 266 267 267 /* add to list of SOF client devices */ 268 - mutex_lock(&sdev->ipc_client_mutex); 269 - list_add(&centry->list, &sdev->ipc_client_list); 270 - mutex_unlock(&sdev->ipc_client_mutex); 268 + scoped_guard(mutex, &sdev->ipc_client_mutex) 269 + list_add(&centry->list, &sdev->ipc_client_list); 271 270 272 271 return 0; 273 272 ··· 284 285 { 285 286 struct sof_client_dev_entry *centry; 286 287 287 - mutex_lock(&sdev->ipc_client_mutex); 288 + guard(mutex)(&sdev->ipc_client_mutex); 288 289 289 290 /* 290 291 * sof_client_auxdev_release() will be invoked to free up memory ··· 300 301 break; 301 302 } 302 303 } 303 - 304 - mutex_unlock(&sdev->ipc_client_mutex); 305 304 } 306 305 EXPORT_SYMBOL_NS_GPL(sof_client_dev_unregister, "SND_SOC_SOF_CLIENT"); 307 306 ··· 397 400 const struct auxiliary_driver *adrv; 398 401 struct sof_client_dev_entry *centry; 399 402 400 - mutex_lock(&sdev->ipc_client_mutex); 403 + guard(mutex)(&sdev->ipc_client_mutex); 401 404 402 405 list_for_each_entry(centry, &sdev->ipc_client_list, list) { 403 406 struct sof_client_dev *cdev = &centry->client_dev; ··· 411 414 adrv->suspend(&cdev->auxdev, state); 412 415 } 413 416 414 - mutex_unlock(&sdev->ipc_client_mutex); 415 - 416 417 return 0; 417 418 } 418 419 EXPORT_SYMBOL_NS_GPL(sof_suspend_clients, "SND_SOC_SOF_CLIENT"); ··· 420 425 const struct auxiliary_driver *adrv; 421 426 struct sof_client_dev_entry *centry; 422 427 423 - mutex_lock(&sdev->ipc_client_mutex); 428 + guard(mutex)(&sdev->ipc_client_mutex); 424 429 425 430 list_for_each_entry(centry, &sdev->ipc_client_list, list) { 426 431 struct sof_client_dev *cdev = &centry->client_dev; ··· 433 438 if (adrv->resume) 434 439 adrv->resume(&cdev->auxdev); 435 440 } 436 - 437 - mutex_unlock(&sdev->ipc_client_mutex); 438 441 439 442 return 0; 440 443 } ··· 525 532 return; 526 533 } 527 534 528 - mutex_lock(&sdev->client_event_handler_mutex); 529 - 535 + guard(mutex)(&sdev->client_event_handler_mutex); 530 536 list_for_each_entry(event, &sdev->ipc_rx_handler_list, list) { 531 537 if (event->ipc_msg_type == msg_type) 532 538 event->callback(event->cdev, msg_buf); 533 539 } 534 - 535 - mutex_unlock(&sdev->client_event_handler_mutex); 536 540 } 537 541 538 542 int sof_client_register_ipc_rx_handler(struct sof_client_dev *cdev, ··· 563 573 event->callback = callback; 564 574 565 575 /* add to list of SOF client devices */ 566 - mutex_lock(&sdev->client_event_handler_mutex); 576 + guard(mutex)(&sdev->client_event_handler_mutex); 567 577 list_add(&event->list, &sdev->ipc_rx_handler_list); 568 - mutex_unlock(&sdev->client_event_handler_mutex); 569 578 570 579 return 0; 571 580 } ··· 576 587 struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev); 577 588 struct sof_ipc_event_entry *event; 578 589 579 - mutex_lock(&sdev->client_event_handler_mutex); 590 + guard(mutex)(&sdev->ipc_client_mutex); 580 591 581 592 list_for_each_entry(event, &sdev->ipc_rx_handler_list, list) { 582 593 if (event->cdev == cdev && event->ipc_msg_type == ipc_msg_type) { ··· 585 596 break; 586 597 } 587 598 } 588 - 589 - mutex_unlock(&sdev->client_event_handler_mutex); 590 599 } 591 600 EXPORT_SYMBOL_NS_GPL(sof_client_unregister_ipc_rx_handler, "SND_SOC_SOF_CLIENT"); 592 601 ··· 593 606 { 594 607 struct sof_state_event_entry *event; 595 608 596 - mutex_lock(&sdev->client_event_handler_mutex); 609 + guard(mutex)(&sdev->ipc_client_mutex); 597 610 598 611 list_for_each_entry(event, &sdev->fw_state_handler_list, list) 599 612 event->callback(event->cdev, sdev->fw_state); 600 - 601 - mutex_unlock(&sdev->client_event_handler_mutex); 602 613 } 603 614 604 615 int sof_client_register_fw_state_handler(struct sof_client_dev *cdev, ··· 616 631 event->callback = callback; 617 632 618 633 /* add to list of SOF client devices */ 619 - mutex_lock(&sdev->client_event_handler_mutex); 634 + guard(mutex)(&sdev->client_event_handler_mutex); 620 635 list_add(&event->list, &sdev->fw_state_handler_list); 621 - mutex_unlock(&sdev->client_event_handler_mutex); 622 636 623 637 return 0; 624 638 } ··· 628 644 struct snd_sof_dev *sdev = sof_client_dev_to_sof_dev(cdev); 629 645 struct sof_state_event_entry *event; 630 646 631 - mutex_lock(&sdev->client_event_handler_mutex); 647 + guard(mutex)(&sdev->ipc_client_mutex); 632 648 633 649 list_for_each_entry(event, &sdev->fw_state_handler_list, list) { 634 650 if (event->cdev == cdev) { ··· 637 653 break; 638 654 } 639 655 } 640 - 641 - mutex_unlock(&sdev->client_event_handler_mutex); 642 656 } 643 657 EXPORT_SYMBOL_NS_GPL(sof_client_unregister_fw_state_handler, "SND_SOC_SOF_CLIENT"); 644 658