drm/panel: Use dev_ based logging · tjh.dev/kernel@a25b6b2

+15 -29

drivers/gpu/drm/panel/panel-boe-himax8279d.c

··· 19 19 #include <drm/drm_mipi_dsi.h> 20 20 #include <drm/drm_modes.h> 21 21 #include <drm/drm_panel.h> 22 - #include <drm/drm_print.h> 23 22 24 23 #include <video/mipi_display.h> 25 24 ··· 92 93 93 94 err = mipi_dsi_dcs_set_display_off(pinfo->link); 94 95 if (err < 0) { 95 - DRM_DEV_ERROR(panel->dev, "failed to set display off: %d\n", 96 - err); 96 + dev_err(panel->dev, "failed to set display off: %d\n", err); 97 97 return err; 98 98 } 99 99 ··· 111 113 112 114 err = mipi_dsi_dcs_set_display_off(pinfo->link); 113 115 if (err < 0) 114 - DRM_DEV_ERROR(panel->dev, "failed to set display off: %d\n", 115 - err); 116 + dev_err(panel->dev, "failed to set display off: %d\n", err); 116 117 117 118 err = mipi_dsi_dcs_enter_sleep_mode(pinfo->link); 118 119 if (err < 0) 119 - DRM_DEV_ERROR(panel->dev, "failed to enter sleep mode: %d\n", 120 - err); 120 + dev_err(panel->dev, "failed to enter sleep mode: %d\n", err); 121 121 122 122 /* sleep_mode_delay: 1ms - 2ms */ 123 123 usleep_range(1000, 2000); ··· 159 163 /* send init code */ 160 164 err = send_mipi_cmds(panel, pinfo->desc->on_cmds); 161 165 if (err < 0) { 162 - DRM_DEV_ERROR(panel->dev, "failed to send DCS Init Code: %d\n", 163 - err); 166 + dev_err(panel->dev, "failed to send DCS Init Code: %d\n", err); 164 167 goto poweroff; 165 168 } 166 169 167 170 err = mipi_dsi_dcs_exit_sleep_mode(pinfo->link); 168 171 if (err < 0) { 169 - DRM_DEV_ERROR(panel->dev, "failed to exit sleep mode: %d\n", 170 - err); 172 + dev_err(panel->dev, "failed to exit sleep mode: %d\n", err); 171 173 goto poweroff; 172 174 } 173 175 ··· 174 180 175 181 err = mipi_dsi_dcs_set_display_on(pinfo->link); 176 182 if (err < 0) { 177 - DRM_DEV_ERROR(panel->dev, "failed to set display on: %d\n", 178 - err); 183 + dev_err(panel->dev, "failed to set display on: %d\n", err); 179 184 goto poweroff; 180 185 } 181 186 ··· 202 209 203 210 ret = mipi_dsi_dcs_set_display_on(pinfo->link); 204 211 if (ret < 0) { 205 - DRM_DEV_ERROR(panel->dev, "failed to set display on: %d\n", 206 - ret); 212 + dev_err(panel->dev, "failed to set display on: %d\n", ret); 207 213 return ret; 208 214 } 209 215 ··· 220 228 221 229 mode = drm_mode_duplicate(connector->dev, m); 222 230 if (!mode) { 223 - DRM_DEV_ERROR(pinfo->base.dev, "failed to add mode %ux%u@%u\n", 224 - m->hdisplay, m->vdisplay, drm_mode_vrefresh(m)); 231 + dev_err(pinfo->base.dev, "failed to add mode %ux%u@%u\n", 232 + m->hdisplay, m->vdisplay, drm_mode_vrefresh(m)); 225 233 return -ENOMEM; 226 234 } 227 235 ··· 857 865 if (IS_ERR(pinfo->pp18_gpio)) { 858 866 ret = PTR_ERR(pinfo->pp18_gpio); 859 867 if (ret != -EPROBE_DEFER) 860 - DRM_DEV_ERROR(dev, "failed to get pp18 gpio: %d\n", 861 - ret); 868 + dev_err(dev, "failed to get pp18 gpio: %d\n", ret); 862 869 return ret; 863 870 } 864 871 ··· 865 874 if (IS_ERR(pinfo->pp33_gpio)) { 866 875 ret = PTR_ERR(pinfo->pp33_gpio); 867 876 if (ret != -EPROBE_DEFER) 868 - DRM_DEV_ERROR(dev, "failed to get pp33 gpio: %d\n", 869 - ret); 877 + dev_err(dev, "failed to get pp33 gpio: %d\n", ret); 870 878 return ret; 871 879 } 872 880 ··· 873 883 if (IS_ERR(pinfo->enable_gpio)) { 874 884 ret = PTR_ERR(pinfo->enable_gpio); 875 885 if (ret != -EPROBE_DEFER) 876 - DRM_DEV_ERROR(dev, "failed to get enable gpio: %d\n", 877 - ret); 886 + dev_err(dev, "failed to get enable gpio: %d\n", ret); 878 887 return ret; 879 888 } 880 889 ··· 926 937 927 938 err = boe_panel_disable(&pinfo->base); 928 939 if (err < 0) 929 - DRM_DEV_ERROR(&dsi->dev, "failed to disable panel: %d\n", 930 - err); 940 + dev_err(&dsi->dev, "failed to disable panel: %d\n", err); 931 941 932 942 err = boe_panel_unprepare(&pinfo->base); 933 943 if (err < 0) 934 - DRM_DEV_ERROR(&dsi->dev, "failed to unprepare panel: %d\n", 935 - err); 944 + dev_err(&dsi->dev, "failed to unprepare panel: %d\n", err); 936 945 937 946 err = mipi_dsi_detach(dsi); 938 947 if (err < 0) 939 - DRM_DEV_ERROR(&dsi->dev, "failed to detach from DSI host: %d\n", 940 - err); 948 + dev_err(&dsi->dev, "failed to detach from DSI host: %d\n", err); 941 949 942 950 drm_panel_remove(&pinfo->base); 943 951

+19 -32

drivers/gpu/drm/panel/panel-elida-kd35t133.c

··· 22 22 #include <drm/drm_mipi_dsi.h> 23 23 #include <drm/drm_modes.h> 24 24 #include <drm/drm_panel.h> 25 - #include <drm/drm_print.h> 26 25 27 26 /* Manufacturer specific Commands send via DSI */ 28 27 #define KD35T133_CMD_INTERFACEMODECTRL 0xb0 ··· 88 89 0xa9, 0x51, 0x2c, 0x82); 89 90 mipi_dsi_dcs_write(dsi, MIPI_DCS_ENTER_INVERT_MODE, NULL, 0); 90 91 91 - DRM_DEV_DEBUG_DRIVER(dev, "Panel init sequence done\n"); 92 + dev_dbg(dev, "Panel init sequence done\n"); 92 93 return 0; 93 94 } 94 95 ··· 103 104 104 105 ret = mipi_dsi_dcs_set_display_off(dsi); 105 106 if (ret < 0) 106 - DRM_DEV_ERROR(ctx->dev, "failed to set display off: %d\n", 107 - ret); 107 + dev_err(ctx->dev, "failed to set display off: %d\n", ret); 108 108 109 109 ret = mipi_dsi_dcs_enter_sleep_mode(dsi); 110 110 if (ret < 0) { 111 - DRM_DEV_ERROR(ctx->dev, "failed to enter sleep mode: %d\n", 112 - ret); 111 + dev_err(ctx->dev, "failed to enter sleep mode: %d\n", ret); 113 112 return ret; 114 113 } 115 114 ··· 128 131 if (ctx->prepared) 129 132 return 0; 130 133 131 - DRM_DEV_DEBUG_DRIVER(ctx->dev, "Resetting the panel\n"); 134 + dev_dbg(ctx->dev, "Resetting the panel\n"); 132 135 ret = regulator_enable(ctx->vdd); 133 136 if (ret < 0) { 134 - DRM_DEV_ERROR(ctx->dev, 135 - "Failed to enable vdd supply: %d\n", ret); 137 + dev_err(ctx->dev, "Failed to enable vdd supply: %d\n", ret); 136 138 return ret; 137 139 } 138 140 139 141 ret = regulator_enable(ctx->iovcc); 140 142 if (ret < 0) { 141 - DRM_DEV_ERROR(ctx->dev, 142 - "Failed to enable iovcc supply: %d\n", ret); 143 + dev_err(ctx->dev, "Failed to enable iovcc supply: %d\n", ret); 143 144 goto disable_vdd; 144 145 } 145 146 ··· 151 156 152 157 ret = mipi_dsi_dcs_exit_sleep_mode(dsi); 153 158 if (ret < 0) { 154 - DRM_DEV_ERROR(ctx->dev, "Failed to exit sleep mode: %d\n", ret); 159 + dev_err(ctx->dev, "Failed to exit sleep mode: %d\n", ret); 155 160 goto disable_iovcc; 156 161 } 157 162 ··· 159 164 160 165 ret = kd35t133_init_sequence(ctx); 161 166 if (ret < 0) { 162 - DRM_DEV_ERROR(ctx->dev, "Panel init sequence failed: %d\n", 163 - ret); 167 + dev_err(ctx->dev, "Panel init sequence failed: %d\n", ret); 164 168 goto disable_iovcc; 165 169 } 166 170 167 171 ret = mipi_dsi_dcs_set_display_on(dsi); 168 172 if (ret < 0) { 169 - DRM_DEV_ERROR(ctx->dev, "Failed to set display on: %d\n", ret); 173 + dev_err(ctx->dev, "Failed to set display on: %d\n", ret); 170 174 goto disable_iovcc; 171 175 } 172 176 ··· 204 210 205 211 mode = drm_mode_duplicate(connector->dev, &default_mode); 206 212 if (!mode) { 207 - DRM_DEV_ERROR(ctx->dev, "Failed to add mode %ux%u@%u\n", 208 - default_mode.hdisplay, default_mode.vdisplay, 209 - drm_mode_vrefresh(&default_mode)); 213 + dev_err(ctx->dev, "Failed to add mode %ux%u@%u\n", 214 + default_mode.hdisplay, default_mode.vdisplay, 215 + drm_mode_vrefresh(&default_mode)); 210 216 return -ENOMEM; 211 217 } 212 218 ··· 238 244 239 245 ctx->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW); 240 246 if (IS_ERR(ctx->reset_gpio)) { 241 - DRM_DEV_ERROR(dev, "cannot get reset gpio\n"); 247 + dev_err(dev, "cannot get reset gpio\n"); 242 248 return PTR_ERR(ctx->reset_gpio); 243 249 } 244 250 ··· 246 252 if (IS_ERR(ctx->vdd)) { 247 253 ret = PTR_ERR(ctx->vdd); 248 254 if (ret != -EPROBE_DEFER) 249 - DRM_DEV_ERROR(dev, 250 - "Failed to request vdd regulator: %d\n", 251 - ret); 255 + dev_err(dev, "Failed to request vdd regulator: %d\n", ret); 252 256 return ret; 253 257 } 254 258 ··· 254 262 if (IS_ERR(ctx->iovcc)) { 255 263 ret = PTR_ERR(ctx->iovcc); 256 264 if (ret != -EPROBE_DEFER) 257 - DRM_DEV_ERROR(dev, 258 - "Failed to request iovcc regulator: %d\n", 259 - ret); 265 + dev_err(dev, "Failed to request iovcc regulator: %d\n", ret); 260 266 return ret; 261 267 } 262 268 ··· 278 288 279 289 ret = mipi_dsi_attach(dsi); 280 290 if (ret < 0) { 281 - DRM_DEV_ERROR(dev, "mipi_dsi_attach failed: %d\n", ret); 291 + dev_err(dev, "mipi_dsi_attach failed: %d\n", ret); 282 292 drm_panel_remove(&ctx->panel); 283 293 return ret; 284 294 } ··· 293 303 294 304 ret = drm_panel_unprepare(&ctx->panel); 295 305 if (ret < 0) 296 - DRM_DEV_ERROR(&dsi->dev, "Failed to unprepare panel: %d\n", 297 - ret); 306 + dev_err(&dsi->dev, "Failed to unprepare panel: %d\n", ret); 298 307 299 308 ret = drm_panel_disable(&ctx->panel); 300 309 if (ret < 0) 301 - DRM_DEV_ERROR(&dsi->dev, "Failed to disable panel: %d\n", 302 - ret); 310 + dev_err(&dsi->dev, "Failed to disable panel: %d\n", ret); 303 311 } 304 312 305 313 static int kd35t133_remove(struct mipi_dsi_device *dsi) ··· 309 321 310 322 ret = mipi_dsi_detach(dsi); 311 323 if (ret < 0) 312 - DRM_DEV_ERROR(&dsi->dev, "Failed to detach from DSI host: %d\n", 313 - ret); 324 + dev_err(&dsi->dev, "Failed to detach from DSI host: %d\n", ret); 314 325 315 326 drm_panel_remove(&ctx->panel); 316 327

