Hi Heinrich,

[auto build test ERROR on drm/drm-next]
[also build test ERROR on v4.8-rc3 next-20160822]
[if your patch is applied to the wrong git tree, please drop us a note to help 
improve the system]
[Suggest to use git(>=2.9.0) format-patch --base=<commit> (or --base=auto for 
convenience) to record what (public, well-known) commit your patch series was 
built on]
[Check https://git-scm.com/docs/git-format-patch for more information]

url:    
https://github.com/0day-ci/linux/commits/Heinrich-Schuchardt/drm-gma500-dont-expose-stack-mrst_lvds_find_best_pll/20160822-040114
base:   git://people.freedesktop.org/~airlied/linux.git drm-next
config: x86_64-randconfig-n0-08221935 (attached as .config)
compiler: gcc-4.8 (Debian 4.8.4-1) 4.8.4
reproduce:
        # save the attached .config to linux build tree
        make ARCH=x86_64 

All errors (new ones prefixed by >>):

   In file included from arch/x86/include/asm/string.h:4:0,
                    from include/linux/string.h:18,
                    from include/uapi/linux/uuid.h:21,
                    from include/linux/uuid.h:19,
                    from include/linux/mod_devicetable.h:12,
                    from include/linux/i2c.h:29,
                    from drivers/gpu/drm/gma500/oaktrail_crtc.c:18:
   drivers/gpu/drm/gma500/oaktrail_crtc.c: In function 
'mrst_lvds_find_best_pll':
>> drivers/gpu/drm/gma500/oaktrail_crtc.c:197:33: error: incompatible type for 
>> argument 1 of '__memset'
     memset(clock, 0, sizeof(struct gma_clock_t));
                                    ^
   arch/x86/include/asm/string_64.h:78:40: note: in definition of macro 'memset'
    #define memset(s, c, n) __memset(s, c, n)
                                           ^
   arch/x86/include/asm/string_64.h:56:7: note: expected 'void *' but argument 
is of type 'struct gma_clock_t'
    void *__memset(void *s, int c, size_t n);
          ^

vim +/__memset +197 drivers/gpu/drm/gma500/oaktrail_crtc.c

    12   *
    13   * You should have received a copy of the GNU General Public License 
along with
    14   * this program; if not, write to the Free Software Foundation, Inc.,
    15   * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
    16   */
    17  
  > 18  #include <linux/i2c.h>
    19  #include <linux/pm_runtime.h>
    20  
    21  #include <drm/drmP.h>
    22  #include "framebuffer.h"
    23  #include "psb_drv.h"
    24  #include "psb_intel_drv.h"
    25  #include "psb_intel_reg.h"
    26  #include "gma_display.h"
    27  #include "power.h"
    28  
    29  #define MRST_LIMIT_LVDS_100L    0
    30  #define MRST_LIMIT_LVDS_83      1
    31  #define MRST_LIMIT_LVDS_100     2
    32  #define MRST_LIMIT_SDVO         3
    33  
    34  #define MRST_DOT_MIN              19750
    35  #define MRST_DOT_MAX              120000
    36  #define MRST_M_MIN_100L             20
    37  #define MRST_M_MIN_100              10
    38  #define MRST_M_MIN_83               12
    39  #define MRST_M_MAX_100L             34
    40  #define MRST_M_MAX_100              17
    41  #define MRST_M_MAX_83               20
    42  #define MRST_P1_MIN                 2
    43  #define MRST_P1_MAX_0               7
    44  #define MRST_P1_MAX_1               8
    45  
    46  static bool mrst_lvds_find_best_pll(const struct gma_limit_t *limit,
    47                                      struct drm_crtc *crtc, int target,
    48                                      int refclk, struct gma_clock_t 
*best_clock);
    49  
    50  static bool mrst_sdvo_find_best_pll(const struct gma_limit_t *limit,
    51                                      struct drm_crtc *crtc, int target,
    52                                      int refclk, struct gma_clock_t 
*best_clock);
    53  
    54  static const struct gma_limit_t mrst_limits[] = {
    55          {                       /* MRST_LIMIT_LVDS_100L */
    56           .dot = {.min = MRST_DOT_MIN, .max = MRST_DOT_MAX},
    57           .m = {.min = MRST_M_MIN_100L, .max = MRST_M_MAX_100L},
    58           .p1 = {.min = MRST_P1_MIN, .max = MRST_P1_MAX_1},
    59           .find_pll = mrst_lvds_find_best_pll,
    60           },
    61          {                       /* MRST_LIMIT_LVDS_83L */
    62           .dot = {.min = MRST_DOT_MIN, .max = MRST_DOT_MAX},
    63           .m = {.min = MRST_M_MIN_83, .max = MRST_M_MAX_83},
    64           .p1 = {.min = MRST_P1_MIN, .max = MRST_P1_MAX_0},
    65           .find_pll = mrst_lvds_find_best_pll,
    66           },
    67          {                       /* MRST_LIMIT_LVDS_100 */
    68           .dot = {.min = MRST_DOT_MIN, .max = MRST_DOT_MAX},
    69           .m = {.min = MRST_M_MIN_100, .max = MRST_M_MAX_100},
    70           .p1 = {.min = MRST_P1_MIN, .max = MRST_P1_MAX_1},
    71           .find_pll = mrst_lvds_find_best_pll,
    72           },
    73          {                       /* MRST_LIMIT_SDVO */
    74           .vco = {.min = 1400000, .max = 2800000},
    75           .n = {.min = 3, .max = 7},
    76           .m = {.min = 80, .max = 137},
    77           .p1 = {.min = 1, .max = 2},
    78           .p2 = {.dot_limit = 200000, .p2_slow = 10, .p2_fast = 10},
    79           .find_pll = mrst_sdvo_find_best_pll,
    80           },
    81  };
    82  
    83  #define MRST_M_MIN          10
    84  static const u32 oaktrail_m_converts[] = {
    85          0x2B, 0x15, 0x2A, 0x35, 0x1A, 0x0D, 0x26, 0x33, 0x19, 0x2C,
    86          0x36, 0x3B, 0x1D, 0x2E, 0x37, 0x1B, 0x2D, 0x16, 0x0B, 0x25,
    87          0x12, 0x09, 0x24, 0x32, 0x39, 0x1c,
    88  };
    89  
    90  static const struct gma_limit_t *mrst_limit(struct drm_crtc *crtc,
    91                                              int refclk)
    92  {
    93          const struct gma_limit_t *limit = NULL;
    94          struct drm_device *dev = crtc->dev;
    95          struct drm_psb_private *dev_priv = dev->dev_private;
    96  
    97          if (gma_pipe_has_type(crtc, INTEL_OUTPUT_LVDS)
    98              || gma_pipe_has_type(crtc, INTEL_OUTPUT_MIPI)) {
    99                  switch (dev_priv->core_freq) {
   100                  case 100:
   101                          limit = &mrst_limits[MRST_LIMIT_LVDS_100L];
   102                          break;
   103                  case 166:
   104                          limit = &mrst_limits[MRST_LIMIT_LVDS_83];
   105                          break;
   106                  case 200:
   107                          limit = &mrst_limits[MRST_LIMIT_LVDS_100];
   108                          break;
   109                  }
   110          } else if (gma_pipe_has_type(crtc, INTEL_OUTPUT_SDVO)) {
   111                  limit = &mrst_limits[MRST_LIMIT_SDVO];
   112          } else {
   113                  limit = NULL;
   114                  dev_err(dev->dev, "mrst_limit Wrong display type.\n");
   115          }
   116  
   117          return limit;
   118  }
   119  
   120  /** Derive the pixel clock for the given refclk and divisors for 8xx 
chips. */
   121  static void mrst_lvds_clock(int refclk, struct gma_clock_t *clock)
   122  {
   123          clock->dot = (refclk * clock->m) / (14 * clock->p1);
   124  }
   125  
   126  static void mrst_print_pll(struct gma_clock_t *clock)
   127  {
   128          DRM_DEBUG_DRIVER("dotclock=%d,  m=%d, m1=%d, m2=%d, n=%d, 
p1=%d, p2=%d\n",
   129                           clock->dot, clock->m, clock->m1, clock->m2, 
clock->n,
   130                           clock->p1, clock->p2);
   131  }
   132  
   133  static bool mrst_sdvo_find_best_pll(const struct gma_limit_t *limit,
   134                                      struct drm_crtc *crtc, int target,
   135                                      int refclk, struct gma_clock_t 
*best_clock)
   136  {
   137          struct gma_clock_t clock;
   138          u32 target_vco, actual_freq;
   139          s32 freq_error, min_error = 100000;
   140  
   141          memset(best_clock, 0, sizeof(*best_clock));
   142  
   143          for (clock.m = limit->m.min; clock.m <= limit->m.max; 
clock.m++) {
   144                  for (clock.n = limit->n.min; clock.n <= limit->n.max;
   145                       clock.n++) {
   146                          for (clock.p1 = limit->p1.min;
   147                               clock.p1 <= limit->p1.max; clock.p1++) {
   148                                  /* p2 value always stored in p2_slow on 
SDVO */
   149                                  clock.p = clock.p1 * limit->p2.p2_slow;
   150                                  target_vco = target * clock.p;
   151  
   152                                  /* VCO will increase at this point so 
break */
   153                                  if (target_vco > limit->vco.max)
   154                                          break;
   155  
   156                                  if (target_vco < limit->vco.min)
   157                                          continue;
   158  
   159                                  actual_freq = (refclk * clock.m) /
   160                                                (clock.n * clock.p);
   161                                  freq_error = 10000 -
   162                                               ((target * 10000) / 
actual_freq);
   163  
   164                                  if (freq_error < -min_error) {
   165                                          /* freq_error will start to 
decrease at
   166                                             this point so break */
   167                                          break;
   168                                  }
   169  
   170                                  if (freq_error < 0)
   171                                          freq_error = -freq_error;
   172  
   173                                  if (freq_error < min_error) {
   174                                          min_error = freq_error;
   175                                          *best_clock = clock;
   176                                  }
   177                          }
   178                  }
   179                  if (min_error == 0)
   180                          break;
   181          }
   182  
   183          return min_error == 0;
   184  }
   185  
   186  /**
   187   * Returns a set of divisors for the desired target clock with the 
given refclk,
   188   * or FALSE.  Divisor values are the actual divisors for
   189   */
   190  static bool mrst_lvds_find_best_pll(const struct gma_limit_t *limit,
   191                                      struct drm_crtc *crtc, int target,
   192                                      int refclk, struct gma_clock_t 
*best_clock)
   193  {
   194          struct gma_clock_t clock;
   195          int err = target;
   196  
 > 197          memset(clock, 0, sizeof(struct gma_clock_t));
   198          memset(best_clock, 0, sizeof(*best_clock));
   199  
   200          for (clock.m = limit->m.min; clock.m <= limit->m.max; 
clock.m++) {

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

Attachment: .config.gz
Description: Binary data

Reply via email to