tree af42e2d58f07091a0d74e21f96a4dc02cb74c8de
parent 04e1e70afec6bb2940aea0ac2e9cbaf7d643d5f4
author Huang Rui <ray.huang@amd.com> 1459928650 +0800
committer Guenter Roeck <linux@roeck-us.net> 1461072754 -0700

hwmon: (fam15h_power) Add CPU_SUP_AMD as the dependence

This patch adds CONFIG_CPU_SUP_AMD as the dependence of fam15h_power
driver. Because the following patch will use the interface from
x86/kernel/cpu/amd.c.

Otherwise, the below error might be encountered:

All errors (new ones prefixed by >>):

   drivers/built-in.o: In function `fam15h_power_probe':
>> fam15h_power.c:(.text+0x26e3a3): undefined reference to
>> `amd_get_cores_per_cu'
   fam15h_power.c:(.text+0x26e41e): undefined reference to
`amd_get_cores_per_cu'

Reported-by: build test robot <lkp@intel.com>
Acked-by: Borislav Petkov <bp@suse.de>
Signed-off-by: Huang Rui <ray.huang@amd.com>
Signed-off-by: Guenter Roeck <linux@roeck-us.net>