+8 -11

drivers/gpu/drm/panel/panel-feixin-k101-im2ba02.c

··· 13 13 #include <drm/drm_mipi_dsi.h> 14 14 #include <drm/drm_modes.h> 15 15 #include <drm/drm_panel.h> 16 - #include <drm/drm_print.h> 17 16 18 17 #define K101_IM2BA02_INIT_CMD_LEN 2 19 18 ··· 373 374 374 375 ret = mipi_dsi_dcs_set_display_off(ctx->dsi); 375 376 if (ret < 0) 376 - DRM_DEV_ERROR(panel->dev, "failed to set display off: %d\n", 377 - ret); 377 + dev_err(panel->dev, "failed to set display off: %d\n", ret); 378 378 379 379 ret = mipi_dsi_dcs_enter_sleep_mode(ctx->dsi); 380 380 if (ret < 0) 381 - DRM_DEV_ERROR(panel->dev, "failed to enter sleep mode: %d\n", 382 - ret); 381 + dev_err(panel->dev, "failed to enter sleep mode: %d\n", ret); 383 382 384 383 msleep(200); 385 384 ··· 413 416 414 417 mode = drm_mode_duplicate(connector->dev, &k101_im2ba02_default_mode); 415 418 if (!mode) { 416 - DRM_DEV_ERROR(&ctx->dsi->dev, "failed to add mode %ux%ux@%u\n", 417 - k101_im2ba02_default_mode.hdisplay, 418 - k101_im2ba02_default_mode.vdisplay, 419 - drm_mode_vrefresh(&k101_im2ba02_default_mode)); 419 + dev_err(&ctx->dsi->dev, "failed to add mode %ux%u@%u\n", 420 + k101_im2ba02_default_mode.hdisplay, 421 + k101_im2ba02_default_mode.vdisplay, 422 + drm_mode_vrefresh(&k101_im2ba02_default_mode)); 420 423 return -ENOMEM; 421 424 } 422 425 ··· 457 460 ret = devm_regulator_bulk_get(&dsi->dev, ARRAY_SIZE(ctx->supplies), 458 461 ctx->supplies); 459 462 if (ret < 0) { 460 - DRM_DEV_ERROR(&dsi->dev, "Couldn't get regulators\n"); 463 + dev_err(&dsi->dev, "Couldn't get regulators\n"); 461 464 return ret; 462 465 } 463 466 464 467 ctx->reset = devm_gpiod_get(&dsi->dev, "reset", GPIOD_OUT_LOW); 465 468 if (IS_ERR(ctx->reset)) { 466 - DRM_DEV_ERROR(&dsi->dev, "Couldn't get our reset GPIO\n"); 469 + dev_err(&dsi->dev, "Couldn't get our reset GPIO\n"); 467 470 return PTR_ERR(ctx->reset); 468 471 } 469 472

+9 -12

drivers/gpu/drm/panel/panel-feiyang-fy07024di26a30d.c

··· 7 7 #include <drm/drm_mipi_dsi.h> 8 8 #include <drm/drm_modes.h> 9 9 #include <drm/drm_panel.h> 10 - #include <drm/drm_print.h> 11 10 12 11 #include <linux/gpio/consumer.h> 13 12 #include <linux/delay.h> ··· 117 118 118 119 ret = mipi_dsi_dcs_set_display_off(ctx->dsi); 119 120 if (ret < 0) 120 - DRM_DEV_ERROR(panel->dev, "failed to set display off: %d\n", 121 - ret); 121 + dev_err(panel->dev, "failed to set display off: %d\n", ret); 122 122 123 123 ret = mipi_dsi_dcs_enter_sleep_mode(ctx->dsi); 124 124 if (ret < 0) 125 - DRM_DEV_ERROR(panel->dev, "failed to enter sleep mode: %d\n", 126 - ret); 125 + dev_err(panel->dev, "failed to enter sleep mode: %d\n", ret); 127 126 128 127 /* T13 (backlight fall + video & logic signal fall) T13 >= 200ms */ 129 128 msleep(200); ··· 162 165 163 166 mode = drm_mode_duplicate(connector->dev, &feiyang_default_mode); 164 167 if (!mode) { 165 - DRM_DEV_ERROR(&ctx->dsi->dev, "failed to add mode %ux%ux@%u\n", 166 - feiyang_default_mode.hdisplay, 167 - feiyang_default_mode.vdisplay, 168 - drm_mode_vrefresh(&feiyang_default_mode)); 168 + dev_err(&ctx->dsi->dev, "failed to add mode %ux%u@%u\n", 169 + feiyang_default_mode.hdisplay, 170 + feiyang_default_mode.vdisplay, 171 + drm_mode_vrefresh(&feiyang_default_mode)); 169 172 return -ENOMEM; 170 173 } 171 174 ··· 201 204 202 205 ctx->dvdd = devm_regulator_get(&dsi->dev, "dvdd"); 203 206 if (IS_ERR(ctx->dvdd)) { 204 - DRM_DEV_ERROR(&dsi->dev, "Couldn't get dvdd regulator\n"); 207 + dev_err(&dsi->dev, "Couldn't get dvdd regulator\n"); 205 208 return PTR_ERR(ctx->dvdd); 206 209 } 207 210 208 211 ctx->avdd = devm_regulator_get(&dsi->dev, "avdd"); 209 212 if (IS_ERR(ctx->avdd)) { 210 - DRM_DEV_ERROR(&dsi->dev, "Couldn't get avdd regulator\n"); 213 + dev_err(&dsi->dev, "Couldn't get avdd regulator\n"); 211 214 return PTR_ERR(ctx->avdd); 212 215 } 213 216 214 217 ctx->reset = devm_gpiod_get(&dsi->dev, "reset", GPIOD_OUT_LOW); 215 218 if (IS_ERR(ctx->reset)) { 216 - DRM_DEV_ERROR(&dsi->dev, "Couldn't get our reset GPIO\n"); 219 + dev_err(&dsi->dev, "Couldn't get our reset GPIO\n"); 217 220 return PTR_ERR(ctx->reset); 218 221 } 219 222

+1 -2

drivers/gpu/drm/panel/panel-ilitek-ili9322.c

··· 33 33 34 34 #include <drm/drm_modes.h> 35 35 #include <drm/drm_panel.h> 36 - #include <drm/drm_print.h> 37 36 38 37 #define ILI9322_CHIP_ID 0x00 39 38 #define ILI9322_CHIP_ID_MAGIC 0x96 ··· 682 683 break; 683 684 } 684 685 if (!mode) { 685 - DRM_ERROR("bad mode or failed to add mode\n"); 686 + dev_err(panel->dev, "bad mode or failed to add mode\n"); 686 687 return -EINVAL; 687 688 } 688 689 drm_mode_set_name(mode);

+11 -20

