if (*buf > 1) {
                va_end(args);
-               dev_err(par->info->device, "%s: Incorrect chip sellect request (%d)\n",
-                       __func__, *buf);
+               dev_err(par->info->device,
+                       "Incorrect chip sellect request (%d)\n", *buf);
                return;
        }
 
                ret = par->fbtftops.write(par, par->buf, len * (sizeof(u8)));
                if (ret < 0) {
                        va_end(args);
-                       dev_err(par->info->device, "%s: write() failed and returned %d\n",
-                               __func__, ret);
+                       dev_err(par->info->device,
+                               "write() failed and returned %d\n", ret);
                        return;
                }
        }
                        ret = par->fbtftops.write(par, buf, len);
                        if (ret < 0)
                                dev_err(par->info->device,
-                                       "%s: write failed and returned: %d\n",
-                                       __func__, ret);
+                                       "write failed and returned: %d\n",
+                                       ret);
                }
                /* right half of display */
                if (addr_win.xe >= par->info->var.xres / 2) {
                        par->fbtftops.write(par, buf, len);
                        if (ret < 0)
                                dev_err(par->info->device,
-                                       "%s: write failed and returned: %d\n",
-                                       __func__, ret);
+                                       "write failed and returned: %d\n",
+                                       ret);
                }
        }
        kfree(convert_buf);
 
        gpio_set_value(par->gpio.dc, 1);
        ret = par->fbtftops.write(par, par->txbuf.buf, 6*84);
        if (ret < 0)
-               dev_err(par->info->device, "%s: write failed and returned: %d\n", __func__, ret);
+               dev_err(par->info->device, "write failed and returned: %d\n",
+                       ret);
 
        return ret;
 }
 
        ret = par->fbtftops.write(par, par->buf, 2);
        if (ret < 0) {
                va_end(args);
-               dev_err(par->info->device, "%s: write() failed and returned %dn",
-                       __func__, ret);
+               dev_err(par->info->device, "write() failed and returned %dn",
+                       ret);
                return;
        }
        len--;
                ret = par->fbtftops.write(par, par->buf, len + 1);
                if (ret < 0) {
                        va_end(args);
-                       dev_err(par->info->device, "%s: write() failed and returned %dn",
-                               __func__, ret);
+                       dev_err(par->info->device,
+                               "write() failed and returned %dn", ret);
                        return;
                }
        }
 
        ret = par->fbtftops.write(par, par->txbuf.buf,
                                par->info->var.xres*par->info->var.yres/8);
        if (ret < 0)
-               dev_err(par->info->device,
-                       "%s: write failed and returned: %d\n", __func__, ret);
+               dev_err(par->info->device, "write failed and returned: %d\n",
+                       ret);
 
        return ret;
 }
 
        ret = par->fbtftops.write(par, par->buf, sizeof(u8));
        if (ret < 0) {
                va_end(args);
-               dev_err(par->info->device, "%s: write() failed and returned %d\n", __func__, ret);
+               dev_err(par->info->device,
+                       "write() failed and returned %d\n", ret);
                return;
        }
        len--;
                ret = par->fbtftops.write(par, par->buf, len * (sizeof(u8)));
                if (ret < 0) {
                        va_end(args);
-                       dev_err(par->info->device, "%s: write() failed and returned %d\n", __func__, ret);
+                       dev_err(par->info->device,
+                               "write() failed and returned %d\n", ret);
                        return;
                }
        }
 
                ret = par->fbtftops.write(par, par->txbuf.buf, WIDTH);
                if (ret < 0) {
                        dev_err(par->info->device,
-                               "%s: write failed and returned: %d\n", __func__, ret);
+                               "write failed and returned: %d\n", ret);
                        break;
                }
        }
 
        }
 
        if (ret < 0)
-               dev_err(par->info->device, "%s: write failed and returned: %d\n", __func__, ret);
+               dev_err(par->info->device, "write failed and returned: %d\n",
+                       ret);
 
        return ret;
 }
 
        ret = par->fbtftops.write(par, par->buf, len);
        if (ret < 0) {
                dev_err(par->info->device,
-                       "%s: write() failed and returned %d\n", __func__, ret);
+                       "write() failed and returned %d\n", ret);
                return;
        }
 }
 
        ret = par->fbtftops.write(par, par->buf, (len + pad) * sizeof(u16));
        if (ret < 0) {
                dev_err(par->info->device,
-                       "%s: write() failed and returned %d\n", __func__, ret);
+                       "write() failed and returned %d\n", ret);
                return;
        }
 }
 
 
        /* sanity check */
        if (display->gamma_num * display->gamma_len > FBTFT_GAMMA_MAX_VALUES_TOTAL) {
-               dev_err(dev,
-                       "%s: FBTFT_GAMMA_MAX_VALUES_TOTAL=%d is exceeded\n",
-                       __func__, FBTFT_GAMMA_MAX_VALUES_TOTAL);
+               dev_err(dev, "FBTFT_GAMMA_MAX_VALUES_TOTAL=%d is exceeded\n",
+                       FBTFT_GAMMA_MAX_VALUES_TOTAL);
                return NULL;
        }
 
 
        }
        if ((len % 8) != 0) {
                dev_err(par->info->device,
-                       "%s: error: len=%zu must be divisible by 8\n",
-                       __func__, len);
+                       "error: len=%zu must be divisible by 8\n", len);
                return -EINVAL;
        }
 
        if (par->startbyte) {
                if (len > 32) {
                        dev_err(par->info->device,
-                               "%s: len=%zu can't be larger than 32 when using 'startbyte'\n",
-                               __func__, len);
+                               "len=%zu can't be larger than 32 when using 'startbyte'\n",
+                               len);
                        return -EINVAL;
                }
                txbuf[0] = par->startbyte | 0x3;