1// SPDX-License-Identifier: GPL-2.0 2// Copyright (c) 2014-2018 Nuvoton Technology corporation. 3 4#include <linux/clk.h> 5#include <linux/device.h> 6#include <linux/hwmon.h> 7#include <linux/hwmon-sysfs.h> 8#include <linux/interrupt.h> 9#include <linux/kernel.h> 10#include <linux/module.h> 11#include <linux/of_address.h> 12#include <linux/of_irq.h> 13#include <linux/platform_device.h> 14#include <linux/spinlock.h> 15#include <linux/sysfs.h> 16#include <linux/thermal.h> 17 18/* NPCM7XX PWM registers */ 19#define NPCM7XX_PWM_REG_BASE(base, n) ((base) + ((n) * 0x1000L)) 20 21#define NPCM7XX_PWM_REG_PR(base, n) (NPCM7XX_PWM_REG_BASE(base, n) + 0x00) 22#define NPCM7XX_PWM_REG_CSR(base, n) (NPCM7XX_PWM_REG_BASE(base, n) + 0x04) 23#define NPCM7XX_PWM_REG_CR(base, n) (NPCM7XX_PWM_REG_BASE(base, n) + 0x08) 24#define NPCM7XX_PWM_REG_CNRx(base, n, ch) \ 25 (NPCM7XX_PWM_REG_BASE(base, n) + 0x0C + (12 * (ch))) 26#define NPCM7XX_PWM_REG_CMRx(base, n, ch) \ 27 (NPCM7XX_PWM_REG_BASE(base, n) + 0x10 + (12 * (ch))) 28#define NPCM7XX_PWM_REG_PDRx(base, n, ch) \ 29 (NPCM7XX_PWM_REG_BASE(base, n) + 0x14 + (12 * (ch))) 30#define NPCM7XX_PWM_REG_PIER(base, n) (NPCM7XX_PWM_REG_BASE(base, n) + 0x3C) 31#define NPCM7XX_PWM_REG_PIIR(base, n) (NPCM7XX_PWM_REG_BASE(base, n) + 0x40) 32 33#define NPCM7XX_PWM_CTRL_CH0_MODE_BIT BIT(3) 34#define NPCM7XX_PWM_CTRL_CH1_MODE_BIT BIT(11) 35#define NPCM7XX_PWM_CTRL_CH2_MODE_BIT BIT(15) 36#define NPCM7XX_PWM_CTRL_CH3_MODE_BIT BIT(19) 37 38#define NPCM7XX_PWM_CTRL_CH0_INV_BIT BIT(2) 39#define NPCM7XX_PWM_CTRL_CH1_INV_BIT BIT(10) 40#define NPCM7XX_PWM_CTRL_CH2_INV_BIT BIT(14) 41#define NPCM7XX_PWM_CTRL_CH3_INV_BIT BIT(18) 42 43#define NPCM7XX_PWM_CTRL_CH0_EN_BIT BIT(0) 44#define NPCM7XX_PWM_CTRL_CH1_EN_BIT BIT(8) 45#define NPCM7XX_PWM_CTRL_CH2_EN_BIT BIT(12) 46#define NPCM7XX_PWM_CTRL_CH3_EN_BIT BIT(16) 47 48/* Define the maximum PWM channel number */ 49#define NPCM7XX_PWM_MAX_CHN_NUM 8 50#define NPCM7XX_PWM_MAX_CHN_NUM_IN_A_MODULE 4 51#define NPCM7XX_PWM_MAX_MODULES 2 52 53/* Define the Counter Register, value = 100 for match 100% */ 54#define NPCM7XX_PWM_COUNTER_DEFAULT_NUM 255 55#define NPCM7XX_PWM_CMR_DEFAULT_NUM 255 56#define NPCM7XX_PWM_CMR_MAX 255 57 58/* default all PWM channels PRESCALE2 = 1 */ 59#define NPCM7XX_PWM_PRESCALE2_DEFAULT_CH0 0x4 60#define NPCM7XX_PWM_PRESCALE2_DEFAULT_CH1 0x40 61#define NPCM7XX_PWM_PRESCALE2_DEFAULT_CH2 0x400 62#define NPCM7XX_PWM_PRESCALE2_DEFAULT_CH3 0x4000 63 64#define PWM_OUTPUT_FREQ_25KHZ 25000 65#define PWN_CNT_DEFAULT 256 66#define MIN_PRESCALE1 2 67#define NPCM7XX_PWM_PRESCALE_SHIFT_CH01 8 68 69#define NPCM7XX_PWM_PRESCALE2_DEFAULT (NPCM7XX_PWM_PRESCALE2_DEFAULT_CH0 | \ 70 NPCM7XX_PWM_PRESCALE2_DEFAULT_CH1 | \ 71 NPCM7XX_PWM_PRESCALE2_DEFAULT_CH2 | \ 72 NPCM7XX_PWM_PRESCALE2_DEFAULT_CH3) 73 74#define NPCM7XX_PWM_CTRL_MODE_DEFAULT (NPCM7XX_PWM_CTRL_CH0_MODE_BIT | \ 75 NPCM7XX_PWM_CTRL_CH1_MODE_BIT | \ 76 NPCM7XX_PWM_CTRL_CH2_MODE_BIT | \ 77 NPCM7XX_PWM_CTRL_CH3_MODE_BIT) 78 79/* NPCM7XX FAN Tacho registers */ 80#define NPCM7XX_FAN_REG_BASE(base, n) ((base) + ((n) * 0x1000L)) 81 82#define NPCM7XX_FAN_REG_TCNT1(base, n) (NPCM7XX_FAN_REG_BASE(base, n) + 0x00) 83#define NPCM7XX_FAN_REG_TCRA(base, n) (NPCM7XX_FAN_REG_BASE(base, n) + 0x02) 84#define NPCM7XX_FAN_REG_TCRB(base, n) (NPCM7XX_FAN_REG_BASE(base, n) + 0x04) 85#define NPCM7XX_FAN_REG_TCNT2(base, n) (NPCM7XX_FAN_REG_BASE(base, n) + 0x06) 86#define NPCM7XX_FAN_REG_TPRSC(base, n) (NPCM7XX_FAN_REG_BASE(base, n) + 0x08) 87#define NPCM7XX_FAN_REG_TCKC(base, n) (NPCM7XX_FAN_REG_BASE(base, n) + 0x0A) 88#define NPCM7XX_FAN_REG_TMCTRL(base, n) (NPCM7XX_FAN_REG_BASE(base, n) + 0x0C) 89#define NPCM7XX_FAN_REG_TICTRL(base, n) (NPCM7XX_FAN_REG_BASE(base, n) + 0x0E) 90#define NPCM7XX_FAN_REG_TICLR(base, n) (NPCM7XX_FAN_REG_BASE(base, n) + 0x10) 91#define NPCM7XX_FAN_REG_TIEN(base, n) (NPCM7XX_FAN_REG_BASE(base, n) + 0x12) 92#define NPCM7XX_FAN_REG_TCPA(base, n) (NPCM7XX_FAN_REG_BASE(base, n) + 0x14) 93#define NPCM7XX_FAN_REG_TCPB(base, n) (NPCM7XX_FAN_REG_BASE(base, n) + 0x16) 94#define NPCM7XX_FAN_REG_TCPCFG(base, n) (NPCM7XX_FAN_REG_BASE(base, n) + 0x18) 95#define NPCM7XX_FAN_REG_TINASEL(base, n) (NPCM7XX_FAN_REG_BASE(base, n) + 0x1A) 96#define NPCM7XX_FAN_REG_TINBSEL(base, n) (NPCM7XX_FAN_REG_BASE(base, n) + 0x1C) 97 98#define NPCM7XX_FAN_TCKC_CLKX_NONE 0 99#define NPCM7XX_FAN_TCKC_CLK1_APB BIT(0) 100#define NPCM7XX_FAN_TCKC_CLK2_APB BIT(3) 101 102#define NPCM7XX_FAN_TMCTRL_TBEN BIT(6) 103#define NPCM7XX_FAN_TMCTRL_TAEN BIT(5) 104#define NPCM7XX_FAN_TMCTRL_TBEDG BIT(4) 105#define NPCM7XX_FAN_TMCTRL_TAEDG BIT(3) 106#define NPCM7XX_FAN_TMCTRL_MODE_5 BIT(2) 107 108#define NPCM7XX_FAN_TICLR_CLEAR_ALL GENMASK(5, 0) 109#define NPCM7XX_FAN_TICLR_TFCLR BIT(5) 110#define NPCM7XX_FAN_TICLR_TECLR BIT(4) 111#define NPCM7XX_FAN_TICLR_TDCLR BIT(3) 112#define NPCM7XX_FAN_TICLR_TCCLR BIT(2) 113#define NPCM7XX_FAN_TICLR_TBCLR BIT(1) 114#define NPCM7XX_FAN_TICLR_TACLR BIT(0) 115 116#define NPCM7XX_FAN_TIEN_ENABLE_ALL GENMASK(5, 0) 117#define NPCM7XX_FAN_TIEN_TFIEN BIT(5) 118#define NPCM7XX_FAN_TIEN_TEIEN BIT(4) 119#define NPCM7XX_FAN_TIEN_TDIEN BIT(3) 120#define NPCM7XX_FAN_TIEN_TCIEN BIT(2) 121#define NPCM7XX_FAN_TIEN_TBIEN BIT(1) 122#define NPCM7XX_FAN_TIEN_TAIEN BIT(0) 123 124#define NPCM7XX_FAN_TICTRL_TFPND BIT(5) 125#define NPCM7XX_FAN_TICTRL_TEPND BIT(4) 126#define NPCM7XX_FAN_TICTRL_TDPND BIT(3) 127#define NPCM7XX_FAN_TICTRL_TCPND BIT(2) 128#define NPCM7XX_FAN_TICTRL_TBPND BIT(1) 129#define NPCM7XX_FAN_TICTRL_TAPND BIT(0) 130 131#define NPCM7XX_FAN_TCPCFG_HIBEN BIT(7) 132#define NPCM7XX_FAN_TCPCFG_EQBEN BIT(6) 133#define NPCM7XX_FAN_TCPCFG_LOBEN BIT(5) 134#define NPCM7XX_FAN_TCPCFG_CPBSEL BIT(4) 135#define NPCM7XX_FAN_TCPCFG_HIAEN BIT(3) 136#define NPCM7XX_FAN_TCPCFG_EQAEN BIT(2) 137#define NPCM7XX_FAN_TCPCFG_LOAEN BIT(1) 138#define NPCM7XX_FAN_TCPCFG_CPASEL BIT(0) 139 140/* FAN General Definition */ 141/* Define the maximum FAN channel number */ 142#define NPCM7XX_FAN_MAX_MODULE 8 143#define NPCM7XX_FAN_MAX_CHN_NUM_IN_A_MODULE 2 144#define NPCM7XX_FAN_MAX_CHN_NUM 16 145 146/* 147 * Get Fan Tach Timeout (base on clock 214843.75Hz, 1 cnt = 4.654us) 148 * Timeout 94ms ~= 0x5000 149 * (The minimum FAN speed could to support ~640RPM/pulse 1, 150 * 320RPM/pulse 2, ...-- 10.6Hz) 151 */ 152#define NPCM7XX_FAN_TIMEOUT 0x5000 153#define NPCM7XX_FAN_TCNT 0xFFFF 154#define NPCM7XX_FAN_TCPA (NPCM7XX_FAN_TCNT - NPCM7XX_FAN_TIMEOUT) 155#define NPCM7XX_FAN_TCPB (NPCM7XX_FAN_TCNT - NPCM7XX_FAN_TIMEOUT) 156 157#define NPCM7XX_FAN_POLL_TIMER_200MS 200 158#define NPCM7XX_FAN_DEFAULT_PULSE_PER_REVOLUTION 2 159#define NPCM7XX_FAN_TINASEL_FANIN_DEFAULT 0 160#define NPCM7XX_FAN_CLK_PRESCALE 255 161 162#define NPCM7XX_FAN_CMPA 0 163#define NPCM7XX_FAN_CMPB 1 164 165/* Obtain the fan number */ 166#define NPCM7XX_FAN_INPUT(fan, cmp) (((fan) << 1) + (cmp)) 167 168/* fan sample status */ 169#define FAN_DISABLE 0xFF 170#define FAN_INIT 0x00 171#define FAN_PREPARE_TO_GET_FIRST_CAPTURE 0x01 172#define FAN_ENOUGH_SAMPLE 0x02 173 174struct npcm7xx_fan_dev { 175 u8 fan_st_flg; 176 u8 fan_pls_per_rev; 177 u16 fan_cnt; 178 u32 fan_cnt_tmp; 179}; 180 181struct npcm7xx_cooling_device { 182 char name[THERMAL_NAME_LENGTH]; 183 struct npcm7xx_pwm_fan_data *data; 184 struct thermal_cooling_device *tcdev; 185 int pwm_port; 186 u8 *cooling_levels; 187 u8 max_state; 188 u8 cur_state; 189}; 190 191struct npcm7xx_pwm_fan_data { 192 void __iomem *pwm_base; 193 void __iomem *fan_base; 194 unsigned long pwm_clk_freq; 195 unsigned long fan_clk_freq; 196 struct clk *pwm_clk; 197 struct clk *fan_clk; 198 struct mutex pwm_lock[NPCM7XX_PWM_MAX_MODULES]; 199 spinlock_t fan_lock[NPCM7XX_FAN_MAX_MODULE]; 200 int fan_irq[NPCM7XX_FAN_MAX_MODULE]; 201 bool pwm_present[NPCM7XX_PWM_MAX_CHN_NUM]; 202 bool fan_present[NPCM7XX_FAN_MAX_CHN_NUM]; 203 u32 input_clk_freq; 204 struct timer_list fan_timer; 205 struct npcm7xx_fan_dev fan_dev[NPCM7XX_FAN_MAX_CHN_NUM]; 206 struct npcm7xx_cooling_device *cdev[NPCM7XX_PWM_MAX_CHN_NUM]; 207 u8 fan_select; 208}; 209 210static int npcm7xx_pwm_config_set(struct npcm7xx_pwm_fan_data *data, 211 int channel, u16 val) 212{ 213 u32 pwm_ch = (channel % NPCM7XX_PWM_MAX_CHN_NUM_IN_A_MODULE); 214 u32 module = (channel / NPCM7XX_PWM_MAX_CHN_NUM_IN_A_MODULE); 215 u32 tmp_buf, ctrl_en_bit, env_bit; 216 217 /* 218 * Config PWM Comparator register for setting duty cycle 219 */ 220 mutex_lock(&data->pwm_lock[module]); 221 222 /* write new CMR value */ 223 iowrite32(val, NPCM7XX_PWM_REG_CMRx(data->pwm_base, module, pwm_ch)); 224 tmp_buf = ioread32(NPCM7XX_PWM_REG_CR(data->pwm_base, module)); 225 226 switch (pwm_ch) { 227 case 0: 228 ctrl_en_bit = NPCM7XX_PWM_CTRL_CH0_EN_BIT; 229 env_bit = NPCM7XX_PWM_CTRL_CH0_INV_BIT; 230 break; 231 case 1: 232 ctrl_en_bit = NPCM7XX_PWM_CTRL_CH1_EN_BIT; 233 env_bit = NPCM7XX_PWM_CTRL_CH1_INV_BIT; 234 break; 235 case 2: 236 ctrl_en_bit = NPCM7XX_PWM_CTRL_CH2_EN_BIT; 237 env_bit = NPCM7XX_PWM_CTRL_CH2_INV_BIT; 238 break; 239 case 3: 240 ctrl_en_bit = NPCM7XX_PWM_CTRL_CH3_EN_BIT; 241 env_bit = NPCM7XX_PWM_CTRL_CH3_INV_BIT; 242 break; 243 default: 244 mutex_unlock(&data->pwm_lock[module]); 245 return -ENODEV; 246 } 247 248 if (val == 0) { 249 /* Disable PWM */ 250 tmp_buf &= ~ctrl_en_bit; 251 tmp_buf |= env_bit; 252 } else { 253 /* Enable PWM */ 254 tmp_buf |= ctrl_en_bit; 255 tmp_buf &= ~env_bit; 256 } 257 258 iowrite32(tmp_buf, NPCM7XX_PWM_REG_CR(data->pwm_base, module)); 259 mutex_unlock(&data->pwm_lock[module]); 260 261 return 0; 262} 263 264static inline void npcm7xx_fan_start_capture(struct npcm7xx_pwm_fan_data *data, 265 u8 fan, u8 cmp) 266{ 267 u8 fan_id; 268 u8 reg_mode; 269 u8 reg_int; 270 unsigned long flags; 271 272 fan_id = NPCM7XX_FAN_INPUT(fan, cmp); 273 274 /* to check whether any fan tach is enable */ 275 if (data->fan_dev[fan_id].fan_st_flg != FAN_DISABLE) { 276 /* reset status */ 277 spin_lock_irqsave(&data->fan_lock[fan], flags); 278 279 data->fan_dev[fan_id].fan_st_flg = FAN_INIT; 280 reg_int = ioread8(NPCM7XX_FAN_REG_TIEN(data->fan_base, fan)); 281 282 /* 283 * the interrupt enable bits do not need to be cleared before 284 * it sets, the interrupt enable bits are cleared only on reset. 285 * the clock unit control register is behaving in the same 286 * manner that the interrupt enable register behave. 287 */ 288 if (cmp == NPCM7XX_FAN_CMPA) { 289 /* enable interrupt */ 290 iowrite8(reg_int | (NPCM7XX_FAN_TIEN_TAIEN | 291 NPCM7XX_FAN_TIEN_TEIEN), 292 NPCM7XX_FAN_REG_TIEN(data->fan_base, fan)); 293 294 reg_mode = NPCM7XX_FAN_TCKC_CLK1_APB 295 | ioread8(NPCM7XX_FAN_REG_TCKC(data->fan_base, 296 fan)); 297 298 /* start to Capture */ 299 iowrite8(reg_mode, NPCM7XX_FAN_REG_TCKC(data->fan_base, 300 fan)); 301 } else { 302 /* enable interrupt */ 303 iowrite8(reg_int | (NPCM7XX_FAN_TIEN_TBIEN | 304 NPCM7XX_FAN_TIEN_TFIEN), 305 NPCM7XX_FAN_REG_TIEN(data->fan_base, fan)); 306 307 reg_mode = 308 NPCM7XX_FAN_TCKC_CLK2_APB 309 | ioread8(NPCM7XX_FAN_REG_TCKC(data->fan_base, 310 fan)); 311 312 /* start to Capture */ 313 iowrite8(reg_mode, 314 NPCM7XX_FAN_REG_TCKC(data->fan_base, fan)); 315 } 316 317 spin_unlock_irqrestore(&data->fan_lock[fan], flags); 318 } 319} 320 321/* 322 * Enable a background timer to poll fan tach value, (200ms * 4) 323 * to polling all fan 324 */ 325static void npcm7xx_fan_polling(struct timer_list *t) 326{ 327 struct npcm7xx_pwm_fan_data *data; 328 int i; 329 330 data = from_timer(data, t, fan_timer); 331 332 /* 333 * Polling two module per one round, 334 * FAN01 & FAN89 / FAN23 & FAN1011 / FAN45 & FAN1213 / FAN67 & FAN1415 335 */ 336 for (i = data->fan_select; i < NPCM7XX_FAN_MAX_MODULE; 337 i = i + 4) { 338 /* clear the flag and reset the counter (TCNT) */ 339 iowrite8(NPCM7XX_FAN_TICLR_CLEAR_ALL, 340 NPCM7XX_FAN_REG_TICLR(data->fan_base, i)); 341 342 if (data->fan_present[i * 2]) { 343 iowrite16(NPCM7XX_FAN_TCNT, 344 NPCM7XX_FAN_REG_TCNT1(data->fan_base, i)); 345 npcm7xx_fan_start_capture(data, i, NPCM7XX_FAN_CMPA); 346 } 347 if (data->fan_present[(i * 2) + 1]) { 348 iowrite16(NPCM7XX_FAN_TCNT, 349 NPCM7XX_FAN_REG_TCNT2(data->fan_base, i)); 350 npcm7xx_fan_start_capture(data, i, NPCM7XX_FAN_CMPB); 351 } 352 } 353 354 data->fan_select++; 355 data->fan_select &= 0x3; 356 357 /* reset the timer interval */ 358 data->fan_timer.expires = jiffies + 359 msecs_to_jiffies(NPCM7XX_FAN_POLL_TIMER_200MS); 360 add_timer(&data->fan_timer); 361} 362 363static inline void npcm7xx_fan_compute(struct npcm7xx_pwm_fan_data *data, 364 u8 fan, u8 cmp, u8 fan_id, u8 flag_int, 365 u8 flag_mode, u8 flag_clear) 366{ 367 u8 reg_int; 368 u8 reg_mode; 369 u16 fan_cap; 370 371 if (cmp == NPCM7XX_FAN_CMPA) 372 fan_cap = ioread16(NPCM7XX_FAN_REG_TCRA(data->fan_base, fan)); 373 else 374 fan_cap = ioread16(NPCM7XX_FAN_REG_TCRB(data->fan_base, fan)); 375 376 /* clear capature flag, H/W will auto reset the NPCM7XX_FAN_TCNTx */ 377 iowrite8(flag_clear, NPCM7XX_FAN_REG_TICLR(data->fan_base, fan)); 378 379 if (data->fan_dev[fan_id].fan_st_flg == FAN_INIT) { 380 /* First capture, drop it */ 381 data->fan_dev[fan_id].fan_st_flg = 382 FAN_PREPARE_TO_GET_FIRST_CAPTURE; 383 384 /* reset counter */ 385 data->fan_dev[fan_id].fan_cnt_tmp = 0; 386 } else if (data->fan_dev[fan_id].fan_st_flg < FAN_ENOUGH_SAMPLE) { 387 /* 388 * collect the enough sample, 389 * (ex: 2 pulse fan need to get 2 sample) 390 */ 391 data->fan_dev[fan_id].fan_cnt_tmp += 392 (NPCM7XX_FAN_TCNT - fan_cap); 393 394 data->fan_dev[fan_id].fan_st_flg++; 395 } else { 396 /* get enough sample or fan disable */ 397 if (data->fan_dev[fan_id].fan_st_flg == FAN_ENOUGH_SAMPLE) { 398 data->fan_dev[fan_id].fan_cnt_tmp += 399 (NPCM7XX_FAN_TCNT - fan_cap); 400 401 /* compute finial average cnt per pulse */ 402 data->fan_dev[fan_id].fan_cnt = 403 data->fan_dev[fan_id].fan_cnt_tmp / 404 FAN_ENOUGH_SAMPLE; 405 406 data->fan_dev[fan_id].fan_st_flg = FAN_INIT; 407 } 408 409 reg_int = ioread8(NPCM7XX_FAN_REG_TIEN(data->fan_base, fan)); 410 411 /* disable interrupt */ 412 iowrite8((reg_int & ~flag_int), 413 NPCM7XX_FAN_REG_TIEN(data->fan_base, fan)); 414 reg_mode = ioread8(NPCM7XX_FAN_REG_TCKC(data->fan_base, fan)); 415 416 /* stop capturing */ 417 iowrite8((reg_mode & ~flag_mode), 418 NPCM7XX_FAN_REG_TCKC(data->fan_base, fan)); 419 } 420} 421 422static inline void npcm7xx_check_cmp(struct npcm7xx_pwm_fan_data *data, 423 u8 fan, u8 cmp, u8 flag) 424{ 425 u8 reg_int; 426 u8 reg_mode; 427 u8 flag_timeout; 428 u8 flag_cap; 429 u8 flag_clear; 430 u8 flag_int; 431 u8 flag_mode; 432 u8 fan_id; 433 434 fan_id = NPCM7XX_FAN_INPUT(fan, cmp); 435 436 if (cmp == NPCM7XX_FAN_CMPA) { 437 flag_cap = NPCM7XX_FAN_TICTRL_TAPND; 438 flag_timeout = NPCM7XX_FAN_TICTRL_TEPND; 439 flag_int = NPCM7XX_FAN_TIEN_TAIEN | NPCM7XX_FAN_TIEN_TEIEN; 440 flag_mode = NPCM7XX_FAN_TCKC_CLK1_APB; 441 flag_clear = NPCM7XX_FAN_TICLR_TACLR | NPCM7XX_FAN_TICLR_TECLR; 442 } else { 443 flag_cap = NPCM7XX_FAN_TICTRL_TBPND; 444 flag_timeout = NPCM7XX_FAN_TICTRL_TFPND; 445 flag_int = NPCM7XX_FAN_TIEN_TBIEN | NPCM7XX_FAN_TIEN_TFIEN; 446 flag_mode = NPCM7XX_FAN_TCKC_CLK2_APB; 447 flag_clear = NPCM7XX_FAN_TICLR_TBCLR | NPCM7XX_FAN_TICLR_TFCLR; 448 } 449 450 if (flag & flag_timeout) { 451 reg_int = ioread8(NPCM7XX_FAN_REG_TIEN(data->fan_base, fan)); 452 453 /* disable interrupt */ 454 iowrite8((reg_int & ~flag_int), 455 NPCM7XX_FAN_REG_TIEN(data->fan_base, fan)); 456 457 /* clear interrupt flag */ 458 iowrite8(flag_clear, 459 NPCM7XX_FAN_REG_TICLR(data->fan_base, fan)); 460 461 reg_mode = ioread8(NPCM7XX_FAN_REG_TCKC(data->fan_base, fan)); 462 463 /* stop capturing */ 464 iowrite8((reg_mode & ~flag_mode), 465 NPCM7XX_FAN_REG_TCKC(data->fan_base, fan)); 466 467 /* 468 * If timeout occurs (NPCM7XX_FAN_TIMEOUT), the fan doesn't 469 * connect or speed is lower than 10.6Hz (320RPM/pulse2). 470 * In these situation, the RPM output should be zero. 471 */ 472 data->fan_dev[fan_id].fan_cnt = 0; 473 } else { 474 /* input capture is occurred */ 475 if (flag & flag_cap) 476 npcm7xx_fan_compute(data, fan, cmp, fan_id, flag_int, 477 flag_mode, flag_clear); 478 } 479} 480 481static irqreturn_t npcm7xx_fan_isr(int irq, void *dev_id) 482{ 483 struct npcm7xx_pwm_fan_data *data = dev_id; 484 unsigned long flags; 485 int module; 486 u8 flag; 487 488 module = irq - data->fan_irq[0]; 489 spin_lock_irqsave(&data->fan_lock[module], flags); 490 491 flag = ioread8(NPCM7XX_FAN_REG_TICTRL(data->fan_base, module)); 492 if (flag > 0) { 493 npcm7xx_check_cmp(data, module, NPCM7XX_FAN_CMPA, flag); 494 npcm7xx_check_cmp(data, module, NPCM7XX_FAN_CMPB, flag); 495 spin_unlock_irqrestore(&data->fan_lock[module], flags); 496 return IRQ_HANDLED; 497 } 498 499 spin_unlock_irqrestore(&data->fan_lock[module], flags); 500 501 return IRQ_NONE; 502} 503 504static int npcm7xx_read_pwm(struct device *dev, u32 attr, int channel, 505 long *val) 506{ 507 struct npcm7xx_pwm_fan_data *data = dev_get_drvdata(dev); 508 u32 pmw_ch = (channel % NPCM7XX_PWM_MAX_CHN_NUM_IN_A_MODULE); 509 u32 module = (channel / NPCM7XX_PWM_MAX_CHN_NUM_IN_A_MODULE); 510 511 switch (attr) { 512 case hwmon_pwm_input: 513 *val = ioread32 514 (NPCM7XX_PWM_REG_CMRx(data->pwm_base, module, pmw_ch)); 515 return 0; 516 default: 517 return -EOPNOTSUPP; 518 } 519} 520 521static int npcm7xx_write_pwm(struct device *dev, u32 attr, int channel, 522 long val) 523{ 524 struct npcm7xx_pwm_fan_data *data = dev_get_drvdata(dev); 525 int err; 526 527 switch (attr) { 528 case hwmon_pwm_input: 529 if (val < 0 || val > NPCM7XX_PWM_CMR_MAX) 530 return -EINVAL; 531 err = npcm7xx_pwm_config_set(data, channel, (u16)val); 532 break; 533 default: 534 err = -EOPNOTSUPP; 535 break; 536 } 537 538 return err; 539} 540 541static umode_t npcm7xx_pwm_is_visible(const void *_data, u32 attr, int channel) 542{ 543 const struct npcm7xx_pwm_fan_data *data = _data; 544 545 if (!data->pwm_present[channel]) 546 return 0; 547 548 switch (attr) { 549 case hwmon_pwm_input: 550 return 0644; 551 default: 552 return 0; 553 } 554} 555 556static int npcm7xx_read_fan(struct device *dev, u32 attr, int channel, 557 long *val) 558{ 559 struct npcm7xx_pwm_fan_data *data = dev_get_drvdata(dev); 560 561 switch (attr) { 562 case hwmon_fan_input: 563 *val = 0; 564 if (data->fan_dev[channel].fan_cnt <= 0) 565 return data->fan_dev[channel].fan_cnt; 566 567 /* Convert the raw reading to RPM */ 568 if (data->fan_dev[channel].fan_cnt > 0 && 569 data->fan_dev[channel].fan_pls_per_rev > 0) 570 *val = ((data->input_clk_freq * 60) / 571 (data->fan_dev[channel].fan_cnt * 572 data->fan_dev[channel].fan_pls_per_rev)); 573 return 0; 574 default: 575 return -EOPNOTSUPP; 576 } 577} 578 579static umode_t npcm7xx_fan_is_visible(const void *_data, u32 attr, int channel) 580{ 581 const struct npcm7xx_pwm_fan_data *data = _data; 582 583 if (!data->fan_present[channel]) 584 return 0; 585 586 switch (attr) { 587 case hwmon_fan_input: 588 return 0444; 589 default: 590 return 0; 591 } 592} 593 594static int npcm7xx_read(struct device *dev, enum hwmon_sensor_types type, 595 u32 attr, int channel, long *val) 596{ 597 switch (type) { 598 case hwmon_pwm: 599 return npcm7xx_read_pwm(dev, attr, channel, val); 600 case hwmon_fan: 601 return npcm7xx_read_fan(dev, attr, channel, val); 602 default: 603 return -EOPNOTSUPP; 604 } 605} 606 607static int npcm7xx_write(struct device *dev, enum hwmon_sensor_types type, 608 u32 attr, int channel, long val) 609{ 610 switch (type) { 611 case hwmon_pwm: 612 return npcm7xx_write_pwm(dev, attr, channel, val); 613 default: 614 return -EOPNOTSUPP; 615 } 616} 617 618static umode_t npcm7xx_is_visible(const void *data, 619 enum hwmon_sensor_types type, 620 u32 attr, int channel) 621{ 622 switch (type) { 623 case hwmon_pwm: 624 return npcm7xx_pwm_is_visible(data, attr, channel); 625 case hwmon_fan: 626 return npcm7xx_fan_is_visible(data, attr, channel); 627 default: 628 return 0; 629 } 630} 631 632static const struct hwmon_channel_info *npcm7xx_info[] = { 633 HWMON_CHANNEL_INFO(pwm, 634 HWMON_PWM_INPUT, 635 HWMON_PWM_INPUT, 636 HWMON_PWM_INPUT, 637 HWMON_PWM_INPUT, 638 HWMON_PWM_INPUT, 639 HWMON_PWM_INPUT, 640 HWMON_PWM_INPUT, 641 HWMON_PWM_INPUT), 642 HWMON_CHANNEL_INFO(fan, 643 HWMON_F_INPUT, 644 HWMON_F_INPUT, 645 HWMON_F_INPUT, 646 HWMON_F_INPUT, 647 HWMON_F_INPUT, 648 HWMON_F_INPUT, 649 HWMON_F_INPUT, 650 HWMON_F_INPUT, 651 HWMON_F_INPUT, 652 HWMON_F_INPUT, 653 HWMON_F_INPUT, 654 HWMON_F_INPUT, 655 HWMON_F_INPUT, 656 HWMON_F_INPUT, 657 HWMON_F_INPUT, 658 HWMON_F_INPUT), 659 NULL 660}; 661 662static const struct hwmon_ops npcm7xx_hwmon_ops = { 663 .is_visible = npcm7xx_is_visible, 664 .read = npcm7xx_read, 665 .write = npcm7xx_write, 666}; 667 668static const struct hwmon_chip_info npcm7xx_chip_info = { 669 .ops = &npcm7xx_hwmon_ops, 670 .info = npcm7xx_info, 671}; 672 673static u32 npcm7xx_pwm_init(struct npcm7xx_pwm_fan_data *data) 674{ 675 int m, ch; 676 u32 prescale_val, output_freq; 677 678 data->pwm_clk_freq = clk_get_rate(data->pwm_clk); 679 680 /* Adjust NPCM7xx PWMs output frequency to ~25Khz */ 681 output_freq = data->pwm_clk_freq / PWN_CNT_DEFAULT; 682 prescale_val = DIV_ROUND_CLOSEST(output_freq, PWM_OUTPUT_FREQ_25KHZ); 683 684 /* If prescale_val = 0, then the prescale output clock is stopped */ 685 if (prescale_val < MIN_PRESCALE1) 686 prescale_val = MIN_PRESCALE1; 687 /* 688 * prescale_val need to decrement in one because in the PWM Prescale 689 * register the Prescale value increment by one 690 */ 691 prescale_val--; 692 693 /* Setting PWM Prescale Register value register to both modules */ 694 prescale_val |= (prescale_val << NPCM7XX_PWM_PRESCALE_SHIFT_CH01); 695 696 for (m = 0; m < NPCM7XX_PWM_MAX_MODULES ; m++) { 697 iowrite32(prescale_val, NPCM7XX_PWM_REG_PR(data->pwm_base, m)); 698 iowrite32(NPCM7XX_PWM_PRESCALE2_DEFAULT, 699 NPCM7XX_PWM_REG_CSR(data->pwm_base, m)); 700 iowrite32(NPCM7XX_PWM_CTRL_MODE_DEFAULT, 701 NPCM7XX_PWM_REG_CR(data->pwm_base, m)); 702 703 for (ch = 0; ch < NPCM7XX_PWM_MAX_CHN_NUM_IN_A_MODULE; ch++) { 704 iowrite32(NPCM7XX_PWM_COUNTER_DEFAULT_NUM, 705 NPCM7XX_PWM_REG_CNRx(data->pwm_base, m, ch)); 706 } 707 } 708 709 return output_freq / ((prescale_val & 0xf) + 1); 710} 711 712static void npcm7xx_fan_init(struct npcm7xx_pwm_fan_data *data) 713{ 714 int md; 715 int ch; 716 int i; 717 u32 apb_clk_freq; 718 719 for (md = 0; md < NPCM7XX_FAN_MAX_MODULE; md++) { 720 /* stop FAN0~7 clock */ 721 iowrite8(NPCM7XX_FAN_TCKC_CLKX_NONE, 722 NPCM7XX_FAN_REG_TCKC(data->fan_base, md)); 723 724 /* disable all interrupt */ 725 iowrite8(0x00, NPCM7XX_FAN_REG_TIEN(data->fan_base, md)); 726 727 /* clear all interrupt */ 728 iowrite8(NPCM7XX_FAN_TICLR_CLEAR_ALL, 729 NPCM7XX_FAN_REG_TICLR(data->fan_base, md)); 730 731 /* set FAN0~7 clock prescaler */ 732 iowrite8(NPCM7XX_FAN_CLK_PRESCALE, 733 NPCM7XX_FAN_REG_TPRSC(data->fan_base, md)); 734 735 /* set FAN0~7 mode (high-to-low transition) */ 736 iowrite8((NPCM7XX_FAN_TMCTRL_MODE_5 | NPCM7XX_FAN_TMCTRL_TBEN | 737 NPCM7XX_FAN_TMCTRL_TAEN), 738 NPCM7XX_FAN_REG_TMCTRL(data->fan_base, md)); 739 740 /* set FAN0~7 Initial Count/Cap */ 741 iowrite16(NPCM7XX_FAN_TCNT, 742 NPCM7XX_FAN_REG_TCNT1(data->fan_base, md)); 743 iowrite16(NPCM7XX_FAN_TCNT, 744 NPCM7XX_FAN_REG_TCNT2(data->fan_base, md)); 745 746 /* set FAN0~7 compare (equal to count) */ 747 iowrite8((NPCM7XX_FAN_TCPCFG_EQAEN | NPCM7XX_FAN_TCPCFG_EQBEN), 748 NPCM7XX_FAN_REG_TCPCFG(data->fan_base, md)); 749 750 /* set FAN0~7 compare value */ 751 iowrite16(NPCM7XX_FAN_TCPA, 752 NPCM7XX_FAN_REG_TCPA(data->fan_base, md)); 753 iowrite16(NPCM7XX_FAN_TCPB, 754 NPCM7XX_FAN_REG_TCPB(data->fan_base, md)); 755 756 /* set FAN0~7 fan input FANIN 0~15 */ 757 iowrite8(NPCM7XX_FAN_TINASEL_FANIN_DEFAULT, 758 NPCM7XX_FAN_REG_TINASEL(data->fan_base, md)); 759 iowrite8(NPCM7XX_FAN_TINASEL_FANIN_DEFAULT, 760 NPCM7XX_FAN_REG_TINBSEL(data->fan_base, md)); 761 762 for (i = 0; i < NPCM7XX_FAN_MAX_CHN_NUM_IN_A_MODULE; i++) { 763 ch = md * NPCM7XX_FAN_MAX_CHN_NUM_IN_A_MODULE + i; 764 data->fan_dev[ch].fan_st_flg = FAN_DISABLE; 765 data->fan_dev[ch].fan_pls_per_rev = 766 NPCM7XX_FAN_DEFAULT_PULSE_PER_REVOLUTION; 767 data->fan_dev[ch].fan_cnt = 0; 768 } 769 } 770 771 apb_clk_freq = clk_get_rate(data->fan_clk); 772 773 /* Fan tach input clock = APB clock / prescalar, default is 255. */ 774 data->input_clk_freq = apb_clk_freq / (NPCM7XX_FAN_CLK_PRESCALE + 1); 775} 776 777static int 778npcm7xx_pwm_cz_get_max_state(struct thermal_cooling_device *tcdev, 779 unsigned long *state) 780{ 781 struct npcm7xx_cooling_device *cdev = tcdev->devdata; 782 783 *state = cdev->max_state; 784 785 return 0; 786} 787 788static int 789npcm7xx_pwm_cz_get_cur_state(struct thermal_cooling_device *tcdev, 790 unsigned long *state) 791{ 792 struct npcm7xx_cooling_device *cdev = tcdev->devdata; 793 794 *state = cdev->cur_state; 795 796 return 0; 797} 798 799static int 800npcm7xx_pwm_cz_set_cur_state(struct thermal_cooling_device *tcdev, 801 unsigned long state) 802{ 803 struct npcm7xx_cooling_device *cdev = tcdev->devdata; 804 int ret; 805 806 if (state > cdev->max_state) 807 return -EINVAL; 808 809 cdev->cur_state = state; 810 ret = npcm7xx_pwm_config_set(cdev->data, cdev->pwm_port, 811 cdev->cooling_levels[cdev->cur_state]); 812 813 return ret; 814} 815 816static const struct thermal_cooling_device_ops npcm7xx_pwm_cool_ops = { 817 .get_max_state = npcm7xx_pwm_cz_get_max_state, 818 .get_cur_state = npcm7xx_pwm_cz_get_cur_state, 819 .set_cur_state = npcm7xx_pwm_cz_set_cur_state, 820}; 821 822static int npcm7xx_create_pwm_cooling(struct device *dev, 823 struct device_node *child, 824 struct npcm7xx_pwm_fan_data *data, 825 u32 pwm_port, u8 num_levels) 826{ 827 int ret; 828 struct npcm7xx_cooling_device *cdev; 829 830 cdev = devm_kzalloc(dev, sizeof(*cdev), GFP_KERNEL); 831 if (!cdev) 832 return -ENOMEM; 833 834 cdev->cooling_levels = devm_kzalloc(dev, num_levels, GFP_KERNEL); 835 if (!cdev->cooling_levels) 836 return -ENOMEM; 837 838 cdev->max_state = num_levels - 1; 839 ret = of_property_read_u8_array(child, "cooling-levels", 840 cdev->cooling_levels, 841 num_levels); 842 if (ret) { 843 dev_err(dev, "Property 'cooling-levels' cannot be read.\n"); 844 return ret; 845 } 846 snprintf(cdev->name, THERMAL_NAME_LENGTH, "%pOFn%d", child, 847 pwm_port); 848 849 cdev->tcdev = devm_thermal_of_cooling_device_register(dev, child, 850 cdev->name, cdev, &npcm7xx_pwm_cool_ops); 851 if (IS_ERR(cdev->tcdev)) 852 return PTR_ERR(cdev->tcdev); 853 854 cdev->data = data; 855 cdev->pwm_port = pwm_port; 856 857 data->cdev[pwm_port] = cdev; 858 859 return 0; 860} 861 862static int npcm7xx_en_pwm_fan(struct device *dev, 863 struct device_node *child, 864 struct npcm7xx_pwm_fan_data *data) 865{ 866 u8 *fan_ch; 867 u32 pwm_port; 868 int ret, fan_cnt; 869 u8 index, ch; 870 871 ret = of_property_read_u32(child, "reg", &pwm_port); 872 if (ret) 873 return ret; 874 875 data->pwm_present[pwm_port] = true; 876 ret = npcm7xx_pwm_config_set(data, pwm_port, 877 NPCM7XX_PWM_CMR_DEFAULT_NUM); 878 879 ret = of_property_count_u8_elems(child, "cooling-levels"); 880 if (ret > 0) { 881 ret = npcm7xx_create_pwm_cooling(dev, child, data, pwm_port, 882 ret); 883 if (ret) 884 return ret; 885 } 886 887 fan_cnt = of_property_count_u8_elems(child, "fan-tach-ch"); 888 if (fan_cnt < 1) 889 return -EINVAL; 890 891 fan_ch = devm_kcalloc(dev, fan_cnt, sizeof(*fan_ch), GFP_KERNEL); 892 if (!fan_ch) 893 return -ENOMEM; 894 895 ret = of_property_read_u8_array(child, "fan-tach-ch", fan_ch, fan_cnt); 896 if (ret) 897 return ret; 898 899 for (ch = 0; ch < fan_cnt; ch++) { 900 index = fan_ch[ch]; 901 data->fan_present[index] = true; 902 data->fan_dev[index].fan_st_flg = FAN_INIT; 903 } 904 905 return 0; 906} 907 908static int npcm7xx_pwm_fan_probe(struct platform_device *pdev) 909{ 910 struct device *dev = &pdev->dev; 911 struct device_node *np, *child; 912 struct npcm7xx_pwm_fan_data *data; 913 struct resource *res; 914 struct device *hwmon; 915 char name[20]; 916 int ret, cnt; 917 u32 output_freq; 918 u32 i; 919 920 np = dev->of_node; 921 922 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 923 if (!data) 924 return -ENOMEM; 925 926 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pwm"); 927 if (!res) { 928 dev_err(dev, "pwm resource not found\n"); 929 return -ENODEV; 930 } 931 932 data->pwm_base = devm_ioremap_resource(dev, res); 933 dev_dbg(dev, "pwm base resource is %pR\n", res); 934 if (IS_ERR(data->pwm_base)) 935 return PTR_ERR(data->pwm_base); 936 937 data->pwm_clk = devm_clk_get(dev, "pwm"); 938 if (IS_ERR(data->pwm_clk)) { 939 dev_err(dev, "couldn't get pwm clock\n"); 940 return PTR_ERR(data->pwm_clk); 941 } 942 943 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "fan"); 944 if (!res) { 945 dev_err(dev, "fan resource not found\n"); 946 return -ENODEV; 947 } 948 949 data->fan_base = devm_ioremap_resource(dev, res); 950 dev_dbg(dev, "fan base resource is %pR\n", res); 951 if (IS_ERR(data->fan_base)) 952 return PTR_ERR(data->fan_base); 953 954 data->fan_clk = devm_clk_get(dev, "fan"); 955 if (IS_ERR(data->fan_clk)) { 956 dev_err(dev, "couldn't get fan clock\n"); 957 return PTR_ERR(data->fan_clk); 958 } 959 960 output_freq = npcm7xx_pwm_init(data); 961 npcm7xx_fan_init(data); 962 963 for (cnt = 0; cnt < NPCM7XX_PWM_MAX_MODULES ; cnt++) 964 mutex_init(&data->pwm_lock[cnt]); 965 966 for (i = 0; i < NPCM7XX_FAN_MAX_MODULE; i++) { 967 spin_lock_init(&data->fan_lock[i]); 968 969 data->fan_irq[i] = platform_get_irq(pdev, i); 970 if (data->fan_irq[i] < 0) 971 return data->fan_irq[i]; 972 973 sprintf(name, "NPCM7XX-FAN-MD%d", i); 974 ret = devm_request_irq(dev, data->fan_irq[i], npcm7xx_fan_isr, 975 0, name, (void *)data); 976 if (ret) { 977 dev_err(dev, "register IRQ fan%d failed\n", i); 978 return ret; 979 } 980 } 981 982 for_each_child_of_node(np, child) { 983 ret = npcm7xx_en_pwm_fan(dev, child, data); 984 if (ret) { 985 dev_err(dev, "enable pwm and fan failed\n"); 986 of_node_put(child); 987 return ret; 988 } 989 } 990 991 hwmon = devm_hwmon_device_register_with_info(dev, "npcm7xx_pwm_fan", 992 data, &npcm7xx_chip_info, 993 NULL); 994 if (IS_ERR(hwmon)) { 995 dev_err(dev, "unable to register hwmon device\n"); 996 return PTR_ERR(hwmon); 997 } 998 999 for (i = 0; i < NPCM7XX_FAN_MAX_CHN_NUM; i++) { 1000 if (data->fan_present[i]) { 1001 /* fan timer initialization */ 1002 data->fan_timer.expires = jiffies + 1003 msecs_to_jiffies(NPCM7XX_FAN_POLL_TIMER_200MS); 1004 timer_setup(&data->fan_timer, 1005 npcm7xx_fan_polling, 0); 1006 add_timer(&data->fan_timer); 1007 break; 1008 } 1009 } 1010 1011 pr_info("NPCM7XX PWM-FAN Driver probed, output Freq %dHz[PWM], input Freq %dHz[FAN]\n", 1012 output_freq, data->input_clk_freq); 1013 1014 return 0; 1015} 1016 1017static const struct of_device_id of_pwm_fan_match_table[] = { 1018 { .compatible = "nuvoton,npcm750-pwm-fan", }, 1019 {}, 1020}; 1021MODULE_DEVICE_TABLE(of, of_pwm_fan_match_table); 1022 1023static struct platform_driver npcm7xx_pwm_fan_driver = { 1024 .probe = npcm7xx_pwm_fan_probe, 1025 .driver = { 1026 .name = "npcm7xx_pwm_fan", 1027 .of_match_table = of_pwm_fan_match_table, 1028 }, 1029}; 1030 1031module_platform_driver(npcm7xx_pwm_fan_driver); 1032 1033MODULE_DESCRIPTION("Nuvoton NPCM7XX PWM and Fan Tacho driver"); 1034MODULE_AUTHOR("Tomer Maimon <tomer.maimon@nuvoton.com>"); 1035MODULE_LICENSE("GPL v2"); 1036