drivers/gpu/drm/panel/panel-innolux-p079zca.c

··· 17 17 #include <drm/drm_mipi_dsi.h> 18 18 #include <drm/drm_modes.h> 19 19 #include <drm/drm_panel.h> 20 - #include <drm/drm_print.h> 21 20 22 21 struct panel_init_cmd { 23 22 size_t len; ··· 84 85 85 86 err = mipi_dsi_dcs_set_display_off(innolux->link); 86 87 if (err < 0) 87 - DRM_DEV_ERROR(panel->dev, "failed to set display off: %d\n", 88 - err); 88 + dev_err(panel->dev, "failed to set display off: %d\n", err); 89 89 90 90 err = mipi_dsi_dcs_enter_sleep_mode(innolux->link); 91 91 if (err < 0) { 92 - DRM_DEV_ERROR(panel->dev, "failed to enter sleep mode: %d\n", 93 - err); 92 + dev_err(panel->dev, "failed to enter sleep mode: %d\n", err); 94 93 return err; 95 94 } 96 95 ··· 144 147 err = mipi_dsi_generic_write(innolux->link, cmd->data, 145 148 cmd->len); 146 149 if (err < 0) { 147 - dev_err(panel->dev, 148 - "failed to write command %u\n", i); 150 + dev_err(panel->dev, "failed to write command %u\n", i); 149 151 goto poweroff; 150 152 } 151 153 ··· 155 159 */ 156 160 err = mipi_dsi_dcs_nop(innolux->link); 157 161 if (err < 0) { 158 - dev_err(panel->dev, 159 - "failed to send DCS nop: %d\n", err); 162 + dev_err(panel->dev, "failed to send DCS nop: %d\n", err); 160 163 goto poweroff; 161 164 } 162 165 } ··· 163 168 164 169 err = mipi_dsi_dcs_exit_sleep_mode(innolux->link); 165 170 if (err < 0) { 166 - DRM_DEV_ERROR(panel->dev, "failed to exit sleep mode: %d\n", 167 - err); 171 + dev_err(panel->dev, "failed to exit sleep mode: %d\n", err); 168 172 goto poweroff; 169 173 } 170 174 ··· 172 178 173 179 err = mipi_dsi_dcs_set_display_on(innolux->link); 174 180 if (err < 0) { 175 - DRM_DEV_ERROR(panel->dev, "failed to set display on: %d\n", 176 - err); 181 + dev_err(panel->dev, "failed to set display on: %d\n", err); 177 182 goto poweroff; 178 183 } 179 184 ··· 391 398 392 399 mode = drm_mode_duplicate(connector->dev, m); 393 400 if (!mode) { 394 - DRM_DEV_ERROR(panel->dev, "failed to add mode %ux%ux@%u\n", 395 - m->hdisplay, m->vdisplay, drm_mode_vrefresh(m)); 401 + dev_err(panel->dev, "failed to add mode %ux%u@%u\n", 402 + m->hdisplay, m->vdisplay, drm_mode_vrefresh(m)); 396 403 return -ENOMEM; 397 404 } 398 405 ··· 505 512 506 513 err = drm_panel_unprepare(&innolux->base); 507 514 if (err < 0) 508 - DRM_DEV_ERROR(&dsi->dev, "failed to unprepare panel: %d\n", 509 - err); 515 + dev_err(&dsi->dev, "failed to unprepare panel: %d\n", err); 510 516 511 517 err = drm_panel_disable(&innolux->base); 512 518 if (err < 0) 513 - DRM_DEV_ERROR(&dsi->dev, "failed to disable panel: %d\n", err); 519 + dev_err(&dsi->dev, "failed to disable panel: %d\n", err); 514 520 515 521 err = mipi_dsi_detach(dsi); 516 522 if (err < 0) 517 - DRM_DEV_ERROR(&dsi->dev, "failed to detach from DSI host: %d\n", 518 - err); 523 + dev_err(&dsi->dev, "failed to detach from DSI host: %d\n", err); 519 524 520 525 innolux_panel_del(innolux); 521 526

+12 -21

drivers/gpu/drm/panel/panel-kingdisplay-kd097d04.c

··· 16 16 #include <drm/drm_mipi_dsi.h> 17 17 #include <drm/drm_modes.h> 18 18 #include <drm/drm_panel.h> 19 - #include <drm/drm_print.h> 20 19 21 20 struct kingdisplay_panel { 22 21 struct drm_panel base; ··· 190 191 191 192 err = mipi_dsi_dcs_set_display_off(kingdisplay->link); 192 193 if (err < 0) 193 - DRM_DEV_ERROR(panel->dev, "failed to set display off: %d\n", 194 - err); 194 + dev_err(panel->dev, "failed to set display off: %d\n", err); 195 195 196 196 kingdisplay->enabled = false; 197 197 ··· 207 209 208 210 err = mipi_dsi_dcs_enter_sleep_mode(kingdisplay->link); 209 211 if (err < 0) { 210 - DRM_DEV_ERROR(panel->dev, "failed to enter sleep mode: %d\n", 211 - err); 212 + dev_err(panel->dev, "failed to enter sleep mode: %d\n", err); 212 213 return err; 213 214 } 214 215 ··· 252 255 err = mipi_dsi_generic_write(kingdisplay->link, &init_code[i], 253 256 sizeof(struct kingdisplay_panel_cmd)); 254 257 if (err < 0) { 255 - DRM_DEV_ERROR(panel->dev, "failed write init cmds: %d\n", 256 - err); 258 + dev_err(panel->dev, "failed write init cmds: %d\n", err); 257 259 goto poweroff; 258 260 } 259 261 } 260 262 261 263 err = mipi_dsi_dcs_exit_sleep_mode(kingdisplay->link); 262 264 if (err < 0) { 263 - DRM_DEV_ERROR(panel->dev, "failed to exit sleep mode: %d\n", 264 - err); 265 + dev_err(panel->dev, "failed to exit sleep mode: %d\n", err); 265 266 goto poweroff; 266 267 } 267 268 ··· 268 273 269 274 err = mipi_dsi_dcs_set_display_on(kingdisplay->link); 270 275 if (err < 0) { 271 - DRM_DEV_ERROR(panel->dev, "failed to set display on: %d\n", 272 - err); 276 + dev_err(panel->dev, "failed to set display on: %d\n", err); 273 277 goto poweroff; 274 278 } 275 279 ··· 284 290 285 291 regulator_err = regulator_disable(kingdisplay->supply); 286 292 if (regulator_err) 287 - DRM_DEV_ERROR(panel->dev, "failed to disable regulator: %d\n", 288 - regulator_err); 293 + dev_err(panel->dev, "failed to disable regulator: %d\n", regulator_err); 289 294 290 295 return err; 291 296 } ··· 320 327 321 328 mode = drm_mode_duplicate(connector->dev, &default_mode); 322 329 if (!mode) { 323 - DRM_DEV_ERROR(panel->dev, "failed to add mode %ux%ux@%u\n", 324 - default_mode.hdisplay, default_mode.vdisplay, 325 - drm_mode_vrefresh(&default_mode)); 330 + dev_err(panel->dev, "failed to add mode %ux%u@%u\n", 331 + default_mode.hdisplay, default_mode.vdisplay, 332 + drm_mode_vrefresh(&default_mode)); 326 333 return -ENOMEM; 327 334 } 328 335 ··· 416 423 417 424 err = drm_panel_unprepare(&kingdisplay->base); 418 425 if (err < 0) 419 - DRM_DEV_ERROR(&dsi->dev, "failed to unprepare panel: %d\n", 420 - err); 426 + dev_err(&dsi->dev, "failed to unprepare panel: %d\n", err); 421 427 422 428 err = drm_panel_disable(&kingdisplay->base); 423 429 if (err < 0) 424 - DRM_DEV_ERROR(&dsi->dev, "failed to disable panel: %d\n", err); 430 + dev_err(&dsi->dev, "failed to disable panel: %d\n", err); 425 431 426 432 err = mipi_dsi_detach(dsi); 427 433 if (err < 0) 428 - DRM_DEV_ERROR(&dsi->dev, "failed to detach from DSI host: %d\n", 429 - err); 434 + dev_err(&dsi->dev, "failed to detach from DSI host: %d\n", err); 430 435 431 436 kingdisplay_panel_del(kingdisplay); 432 437

+14 -26

drivers/gpu/drm/panel/panel-novatek-nt35510.c

