1124 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * g762 - Driver for the Global Mixed-mode Technology Inc. fan speed4 * PWM controller chips from G762 family, i.e. G762 and G7635 *6 * Copyright (C) 2013, Arnaud EBALARD <arno@natisbad.org>7 *8 * This work is based on a basic version for 2.6.31 kernel developed9 * by Olivier Mouchet for LaCie. Updates and correction have been10 * performed to run on recent kernels. Additional features, like the11 * ability to configure various characteristics via .dts file or12 * board init file have been added. Detailed datasheet on which this13 * development is based is available here:14 *15 * http://natisbad.org/NAS/refs/GMT_EDS-762_763-080710-0.2.pdf16 *17 * Headers from previous developments have been kept below:18 *19 * Copyright (c) 2009 LaCie20 *21 * Author: Olivier Mouchet <olivier.mouchet@gmail.com>22 *23 * based on g760a code written by Herbert Valerio Riedel <hvr@gnu.org>24 * Copyright (C) 2007 Herbert Valerio Riedel <hvr@gnu.org>25 *26 * g762: minimal datasheet available at:27 * http://www.gmt.com.tw/product/datasheet/EDS-762_3.pdf28 */29 30#include <linux/device.h>31#include <linux/module.h>32#include <linux/init.h>33#include <linux/jiffies.h>34#include <linux/i2c.h>35#include <linux/hwmon.h>36#include <linux/hwmon-sysfs.h>37#include <linux/err.h>38#include <linux/mutex.h>39#include <linux/kernel.h>40#include <linux/clk.h>41#include <linux/of.h>42#include <linux/platform_data/g762.h>43 44#define DRVNAME "g762"45 46static const struct i2c_device_id g762_id[] = {47 { "g761" },48 { "g762" },49 { "g763" },50 { }51};52MODULE_DEVICE_TABLE(i2c, g762_id);53 54enum g762_regs {55 G762_REG_SET_CNT = 0x00,56 G762_REG_ACT_CNT = 0x01,57 G762_REG_FAN_STA = 0x02,58 G762_REG_SET_OUT = 0x03,59 G762_REG_FAN_CMD1 = 0x04,60 G762_REG_FAN_CMD2 = 0x05,61};62 63/* Config register bits */64#define G762_REG_FAN_CMD1_DET_FAN_FAIL 0x80 /* enable fan_fail signal */65#define G762_REG_FAN_CMD1_DET_FAN_OOC 0x40 /* enable fan_out_of_control */66#define G762_REG_FAN_CMD1_OUT_MODE 0x20 /* out mode: PWM or DC */67#define G762_REG_FAN_CMD1_FAN_MODE 0x10 /* fan mode: closed/open-loop */68#define G762_REG_FAN_CMD1_CLK_DIV_ID1 0x08 /* clock divisor value */69#define G762_REG_FAN_CMD1_CLK_DIV_ID0 0x0470#define G762_REG_FAN_CMD1_PWM_POLARITY 0x02 /* PWM polarity */71#define G762_REG_FAN_CMD1_PULSE_PER_REV 0x01 /* pulse per fan revolution */72 73#define G761_REG_FAN_CMD2_FAN_CLOCK 0x20 /* choose internal clock*/74#define G762_REG_FAN_CMD2_GEAR_MODE_1 0x08 /* fan gear mode */75#define G762_REG_FAN_CMD2_GEAR_MODE_0 0x0476#define G762_REG_FAN_CMD2_FAN_STARTV_1 0x02 /* fan startup voltage */77#define G762_REG_FAN_CMD2_FAN_STARTV_0 0x0178 79#define G762_REG_FAN_STA_FAIL 0x02 /* fan fail */80#define G762_REG_FAN_STA_OOC 0x01 /* fan out of control */81 82/* Config register values */83#define G762_OUT_MODE_PWM 184#define G762_OUT_MODE_DC 085 86#define G762_FAN_MODE_CLOSED_LOOP 287#define G762_FAN_MODE_OPEN_LOOP 188 89#define G762_PWM_POLARITY_NEGATIVE 190#define G762_PWM_POLARITY_POSITIVE 091 92/* Register data is read (and cached) at most once per second. */93#define G762_UPDATE_INTERVAL HZ94 95/*96 * Extract pulse count per fan revolution value (2 or 4) from given97 * FAN_CMD1 register value.98 */99#define G762_PULSE_FROM_REG(reg) \100 ((((reg) & G762_REG_FAN_CMD1_PULSE_PER_REV) + 1) << 1)101 102/*103 * Extract fan clock divisor (1, 2, 4 or 8) from given FAN_CMD1104 * register value.105 */106#define G762_CLKDIV_FROM_REG(reg) \107 (1 << (((reg) & (G762_REG_FAN_CMD1_CLK_DIV_ID0 | \108 G762_REG_FAN_CMD1_CLK_DIV_ID1)) >> 2))109 110/*111 * Extract fan gear mode multiplier value (0, 2 or 4) from given112 * FAN_CMD2 register value.113 */114#define G762_GEARMULT_FROM_REG(reg) \115 (1 << (((reg) & (G762_REG_FAN_CMD2_GEAR_MODE_0 | \116 G762_REG_FAN_CMD2_GEAR_MODE_1)) >> 2))117 118struct g762_data {119 struct i2c_client *client;120 bool internal_clock;121 struct clk *clk;122 123 /* update mutex */124 struct mutex update_lock;125 126 /* board specific parameters. */127 u32 clk_freq;128 129 /* g762 register cache */130 bool valid;131 unsigned long last_updated; /* in jiffies */132 133 u8 set_cnt; /* controls fan rotation speed in closed-loop mode */134 u8 act_cnt; /* provides access to current fan RPM value */135 u8 fan_sta; /* bit 0: set when actual fan speed is more than136 * 25% outside requested fan speed137 * bit 1: set when no transition occurs on fan138 * pin for 0.7s139 */140 u8 set_out; /* controls fan rotation speed in open-loop mode */141 u8 fan_cmd1; /* 0: FG_PLS_ID0 FG pulses count per revolution142 * 0: 2 counts per revolution143 * 1: 4 counts per revolution144 * 1: PWM_POLARITY 1: negative_duty145 * 0: positive_duty146 * 2,3: [FG_CLOCK_ID0, FG_CLK_ID1]147 * 00: Divide fan clock by 1148 * 01: Divide fan clock by 2149 * 10: Divide fan clock by 4150 * 11: Divide fan clock by 8151 * 4: FAN_MODE 1:closed-loop, 0:open-loop152 * 5: OUT_MODE 1:PWM, 0:DC153 * 6: DET_FAN_OOC enable "fan ooc" status154 * 7: DET_FAN_FAIL enable "fan fail" status155 */156 u8 fan_cmd2; /* 0,1: FAN_STARTV 0,1,2,3 -> 0,32,64,96 dac_code157 * 2,3: FG_GEAR_MODE158 * 00: multiplier = 1159 * 01: multiplier = 2160 * 10: multiplier = 4161 * 4: Mask ALERT# (g763 only)162 */163};164 165/*166 * Convert count value from fan controller register (FAN_SET_CNT) into fan167 * speed RPM value. Note that the datasheet documents a basic formula;168 * influence of additional parameters (fan clock divisor, fan gear mode)169 * have been infered from examples in the datasheet and tests.170 */171static inline unsigned int rpm_from_cnt(u8 cnt, u32 clk_freq, u16 p,172 u8 clk_div, u8 gear_mult)173{174 if (cnt == 0xff) /* setting cnt to 255 stops the fan */175 return 0;176 177 return (clk_freq * 30 * gear_mult) / ((cnt ? cnt : 1) * p * clk_div);178}179 180/*181 * Convert fan RPM value from sysfs into count value for fan controller182 * register (FAN_SET_CNT).183 */184static inline unsigned char cnt_from_rpm(unsigned long rpm, u32 clk_freq, u16 p,185 u8 clk_div, u8 gear_mult)186{187 unsigned long f1 = clk_freq * 30 * gear_mult;188 unsigned long f2 = p * clk_div;189 190 if (!rpm) /* to stop the fan, set cnt to 255 */191 return 0xff;192 193 rpm = clamp_val(rpm, f1 / (255 * f2), ULONG_MAX / f2);194 return DIV_ROUND_CLOSEST(f1, rpm * f2);195}196 197/* helper to grab and cache data, at most one time per second */198static struct g762_data *g762_update_client(struct device *dev)199{200 struct g762_data *data = dev_get_drvdata(dev);201 struct i2c_client *client = data->client;202 int ret = 0;203 204 mutex_lock(&data->update_lock);205 if (time_before(jiffies, data->last_updated + G762_UPDATE_INTERVAL) &&206 likely(data->valid))207 goto out;208 209 ret = i2c_smbus_read_byte_data(client, G762_REG_SET_CNT);210 if (ret < 0)211 goto out;212 data->set_cnt = ret;213 214 ret = i2c_smbus_read_byte_data(client, G762_REG_ACT_CNT);215 if (ret < 0)216 goto out;217 data->act_cnt = ret;218 219 ret = i2c_smbus_read_byte_data(client, G762_REG_FAN_STA);220 if (ret < 0)221 goto out;222 data->fan_sta = ret;223 224 ret = i2c_smbus_read_byte_data(client, G762_REG_SET_OUT);225 if (ret < 0)226 goto out;227 data->set_out = ret;228 229 ret = i2c_smbus_read_byte_data(client, G762_REG_FAN_CMD1);230 if (ret < 0)231 goto out;232 data->fan_cmd1 = ret;233 234 ret = i2c_smbus_read_byte_data(client, G762_REG_FAN_CMD2);235 if (ret < 0)236 goto out;237 data->fan_cmd2 = ret;238 239 data->last_updated = jiffies;240 data->valid = true;241 out:242 mutex_unlock(&data->update_lock);243 244 if (ret < 0) /* upon error, encode it in return value */245 data = ERR_PTR(ret);246 247 return data;248}249 250/* helpers for writing hardware parameters */251 252/*253 * Set input clock frequency received on CLK pin of the chip. Accepted values254 * are between 0 and 0xffffff. If zero is given, then default frequency255 * (32,768Hz) is used. Note that clock frequency is a characteristic of the256 * system but an internal parameter, i.e. value is not passed to the device.257 */258static int do_set_clk_freq(struct device *dev, unsigned long val)259{260 struct g762_data *data = dev_get_drvdata(dev);261 262 if (val > 0xffffff)263 return -EINVAL;264 if (!val)265 val = 32768;266 267 data->clk_freq = val;268 269 return 0;270}271 272/* Set pwm mode. Accepts either 0 (PWM mode) or 1 (DC mode) */273static int do_set_pwm_mode(struct device *dev, unsigned long val)274{275 struct g762_data *data = g762_update_client(dev);276 int ret;277 278 if (IS_ERR(data))279 return PTR_ERR(data);280 281 mutex_lock(&data->update_lock);282 switch (val) {283 case G762_OUT_MODE_PWM:284 data->fan_cmd1 |= G762_REG_FAN_CMD1_OUT_MODE;285 break;286 case G762_OUT_MODE_DC:287 data->fan_cmd1 &= ~G762_REG_FAN_CMD1_OUT_MODE;288 break;289 default:290 ret = -EINVAL;291 goto out;292 }293 ret = i2c_smbus_write_byte_data(data->client, G762_REG_FAN_CMD1,294 data->fan_cmd1);295 data->valid = false;296 out:297 mutex_unlock(&data->update_lock);298 299 return ret;300}301 302/* Set fan clock divisor. Accepts either 1, 2, 4 or 8. */303static int do_set_fan_div(struct device *dev, unsigned long val)304{305 struct g762_data *data = g762_update_client(dev);306 int ret;307 308 if (IS_ERR(data))309 return PTR_ERR(data);310 311 mutex_lock(&data->update_lock);312 switch (val) {313 case 1:314 data->fan_cmd1 &= ~G762_REG_FAN_CMD1_CLK_DIV_ID0;315 data->fan_cmd1 &= ~G762_REG_FAN_CMD1_CLK_DIV_ID1;316 break;317 case 2:318 data->fan_cmd1 |= G762_REG_FAN_CMD1_CLK_DIV_ID0;319 data->fan_cmd1 &= ~G762_REG_FAN_CMD1_CLK_DIV_ID1;320 break;321 case 4:322 data->fan_cmd1 &= ~G762_REG_FAN_CMD1_CLK_DIV_ID0;323 data->fan_cmd1 |= G762_REG_FAN_CMD1_CLK_DIV_ID1;324 break;325 case 8:326 data->fan_cmd1 |= G762_REG_FAN_CMD1_CLK_DIV_ID0;327 data->fan_cmd1 |= G762_REG_FAN_CMD1_CLK_DIV_ID1;328 break;329 default:330 ret = -EINVAL;331 goto out;332 }333 ret = i2c_smbus_write_byte_data(data->client, G762_REG_FAN_CMD1,334 data->fan_cmd1);335 data->valid = false;336 out:337 mutex_unlock(&data->update_lock);338 339 return ret;340}341 342/* Set fan gear mode. Accepts either 0, 1 or 2. */343static int do_set_fan_gear_mode(struct device *dev, unsigned long val)344{345 struct g762_data *data = g762_update_client(dev);346 int ret;347 348 if (IS_ERR(data))349 return PTR_ERR(data);350 351 mutex_lock(&data->update_lock);352 switch (val) {353 case 0:354 data->fan_cmd2 &= ~G762_REG_FAN_CMD2_GEAR_MODE_0;355 data->fan_cmd2 &= ~G762_REG_FAN_CMD2_GEAR_MODE_1;356 break;357 case 1:358 data->fan_cmd2 |= G762_REG_FAN_CMD2_GEAR_MODE_0;359 data->fan_cmd2 &= ~G762_REG_FAN_CMD2_GEAR_MODE_1;360 break;361 case 2:362 data->fan_cmd2 &= ~G762_REG_FAN_CMD2_GEAR_MODE_0;363 data->fan_cmd2 |= G762_REG_FAN_CMD2_GEAR_MODE_1;364 break;365 default:366 ret = -EINVAL;367 goto out;368 }369 ret = i2c_smbus_write_byte_data(data->client, G762_REG_FAN_CMD2,370 data->fan_cmd2);371 data->valid = false;372 out:373 mutex_unlock(&data->update_lock);374 375 return ret;376}377 378/* Set number of fan pulses per revolution. Accepts either 2 or 4. */379static int do_set_fan_pulses(struct device *dev, unsigned long val)380{381 struct g762_data *data = g762_update_client(dev);382 int ret;383 384 if (IS_ERR(data))385 return PTR_ERR(data);386 387 mutex_lock(&data->update_lock);388 switch (val) {389 case 2:390 data->fan_cmd1 &= ~G762_REG_FAN_CMD1_PULSE_PER_REV;391 break;392 case 4:393 data->fan_cmd1 |= G762_REG_FAN_CMD1_PULSE_PER_REV;394 break;395 default:396 ret = -EINVAL;397 goto out;398 }399 ret = i2c_smbus_write_byte_data(data->client, G762_REG_FAN_CMD1,400 data->fan_cmd1);401 data->valid = false;402 out:403 mutex_unlock(&data->update_lock);404 405 return ret;406}407 408/* Set fan mode. Accepts either 1 (open-loop) or 2 (closed-loop). */409static int do_set_pwm_enable(struct device *dev, unsigned long val)410{411 struct g762_data *data = g762_update_client(dev);412 int ret;413 414 if (IS_ERR(data))415 return PTR_ERR(data);416 417 mutex_lock(&data->update_lock);418 switch (val) {419 case G762_FAN_MODE_CLOSED_LOOP:420 data->fan_cmd1 |= G762_REG_FAN_CMD1_FAN_MODE;421 break;422 case G762_FAN_MODE_OPEN_LOOP:423 data->fan_cmd1 &= ~G762_REG_FAN_CMD1_FAN_MODE;424 /*425 * BUG FIX: if SET_CNT register value is 255 then, for some426 * unknown reason, fan will not rotate as expected, no matter427 * the value of SET_OUT (to be specific, this seems to happen428 * only in PWM mode). To workaround this bug, we give SET_CNT429 * value of 254 if it is 255 when switching to open-loop.430 */431 if (data->set_cnt == 0xff)432 i2c_smbus_write_byte_data(data->client,433 G762_REG_SET_CNT, 254);434 break;435 default:436 ret = -EINVAL;437 goto out;438 }439 440 ret = i2c_smbus_write_byte_data(data->client, G762_REG_FAN_CMD1,441 data->fan_cmd1);442 data->valid = false;443 out:444 mutex_unlock(&data->update_lock);445 446 return ret;447}448 449/* Set PWM polarity. Accepts either 0 (positive duty) or 1 (negative duty) */450static int do_set_pwm_polarity(struct device *dev, unsigned long val)451{452 struct g762_data *data = g762_update_client(dev);453 int ret;454 455 if (IS_ERR(data))456 return PTR_ERR(data);457 458 mutex_lock(&data->update_lock);459 switch (val) {460 case G762_PWM_POLARITY_POSITIVE:461 data->fan_cmd1 &= ~G762_REG_FAN_CMD1_PWM_POLARITY;462 break;463 case G762_PWM_POLARITY_NEGATIVE:464 data->fan_cmd1 |= G762_REG_FAN_CMD1_PWM_POLARITY;465 break;466 default:467 ret = -EINVAL;468 goto out;469 }470 ret = i2c_smbus_write_byte_data(data->client, G762_REG_FAN_CMD1,471 data->fan_cmd1);472 data->valid = false;473 out:474 mutex_unlock(&data->update_lock);475 476 return ret;477}478 479/*480 * Set pwm value. Accepts values between 0 (stops the fan) and481 * 255 (full speed). This only makes sense in open-loop mode.482 */483static int do_set_pwm(struct device *dev, unsigned long val)484{485 struct g762_data *data = dev_get_drvdata(dev);486 struct i2c_client *client = data->client;487 int ret;488 489 if (val > 255)490 return -EINVAL;491 492 mutex_lock(&data->update_lock);493 ret = i2c_smbus_write_byte_data(client, G762_REG_SET_OUT, val);494 data->valid = false;495 mutex_unlock(&data->update_lock);496 497 return ret;498}499 500/*501 * Set fan RPM value. Can be called both in closed and open-loop mode502 * but effect will only be seen after closed-loop mode is configured.503 */504static int do_set_fan_target(struct device *dev, unsigned long val)505{506 struct g762_data *data = g762_update_client(dev);507 int ret;508 509 if (IS_ERR(data))510 return PTR_ERR(data);511 512 mutex_lock(&data->update_lock);513 data->set_cnt = cnt_from_rpm(val, data->clk_freq,514 G762_PULSE_FROM_REG(data->fan_cmd1),515 G762_CLKDIV_FROM_REG(data->fan_cmd1),516 G762_GEARMULT_FROM_REG(data->fan_cmd2));517 ret = i2c_smbus_write_byte_data(data->client, G762_REG_SET_CNT,518 data->set_cnt);519 data->valid = false;520 mutex_unlock(&data->update_lock);521 522 return ret;523}524 525/* Set fan startup voltage. Accepted values are either 0, 1, 2 or 3. */526static int do_set_fan_startv(struct device *dev, unsigned long val)527{528 struct g762_data *data = g762_update_client(dev);529 int ret;530 531 if (IS_ERR(data))532 return PTR_ERR(data);533 534 mutex_lock(&data->update_lock);535 switch (val) {536 case 0:537 data->fan_cmd2 &= ~G762_REG_FAN_CMD2_FAN_STARTV_0;538 data->fan_cmd2 &= ~G762_REG_FAN_CMD2_FAN_STARTV_1;539 break;540 case 1:541 data->fan_cmd2 |= G762_REG_FAN_CMD2_FAN_STARTV_0;542 data->fan_cmd2 &= ~G762_REG_FAN_CMD2_FAN_STARTV_1;543 break;544 case 2:545 data->fan_cmd2 &= ~G762_REG_FAN_CMD2_FAN_STARTV_0;546 data->fan_cmd2 |= G762_REG_FAN_CMD2_FAN_STARTV_1;547 break;548 case 3:549 data->fan_cmd2 |= G762_REG_FAN_CMD2_FAN_STARTV_0;550 data->fan_cmd2 |= G762_REG_FAN_CMD2_FAN_STARTV_1;551 break;552 default:553 ret = -EINVAL;554 goto out;555 }556 ret = i2c_smbus_write_byte_data(data->client, G762_REG_FAN_CMD2,557 data->fan_cmd2);558 data->valid = false;559 out:560 mutex_unlock(&data->update_lock);561 562 return ret;563}564 565/*566 * Helper to import hardware characteristics from .dts file and push567 * those to the chip.568 */569 570#ifdef CONFIG_OF571static const struct of_device_id g762_dt_match[] = {572 { .compatible = "gmt,g761" },573 { .compatible = "gmt,g762" },574 { .compatible = "gmt,g763" },575 { },576};577MODULE_DEVICE_TABLE(of, g762_dt_match);578 579/*580 * Grab clock (a required property), enable it, get (fixed) clock frequency581 * and store it. Note: upon success, clock has been prepared and enabled; it582 * must later be unprepared and disabled (e.g. during module unloading) by a583 * call to g762_of_clock_disable(). Note that a reference to clock is kept584 * in our private data structure to be used in this function.585 */586static void g762_of_clock_disable(void *data)587{588 struct g762_data *g762 = data;589 590 clk_disable_unprepare(g762->clk);591 clk_put(g762->clk);592}593 594static int g762_of_clock_enable(struct i2c_client *client)595{596 struct g762_data *data;597 unsigned long clk_freq;598 struct clk *clk;599 int ret;600 601 if (!client->dev.of_node)602 return 0;603 604 data = i2c_get_clientdata(client);605 606 /*607 * Skip CLK detection and handling if we use internal clock.608 * This is only valid for g761.609 */610 data->internal_clock = of_device_is_compatible(client->dev.of_node,611 "gmt,g761") &&612 !of_property_present(client->dev.of_node,613 "clocks");614 if (data->internal_clock) {615 do_set_clk_freq(&client->dev, 32768);616 return 0;617 }618 619 clk = of_clk_get(client->dev.of_node, 0);620 if (IS_ERR(clk)) {621 dev_err(&client->dev, "failed to get clock\n");622 return PTR_ERR(clk);623 }624 625 ret = clk_prepare_enable(clk);626 if (ret) {627 dev_err(&client->dev, "failed to enable clock\n");628 goto clk_put;629 }630 631 clk_freq = clk_get_rate(clk);632 ret = do_set_clk_freq(&client->dev, clk_freq);633 if (ret) {634 dev_err(&client->dev, "invalid clock freq %lu\n", clk_freq);635 goto clk_unprep;636 }637 638 data->clk = clk;639 640 ret = devm_add_action(&client->dev, g762_of_clock_disable, data);641 if (ret) {642 dev_err(&client->dev, "failed to add disable clock action\n");643 goto clk_unprep;644 }645 646 return 0;647 648 clk_unprep:649 clk_disable_unprepare(clk);650 651 clk_put:652 clk_put(clk);653 654 return ret;655}656 657static int g762_of_prop_import_one(struct i2c_client *client,658 const char *pname,659 int (*psetter)(struct device *dev,660 unsigned long val))661{662 int ret;663 u32 pval;664 665 if (of_property_read_u32(client->dev.of_node, pname, &pval))666 return 0;667 668 dev_dbg(&client->dev, "found %s (%d)\n", pname, pval);669 ret = (*psetter)(&client->dev, pval);670 if (ret)671 dev_err(&client->dev, "unable to set %s (%d)\n", pname, pval);672 673 return ret;674}675 676static int g762_of_prop_import(struct i2c_client *client)677{678 int ret;679 680 if (!client->dev.of_node)681 return 0;682 683 ret = g762_of_prop_import_one(client, "fan_gear_mode",684 do_set_fan_gear_mode);685 if (ret)686 return ret;687 688 ret = g762_of_prop_import_one(client, "pwm_polarity",689 do_set_pwm_polarity);690 if (ret)691 return ret;692 693 return g762_of_prop_import_one(client, "fan_startv",694 do_set_fan_startv);695}696 697#else698static int g762_of_prop_import(struct i2c_client *client)699{700 return 0;701}702 703static int g762_of_clock_enable(struct i2c_client *client)704{705 return 0;706}707#endif708 709/*710 * Helper to import hardware characteristics from .dts file and push711 * those to the chip.712 */713 714static int g762_pdata_prop_import(struct i2c_client *client)715{716 struct g762_platform_data *pdata = dev_get_platdata(&client->dev);717 int ret;718 719 if (!pdata)720 return 0;721 722 ret = do_set_fan_gear_mode(&client->dev, pdata->fan_gear_mode);723 if (ret)724 return ret;725 726 ret = do_set_pwm_polarity(&client->dev, pdata->pwm_polarity);727 if (ret)728 return ret;729 730 ret = do_set_fan_startv(&client->dev, pdata->fan_startv);731 if (ret)732 return ret;733 734 return do_set_clk_freq(&client->dev, pdata->clk_freq);735}736 737/*738 * sysfs attributes739 */740 741/*742 * Read function for fan1_input sysfs file. Return current fan RPM value, or743 * 0 if fan is out of control.744 */745static ssize_t fan1_input_show(struct device *dev,746 struct device_attribute *da, char *buf)747{748 struct g762_data *data = g762_update_client(dev);749 unsigned int rpm = 0;750 751 if (IS_ERR(data))752 return PTR_ERR(data);753 754 mutex_lock(&data->update_lock);755 /* reverse logic: fan out of control reporting is enabled low */756 if (data->fan_sta & G762_REG_FAN_STA_OOC) {757 rpm = rpm_from_cnt(data->act_cnt, data->clk_freq,758 G762_PULSE_FROM_REG(data->fan_cmd1),759 G762_CLKDIV_FROM_REG(data->fan_cmd1),760 G762_GEARMULT_FROM_REG(data->fan_cmd2));761 }762 mutex_unlock(&data->update_lock);763 764 return sprintf(buf, "%u\n", rpm);765}766 767/*768 * Read and write functions for pwm1_mode sysfs file. Get and set fan speed769 * control mode i.e. PWM (1) or DC (0).770 */771static ssize_t pwm1_mode_show(struct device *dev, struct device_attribute *da,772 char *buf)773{774 struct g762_data *data = g762_update_client(dev);775 776 if (IS_ERR(data))777 return PTR_ERR(data);778 779 return sprintf(buf, "%d\n",780 !!(data->fan_cmd1 & G762_REG_FAN_CMD1_OUT_MODE));781}782 783static ssize_t pwm1_mode_store(struct device *dev,784 struct device_attribute *da, const char *buf,785 size_t count)786{787 unsigned long val;788 int ret;789 790 if (kstrtoul(buf, 10, &val))791 return -EINVAL;792 793 ret = do_set_pwm_mode(dev, val);794 if (ret < 0)795 return ret;796 797 return count;798}799 800/*801 * Read and write functions for fan1_div sysfs file. Get and set fan802 * controller prescaler value803 */804static ssize_t fan1_div_show(struct device *dev, struct device_attribute *da,805 char *buf)806{807 struct g762_data *data = g762_update_client(dev);808 809 if (IS_ERR(data))810 return PTR_ERR(data);811 812 return sprintf(buf, "%d\n", G762_CLKDIV_FROM_REG(data->fan_cmd1));813}814 815static ssize_t fan1_div_store(struct device *dev, struct device_attribute *da,816 const char *buf, size_t count)817{818 unsigned long val;819 int ret;820 821 if (kstrtoul(buf, 10, &val))822 return -EINVAL;823 824 ret = do_set_fan_div(dev, val);825 if (ret < 0)826 return ret;827 828 return count;829}830 831/*832 * Read and write functions for fan1_pulses sysfs file. Get and set number833 * of tachometer pulses per fan revolution.834 */835static ssize_t fan1_pulses_show(struct device *dev,836 struct device_attribute *da, char *buf)837{838 struct g762_data *data = g762_update_client(dev);839 840 if (IS_ERR(data))841 return PTR_ERR(data);842 843 return sprintf(buf, "%d\n", G762_PULSE_FROM_REG(data->fan_cmd1));844}845 846static ssize_t fan1_pulses_store(struct device *dev,847 struct device_attribute *da, const char *buf,848 size_t count)849{850 unsigned long val;851 int ret;852 853 if (kstrtoul(buf, 10, &val))854 return -EINVAL;855 856 ret = do_set_fan_pulses(dev, val);857 if (ret < 0)858 return ret;859 860 return count;861}862 863/*864 * Read and write functions for pwm1_enable. Get and set fan speed control mode865 * (i.e. closed or open-loop).866 *867 * Following documentation about hwmon's sysfs interface, a pwm1_enable node868 * should accept the following:869 *870 * 0 : no fan speed control (i.e. fan at full speed)871 * 1 : manual fan speed control enabled (use pwm[1-*]) (open-loop)872 * 2+: automatic fan speed control enabled (use fan[1-*]_target) (closed-loop)873 *874 * but we do not accept 0 as this mode is not natively supported by the chip875 * and it is not emulated by g762 driver. -EINVAL is returned in this case.876 */877static ssize_t pwm1_enable_show(struct device *dev,878 struct device_attribute *da, char *buf)879{880 struct g762_data *data = g762_update_client(dev);881 882 if (IS_ERR(data))883 return PTR_ERR(data);884 885 return sprintf(buf, "%d\n",886 (!!(data->fan_cmd1 & G762_REG_FAN_CMD1_FAN_MODE)) + 1);887}888 889static ssize_t pwm1_enable_store(struct device *dev,890 struct device_attribute *da, const char *buf,891 size_t count)892{893 unsigned long val;894 int ret;895 896 if (kstrtoul(buf, 10, &val))897 return -EINVAL;898 899 ret = do_set_pwm_enable(dev, val);900 if (ret < 0)901 return ret;902 903 return count;904}905 906/*907 * Read and write functions for pwm1 sysfs file. Get and set pwm value908 * (which affects fan speed) in open-loop mode. 0 stops the fan and 255909 * makes it run at full speed.910 */911static ssize_t pwm1_show(struct device *dev, struct device_attribute *da,912 char *buf)913{914 struct g762_data *data = g762_update_client(dev);915 916 if (IS_ERR(data))917 return PTR_ERR(data);918 919 return sprintf(buf, "%d\n", data->set_out);920}921 922static ssize_t pwm1_store(struct device *dev, struct device_attribute *da,923 const char *buf, size_t count)924{925 unsigned long val;926 int ret;927 928 if (kstrtoul(buf, 10, &val))929 return -EINVAL;930 931 ret = do_set_pwm(dev, val);932 if (ret < 0)933 return ret;934 935 return count;936}937 938/*939 * Read and write function for fan1_target sysfs file. Get/set the fan speed in940 * closed-loop mode. Speed is given as a RPM value; then the chip will regulate941 * the fan speed using pulses from fan tachometer.942 *943 * Refer to rpm_from_cnt() implementation above to get info about count number944 * calculation.945 *946 * Also note that due to rounding errors it is possible that you don't read947 * back exactly the value you have set.948 */949static ssize_t fan1_target_show(struct device *dev,950 struct device_attribute *da, char *buf)951{952 struct g762_data *data = g762_update_client(dev);953 unsigned int rpm;954 955 if (IS_ERR(data))956 return PTR_ERR(data);957 958 mutex_lock(&data->update_lock);959 rpm = rpm_from_cnt(data->set_cnt, data->clk_freq,960 G762_PULSE_FROM_REG(data->fan_cmd1),961 G762_CLKDIV_FROM_REG(data->fan_cmd1),962 G762_GEARMULT_FROM_REG(data->fan_cmd2));963 mutex_unlock(&data->update_lock);964 965 return sprintf(buf, "%u\n", rpm);966}967 968static ssize_t fan1_target_store(struct device *dev,969 struct device_attribute *da, const char *buf,970 size_t count)971{972 unsigned long val;973 int ret;974 975 if (kstrtoul(buf, 10, &val))976 return -EINVAL;977 978 ret = do_set_fan_target(dev, val);979 if (ret < 0)980 return ret;981 982 return count;983}984 985/* read function for fan1_fault sysfs file. */986static ssize_t fan1_fault_show(struct device *dev, struct device_attribute *da,987 char *buf)988{989 struct g762_data *data = g762_update_client(dev);990 991 if (IS_ERR(data))992 return PTR_ERR(data);993 994 return sprintf(buf, "%u\n", !!(data->fan_sta & G762_REG_FAN_STA_FAIL));995}996 997/*998 * read function for fan1_alarm sysfs file. Note that OOC condition is999 * enabled low1000 */1001static ssize_t fan1_alarm_show(struct device *dev,1002 struct device_attribute *da, char *buf)1003{1004 struct g762_data *data = g762_update_client(dev);1005 1006 if (IS_ERR(data))1007 return PTR_ERR(data);1008 1009 return sprintf(buf, "%u\n", !(data->fan_sta & G762_REG_FAN_STA_OOC));1010}1011 1012static DEVICE_ATTR_RW(pwm1);1013static DEVICE_ATTR_RW(pwm1_mode);1014static DEVICE_ATTR_RW(pwm1_enable);1015static DEVICE_ATTR_RO(fan1_input);1016static DEVICE_ATTR_RO(fan1_alarm);1017static DEVICE_ATTR_RO(fan1_fault);1018static DEVICE_ATTR_RW(fan1_target);1019static DEVICE_ATTR_RW(fan1_div);1020static DEVICE_ATTR_RW(fan1_pulses);1021 1022/* Driver data */1023static struct attribute *g762_attrs[] = {1024 &dev_attr_fan1_input.attr,1025 &dev_attr_fan1_alarm.attr,1026 &dev_attr_fan1_fault.attr,1027 &dev_attr_fan1_target.attr,1028 &dev_attr_fan1_div.attr,1029 &dev_attr_fan1_pulses.attr,1030 &dev_attr_pwm1.attr,1031 &dev_attr_pwm1_mode.attr,1032 &dev_attr_pwm1_enable.attr,1033 NULL1034};1035 1036ATTRIBUTE_GROUPS(g762);1037 1038/*1039 * Enable both fan failure detection and fan out of control protection. The1040 * function does not protect change/access to data structure; it must thus1041 * only be called during initialization.1042 */1043static inline int g762_fan_init(struct device *dev)1044{1045 struct g762_data *data = g762_update_client(dev);1046 int ret;1047 1048 if (IS_ERR(data))1049 return PTR_ERR(data);1050 1051 /* internal_clock can only be set with compatible g761 */1052 if (data->internal_clock)1053 data->fan_cmd2 |= G761_REG_FAN_CMD2_FAN_CLOCK;1054 1055 data->fan_cmd1 |= G762_REG_FAN_CMD1_DET_FAN_FAIL;1056 data->fan_cmd1 |= G762_REG_FAN_CMD1_DET_FAN_OOC;1057 data->valid = false;1058 1059 ret = i2c_smbus_write_byte_data(data->client, G762_REG_FAN_CMD1,1060 data->fan_cmd1);1061 if (ret)1062 return ret;1063 1064 return i2c_smbus_write_byte_data(data->client, G762_REG_FAN_CMD2,1065 data->fan_cmd2);1066}1067 1068static int g762_probe(struct i2c_client *client)1069{1070 struct device *dev = &client->dev;1071 struct device *hwmon_dev;1072 struct g762_data *data;1073 int ret;1074 1075 if (!i2c_check_functionality(client->adapter,1076 I2C_FUNC_SMBUS_BYTE_DATA))1077 return -ENODEV;1078 1079 data = devm_kzalloc(dev, sizeof(struct g762_data), GFP_KERNEL);1080 if (!data)1081 return -ENOMEM;1082 1083 i2c_set_clientdata(client, data);1084 data->client = client;1085 mutex_init(&data->update_lock);1086 1087 /* Get configuration via DT ... */1088 ret = g762_of_clock_enable(client);1089 if (ret)1090 return ret;1091 1092 /* Enable fan failure detection and fan out of control protection */1093 ret = g762_fan_init(dev);1094 if (ret)1095 return ret;1096 1097 ret = g762_of_prop_import(client);1098 if (ret)1099 return ret;1100 /* ... or platform_data */1101 ret = g762_pdata_prop_import(client);1102 if (ret)1103 return ret;1104 1105 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,1106 data, g762_groups);1107 return PTR_ERR_OR_ZERO(hwmon_dev);1108}1109 1110static struct i2c_driver g762_driver = {1111 .driver = {1112 .name = DRVNAME,1113 .of_match_table = of_match_ptr(g762_dt_match),1114 },1115 .probe = g762_probe,1116 .id_table = g762_id,1117};1118 1119module_i2c_driver(g762_driver);1120 1121MODULE_AUTHOR("Arnaud EBALARD <arno@natisbad.org>");1122MODULE_DESCRIPTION("GMT G762/G763 driver");1123MODULE_LICENSE("GPL");1124