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.

drm/imx/dcss: have all init functions use devres

dcss currently allocates and ioremaps quite a few resources in its probe
function's call graph. Devres now provides convenient functions which
perform the same task but do the cleanup automatically.

Port all memory allocations and ioremap() calls to the devres
counterparts.

Signed-off-by: Philipp Stanner <pstanner@redhat.com>
Reviewed-by: Laurentiu Palcu <laurentiu.palcu@oss.nxp.com>
Signed-off-by: Laurentiu Palcu <laurentiu.palcu@oss.nxp.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20240124111904.18261-4-pstanner@redhat.com

authored by

Philipp Stanner and committed by
Laurentiu Palcu 2bb98fc1 90393c9b

+24 -108
+2 -11
drivers/gpu/drm/imx/dcss/dcss-blkctl.c
··· 42 42 { 43 43 struct dcss_blkctl *blkctl; 44 44 45 - blkctl = kzalloc(sizeof(*blkctl), GFP_KERNEL); 45 + blkctl = devm_kzalloc(dcss->dev, sizeof(*blkctl), GFP_KERNEL); 46 46 if (!blkctl) 47 47 return -ENOMEM; 48 48 49 - blkctl->base_reg = ioremap(blkctl_base, SZ_4K); 49 + blkctl->base_reg = devm_ioremap(dcss->dev, blkctl_base, SZ_4K); 50 50 if (!blkctl->base_reg) { 51 51 dev_err(dcss->dev, "unable to remap BLK CTRL base\n"); 52 - kfree(blkctl); 53 52 return -ENOMEM; 54 53 } 55 54 ··· 58 59 dcss_blkctl_cfg(blkctl); 59 60 60 61 return 0; 61 - } 62 - 63 - void dcss_blkctl_exit(struct dcss_blkctl *blkctl) 64 - { 65 - if (blkctl->base_reg) 66 - iounmap(blkctl->base_reg); 67 - 68 - kfree(blkctl); 69 62 }
+3 -11
drivers/gpu/drm/imx/dcss/dcss-ctxld.c
··· 202 202 struct dcss_ctxld *ctxld; 203 203 int ret; 204 204 205 - ctxld = kzalloc(sizeof(*ctxld), GFP_KERNEL); 205 + ctxld = devm_kzalloc(dcss->dev, sizeof(*ctxld), GFP_KERNEL); 206 206 if (!ctxld) 207 207 return -ENOMEM; 208 208 ··· 217 217 goto err; 218 218 } 219 219 220 - ctxld->ctxld_reg = ioremap(ctxld_base, SZ_4K); 220 + ctxld->ctxld_reg = devm_ioremap(dcss->dev, ctxld_base, SZ_4K); 221 221 if (!ctxld->ctxld_reg) { 222 222 dev_err(dcss->dev, "ctxld: unable to remap ctxld base\n"); 223 223 ret = -ENOMEM; ··· 226 226 227 227 ret = dcss_ctxld_irq_config(ctxld, to_platform_device(dcss->dev)); 228 228 if (ret) 229 - goto err_irq; 229 + goto err; 230 230 231 231 dcss_ctxld_hw_cfg(ctxld); 232 232 233 233 return 0; 234 234 235 - err_irq: 236 - iounmap(ctxld->ctxld_reg); 237 - 238 235 err: 239 236 dcss_ctxld_free_ctx(ctxld); 240 - kfree(ctxld); 241 237 242 238 return ret; 243 239 } ··· 242 246 { 243 247 free_irq(ctxld->irq, ctxld); 244 248 245 - if (ctxld->ctxld_reg) 246 - iounmap(ctxld->ctxld_reg); 247 - 248 249 dcss_ctxld_free_ctx(ctxld); 249 - kfree(ctxld); 250 250 } 251 251 252 252 static int dcss_ctxld_enable_locked(struct dcss_ctxld *ctxld)
+2 -10
drivers/gpu/drm/imx/dcss/dcss-dev.c
··· 109 109 dcss_ctxld_exit(dcss->ctxld); 110 110 111 111 ctxld_err: 112 - dcss_blkctl_exit(dcss->blkctl); 113 - 114 112 dcss_clocks_disable(dcss); 115 113 116 114 return ret; ··· 122 124 dcss_ss_exit(dcss->ss); 123 125 dcss_dtg_exit(dcss->dtg); 124 126 dcss_ctxld_exit(dcss->ctxld); 125 - dcss_blkctl_exit(dcss->blkctl); 126 127 dcss_clocks_disable(dcss); 127 128 } 128 129 ··· 187 190 return ERR_PTR(-EBUSY); 188 191 } 189 192 190 - dcss = kzalloc(sizeof(*dcss), GFP_KERNEL); 193 + dcss = devm_kzalloc(dev, sizeof(*dcss), GFP_KERNEL); 191 194 if (!dcss) 192 195 return ERR_PTR(-ENOMEM); 193 196 ··· 198 201 ret = dcss_clks_init(dcss); 199 202 if (ret) { 200 203 dev_err(dev, "clocks initialization failed\n"); 201 - goto err; 204 + return ERR_PTR(ret); 202 205 } 203 206 204 207 dcss->of_port = of_graph_get_port_by_id(dev->of_node, 0); ··· 230 233 clks_err: 231 234 dcss_clks_release(dcss); 232 235 233 - err: 234 - kfree(dcss); 235 - 236 236 return ERR_PTR(ret); 237 237 } 238 238 ··· 247 253 dcss_submodules_stop(dcss); 248 254 249 255 dcss_clks_release(dcss); 250 - 251 - kfree(dcss); 252 256 } 253 257 254 258 static int dcss_dev_suspend(struct device *dev)
-1
drivers/gpu/drm/imx/dcss/dcss-dev.h
··· 104 104 /* BLKCTL */ 105 105 int dcss_blkctl_init(struct dcss_dev *dcss, unsigned long blkctl_base); 106 106 void dcss_blkctl_cfg(struct dcss_blkctl *blkctl); 107 - void dcss_blkctl_exit(struct dcss_blkctl *blkctl); 108 107 109 108 /* CTXLD */ 110 109 int dcss_ctxld_init(struct dcss_dev *dcss, unsigned long ctxld_base);
+3 -18
drivers/gpu/drm/imx/dcss/dcss-dpr.c
··· 135 135 136 136 ch->base_ofs = dpr_base + i * 0x1000; 137 137 138 - ch->base_reg = ioremap(ch->base_ofs, SZ_4K); 138 + ch->base_reg = devm_ioremap(dpr->dev, ch->base_ofs, SZ_4K); 139 139 if (!ch->base_reg) { 140 140 dev_err(dpr->dev, "dpr: unable to remap ch %d base\n", 141 141 i); ··· 155 155 { 156 156 struct dcss_dpr *dpr; 157 157 158 - dpr = kzalloc(sizeof(*dpr), GFP_KERNEL); 158 + dpr = devm_kzalloc(dcss->dev, sizeof(*dpr), GFP_KERNEL); 159 159 if (!dpr) 160 160 return -ENOMEM; 161 161 ··· 164 164 dpr->ctxld = dcss->ctxld; 165 165 dpr->ctx_id = CTX_SB_HP; 166 166 167 - if (dcss_dpr_ch_init_all(dpr, dpr_base)) { 168 - int i; 169 - 170 - for (i = 0; i < 3; i++) { 171 - if (dpr->ch[i].base_reg) 172 - iounmap(dpr->ch[i].base_reg); 173 - } 174 - 175 - kfree(dpr); 176 - 167 + if (dcss_dpr_ch_init_all(dpr, dpr_base)) 177 168 return -ENOMEM; 178 - } 179 169 180 170 return 0; 181 171 } ··· 179 189 struct dcss_dpr_ch *ch = &dpr->ch[ch_no]; 180 190 181 191 dcss_writel(0, ch->base_reg + DCSS_DPR_SYSTEM_CTRL0); 182 - 183 - if (ch->base_reg) 184 - iounmap(ch->base_reg); 185 192 } 186 - 187 - kfree(dpr); 188 193 } 189 194 190 195 static u32 dcss_dpr_x_pix_wide_adjust(struct dcss_dpr_ch *ch, u32 pix_wide,
+3 -9
drivers/gpu/drm/imx/dcss/dcss-drv.c
··· 51 51 52 52 of_node_put(remote); 53 53 54 - mdrv = kzalloc(sizeof(*mdrv), GFP_KERNEL); 54 + mdrv = devm_kzalloc(dev, sizeof(*mdrv), GFP_KERNEL); 55 55 if (!mdrv) 56 56 return -ENOMEM; 57 57 58 58 mdrv->dcss = dcss_dev_create(dev, hdmi_output); 59 - if (IS_ERR(mdrv->dcss)) { 60 - err = PTR_ERR(mdrv->dcss); 61 - goto err; 62 - } 59 + if (IS_ERR(mdrv->dcss)) 60 + return PTR_ERR(mdrv->dcss); 63 61 64 62 dev_set_drvdata(dev, mdrv); 65 63 ··· 73 75 dcss_shutoff: 74 76 dcss_dev_destroy(mdrv->dcss); 75 77 76 - err: 77 - kfree(mdrv); 78 78 return err; 79 79 } 80 80 ··· 82 86 83 87 dcss_kms_detach(mdrv->kms); 84 88 dcss_dev_destroy(mdrv->dcss); 85 - 86 - kfree(mdrv); 87 89 } 88 90 89 91 static void dcss_drv_platform_shutdown(struct platform_device *pdev)
+5 -21
drivers/gpu/drm/imx/dcss/dcss-dtg.c
··· 152 152 int ret = 0; 153 153 struct dcss_dtg *dtg; 154 154 155 - dtg = kzalloc(sizeof(*dtg), GFP_KERNEL); 155 + dtg = devm_kzalloc(dcss->dev, sizeof(*dtg), GFP_KERNEL); 156 156 if (!dtg) 157 157 return -ENOMEM; 158 158 ··· 160 160 dtg->dev = dcss->dev; 161 161 dtg->ctxld = dcss->ctxld; 162 162 163 - dtg->base_reg = ioremap(dtg_base, SZ_4K); 163 + dtg->base_reg = devm_ioremap(dtg->dev, dtg_base, SZ_4K); 164 164 if (!dtg->base_reg) { 165 - dev_err(dcss->dev, "dtg: unable to remap dtg base\n"); 166 - ret = -ENOMEM; 167 - goto err_ioremap; 165 + dev_err(dtg->dev, "dtg: unable to remap dtg base\n"); 166 + return -ENOMEM; 168 167 } 169 168 170 169 dtg->base_ofs = dtg_base; ··· 174 175 dtg->control_status |= OVL_DATA_MODE | BLENDER_VIDEO_ALPHA_SEL | 175 176 ((dtg->alpha << DEFAULT_FG_ALPHA_POS) & DEFAULT_FG_ALPHA_MASK); 176 177 177 - ret = dcss_dtg_irq_config(dtg, to_platform_device(dcss->dev)); 178 - if (ret) 179 - goto err_irq; 180 - 181 - return 0; 182 - 183 - err_irq: 184 - iounmap(dtg->base_reg); 185 - 186 - err_ioremap: 187 - kfree(dtg); 178 + ret = dcss_dtg_irq_config(dtg, to_platform_device(dtg->dev)); 188 179 189 180 return ret; 190 181 } ··· 182 193 void dcss_dtg_exit(struct dcss_dtg *dtg) 183 194 { 184 195 free_irq(dtg->ctxld_kick_irq, dtg); 185 - 186 - if (dtg->base_reg) 187 - iounmap(dtg->base_reg); 188 - 189 - kfree(dtg); 190 196 } 191 197 192 198 void dcss_dtg_sync_set(struct dcss_dtg *dtg, struct videomode *vm)
+3 -18
drivers/gpu/drm/imx/dcss/dcss-scaler.c
··· 302 302 303 303 ch->base_ofs = scaler_base + i * 0x400; 304 304 305 - ch->base_reg = ioremap(ch->base_ofs, SZ_4K); 305 + ch->base_reg = devm_ioremap(scl->dev, ch->base_ofs, SZ_4K); 306 306 if (!ch->base_reg) { 307 307 dev_err(scl->dev, "scaler: unable to remap ch base\n"); 308 308 return -ENOMEM; ··· 318 318 { 319 319 struct dcss_scaler *scaler; 320 320 321 - scaler = kzalloc(sizeof(*scaler), GFP_KERNEL); 321 + scaler = devm_kzalloc(dcss->dev, sizeof(*scaler), GFP_KERNEL); 322 322 if (!scaler) 323 323 return -ENOMEM; 324 324 ··· 327 327 scaler->ctxld = dcss->ctxld; 328 328 scaler->ctx_id = CTX_SB_HP; 329 329 330 - if (dcss_scaler_ch_init_all(scaler, scaler_base)) { 331 - int i; 332 - 333 - for (i = 0; i < 3; i++) { 334 - if (scaler->ch[i].base_reg) 335 - iounmap(scaler->ch[i].base_reg); 336 - } 337 - 338 - kfree(scaler); 339 - 330 + if (dcss_scaler_ch_init_all(scaler, scaler_base)) 340 331 return -ENOMEM; 341 - } 342 332 343 333 return 0; 344 334 } ··· 341 351 struct dcss_scaler_ch *ch = &scl->ch[ch_no]; 342 352 343 353 dcss_writel(0, ch->base_reg + DCSS_SCALER_CTRL); 344 - 345 - if (ch->base_reg) 346 - iounmap(ch->base_reg); 347 354 } 348 - 349 - kfree(scl); 350 355 } 351 356 352 357 void dcss_scaler_ch_enable(struct dcss_scaler *scl, int ch_num, bool en)
+3 -9
drivers/gpu/drm/imx/dcss/dcss-ss.c
··· 83 83 { 84 84 struct dcss_ss *ss; 85 85 86 - ss = kzalloc(sizeof(*ss), GFP_KERNEL); 86 + ss = devm_kzalloc(dcss->dev, sizeof(*ss), GFP_KERNEL); 87 87 if (!ss) 88 88 return -ENOMEM; 89 89 ··· 91 91 ss->dev = dcss->dev; 92 92 ss->ctxld = dcss->ctxld; 93 93 94 - ss->base_reg = ioremap(ss_base, SZ_4K); 94 + ss->base_reg = devm_ioremap(ss->dev, ss_base, SZ_4K); 95 95 if (!ss->base_reg) { 96 - dev_err(dcss->dev, "ss: unable to remap ss base\n"); 97 - kfree(ss); 96 + dev_err(ss->dev, "ss: unable to remap ss base\n"); 98 97 return -ENOMEM; 99 98 } 100 99 ··· 107 108 { 108 109 /* stop SS */ 109 110 dcss_writel(0, ss->base_reg + DCSS_SS_SYS_CTRL); 110 - 111 - if (ss->base_reg) 112 - iounmap(ss->base_reg); 113 - 114 - kfree(ss); 115 111 } 116 112 117 113 void dcss_ss_subsam_set(struct dcss_ss *ss)