··· 35 35 #include <drm/drm_mipi_dsi.h> 36 36 #include <drm/drm_modes.h> 37 37 #include <drm/drm_panel.h> 38 - #include <drm/drm_print.h> 39 38 40 39 #define MCS_CMD_MAUCCTR 0xF0 /* Manufacturer command enable */ 41 40 #define MCS_CMD_READ_ID1 0xDA ··· 403 404 chunk = 15; 404 405 ret = mipi_dsi_dcs_write(dsi, cmd, seqp, chunk); 405 406 if (ret < 0) { 406 - DRM_DEV_ERROR(nt->dev, 407 - "error sending DCS command seq cmd %02x\n", 408 - cmd); 407 + dev_err(nt->dev, "error sending DCS command seq cmd %02x\n", cmd); 409 408 return ret; 410 409 } 411 410 cmdwritten += chunk; ··· 415 418 chunk = 15; 416 419 ret = mipi_dsi_generic_write(dsi, seqp, chunk); 417 420 if (ret < 0) { 418 - DRM_DEV_ERROR(nt->dev, 419 - "error sending generic write seq %02x\n", 420 - cmd); 421 + dev_err(nt->dev, "error sending generic write seq %02x\n", cmd); 421 422 return ret; 422 423 } 423 424 cmdwritten += chunk; 424 425 seqp += chunk; 425 426 } 426 - DRM_DEV_DEBUG(nt->dev, "sent command %02x %02x bytes\n", 427 - cmd, cmdlen); 427 + dev_dbg(nt->dev, "sent command %02x %02x bytes\n", cmd, cmdlen); 428 428 return 0; 429 429 } 430 430 ··· 433 439 434 440 ret = mipi_dsi_dcs_read(dsi, MCS_CMD_READ_ID1, &id1, 1); 435 441 if (ret < 0) { 436 - DRM_DEV_ERROR(nt->dev, "could not read MTP ID1\n"); 442 + dev_err(nt->dev, "could not read MTP ID1\n"); 437 443 return ret; 438 444 } 439 445 ret = mipi_dsi_dcs_read(dsi, MCS_CMD_READ_ID2, &id2, 1); 440 446 if (ret < 0) { 441 - DRM_DEV_ERROR(nt->dev, "could not read MTP ID2\n"); 447 + dev_err(nt->dev, "could not read MTP ID2\n"); 442 448 return ret; 443 449 } 444 450 ret = mipi_dsi_dcs_read(dsi, MCS_CMD_READ_ID3, &id3, 1); 445 451 if (ret < 0) { 446 - DRM_DEV_ERROR(nt->dev, "could not read MTP ID3\n"); 452 + dev_err(nt->dev, "could not read MTP ID3\n"); 447 453 return ret; 448 454 } 449 455 ··· 452 458 * ID (e.g. Hydis 0x55), driver ID (e.g. NT35510 0xc0) and 453 459 * version. 454 460 */ 455 - DRM_DEV_INFO(nt->dev, 456 - "MTP ID manufacturer: %02x version: %02x driver: %02x\n", 457 - id1, id2, id3); 461 + dev_info(nt->dev, "MTP ID manufacturer: %02x version: %02x driver: %02x\n", id1, id2, id3); 458 462 459 463 return 0; 460 464 } ··· 653 661 u8 brightness = bl->props.brightness; 654 662 int ret; 655 663 656 - DRM_DEV_DEBUG(nt->dev, "set brightness %d\n", brightness); 664 + dev_dbg(nt->dev, "set brightness %d\n", brightness); 657 665 ret = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_BRIGHTNESS, 658 666 &brightness, 659 667 sizeof(brightness)); ··· 788 796 789 797 ret = mipi_dsi_dcs_set_display_off(dsi); 790 798 if (ret) { 791 - DRM_DEV_ERROR(nt->dev, "failed to turn display off (%d)\n", 792 - ret); 799 + dev_err(nt->dev, "failed to turn display off (%d)\n", ret); 793 800 return ret; 794 801 } 795 802 usleep_range(10000, 20000); ··· 796 805 /* Enter sleep mode */ 797 806 ret = mipi_dsi_dcs_enter_sleep_mode(dsi); 798 807 if (ret) { 799 - DRM_DEV_ERROR(nt->dev, "failed to enter sleep mode (%d)\n", 800 - ret); 808 + dev_err(nt->dev, "failed to enter sleep mode (%d)\n", ret); 801 809 return ret; 802 810 } 803 811 ··· 823 833 /* Exit sleep mode */ 824 834 ret = mipi_dsi_dcs_exit_sleep_mode(dsi); 825 835 if (ret) { 826 - DRM_DEV_ERROR(nt->dev, "failed to exit sleep mode (%d)\n", 827 - ret); 836 + dev_err(nt->dev, "failed to exit sleep mode (%d)\n", ret); 828 837 return ret; 829 838 } 830 839 /* Up to 120 ms */ ··· 831 842 832 843 ret = mipi_dsi_dcs_set_display_on(dsi); 833 844 if (ret) { 834 - DRM_DEV_ERROR(nt->dev, "failed to turn display on (%d)\n", 835 - ret); 845 + dev_err(nt->dev, "failed to turn display on (%d)\n", ret); 836 846 return ret; 837 847 } 838 848 /* Some 10 ms */ ··· 852 864 info->height_mm = nt->conf->height_mm; 853 865 mode = drm_mode_duplicate(connector->dev, &nt->conf->mode); 854 866 if (!mode) { 855 - DRM_ERROR("bad mode or failed to add mode\n"); 867 + dev_err(panel->dev, "bad mode or failed to add mode\n"); 856 868 return -EINVAL; 857 869 } 858 870 drm_mode_set_name(mode); ··· 951 963 bl = devm_backlight_device_register(dev, "nt35510", dev, nt, 952 964 &nt35510_bl_ops, NULL); 953 965 if (IS_ERR(bl)) { 954 - DRM_DEV_ERROR(dev, "failed to register backlight device\n"); 966 + dev_err(dev, "failed to register backlight device\n"); 955 967 return PTR_ERR(bl); 956 968 } 957 969 bl->props.max_brightness = 255;

+6 -7

drivers/gpu/drm/panel/panel-orisetech-otm8009a.c

··· 17 17 #include <drm/drm_mipi_dsi.h> 18 18 #include <drm/drm_modes.h> 19 19 #include <drm/drm_panel.h> 20 - #include <drm/drm_print.h> 21 20 22 21 #define OTM8009A_BACKLIGHT_DEFAULT 240 23 22 #define OTM8009A_BACKLIGHT_MAX 255 ··· 96 97 struct mipi_dsi_device *dsi = to_mipi_dsi_device(ctx->dev); 97 98 98 99 if (mipi_dsi_dcs_write_buffer(dsi, data, len) < 0) 99 - DRM_WARN("mipi dsi dcs write buffer failed\n"); 100 + dev_warn(ctx->dev, "mipi dsi dcs write buffer failed\n"); 100 101 } 101 102 102 103 static void otm8009a_dcs_write_buf_hs(struct otm8009a *ctx, const void *data, ··· 312 313 313 314 ret = regulator_enable(ctx->supply); 314 315 if (ret < 0) { 315 - DRM_ERROR("failed to enable supply: %d\n", ret); 316 + dev_err(panel->dev, "failed to enable supply: %d\n", ret); 316 317 return ret; 317 318 } 318 319 ··· 354 355 355 356 mode = drm_mode_duplicate(connector->dev, &default_mode); 356 357 if (!mode) { 357 - DRM_ERROR("failed to add mode %ux%ux@%u\n", 358 - default_mode.hdisplay, default_mode.vdisplay, 359 - drm_mode_vrefresh(&default_mode)); 358 + dev_err(panel->dev, "failed to add mode %ux%u@%u\n", 359 + default_mode.hdisplay, default_mode.vdisplay, 360 + drm_mode_vrefresh(&default_mode)); 360 361 return -ENOMEM; 361 362 } 362 363 ··· 389 390 u8 data[2]; 390 391 391 392 if (!ctx->prepared) { 392 - DRM_DEBUG("lcd not ready yet for setting its backlight!\n"); 393 + dev_dbg(&bd->dev, "lcd not ready yet for setting its backlight!\n"); 393 394 return -ENXIO; 394 395 } 395 396

+7 -9

drivers/gpu/drm/panel/panel-ronbo-rb070d30.c

··· 23 23 #include <drm/drm_mipi_dsi.h> 24 24 #include <drm/drm_modes.h> 25 25 #include <drm/drm_panel.h> 26 - #include <drm/drm_print.h> 27 26 28 27 struct rb070d30_panel { 29 28 struct drm_panel panel; ··· 49 50 50 51 ret = regulator_enable(ctx->supply); 51 52 if (ret < 0) { 52 - DRM_DEV_ERROR(&ctx->dsi->dev, "Failed to enable supply: %d\n", ret); 53 + dev_err(&ctx->dsi->dev, "Failed to enable supply: %d\n", ret); 53 54 return ret; 54 55 } 55 56 ··· 116 117 117 118 mode = drm_mode_duplicate(connector->dev, &default_mode); 118 119 if (!mode) { 119 - DRM_DEV_ERROR(&ctx->dsi->dev, 120 - "Failed to add mode " DRM_MODE_FMT "\n", 121 - DRM_MODE_ARG(&default_mode)); 120 + dev_err(&ctx->dsi->dev, "Failed to add mode " DRM_MODE_FMT "\n", 121 + DRM_MODE_ARG(&default_mode)); 122 122 return -EINVAL; 123 123 } 124 124 ··· 164 166 165 167 ctx->gpios.reset = devm_gpiod_get(&dsi->dev, "reset", GPIOD_OUT_LOW); 166 168 if (IS_ERR(ctx->gpios.reset)) { 167 - DRM_DEV_ERROR(&dsi->dev, "Couldn't get our reset GPIO\n"); 169 + dev_err(&dsi->dev, "Couldn't get our reset GPIO\n"); 168 170 return PTR_ERR(ctx->gpios.reset); 169 171 } 170 172 171 173 ctx->gpios.power = devm_gpiod_get(&dsi->dev, "power", GPIOD_OUT_LOW); 172 174 if (IS_ERR(ctx->gpios.power)) { 173 - DRM_DEV_ERROR(&dsi->dev, "Couldn't get our power GPIO\n"); 175 + dev_err(&dsi->dev, "Couldn't get our power GPIO\n"); 174 176 return PTR_ERR(ctx->gpios.power); 175 177 } 176 178 ··· 180 182 */ 181 183 ctx->gpios.updn = devm_gpiod_get(&dsi->dev, "updn", GPIOD_OUT_LOW); 182 184 if (IS_ERR(ctx->gpios.updn)) { 183 - DRM_DEV_ERROR(&dsi->dev, "Couldn't get our updn GPIO\n"); 185 + dev_err(&dsi->dev, "Couldn't get our updn GPIO\n"); 184 186 return PTR_ERR(ctx->gpios.updn); 185 187 } 186 188 ··· 190 192 */ 191 193 ctx->gpios.shlr = devm_gpiod_get(&dsi->dev, "shlr", GPIOD_OUT_LOW); 192 194 if (IS_ERR(ctx->gpios.shlr)) { 193 - DRM_DEV_ERROR(&dsi->dev, "Couldn't get our shlr GPIO\n"); 195 + dev_err(&dsi->dev, "Couldn't get our shlr GPIO\n"); 194 196 return PTR_ERR(ctx->gpios.shlr); 195 197 } 196 198

