LCOV - code coverage report
Current view: top level - drivers/video/fbdev/core - fbcmap.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 69 115 60.0 %
Date: 2020-09-30 20:25:40 Functions: 5 9 55.6 %
Branches: 30 100 30.0 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  *  linux/drivers/video/fbcmap.c -- Colormap handling for frame buffer devices
       3                 :            :  *
       4                 :            :  *      Created 15 Jun 1997 by Geert Uytterhoeven
       5                 :            :  *
       6                 :            :  *      2001 - Documented with DocBook
       7                 :            :  *      - Brad Douglas <brad@neruo.com>
       8                 :            :  *
       9                 :            :  *  This file is subject to the terms and conditions of the GNU General Public
      10                 :            :  *  License.  See the file COPYING in the main directory of this archive for
      11                 :            :  *  more details.
      12                 :            :  */
      13                 :            : 
      14                 :            : #include <linux/string.h>
      15                 :            : #include <linux/module.h>
      16                 :            : #include <linux/fb.h>
      17                 :            : #include <linux/slab.h>
      18                 :            : #include <linux/uaccess.h>
      19                 :            : 
      20                 :            : static u16 red2[] __read_mostly = {
      21                 :            :     0x0000, 0xaaaa
      22                 :            : };
      23                 :            : static u16 green2[] __read_mostly = {
      24                 :            :     0x0000, 0xaaaa
      25                 :            : };
      26                 :            : static u16 blue2[] __read_mostly = {
      27                 :            :     0x0000, 0xaaaa
      28                 :            : };
      29                 :            : 
      30                 :            : static u16 red4[] __read_mostly = {
      31                 :            :     0x0000, 0xaaaa, 0x5555, 0xffff
      32                 :            : };
      33                 :            : static u16 green4[] __read_mostly = {
      34                 :            :     0x0000, 0xaaaa, 0x5555, 0xffff
      35                 :            : };
      36                 :            : static u16 blue4[] __read_mostly = {
      37                 :            :     0x0000, 0xaaaa, 0x5555, 0xffff
      38                 :            : };
      39                 :            : 
      40                 :            : static u16 red8[] __read_mostly = {
      41                 :            :     0x0000, 0x0000, 0x0000, 0x0000, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa
      42                 :            : };
      43                 :            : static u16 green8[] __read_mostly = {
      44                 :            :     0x0000, 0x0000, 0xaaaa, 0xaaaa, 0x0000, 0x0000, 0x5555, 0xaaaa
      45                 :            : };
      46                 :            : static u16 blue8[] __read_mostly = {
      47                 :            :     0x0000, 0xaaaa, 0x0000, 0xaaaa, 0x0000, 0xaaaa, 0x0000, 0xaaaa
      48                 :            : };
      49                 :            : 
      50                 :            : static u16 red16[] __read_mostly = {
      51                 :            :     0x0000, 0x0000, 0x0000, 0x0000, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa,
      52                 :            :     0x5555, 0x5555, 0x5555, 0x5555, 0xffff, 0xffff, 0xffff, 0xffff
      53                 :            : };
      54                 :            : static u16 green16[] __read_mostly = {
      55                 :            :     0x0000, 0x0000, 0xaaaa, 0xaaaa, 0x0000, 0x0000, 0x5555, 0xaaaa,
      56                 :            :     0x5555, 0x5555, 0xffff, 0xffff, 0x5555, 0x5555, 0xffff, 0xffff
      57                 :            : };
      58                 :            : static u16 blue16[] __read_mostly = {
      59                 :            :     0x0000, 0xaaaa, 0x0000, 0xaaaa, 0x0000, 0xaaaa, 0x0000, 0xaaaa,
      60                 :            :     0x5555, 0xffff, 0x5555, 0xffff, 0x5555, 0xffff, 0x5555, 0xffff
      61                 :            : };
      62                 :            : 
      63                 :            : static const struct fb_cmap default_2_colors = {
      64                 :            :     .len=2, .red=red2, .green=green2, .blue=blue2
      65                 :            : };
      66                 :            : static const struct fb_cmap default_8_colors = {
      67                 :            :     .len=8, .red=red8, .green=green8, .blue=blue8
      68                 :            : };
      69                 :            : static const struct fb_cmap default_4_colors = {
      70                 :            :     .len=4, .red=red4, .green=green4, .blue=blue4
      71                 :            : };
      72                 :            : static const struct fb_cmap default_16_colors = {
      73                 :            :     .len=16, .red=red16, .green=green16, .blue=blue16
      74                 :            : };
      75                 :            : 
      76                 :            : 
      77                 :            : 
      78                 :            : /**
      79                 :            :  *      fb_alloc_cmap - allocate a colormap
      80                 :            :  *      @cmap: frame buffer colormap structure
      81                 :            :  *      @len: length of @cmap
      82                 :            :  *      @transp: boolean, 1 if there is transparency, 0 otherwise
      83                 :            :  *      @flags: flags for kmalloc memory allocation
      84                 :            :  *
      85                 :            :  *      Allocates memory for a colormap @cmap.  @len is the
      86                 :            :  *      number of entries in the palette.
      87                 :            :  *
      88                 :            :  *      Returns negative errno on error, or zero on success.
      89                 :            :  *
      90                 :            :  */
      91                 :            : 
      92                 :      52992 : int fb_alloc_cmap_gfp(struct fb_cmap *cmap, int len, int transp, gfp_t flags)
      93                 :            : {
      94                 :      52992 :         int size = len * sizeof(u16);
      95                 :            :         int ret = -ENOMEM;
      96                 :            : 
      97                 :      52992 :         flags |= __GFP_NOWARN;
      98                 :            : 
      99         [ +  - ]:      52992 :         if (cmap->len != len) {
     100                 :      52992 :                 fb_dealloc_cmap(cmap);
     101         [ +  - ]:      52992 :                 if (!len)
     102                 :            :                         return 0;
     103                 :            : 
     104                 :      52992 :                 cmap->red = kmalloc(size, flags);
     105         [ +  - ]:      52992 :                 if (!cmap->red)
     106                 :            :                         goto fail;
     107                 :      52992 :                 cmap->green = kmalloc(size, flags);
     108         [ +  - ]:      52992 :                 if (!cmap->green)
     109                 :            :                         goto fail;
     110                 :      52992 :                 cmap->blue = kmalloc(size, flags);
     111         [ +  - ]:      52992 :                 if (!cmap->blue)
     112                 :            :                         goto fail;
     113         [ -  + ]:      52992 :                 if (transp) {
     114                 :          0 :                         cmap->transp = kmalloc(size, flags);
     115         [ #  # ]:          0 :                         if (!cmap->transp)
     116                 :            :                                 goto fail;
     117                 :            :                 } else {
     118                 :      52992 :                         cmap->transp = NULL;
     119                 :            :                 }
     120                 :            :         }
     121                 :      52992 :         cmap->start = 0;
     122                 :      52992 :         cmap->len = len;
     123                 :      52992 :         ret = fb_copy_cmap(fb_default_cmap(len), cmap);
     124         [ -  + ]:      52992 :         if (ret)
     125                 :            :                 goto fail;
     126                 :            :         return 0;
     127                 :            : 
     128                 :            : fail:
     129                 :          0 :         fb_dealloc_cmap(cmap);
     130                 :          0 :         return ret;
     131                 :            : }
     132                 :            : 
     133                 :          0 : int fb_alloc_cmap(struct fb_cmap *cmap, int len, int transp)
     134                 :            : {
     135                 :          0 :         return fb_alloc_cmap_gfp(cmap, len, transp, GFP_ATOMIC);
     136                 :            : }
     137                 :            : 
     138                 :            : /**
     139                 :            :  *      fb_dealloc_cmap - deallocate a colormap
     140                 :            :  *      @cmap: frame buffer colormap structure
     141                 :            :  *
     142                 :            :  *      Deallocates a colormap that was previously allocated with
     143                 :            :  *      fb_alloc_cmap().
     144                 :            :  *
     145                 :            :  */
     146                 :            : 
     147                 :     105984 : void fb_dealloc_cmap(struct fb_cmap *cmap)
     148                 :            : {
     149                 :     105984 :         kfree(cmap->red);
     150                 :     105984 :         kfree(cmap->green);
     151                 :     105984 :         kfree(cmap->blue);
     152                 :     105984 :         kfree(cmap->transp);
     153                 :            : 
     154                 :     105984 :         cmap->red = cmap->green = cmap->blue = cmap->transp = NULL;
     155                 :     105984 :         cmap->len = 0;
     156                 :     105984 : }
     157                 :            : 
     158                 :            : /**
     159                 :            :  *      fb_copy_cmap - copy a colormap
     160                 :            :  *      @from: frame buffer colormap structure
     161                 :            :  *      @to: frame buffer colormap structure
     162                 :            :  *
     163                 :            :  *      Copy contents of colormap from @from to @to.
     164                 :            :  */
     165                 :            : 
     166                 :     107847 : int fb_copy_cmap(const struct fb_cmap *from, struct fb_cmap *to)
     167                 :            : {
     168                 :            :         unsigned int tooff = 0, fromoff = 0;
     169                 :            :         size_t size;
     170                 :            : 
     171         [ -  + ]:     107847 :         if (to->start > from->start)
     172                 :          0 :                 fromoff = to->start - from->start;
     173                 :            :         else
     174                 :     107847 :                 tooff = from->start - to->start;
     175   [ +  +  +  + ]:     107847 :         if (fromoff >= from->len || tooff >= to->len)
     176                 :            :                 return -EINVAL;
     177                 :            : 
     178                 :      52992 :         size = min_t(size_t, to->len - tooff, from->len - fromoff);
     179         [ +  - ]:      52992 :         if (size == 0)
     180                 :            :                 return -EINVAL;
     181                 :      52992 :         size *= sizeof(u16);
     182                 :            : 
     183                 :      52992 :         memcpy(to->red+tooff, from->red+fromoff, size);
     184                 :      52992 :         memcpy(to->green+tooff, from->green+fromoff, size);
     185                 :      52992 :         memcpy(to->blue+tooff, from->blue+fromoff, size);
     186   [ -  +  #  # ]:      52992 :         if (from->transp && to->transp)
     187                 :          0 :                 memcpy(to->transp+tooff, from->transp+fromoff, size);
     188                 :            :         return 0;
     189                 :            : }
     190                 :            : 
     191                 :          0 : int fb_cmap_to_user(const struct fb_cmap *from, struct fb_cmap_user *to)
     192                 :            : {
     193                 :            :         unsigned int tooff = 0, fromoff = 0;
     194                 :            :         size_t size;
     195                 :            : 
     196         [ #  # ]:          0 :         if (to->start > from->start)
     197                 :          0 :                 fromoff = to->start - from->start;
     198                 :            :         else
     199                 :          0 :                 tooff = from->start - to->start;
     200   [ #  #  #  # ]:          0 :         if (fromoff >= from->len || tooff >= to->len)
     201                 :            :                 return -EINVAL;
     202                 :            : 
     203                 :          0 :         size = min_t(size_t, to->len - tooff, from->len - fromoff);
     204         [ #  # ]:          0 :         if (size == 0)
     205                 :            :                 return -EINVAL;
     206                 :          0 :         size *= sizeof(u16);
     207                 :            : 
     208         [ #  # ]:          0 :         if (copy_to_user(to->red+tooff, from->red+fromoff, size))
     209                 :            :                 return -EFAULT;
     210         [ #  # ]:          0 :         if (copy_to_user(to->green+tooff, from->green+fromoff, size))
     211                 :            :                 return -EFAULT;
     212         [ #  # ]:          0 :         if (copy_to_user(to->blue+tooff, from->blue+fromoff, size))
     213                 :            :                 return -EFAULT;
     214   [ #  #  #  # ]:          0 :         if (from->transp && to->transp)
     215         [ #  # ]:          0 :                 if (copy_to_user(to->transp+tooff, from->transp+fromoff, size))
     216                 :            :                         return -EFAULT;
     217                 :            :         return 0;
     218                 :            : }
     219                 :            : 
     220                 :            : /**
     221                 :            :  *      fb_set_cmap - set the colormap
     222                 :            :  *      @cmap: frame buffer colormap structure
     223                 :            :  *      @info: frame buffer info structure
     224                 :            :  *
     225                 :            :  *      Sets the colormap @cmap for a screen of device @info.
     226                 :            :  *
     227                 :            :  *      Returns negative errno on error, or zero on success.
     228                 :            :  *
     229                 :            :  */
     230                 :            : 
     231                 :      54855 : int fb_set_cmap(struct fb_cmap *cmap, struct fb_info *info)
     232                 :            : {
     233                 :            :         int i, start, rc = 0;
     234                 :            :         u16 *red, *green, *blue, *transp;
     235                 :            :         u_int hred, hgreen, hblue, htransp = 0xffff;
     236                 :            : 
     237                 :      54855 :         red = cmap->red;
     238                 :      54855 :         green = cmap->green;
     239                 :      54855 :         blue = cmap->blue;
     240                 :      54855 :         transp = cmap->transp;
     241                 :      54855 :         start = cmap->start;
     242                 :            : 
     243   [ +  -  -  +  :      54855 :         if (start < 0 || (!info->fbops->fb_setcolreg &&
                   #  # ]
     244                 :          0 :                           !info->fbops->fb_setcmap))
     245                 :            :                 return -EINVAL;
     246         [ +  - ]:      54855 :         if (info->fbops->fb_setcmap) {
     247                 :          0 :                 rc = info->fbops->fb_setcmap(cmap, info);
     248                 :            :         } else {
     249         [ +  + ]:      79488 :                 for (i = 0; i < cmap->len; i++) {
     250                 :      79488 :                         hred = *red++;
     251                 :      79488 :                         hgreen = *green++;
     252                 :      79488 :                         hblue = *blue++;
     253         [ -  + ]:      79488 :                         if (transp)
     254                 :          0 :                                 htransp = *transp++;
     255         [ +  - ]:      79488 :                         if (info->fbops->fb_setcolreg(start++,
     256                 :            :                                                       hred, hgreen, hblue,
     257                 :            :                                                       htransp, info))
     258                 :            :                                 break;
     259                 :            :                 }
     260                 :            :         }
     261         [ +  - ]:      54855 :         if (rc == 0)
     262                 :      54855 :                 fb_copy_cmap(cmap, &info->cmap);
     263                 :            : 
     264                 :      54855 :         return rc;
     265                 :            : }
     266                 :            : 
     267                 :      52992 : int fb_set_user_cmap(struct fb_cmap_user *cmap, struct fb_info *info)
     268                 :            : {
     269                 :      52992 :         int rc, size = cmap->len * sizeof(u16);
     270                 :            :         struct fb_cmap umap;
     271                 :            : 
     272   [ +  -  +  - ]:      52992 :         if (size < 0 || size < cmap->len)
     273                 :            :                 return -E2BIG;
     274                 :            : 
     275                 :      52992 :         memset(&umap, 0, sizeof(struct fb_cmap));
     276                 :      52992 :         rc = fb_alloc_cmap_gfp(&umap, cmap->len, cmap->transp != NULL,
     277                 :            :                                 GFP_KERNEL);
     278         [ +  - ]:      52992 :         if (rc)
     279                 :            :                 return rc;
     280   [ +  -  +  - ]:     158976 :         if (copy_from_user(umap.red, cmap->red, size) ||
     281         [ +  - ]:     105984 :             copy_from_user(umap.green, cmap->green, size) ||
     282         [ -  + ]:     105984 :             copy_from_user(umap.blue, cmap->blue, size) ||
     283         [ #  # ]:      52992 :             (cmap->transp && copy_from_user(umap.transp, cmap->transp, size))) {
     284                 :            :                 rc = -EFAULT;
     285                 :            :                 goto out;
     286                 :            :         }
     287                 :      52992 :         umap.start = cmap->start;
     288                 :            :         lock_fb_info(info);
     289                 :      52992 :         rc = fb_set_cmap(&umap, info);
     290                 :            :         unlock_fb_info(info);
     291                 :            : out:
     292                 :      52992 :         fb_dealloc_cmap(&umap);
     293                 :      52992 :         return rc;
     294                 :            : }
     295                 :            : 
     296                 :            : /**
     297                 :            :  *      fb_default_cmap - get default colormap
     298                 :            :  *      @len: size of palette for a depth
     299                 :            :  *
     300                 :            :  *      Gets the default colormap for a specific screen depth.  @len
     301                 :            :  *      is the size of the palette for a particular screen depth.
     302                 :            :  *
     303                 :            :  *      Returns pointer to a frame buffer colormap structure.
     304                 :            :  *
     305                 :            :  */
     306                 :            : 
     307                 :          0 : const struct fb_cmap *fb_default_cmap(int len)
     308                 :            : {
     309   [ #  #  -  + ]:      52992 :     if (len <= 2)
     310                 :            :         return &default_2_colors;
     311   [ #  #  #  # ]:          0 :     if (len <= 4)
     312                 :            :         return &default_4_colors;
     313   [ #  #  #  # ]:          0 :     if (len <= 8)
     314                 :            :         return &default_8_colors;
     315                 :          0 :     return &default_16_colors;
     316                 :            : }
     317                 :            : 
     318                 :            : 
     319                 :            : /**
     320                 :            :  *      fb_invert_cmaps - invert all defaults colormaps
     321                 :            :  *
     322                 :            :  *      Invert all default colormaps.
     323                 :            :  *
     324                 :            :  */
     325                 :            : 
     326                 :          0 : void fb_invert_cmaps(void)
     327                 :            : {
     328                 :            :     u_int i;
     329                 :            : 
     330         [ #  # ]:          0 :     for (i = 0; i < ARRAY_SIZE(red2); i++) {
     331                 :          0 :         red2[i] = ~red2[i];
     332                 :          0 :         green2[i] = ~green2[i];
     333                 :          0 :         blue2[i] = ~blue2[i];
     334                 :            :     }
     335         [ #  # ]:          0 :     for (i = 0; i < ARRAY_SIZE(red4); i++) {
     336                 :          0 :         red4[i] = ~red4[i];
     337                 :          0 :         green4[i] = ~green4[i];
     338                 :          0 :         blue4[i] = ~blue4[i];
     339                 :            :     }
     340         [ #  # ]:          0 :     for (i = 0; i < ARRAY_SIZE(red8); i++) {
     341                 :          0 :         red8[i] = ~red8[i];
     342                 :          0 :         green8[i] = ~green8[i];
     343                 :          0 :         blue8[i] = ~blue8[i];
     344                 :            :     }
     345         [ #  # ]:          0 :     for (i = 0; i < ARRAY_SIZE(red16); i++) {
     346                 :          0 :         red16[i] = ~red16[i];
     347                 :          0 :         green16[i] = ~green16[i];
     348                 :          0 :         blue16[i] = ~blue16[i];
     349                 :            :     }
     350                 :          0 : }
     351                 :            : 
     352                 :            : 
     353                 :            :     /*
     354                 :            :      *  Visible symbols for modules
     355                 :            :      */
     356                 :            : 
     357                 :            : EXPORT_SYMBOL(fb_alloc_cmap);
     358                 :            : EXPORT_SYMBOL(fb_dealloc_cmap);
     359                 :            : EXPORT_SYMBOL(fb_copy_cmap);
     360                 :            : EXPORT_SYMBOL(fb_set_cmap);
     361                 :            : EXPORT_SYMBOL(fb_default_cmap);
     362                 :            : EXPORT_SYMBOL(fb_invert_cmaps);

Generated by: LCOV version 1.14