aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/hwmon/lm80.c
diff options
context:
space:
mode:
authorGuenter Roeck <linux@roeck-us.net>2014-04-13 14:56:15 -0400
committerGuenter Roeck <linux@roeck-us.net>2014-05-21 19:02:26 -0400
commitc254ffdefc002b57f1e9eedddcb3569c0d80578f (patch)
treea74e48aac71bc02c00d35f67603ed24a6cbcd802 /drivers/hwmon/lm80.c
parent85b3ee07b986e90d5e9821dcb28bde340dfc7805 (diff)
hwmon: (lm80) Rearrange code to avoid forward declarations
Avoid need for forward declarations by rearranging code. No functional change. Signed-off-by: Guenter Roeck <linux@roeck-us.net>
Diffstat (limited to 'drivers/hwmon/lm80.c')
-rw-r--r--drivers/hwmon/lm80.c290
1 files changed, 139 insertions, 151 deletions
diff --git a/drivers/hwmon/lm80.c b/drivers/hwmon/lm80.c
index 420ad7c5ec28..4bcd9b882948 100644
--- a/drivers/hwmon/lm80.c
+++ b/drivers/hwmon/lm80.c
@@ -140,39 +140,130 @@ struct lm80_data {
140 u16 alarms; /* Register encoding, combined */ 140 u16 alarms; /* Register encoding, combined */
141}; 141};
142 142
143/* 143static int lm80_read_value(struct i2c_client *client, u8 reg)
144 * Functions declaration 144{
145 */ 145 return i2c_smbus_read_byte_data(client, reg);
146}
146 147
147static int lm80_probe(struct i2c_client *client, 148static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value)
148 const struct i2c_device_id *id); 149{
149static int lm80_detect(struct i2c_client *client, struct i2c_board_info *info); 150 return i2c_smbus_write_byte_data(client, reg, value);
150static void lm80_init_client(struct i2c_client *client); 151}
151static struct lm80_data *lm80_update_device(struct device *dev);
152static int lm80_read_value(struct i2c_client *client, u8 reg);
153static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value);
154 152
155/* 153/* Called when we have found a new LM80 and after read errors */
156 * Driver data (common to all clients) 154static void lm80_init_client(struct i2c_client *client)
157 */ 155{
156 /*
157 * Reset all except Watchdog values and last conversion values
158 * This sets fan-divs to 2, among others. This makes most other
159 * initializations unnecessary
160 */
161 lm80_write_value(client, LM80_REG_CONFIG, 0x80);
162 /* Set 11-bit temperature resolution */
163 lm80_write_value(client, LM80_REG_RES, 0x08);
158 164
159static const struct i2c_device_id lm80_id[] = { 165 /* Start monitoring */
160 { "lm80", 0 }, 166 lm80_write_value(client, LM80_REG_CONFIG, 0x01);
161 { "lm96080", 1 }, 167}
162 { }
163};
164MODULE_DEVICE_TABLE(i2c, lm80_id);
165 168
166static struct i2c_driver lm80_driver = { 169static struct lm80_data *lm80_update_device(struct device *dev)
167 .class = I2C_CLASS_HWMON, 170{
168 .driver = { 171 struct lm80_data *data = dev_get_drvdata(dev);
169 .name = "lm80", 172 struct i2c_client *client = data->client;
170 }, 173 int i;
171 .probe = lm80_probe, 174 int rv;
172 .id_table = lm80_id, 175 int prev_rv;
173 .detect = lm80_detect, 176 struct lm80_data *ret = data;
174 .address_list = normal_i2c, 177
175}; 178 mutex_lock(&data->update_lock);
179
180 if (data->error)
181 lm80_init_client(client);
182
183 if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
184 dev_dbg(dev, "Starting lm80 update\n");
185 for (i = 0; i <= 6; i++) {
186 rv = lm80_read_value(client, LM80_REG_IN(i));
187 if (rv < 0)
188 goto abort;
189 data->in[i_input][i] = rv;
190
191 rv = lm80_read_value(client, LM80_REG_IN_MIN(i));
192 if (rv < 0)
193 goto abort;
194 data->in[i_min][i] = rv;
195
196 rv = lm80_read_value(client, LM80_REG_IN_MAX(i));
197 if (rv < 0)
198 goto abort;
199 data->in[i_max][i] = rv;
200 }
201
202 rv = lm80_read_value(client, LM80_REG_FAN1);
203 if (rv < 0)
204 goto abort;
205 data->fan[f_input][0] = rv;
206
207 rv = lm80_read_value(client, LM80_REG_FAN_MIN(1));
208 if (rv < 0)
209 goto abort;
210 data->fan[f_min][0] = rv;
211
212 rv = lm80_read_value(client, LM80_REG_FAN2);
213 if (rv < 0)
214 goto abort;
215 data->fan[f_input][1] = rv;
216
217 rv = lm80_read_value(client, LM80_REG_FAN_MIN(2));
218 if (rv < 0)
219 goto abort;
220 data->fan[f_min][1] = rv;
221
222 prev_rv = rv = lm80_read_value(client, LM80_REG_TEMP);
223 if (rv < 0)
224 goto abort;
225 rv = lm80_read_value(client, LM80_REG_RES);
226 if (rv < 0)
227 goto abort;
228 data->temp[t_input] = (prev_rv << 8) | (rv & 0xf0);
229
230 for (i = t_input + 1; i < t_num_temp; i++) {
231 rv = lm80_read_value(client, temp_regs[i]);
232 if (rv < 0)
233 goto abort;
234 data->temp[i] = rv << 8;
235 }
236
237 rv = lm80_read_value(client, LM80_REG_FANDIV);
238 if (rv < 0)
239 goto abort;
240 data->fan_div[0] = (rv >> 2) & 0x03;
241 data->fan_div[1] = (rv >> 4) & 0x03;
242
243 prev_rv = rv = lm80_read_value(client, LM80_REG_ALARM1);
244 if (rv < 0)
245 goto abort;
246 rv = lm80_read_value(client, LM80_REG_ALARM2);
247 if (rv < 0)
248 goto abort;
249 data->alarms = prev_rv + (rv << 8);
250
251 data->last_updated = jiffies;
252 data->valid = 1;
253 data->error = 0;
254 }
255 goto done;
256
257abort:
258 ret = ERR_PTR(rv);
259 data->valid = 0;
260 data->error = 1;
261
262done:
263 mutex_unlock(&data->update_lock);
264
265 return ret;
266}
176 267
177/* 268/*
178 * Sysfs stuff 269 * Sysfs stuff
@@ -553,130 +644,27 @@ static int lm80_probe(struct i2c_client *client,
553 return PTR_ERR_OR_ZERO(hwmon_dev); 644 return PTR_ERR_OR_ZERO(hwmon_dev);
554} 645}
555 646
556static int lm80_read_value(struct i2c_client *client, u8 reg) 647/*
557{ 648 * Driver data (common to all clients)
558 return i2c_smbus_read_byte_data(client, reg); 649 */
559}
560
561static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value)
562{
563 return i2c_smbus_write_byte_data(client, reg, value);
564}
565
566/* Called when we have found a new LM80. */
567static void lm80_init_client(struct i2c_client *client)
568{
569 /*
570 * Reset all except Watchdog values and last conversion values
571 * This sets fan-divs to 2, among others. This makes most other
572 * initializations unnecessary
573 */
574 lm80_write_value(client, LM80_REG_CONFIG, 0x80);
575 /* Set 11-bit temperature resolution */
576 lm80_write_value(client, LM80_REG_RES, 0x08);
577
578 /* Start monitoring */
579 lm80_write_value(client, LM80_REG_CONFIG, 0x01);
580}
581
582static struct lm80_data *lm80_update_device(struct device *dev)
583{
584 struct lm80_data *data = dev_get_drvdata(dev);
585 struct i2c_client *client = data->client;
586 int i;
587 int rv;
588 int prev_rv;
589 struct lm80_data *ret = data;
590
591 mutex_lock(&data->update_lock);
592
593 if (data->error)
594 lm80_init_client(client);
595
596 if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
597 dev_dbg(dev, "Starting lm80 update\n");
598 for (i = 0; i <= 6; i++) {
599 rv = lm80_read_value(client, LM80_REG_IN(i));
600 if (rv < 0)
601 goto abort;
602 data->in[i_input][i] = rv;
603
604 rv = lm80_read_value(client, LM80_REG_IN_MIN(i));
605 if (rv < 0)
606 goto abort;
607 data->in[i_min][i] = rv;
608
609 rv = lm80_read_value(client, LM80_REG_IN_MAX(i));
610 if (rv < 0)
611 goto abort;
612 data->in[i_max][i] = rv;
613 }
614
615 rv = lm80_read_value(client, LM80_REG_FAN1);
616 if (rv < 0)
617 goto abort;
618 data->fan[f_input][0] = rv;
619
620 rv = lm80_read_value(client, LM80_REG_FAN_MIN(1));
621 if (rv < 0)
622 goto abort;
623 data->fan[f_min][0] = rv;
624
625 rv = lm80_read_value(client, LM80_REG_FAN2);
626 if (rv < 0)
627 goto abort;
628 data->fan[f_input][1] = rv;
629
630 rv = lm80_read_value(client, LM80_REG_FAN_MIN(2));
631 if (rv < 0)
632 goto abort;
633 data->fan[f_min][1] = rv;
634
635 prev_rv = rv = lm80_read_value(client, LM80_REG_TEMP);
636 if (rv < 0)
637 goto abort;
638 rv = lm80_read_value(client, LM80_REG_RES);
639 if (rv < 0)
640 goto abort;
641 data->temp[t_input] = (prev_rv << 8) | (rv & 0xf0);
642
643 for (i = t_input + 1; i < t_num_temp; i++) {
644 rv = lm80_read_value(client, temp_regs[i]);
645 if (rv < 0)
646 goto abort;
647 data->temp[i] = rv << 8;
648 }
649
650 rv = lm80_read_value(client, LM80_REG_FANDIV);
651 if (rv < 0)
652 goto abort;
653 data->fan_div[0] = (rv >> 2) & 0x03;
654 data->fan_div[1] = (rv >> 4) & 0x03;
655
656 prev_rv = rv = lm80_read_value(client, LM80_REG_ALARM1);
657 if (rv < 0)
658 goto abort;
659 rv = lm80_read_value(client, LM80_REG_ALARM2);
660 if (rv < 0)
661 goto abort;
662 data->alarms = prev_rv + (rv << 8);
663
664 data->last_updated = jiffies;
665 data->valid = 1;
666 data->error = 0;
667 }
668 goto done;
669
670abort:
671 ret = ERR_PTR(rv);
672 data->valid = 0;
673 data->error = 1;
674 650
675done: 651static const struct i2c_device_id lm80_id[] = {
676 mutex_unlock(&data->update_lock); 652 { "lm80", 0 },
653 { "lm96080", 1 },
654 { }
655};
656MODULE_DEVICE_TABLE(i2c, lm80_id);
677 657
678 return ret; 658static struct i2c_driver lm80_driver = {
679} 659 .class = I2C_CLASS_HWMON,
660 .driver = {
661 .name = "lm80",
662 },
663 .probe = lm80_probe,
664 .id_table = lm80_id,
665 .detect = lm80_detect,
666 .address_list = normal_i2c,
667};
680 668
681module_i2c_driver(lm80_driver); 669module_i2c_driver(lm80_driver);
682 670
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-12 08:31:45 -0400