+28 -53

drivers/gpu/drm/panel/panel-sony-acx424akp.c

··· 20 20 #include <drm/drm_mipi_dsi.h> 21 21 #include <drm/drm_modes.h> 22 22 #include <drm/drm_panel.h> 23 - #include <drm/drm_print.h> 24 23 25 24 #define ACX424_DCS_READ_ID1 0xDA 26 25 #define ACX424_DCS_READ_ID2 0xDB ··· 109 110 SCALE_FACTOR_NS_DIV_MHZ); 110 111 111 112 /* Set up PWM dutycycle ONE byte (differs from the standard) */ 112 - DRM_DEV_DEBUG(acx->dev, "calculated duty cycle %02x\n", pwm_ratio); 113 + dev_dbg(acx->dev, "calculated duty cycle %02x\n", pwm_ratio); 113 114 ret = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_BRIGHTNESS, 114 115 &pwm_ratio, 1); 115 116 if (ret < 0) { 116 - DRM_DEV_ERROR(acx->dev, 117 - "failed to set display PWM ratio (%d)\n", 118 - ret); 117 + dev_err(acx->dev, "failed to set display PWM ratio (%d)\n", ret); 119 118 return ret; 120 119 } 121 120 ··· 129 132 par = 0xaa; 130 133 ret = mipi_dsi_dcs_write(dsi, 0xf3, &par, 1); 131 134 if (ret < 0) { 132 - DRM_DEV_ERROR(acx->dev, 133 - "failed to unlock CMD 2 (%d)\n", 134 - ret); 135 + dev_err(acx->dev, "failed to unlock CMD 2 (%d)\n", ret); 135 136 return ret; 136 137 } 137 138 par = 0x01; 138 139 ret = mipi_dsi_dcs_write(dsi, 0x00, &par, 1); 139 140 if (ret < 0) { 140 - DRM_DEV_ERROR(acx->dev, 141 - "failed to enter page 1 (%d)\n", 142 - ret); 141 + dev_err(acx->dev, "failed to enter page 1 (%d)\n", ret); 143 142 return ret; 144 143 } 145 144 par = 0x01; 146 145 ret = mipi_dsi_dcs_write(dsi, 0x7d, &par, 1); 147 146 if (ret < 0) { 148 - DRM_DEV_ERROR(acx->dev, 149 - "failed to disable MTP reload (%d)\n", 150 - ret); 147 + dev_err(acx->dev, "failed to disable MTP reload (%d)\n", ret); 151 148 return ret; 152 149 } 153 150 ret = mipi_dsi_dcs_write(dsi, 0x22, &pwm_div, 1); 154 151 if (ret < 0) { 155 - DRM_DEV_ERROR(acx->dev, 156 - "failed to set PWM divisor (%d)\n", 157 - ret); 152 + dev_err(acx->dev, "failed to set PWM divisor (%d)\n", ret); 158 153 return ret; 159 154 } 160 155 par = 0xaa; 161 156 ret = mipi_dsi_dcs_write(dsi, 0x7f, &par, 1); 162 157 if (ret < 0) { 163 - DRM_DEV_ERROR(acx->dev, 164 - "failed to lock CMD 2 (%d)\n", 165 - ret); 158 + dev_err(acx->dev, "failed to lock CMD 2 (%d)\n", ret); 166 159 return ret; 167 160 } 168 161 ··· 161 174 ret = mipi_dsi_dcs_write(dsi, MIPI_DCS_WRITE_CONTROL_DISPLAY, 162 175 &par, 1); 163 176 if (ret < 0) { 164 - DRM_DEV_ERROR(acx->dev, 165 - "failed to enable display backlight (%d)\n", 166 - ret); 177 + dev_err(acx->dev, "failed to enable display backlight (%d)\n", ret); 167 178 return ret; 168 179 } 169 180 ··· 181 196 182 197 ret = mipi_dsi_dcs_read(dsi, ACX424_DCS_READ_ID1, &vendor, 1); 183 198 if (ret < 0) { 184 - DRM_DEV_ERROR(acx->dev, "could not vendor ID byte\n"); 199 + dev_err(acx->dev, "could not vendor ID byte\n"); 185 200 return ret; 186 201 } 187 202 ret = mipi_dsi_dcs_read(dsi, ACX424_DCS_READ_ID2, &version, 1); 188 203 if (ret < 0) { 189 - DRM_DEV_ERROR(acx->dev, "could not read device version byte\n"); 204 + dev_err(acx->dev, "could not read device version byte\n"); 190 205 return ret; 191 206 } 192 207 ret = mipi_dsi_dcs_read(dsi, ACX424_DCS_READ_ID3, &panel, 1); 193 208 if (ret < 0) { 194 - DRM_DEV_ERROR(acx->dev, "could not read panel ID byte\n"); 209 + dev_err(acx->dev, "could not read panel ID byte\n"); 195 210 return ret; 196 211 } 197 212 198 213 if (vendor == 0x00) { 199 - DRM_DEV_ERROR(acx->dev, "device vendor ID is zero\n"); 214 + dev_err(acx->dev, "device vendor ID is zero\n"); 200 215 return -ENODEV; 201 216 } 202 217 ··· 205 220 case DISPLAY_SONY_ACX424AKP_ID1: 206 221 case DISPLAY_SONY_ACX424AKP_ID2: 207 222 case DISPLAY_SONY_ACX424AKP_ID3: 208 - DRM_DEV_INFO(acx->dev, 209 - "MTP vendor: %02x, version: %02x, panel: %02x\n", 210 - vendor, version, panel); 223 + dev_info(acx->dev, "MTP vendor: %02x, version: %02x, panel: %02x\n", 224 + vendor, version, panel); 211 225 break; 212 226 default: 213 - DRM_DEV_INFO(acx->dev, 214 - "unknown vendor: %02x, version: %02x, panel: %02x\n", 215 - vendor, version, panel); 227 + dev_info(acx->dev, "unknown vendor: %02x, version: %02x, panel: %02x\n", 228 + vendor, version, panel); 216 229 break; 217 230 } 218 231 ··· 223 240 224 241 ret = regulator_enable(acx->supply); 225 242 if (ret) { 226 - DRM_DEV_ERROR(acx->dev, "failed to enable supply (%d)\n", ret); 243 + dev_err(acx->dev, "failed to enable supply (%d)\n", ret); 227 244 return ret; 228 245 } 229 246 ··· 259 276 260 277 ret = acx424akp_read_id(acx); 261 278 if (ret) { 262 - DRM_DEV_ERROR(acx->dev, "failed to read panel ID (%d)\n", ret); 279 + dev_err(acx->dev, "failed to read panel ID (%d)\n", ret); 263 280 goto err_power_off; 264 281 } 265 282 ··· 267 284 ret = mipi_dsi_dcs_set_tear_on(dsi, 268 285 MIPI_DSI_DCS_TEAR_MODE_VBLANK); 269 286 if (ret) { 270 - DRM_DEV_ERROR(acx->dev, "failed to enable vblank TE (%d)\n", 271 - ret); 287 + dev_err(acx->dev, "failed to enable vblank TE (%d)\n", ret); 272 288 goto err_power_off; 273 289 } 274 290 ··· 284 302 ret = mipi_dsi_dcs_write(dsi, ACX424_DCS_SET_MDDI, 285 303 &mddi, sizeof(mddi)); 286 304 if (ret < 0) { 287 - DRM_DEV_ERROR(acx->dev, "failed to set MDDI (%d)\n", ret); 305 + dev_err(acx->dev, "failed to set MDDI (%d)\n", ret); 288 306 goto err_power_off; 289 307 } 290 308 291 309 /* Exit sleep mode */ 292 310 ret = mipi_dsi_dcs_exit_sleep_mode(dsi); 293 311 if (ret) { 294 - DRM_DEV_ERROR(acx->dev, "failed to exit sleep mode (%d)\n", 295 - ret); 312 + dev_err(acx->dev, "failed to exit sleep mode (%d)\n", ret); 296 313 goto err_power_off; 297 314 } 298 315 msleep(140); 299 316 300 317 ret = mipi_dsi_dcs_set_display_on(dsi); 301 318 if (ret) { 302 - DRM_DEV_ERROR(acx->dev, "failed to turn display on (%d)\n", 303 - ret); 319 + dev_err(acx->dev, "failed to turn display on (%d)\n", ret); 304 320 goto err_power_off; 305 321 } 306 322 if (acx->video_mode) { ··· 331 351 ret = mipi_dsi_dcs_write(dsi, MIPI_DCS_WRITE_CONTROL_DISPLAY, 332 352 &par, 1); 333 353 if (ret) { 334 - DRM_DEV_ERROR(acx->dev, 335 - "failed to disable display backlight (%d)\n", 336 - ret); 354 + dev_err(acx->dev, "failed to disable display backlight (%d)\n", ret); 337 355 return ret; 338 356 } 339 357 340 358 ret = mipi_dsi_dcs_set_display_off(dsi); 341 359 if (ret) { 342 - DRM_DEV_ERROR(acx->dev, "failed to turn display off (%d)\n", 343 - ret); 360 + dev_err(acx->dev, "failed to turn display off (%d)\n", ret); 344 361 return ret; 345 362 } 346 363 347 364 /* Enter sleep mode */ 348 365 ret = mipi_dsi_dcs_enter_sleep_mode(dsi); 349 366 if (ret) { 350 - DRM_DEV_ERROR(acx->dev, "failed to enter sleep mode (%d)\n", 351 - ret); 367 + dev_err(acx->dev, "failed to enter sleep mode (%d)\n", ret); 352 368 return ret; 353 369 } 354 370 msleep(85); ··· 394 418 mode = drm_mode_duplicate(connector->dev, 395 419 &sony_acx424akp_cmd_mode); 396 420 if (!mode) { 397 - DRM_ERROR("bad mode or failed to add mode\n"); 421 + dev_err(panel->dev, "bad mode or failed to add mode\n"); 398 422 return -EINVAL; 399 423 } 400 424 drm_mode_set_name(mode); ··· 462 486 if (IS_ERR(acx->reset_gpio)) { 463 487 ret = PTR_ERR(acx->reset_gpio); 464 488 if (ret != -EPROBE_DEFER) 465 - DRM_DEV_ERROR(dev, "failed to request GPIO (%d)\n", 466 - ret); 489 + dev_err(dev, "failed to request GPIO (%d)\n", ret); 467 490 return ret; 468 491 } 469 492 ··· 472 497 acx->bl = devm_backlight_device_register(dev, "acx424akp", dev, acx, 473 498 &acx424akp_bl_ops, NULL); 474 499 if (IS_ERR(acx->bl)) { 475 - DRM_DEV_ERROR(dev, "failed to register backlight device\n"); 500 + dev_err(dev, "failed to register backlight device\n"); 476 501 return PTR_ERR(acx->bl); 477 502 } 478 503 acx->bl->props.max_brightness = 1023;

+17 -21

drivers/gpu/drm/panel/panel-tpo-tpg110.c

··· 12 12 */ 13 13 #include <drm/drm_modes.h> 14 14 #include <drm/drm_panel.h> 15 - #include <drm/drm_print.h> 16 15 17 16 #include <linux/bitops.h> 18 17 #include <linux/delay.h> ··· 237 238 spi_message_add_tail(&t[1], &m); 238 239 ret = spi_sync(tpg->spi, &m); 239 240 if (ret) { 240 - DRM_DEV_ERROR(tpg->dev, "SPI message error %d\n", ret); 241 + dev_err(tpg->dev, "SPI message error %d\n", ret); 241 242 return ret; 242 243 } 243 244 if (write) ··· 264 265 /* De-assert the reset signal */ 265 266 gpiod_set_value_cansleep(tpg->grestb, 0); 266 267 usleep_range(1000, 2000); 267 - DRM_DEV_DEBUG(tpg->dev, "de-asserted GRESTB\n"); 268 + dev_dbg(tpg->dev, "de-asserted GRESTB\n"); 268 269 269 270 /* Test display communication */ 270 271 tpg110_write_reg(tpg, TPG110_TEST, 0x55); 271 272 val = tpg110_read_reg(tpg, TPG110_TEST); 272 273 if (val != 0x55) { 273 - DRM_DEV_ERROR(tpg->dev, "failed communication test\n"); 274 + dev_err(tpg->dev, "failed communication test\n"); 274 275 return -ENODEV; 275 276 } 276 277 277 278 val = tpg110_read_reg(tpg, TPG110_CHIPID); 278 - DRM_DEV_INFO(tpg->dev, "TPG110 chip ID: %d version: %d\n", 279 + dev_info(tpg->dev, "TPG110 chip ID: %d version: %d\n", 279 280 val >> 4, val & 0x0f); 280 281 281 282 /* Show display resolution */ ··· 283 284 val &= TPG110_RES_MASK; 284 285 switch (val) { 285 286 case TPG110_RES_400X240_D: 286 - DRM_DEV_INFO(tpg->dev, 287 - "IN 400x240 RGB -> OUT 800x480 RGB (dual scan)\n"); 287 + dev_info(tpg->dev, "IN 400x240 RGB -> OUT 800x480 RGB (dual scan)\n"); 288 288 break; 289 289 case TPG110_RES_480X272_D: 290 - DRM_DEV_INFO(tpg->dev, 291 - "IN 480x272 RGB -> OUT 800x480 RGB (dual scan)\n"); 290 + dev_info(tpg->dev, "IN 480x272 RGB -> OUT 800x480 RGB (dual scan)\n"); 292 291 break; 293 292 case TPG110_RES_480X640: 294 - DRM_DEV_INFO(tpg->dev, "480x640 RGB\n"); 293 + dev_info(tpg->dev, "480x640 RGB\n"); 295 294 break; 296 295 case TPG110_RES_480X272: 297 - DRM_DEV_INFO(tpg->dev, "480x272 RGB\n"); 296 + dev_info(tpg->dev, "480x272 RGB\n"); 298 297 break; 299 298 case TPG110_RES_640X480: 300 - DRM_DEV_INFO(tpg->dev, "640x480 RGB\n"); 299 + dev_info(tpg->dev, "640x480 RGB\n"); 301 300 break; 302 301 case TPG110_RES_800X480: 303 - DRM_DEV_INFO(tpg->dev, "800x480 RGB\n"); 302 + dev_info(tpg->dev, "800x480 RGB\n"); 304 303 break; 305 304 default: 306 - DRM_DEV_ERROR(tpg->dev, "ILLEGAL RESOLUTION 0x%02x\n", val); 305 + dev_err(tpg->dev, "ILLEGAL RESOLUTION 0x%02x\n", val); 307 306 break; 308 307 } 309 308 ··· 319 322 } 320 323 } 321 324 if (i == ARRAY_SIZE(tpg110_modes)) { 322 - DRM_DEV_ERROR(tpg->dev, "unsupported mode (%02x) detected\n", 323 - val); 325 + dev_err(tpg->dev, "unsupported mode (%02x) detected\n", val); 324 326 return -ENODEV; 325 327 } 326 328 327 329 val = tpg110_read_reg(tpg, TPG110_CTRL2); 328 - DRM_DEV_INFO(tpg->dev, "resolution and standby is controlled by %s\n", 330 + dev_info(tpg->dev, "resolution and standby is controlled by %s\n", 329 331 (val & TPG110_CTRL2_RES_PM_CTRL) ? "software" : "hardware"); 330 332 /* Take control over resolution and standby */ 331 333 val |= TPG110_CTRL2_RES_PM_CTRL; ··· 410 414 /* We get the physical display dimensions from the DT */ 411 415 ret = of_property_read_u32(np, "width-mm", &tpg->width); 412 416 if (ret) 413 - DRM_DEV_ERROR(dev, "no panel width specified\n"); 417 + dev_err(dev, "no panel width specified\n"); 414 418 ret = of_property_read_u32(np, "height-mm", &tpg->height); 415 419 if (ret) 416 - DRM_DEV_ERROR(dev, "no panel height specified\n"); 420 + dev_err(dev, "no panel height specified\n"); 417 421 418 422 /* This asserts the GRESTB signal, putting the display into reset */ 419 423 tpg->grestb = devm_gpiod_get(dev, "grestb", GPIOD_OUT_HIGH); 420 424 if (IS_ERR(tpg->grestb)) { 421 - DRM_DEV_ERROR(dev, "no GRESTB GPIO\n"); 425 + dev_err(dev, "no GRESTB GPIO\n"); 422 426 return -ENODEV; 423 427 } 424 428 ··· 426 430 spi->mode |= SPI_3WIRE_HIZ; 427 431 ret = spi_setup(spi); 428 432 if (ret < 0) { 429 - DRM_DEV_ERROR(dev, "spi setup failed.\n"); 433 + dev_err(dev, "spi setup failed.\n"); 430 434 return ret; 431 435 } 432 436 tpg->spi = spi;

+21 -42

drivers/gpu/drm/panel/panel-truly-nt35597.c

··· 17 17 #include <drm/drm_mipi_dsi.h> 18 18 #include <drm/drm_modes.h> 19 19 #include <drm/drm_panel.h> 20 - #include <drm/drm_print.h> 21 20 22 21 static const char * const regulator_names[] = { 23 22 "vdda", ··· 230 231 for (i = 0; i < ARRAY_SIZE(ctx->dsi); i++) { 231 232 ret = mipi_dsi_dcs_write(ctx->dsi[i], command, NULL, 0); 232 233 if (ret < 0) { 233 - DRM_DEV_ERROR(ctx->dev, 234 - "cmd 0x%x failed for dsi = %d\n", 235 - command, i); 234 + dev_err(ctx->dev, "cmd 0x%x failed for dsi = %d\n", command, i); 236 235 } 237 236 } 238 237 ··· 247 250 for (i = 0; i < ARRAY_SIZE(ctx->dsi); i++) { 248 251 ret = mipi_dsi_dcs_write_buffer(ctx->dsi[i], buf, size); 249 252 if (ret < 0) { 250 - DRM_DEV_ERROR(ctx->dev, 251 - "failed to tx cmd [%d], err: %d\n", i, ret); 253 + dev_err(ctx->dev, "failed to tx cmd [%d], err: %d\n", i, ret); 252 254 return ret; 253 255 } 254 256 } ··· 296 300 ret = regulator_set_load(ctx->supplies[i].consumer, 297 301 regulator_disable_loads[i]); 298 302 if (ret) { 299 - DRM_DEV_ERROR(ctx->dev, 300 - "regulator_set_load failed %d\n", ret); 303 + dev_err(ctx->dev, "regulator_set_load failed %d\n", ret); 301 304 return ret; 302 305 } 303 306 } 304 307 305 308 ret = regulator_bulk_disable(ARRAY_SIZE(ctx->supplies), ctx->supplies); 306 309 if (ret) { 307 - DRM_DEV_ERROR(ctx->dev, 308 - "regulator_bulk_disable failed %d\n", ret); 310 + dev_err(ctx->dev, "regulator_bulk_disable failed %d\n", ret); 309 311 } 310 312 return ret; 311 313 } ··· 319 325 if (ctx->backlight) { 320 326 ret = backlight_disable(ctx->backlight); 321 327 if (ret < 0) 322 - DRM_DEV_ERROR(ctx->dev, "backlight disable failed %d\n", 323 - ret); 328 + dev_err(ctx->dev, "backlight disable failed %d\n", ret); 324 329 } 325 330 326 331 ctx->enabled = false; ··· 339 346 340 347 ret = truly_dcs_write(panel, MIPI_DCS_SET_DISPLAY_OFF); 341 348 if (ret < 0) { 342 - DRM_DEV_ERROR(ctx->dev, 343 - "set_display_off cmd failed ret = %d\n", 344 - ret); 349 + dev_err(ctx->dev, "set_display_off cmd failed ret = %d\n", ret); 345 350 } 346 351 347 352 /* 120ms delay required here as per DCS spec */ ··· 347 356 348 357 ret = truly_dcs_write(panel, MIPI_DCS_ENTER_SLEEP_MODE); 349 358 if (ret < 0) { 350 - DRM_DEV_ERROR(ctx->dev, 351 - "enter_sleep cmd failed ret = %d\n", ret); 359 + dev_err(ctx->dev, "enter_sleep cmd failed ret = %d\n", ret); 352 360 } 353 361 354 362 ret = truly_nt35597_power_off(ctx); 355 363 if (ret < 0) 356 - DRM_DEV_ERROR(ctx->dev, "power_off failed ret = %d\n", ret); 364 + dev_err(ctx->dev, "power_off failed ret = %d\n", ret); 357 365 358 366 ctx->prepared = false; 359 367 return ret; ··· 386 396 panel_on_cmds[i].size, 387 397 panel_on_cmds[i].commands); 388 398 if (ret < 0) { 389 - DRM_DEV_ERROR(ctx->dev, 390 - "cmd set tx failed i = %d ret = %d\n", 391 - i, ret); 399 + dev_err(ctx->dev, "cmd set tx failed i = %d ret = %d\n", i, ret); 392 400 goto power_off; 393 401 } 394 402 } 395 403 396 404 ret = truly_dcs_write(panel, MIPI_DCS_EXIT_SLEEP_MODE); 397 405 if (ret < 0) { 398 - DRM_DEV_ERROR(ctx->dev, 399 - "exit_sleep_mode cmd failed ret = %d\n", 400 - ret); 406 + dev_err(ctx->dev, "exit_sleep_mode cmd failed ret = %d\n", ret); 401 407 goto power_off; 402 408 } 403 409 ··· 402 416 403 417 ret = truly_dcs_write(panel, MIPI_DCS_SET_DISPLAY_ON); 404 418 if (ret < 0) { 405 - DRM_DEV_ERROR(ctx->dev, 406 - "set_display_on cmd failed ret = %d\n", ret); 419 + dev_err(ctx->dev, "set_display_on cmd failed ret = %d\n", ret); 407 420 goto power_off; 408 421 } 409 422 ··· 415 430 416 431 power_off: 417 432 if (truly_nt35597_power_off(ctx)) 418 - DRM_DEV_ERROR(ctx->dev, "power_off failed\n"); 433 + dev_err(ctx->dev, "power_off failed\n"); 419 434 return ret; 420 435 } 421 436 ··· 430 445 if (ctx->backlight) { 431 446 ret = backlight_enable(ctx->backlight); 432 447 if (ret < 0) 433 - DRM_DEV_ERROR(ctx->dev, "backlight enable failed %d\n", 434 - ret); 448 + dev_err(ctx->dev, "backlight enable failed %d\n", ret); 435 449 } 436 450 437 451 ctx->enabled = true; ··· 448 464 config = ctx->config; 449 465 mode = drm_mode_create(connector->dev); 450 466 if (!mode) { 451 - DRM_DEV_ERROR(ctx->dev, 452 - "failed to create a new display mode\n"); 467 + dev_err(ctx->dev, "failed to create a new display mode\n"); 453 468 return 0; 454 469 } 455 470 ··· 484 501 485 502 ctx->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW); 486 503 if (IS_ERR(ctx->reset_gpio)) { 487 - DRM_DEV_ERROR(dev, "cannot get reset gpio %ld\n", 488 - PTR_ERR(ctx->reset_gpio)); 504 + dev_err(dev, "cannot get reset gpio %ld\n", PTR_ERR(ctx->reset_gpio)); 489 505 return PTR_ERR(ctx->reset_gpio); 490 506 } 491 507 492 508 ctx->mode_gpio = devm_gpiod_get(dev, "mode", GPIOD_OUT_LOW); 493 509 if (IS_ERR(ctx->mode_gpio)) { 494 - DRM_DEV_ERROR(dev, "cannot get mode gpio %ld\n", 495 - PTR_ERR(ctx->mode_gpio)); 510 + dev_err(dev, "cannot get mode gpio %ld\n", PTR_ERR(ctx->mode_gpio)); 496 511 return PTR_ERR(ctx->mode_gpio); 497 512 } 498 513 ··· 565 584 566 585 dsi1 = of_graph_get_remote_node(dsi->dev.of_node, 1, -1); 567 586 if (!dsi1) { 568 - DRM_DEV_ERROR(dev, 569 - "failed to get remote node for dsi1_device\n"); 587 + dev_err(dev, "failed to get remote node for dsi1_device\n"); 570 588 return -ENODEV; 571 589 } 572 590 573 591 dsi1_host = of_find_mipi_dsi_host_by_node(dsi1); 574 592 of_node_put(dsi1); 575 593 if (!dsi1_host) { 576 - DRM_DEV_ERROR(dev, "failed to find dsi host\n"); 594 + dev_err(dev, "failed to find dsi host\n"); 577 595 return -EPROBE_DEFER; 578 596 } 579 597 580 598 /* register the second DSI device */ 581 599 dsi1_device = mipi_dsi_device_register_full(dsi1_host, &info); 582 600 if (IS_ERR(dsi1_device)) { 583 - DRM_DEV_ERROR(dev, "failed to create dsi device\n"); 601 + dev_err(dev, "failed to create dsi device\n"); 584 602 return PTR_ERR(dsi1_device); 585 603 } 586 604 ··· 591 611 592 612 ret = truly_nt35597_panel_add(ctx); 593 613 if (ret) { 594 - DRM_DEV_ERROR(dev, "failed to add panel\n"); 614 + dev_err(dev, "failed to add panel\n"); 595 615 goto err_panel_add; 596 616 } 597 617 ··· 603 623 MIPI_DSI_CLOCK_NON_CONTINUOUS; 604 624 ret = mipi_dsi_attach(dsi_dev); 605 625 if (ret < 0) { 606 - DRM_DEV_ERROR(dev, 607 - "dsi attach failed i = %d\n", i); 626 + dev_err(dev, "dsi attach failed i = %d\n", i); 608 627 goto err_dsi_attach; 609 628 } 610 629 }

+13 -28

drivers/gpu/drm/panel/panel-visionox-rm69299.c

··· 14 14 #include <drm/drm_mipi_dsi.h> 15 15 #include <drm/drm_modes.h> 16 16 #include <drm/drm_panel.h> 17 - #include <drm/drm_print.h> 18 17 19 18 struct visionox_rm69299 { 20 19 struct drm_panel panel; ··· 68 69 69 70 ret = mipi_dsi_dcs_write(ctx->dsi, MIPI_DCS_SET_DISPLAY_OFF, NULL, 0); 70 71 if (ret < 0) 71 - DRM_DEV_ERROR(ctx->panel.dev, 72 - "set_display_off cmd failed ret = %d\n", ret); 72 + dev_err(ctx->panel.dev, "set_display_off cmd failed ret = %d\n", ret); 73 73 74 74 /* 120ms delay required here as per DCS spec */ 75 75 msleep(120); 76 76 77 77 ret = mipi_dsi_dcs_write(ctx->dsi, MIPI_DCS_ENTER_SLEEP_MODE, NULL, 0); 78 78 if (ret < 0) { 79 - DRM_DEV_ERROR(ctx->panel.dev, 80 - "enter_sleep cmd failed ret = %d\n", ret); 79 + dev_err(ctx->panel.dev, "enter_sleep cmd failed ret = %d\n", ret); 81 80 } 82 81 83 82 ret = visionox_rm69299_power_off(ctx); ··· 100 103 101 104 ret = mipi_dsi_dcs_write_buffer(ctx->dsi, (u8[]) { 0xfe, 0x00 }, 2); 102 105 if (ret < 0) { 103 - DRM_DEV_ERROR(ctx->panel.dev, 104 - "cmd set tx 0 failed, ret = %d\n", ret); 106 + dev_err(ctx->panel.dev, "cmd set tx 0 failed, ret = %d\n", ret); 105 107 goto power_off; 106 108 } 107 109 108 110 ret = mipi_dsi_dcs_write_buffer(ctx->dsi, (u8[]) { 0xc2, 0x08 }, 2); 109 111 if (ret < 0) { 110 - DRM_DEV_ERROR(ctx->panel.dev, 111 - "cmd set tx 1 failed, ret = %d\n", ret); 112 + dev_err(ctx->panel.dev, "cmd set tx 1 failed, ret = %d\n", ret); 112 113 goto power_off; 113 114 } 114 115 115 116 ret = mipi_dsi_dcs_write_buffer(ctx->dsi, (u8[]) { 0x35, 0x00 }, 2); 116 117 if (ret < 0) { 117 - DRM_DEV_ERROR(ctx->panel.dev, 118 - "cmd set tx 2 failed, ret = %d\n", ret); 118 + dev_err(ctx->panel.dev, "cmd set tx 2 failed, ret = %d\n", ret); 119 119 goto power_off; 120 120 } 121 121 122 122 ret = mipi_dsi_dcs_write_buffer(ctx->dsi, (u8[]) { 0x51, 0xff }, 2); 123 123 if (ret < 0) { 124 - DRM_DEV_ERROR(ctx->panel.dev, 125 - "cmd set tx 3 failed, ret = %d\n", ret); 124 + dev_err(ctx->panel.dev, "cmd set tx 3 failed, ret = %d\n", ret); 126 125 goto power_off; 127 126 } 128 127 129 128 ret = mipi_dsi_dcs_write(ctx->dsi, MIPI_DCS_EXIT_SLEEP_MODE, NULL, 0); 130 129 if (ret < 0) { 131 - DRM_DEV_ERROR(ctx->panel.dev, 132 - "exit_sleep_mode cmd failed ret = %d\n", ret); 130 + dev_err(ctx->panel.dev, "exit_sleep_mode cmd failed ret = %d\n", ret); 133 131 goto power_off; 134 132 } 135 133 ··· 133 141 134 142 ret = mipi_dsi_dcs_write(ctx->dsi, MIPI_DCS_SET_DISPLAY_ON, NULL, 0); 135 143 if (ret < 0) { 136 - DRM_DEV_ERROR(ctx->panel.dev, 137 - "set_display_on cmd failed ret = %d\n", ret); 144 + dev_err(ctx->panel.dev, "set_display_on cmd failed ret = %d\n", ret); 138 145 goto power_off; 139 146 } 140 147 ··· 170 179 171 180 mode = drm_mode_create(connector->dev); 172 181 if (!mode) { 173 - DRM_DEV_ERROR(ctx->panel.dev, 174 - "failed to create a new display mode\n"); 182 + dev_err(ctx->panel.dev, "failed to create a new display mode\n"); 175 183 return 0; 176 184 } 177 185 ··· 215 225 ctx->reset_gpio = devm_gpiod_get(ctx->panel.dev, 216 226 "reset", GPIOD_OUT_LOW); 217 227 if (IS_ERR(ctx->reset_gpio)) { 218 - DRM_DEV_ERROR(dev, "cannot get reset gpio %ld\n", 219 - PTR_ERR(ctx->reset_gpio)); 228 + dev_err(dev, "cannot get reset gpio %ld\n", PTR_ERR(ctx->reset_gpio)); 220 229 return PTR_ERR(ctx->reset_gpio); 221 230 } 222 231 ··· 231 242 MIPI_DSI_CLOCK_NON_CONTINUOUS; 232 243 ret = mipi_dsi_attach(dsi); 233 244 if (ret < 0) { 234 - DRM_DEV_ERROR(dev, "dsi attach failed ret = %d\n", ret); 245 + dev_err(dev, "dsi attach failed ret = %d\n", ret); 235 246 goto err_dsi_attach; 236 247 } 237 248 238 249 ret = regulator_set_load(ctx->supplies[0].consumer, 32000); 239 250 if (ret) { 240 - DRM_DEV_ERROR(dev, 241 - "regulator set load failed for vdda supply ret = %d\n", 242 - ret); 251 + dev_err(dev, "regulator set load failed for vdda supply ret = %d\n", ret); 243 252 goto err_set_load; 244 253 } 245 254 246 255 ret = regulator_set_load(ctx->supplies[1].consumer, 13200); 247 256 if (ret) { 248 - DRM_DEV_ERROR(dev, 249 - "regulator set load failed for vdd3p3 supply ret = %d\n", 250 - ret); 257 + dev_err(dev, "regulator set load failed for vdd3p3 supply ret = %d\n", ret); 251 258 goto err_set_load; 252 259 } 253 260

+19 -32

drivers/gpu/drm/panel/panel-xinpeng-xpp055c272.c

··· 12 12 #include <drm/drm_mipi_dsi.h> 13 13 #include <drm/drm_modes.h> 14 14 #include <drm/drm_panel.h> 15 - #include <drm/drm_print.h> 16 15 17 16 #include <video/display_timing.h> 18 17 #include <video/mipi_display.h> ··· 134 135 135 136 msleep(60); 136 137 137 - DRM_DEV_DEBUG_DRIVER(dev, "Panel init sequence done\n"); 138 + dev_dbg(dev, "Panel init sequence done\n"); 138 139 return 0; 139 140 } 140 141 ··· 149 150 150 151 ret = mipi_dsi_dcs_set_display_off(dsi); 151 152 if (ret < 0) 152 - DRM_DEV_ERROR(ctx->dev, "failed to set display off: %d\n", 153 - ret); 153 + dev_err(ctx->dev, "failed to set display off: %d\n", ret); 154 154 155 155 mipi_dsi_dcs_enter_sleep_mode(dsi); 156 156 if (ret < 0) { 157 - DRM_DEV_ERROR(ctx->dev, "failed to enter sleep mode: %d\n", 158 - ret); 157 + dev_err(ctx->dev, "failed to enter sleep mode: %d\n", ret); 159 158 return ret; 160 159 } 161 160 ··· 174 177 if (ctx->prepared) 175 178 return 0; 176 179 177 - DRM_DEV_DEBUG_DRIVER(ctx->dev, "Resetting the panel\n"); 180 + dev_dbg(ctx->dev, "Resetting the panel\n"); 178 181 ret = regulator_enable(ctx->vci); 179 182 if (ret < 0) { 180 - DRM_DEV_ERROR(ctx->dev, 181 - "Failed to enable vci supply: %d\n", ret); 183 + dev_err(ctx->dev, "Failed to enable vci supply: %d\n", ret); 182 184 return ret; 183 185 } 184 186 ret = regulator_enable(ctx->iovcc); 185 187 if (ret < 0) { 186 - DRM_DEV_ERROR(ctx->dev, 187 - "Failed to enable iovcc supply: %d\n", ret); 188 + dev_err(ctx->dev, "Failed to enable iovcc supply: %d\n", ret); 188 189 goto disable_vci; 189 190 } 190 191 ··· 196 201 197 202 ret = xpp055c272_init_sequence(ctx); 198 203 if (ret < 0) { 199 - DRM_DEV_ERROR(ctx->dev, "Panel init sequence failed: %d\n", 200 - ret); 204 + dev_err(ctx->dev, "Panel init sequence failed: %d\n", ret); 201 205 goto disable_iovcc; 202 206 } 203 207 204 208 ret = mipi_dsi_dcs_exit_sleep_mode(dsi); 205 209 if (ret < 0) { 206 - DRM_DEV_ERROR(ctx->dev, "Failed to exit sleep mode: %d\n", ret); 210 + dev_err(ctx->dev, "Failed to exit sleep mode: %d\n", ret); 207 211 goto disable_iovcc; 208 212 } 209 213 ··· 211 217 212 218 ret = mipi_dsi_dcs_set_display_on(dsi); 213 219 if (ret < 0) { 214 - DRM_DEV_ERROR(ctx->dev, "Failed to set display on: %d\n", ret); 220 + dev_err(ctx->dev, "Failed to set display on: %d\n", ret); 215 221 goto disable_iovcc; 216 222 } 217 223 ··· 250 256 251 257 mode = drm_mode_duplicate(connector->dev, &default_mode); 252 258 if (!mode) { 253 - DRM_DEV_ERROR(ctx->dev, "Failed to add mode %ux%u@%u\n", 254 - default_mode.hdisplay, default_mode.vdisplay, 255 - drm_mode_vrefresh(&default_mode)); 259 + dev_err(ctx->dev, "Failed to add mode %ux%u@%u\n", 260 + default_mode.hdisplay, default_mode.vdisplay, 261 + drm_mode_vrefresh(&default_mode)); 256 262 return -ENOMEM; 257 263 } 258 264 ··· 284 290 285 291 ctx->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW); 286 292 if (IS_ERR(ctx->reset_gpio)) { 287 - DRM_DEV_ERROR(dev, "cannot get reset gpio\n"); 293 + dev_err(dev, "cannot get reset gpio\n"); 288 294 return PTR_ERR(ctx->reset_gpio); 289 295 } 290 296 ··· 292 298 if (IS_ERR(ctx->vci)) { 293 299 ret = PTR_ERR(ctx->vci); 294 300 if (ret != -EPROBE_DEFER) 295 - DRM_DEV_ERROR(dev, 296 - "Failed to request vci regulator: %d\n", 297 - ret); 301 + dev_err(dev, "Failed to request vci regulator: %d\n", ret); 298 302 return ret; 299 303 } 300 304 ··· 300 308 if (IS_ERR(ctx->iovcc)) { 301 309 ret = PTR_ERR(ctx->iovcc); 302 310 if (ret != -EPROBE_DEFER) 303 - DRM_DEV_ERROR(dev, 304 - "Failed to request iovcc regulator: %d\n", 305 - ret); 311 + dev_err(dev, "Failed to request iovcc regulator: %d\n", ret); 306 312 return ret; 307 313 } 308 314 ··· 324 334 325 335 ret = mipi_dsi_attach(dsi); 326 336 if (ret < 0) { 327 - DRM_DEV_ERROR(dev, "mipi_dsi_attach failed: %d\n", ret); 337 + dev_err(dev, "mipi_dsi_attach failed: %d\n", ret); 328 338 drm_panel_remove(&ctx->panel); 329 339 return ret; 330 340 } ··· 339 349 340 350 ret = drm_panel_unprepare(&ctx->panel); 341 351 if (ret < 0) 342 - DRM_DEV_ERROR(&dsi->dev, "Failed to unprepare panel: %d\n", 343 - ret); 352 + dev_err(&dsi->dev, "Failed to unprepare panel: %d\n", ret); 344 353 345 354 ret = drm_panel_disable(&ctx->panel); 346 355 if (ret < 0) 347 - DRM_DEV_ERROR(&dsi->dev, "Failed to disable panel: %d\n", 348 - ret); 356 + dev_err(&dsi->dev, "Failed to disable panel: %d\n", ret); 349 357 } 350 358 351 359 static int xpp055c272_remove(struct mipi_dsi_device *dsi) ··· 355 367 356 368 ret = mipi_dsi_detach(dsi); 357 369 if (ret < 0) 358 - DRM_DEV_ERROR(&dsi->dev, "Failed to detach from DSI host: %d\n", 359 - ret); 370 + dev_err(&dsi->dev, "Failed to detach from DSI host: %d\n", ret); 360 371 361 372 drm_panel_remove(&ctx->panel); 362 373