← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to drivers/hwmon/max1668.c

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/hwmon/max1668.c
 
1
/*
 
2
    Copyright (c) 2011 David George <david.george@ska.ac.za>
 
3
 
 
4
    based on adm1021.c
 
5
    some credit to Christoph Scheurer, but largely a rewrite
 
6
 
 
7
    This program is free software; you can redistribute it and/or modify
 
8
    it under the terms of the GNU General Public License as published by
 
9
    the Free Software Foundation; either version 2 of the License, or
 
10
    (at your option) any later version.
 
11
 
 
12
    This program is distributed in the hope that it will be useful,
 
13
    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
    GNU General Public License for more details.
 
16
 
 
17
    You should have received a copy of the GNU General Public License
 
18
    along with this program; if not, write to the Free Software
 
19
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
20
*/
 
21
 
 
22
#include <linux/module.h>
 
23
#include <linux/init.h>
 
24
#include <linux/slab.h>
 
25
#include <linux/jiffies.h>
 
26
#include <linux/i2c.h>
 
27
#include <linux/hwmon.h>
 
28
#include <linux/hwmon-sysfs.h>
 
29
#include <linux/err.h>
 
30
#include <linux/mutex.h>
 
31
 
 
32
/* Addresses to scan */
 
33
static unsigned short max1668_addr_list[] = {
 
34
        0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
 
35
 
 
36
/* max1668 registers */
 
37
 
 
38
#define MAX1668_REG_TEMP(nr)    (nr)
 
39
#define MAX1668_REG_STAT1       0x05
 
40
#define MAX1668_REG_STAT2       0x06
 
41
#define MAX1668_REG_MAN_ID      0xfe
 
42
#define MAX1668_REG_DEV_ID      0xff
 
43
 
 
44
/* limits */
 
45
 
 
46
/* write high limits */
 
47
#define MAX1668_REG_LIMH_WR(nr) (0x13 + 2 * (nr))
 
48
/* write low limits */
 
49
#define MAX1668_REG_LIML_WR(nr) (0x14 + 2 * (nr))
 
50
/* read high limits */
 
51
#define MAX1668_REG_LIMH_RD(nr) (0x08 + 2 * (nr))
 
52
/* read low limits */
 
53
#define MAX1668_REG_LIML_RD(nr) (0x09 + 2 * (nr))
 
54
 
 
55
/* manufacturer and device ID Constants */
 
56
#define MAN_ID_MAXIM            0x4d
 
57
#define DEV_ID_MAX1668          0x3
 
58
#define DEV_ID_MAX1805          0x5
 
59
#define DEV_ID_MAX1989          0xb
 
60
 
 
61
/* read only mode module parameter */
 
62
static int read_only;
 
63
module_param(read_only, bool, 0);
 
64
MODULE_PARM_DESC(read_only, "Don't set any values, read only mode");
 
65
 
 
66
enum chips { max1668, max1805, max1989 };
 
67
 
 
68
struct max1668_data {
 
69
        struct device *hwmon_dev;
 
70
        enum chips type;
 
71
 
 
72
        struct mutex update_lock;
 
73
        char valid;             /* !=0 if following fields are valid */
 
74
        unsigned long last_updated;     /* In jiffies */
 
75
 
 
76
        /* 1x local and 4x remote */
 
77
        s8 temp_max[5];
 
78
        s8 temp_min[5];
 
79
        s8 temp[5];
 
80
        u16 alarms;
 
81
};
 
82
 
 
83
static struct max1668_data *max1668_update_device(struct device *dev)
 
84
{
 
85
        struct i2c_client *client = to_i2c_client(dev);
 
86
        struct max1668_data *data = i2c_get_clientdata(client);
 
87
        struct max1668_data *ret = data;
 
88
        s32 val;
 
89
        int i;
 
90
 
 
91
        mutex_lock(&data->update_lock);
 
92
 
 
93
        if (data->valid && !time_after(jiffies,
 
94
                        data->last_updated + HZ + HZ / 2))
 
95
                goto abort;
 
96
 
 
97
        for (i = 0; i < 5; i++) {
 
98
                val = i2c_smbus_read_byte_data(client, MAX1668_REG_TEMP(i));
 
99
                if (unlikely(val < 0)) {
 
100
                        ret = ERR_PTR(val);
 
101
                        goto abort;
 
102
                }
 
103
                data->temp[i] = (s8) val;
 
104
 
 
105
                val = i2c_smbus_read_byte_data(client, MAX1668_REG_LIMH_RD(i));
 
106
                if (unlikely(val < 0)) {
 
107
                        ret = ERR_PTR(val);
 
108
                        goto abort;
 
109
                }
 
110
                data->temp_max[i] = (s8) val;
 
111
 
 
112
                val = i2c_smbus_read_byte_data(client, MAX1668_REG_LIML_RD(i));
 
113
                if (unlikely(val < 0)) {
 
114
                        ret = ERR_PTR(val);
 
115
                        goto abort;
 
116
                }
 
117
                data->temp_min[i] = (s8) val;
 
118
        }
 
119
 
 
120
        val = i2c_smbus_read_byte_data(client, MAX1668_REG_STAT1);
 
121
        if (unlikely(val < 0)) {
 
122
                ret = ERR_PTR(val);
 
123
                goto abort;
 
124
        }
 
125
        data->alarms = val << 8;
 
126
 
 
127
        val = i2c_smbus_read_byte_data(client, MAX1668_REG_STAT2);
 
128
        if (unlikely(val < 0)) {
 
129
                ret = ERR_PTR(val);
 
130
                goto abort;
 
131
        }
 
132
        data->alarms |= val;
 
133
 
 
134
        data->last_updated = jiffies;
 
135
        data->valid = 1;
 
136
abort:
 
137
        mutex_unlock(&data->update_lock);
 
138
 
 
139
        return ret;
 
140
}
 
141
 
 
142
static ssize_t show_temp(struct device *dev,
 
143
                         struct device_attribute *devattr, char *buf)
 
144
{
 
145
        int index = to_sensor_dev_attr(devattr)->index;
 
146
        struct max1668_data *data = max1668_update_device(dev);
 
147
 
 
148
        if (IS_ERR(data))
 
149
                return PTR_ERR(data);
 
150
 
 
151
        return sprintf(buf, "%d\n", data->temp[index] * 1000);
 
152
}
 
153
 
 
154
static ssize_t show_temp_max(struct device *dev,
 
155
                             struct device_attribute *devattr, char *buf)
 
156
{
 
157
        int index = to_sensor_dev_attr(devattr)->index;
 
158
        struct max1668_data *data = max1668_update_device(dev);
 
159
 
 
160
        if (IS_ERR(data))
 
161
                return PTR_ERR(data);
 
162
 
 
163
        return sprintf(buf, "%d\n", data->temp_max[index] * 1000);
 
164
}
 
165
 
 
166
static ssize_t show_temp_min(struct device *dev,
 
167
                             struct device_attribute *devattr, char *buf)
 
168
{
 
169
        int index = to_sensor_dev_attr(devattr)->index;
 
170
        struct max1668_data *data = max1668_update_device(dev);
 
171
 
 
172
        if (IS_ERR(data))
 
173
                return PTR_ERR(data);
 
174
 
 
175
        return sprintf(buf, "%d\n", data->temp_min[index] * 1000);
 
176
}
 
177
 
 
178
static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
 
179
                          char *buf)
 
180
{
 
181
        int index = to_sensor_dev_attr(attr)->index;
 
182
        struct max1668_data *data = max1668_update_device(dev);
 
183
 
 
184
        if (IS_ERR(data))
 
185
                return PTR_ERR(data);
 
186
 
 
187
        return sprintf(buf, "%u\n", (data->alarms >> index) & 0x1);
 
188
}
 
189
 
 
190
static ssize_t show_fault(struct device *dev,
 
191
                          struct device_attribute *devattr, char *buf)
 
192
{
 
193
        int index = to_sensor_dev_attr(devattr)->index;
 
194
        struct max1668_data *data = max1668_update_device(dev);
 
195
 
 
196
        if (IS_ERR(data))
 
197
                return PTR_ERR(data);
 
198
 
 
199
        return sprintf(buf, "%u\n",
 
200
                       (data->alarms & (1 << 12)) && data->temp[index] == 127);
 
201
}
 
202
 
 
203
static ssize_t set_temp_max(struct device *dev,
 
204
                            struct device_attribute *devattr,
 
205
                            const char *buf, size_t count)
 
206
{
 
207
        int index = to_sensor_dev_attr(devattr)->index;
 
208
        struct i2c_client *client = to_i2c_client(dev);
 
209
        struct max1668_data *data = i2c_get_clientdata(client);
 
210
        long temp;
 
211
        int ret;
 
212
 
 
213
        ret = kstrtol(buf, 10, &temp);
 
214
        if (ret < 0)
 
215
                return ret;
 
216
 
 
217
        mutex_lock(&data->update_lock);
 
218
        data->temp_max[index] = SENSORS_LIMIT(temp/1000, -128, 127);
 
219
        if (i2c_smbus_write_byte_data(client,
 
220
                                        MAX1668_REG_LIMH_WR(index),
 
221
                                        data->temp_max[index]))
 
222
                count = -EIO;
 
223
        mutex_unlock(&data->update_lock);
 
224
 
 
225
        return count;
 
226
}
 
227
 
 
228
static ssize_t set_temp_min(struct device *dev,
 
229
                            struct device_attribute *devattr,
 
230
                            const char *buf, size_t count)
 
231
{
 
232
        int index = to_sensor_dev_attr(devattr)->index;
 
233
        struct i2c_client *client = to_i2c_client(dev);
 
234
        struct max1668_data *data = i2c_get_clientdata(client);
 
235
        long temp;
 
236
        int ret;
 
237
 
 
238
        ret = kstrtol(buf, 10, &temp);
 
239
        if (ret < 0)
 
240
                return ret;
 
241
 
 
242
        mutex_lock(&data->update_lock);
 
243
        data->temp_min[index] = SENSORS_LIMIT(temp/1000, -128, 127);
 
244
        if (i2c_smbus_write_byte_data(client,
 
245
                                        MAX1668_REG_LIML_WR(index),
 
246
                                        data->temp_max[index]))
 
247
                count = -EIO;
 
248
        mutex_unlock(&data->update_lock);
 
249
 
 
250
        return count;
 
251
}
 
252
 
 
253
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
 
254
static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO, show_temp_max,
 
255
                                set_temp_max, 0);
 
256
static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO, show_temp_min,
 
257
                                set_temp_min, 0);
 
258
static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
 
259
static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO, show_temp_max,
 
260
                                set_temp_max, 1);
 
261
static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO, show_temp_min,
 
262
                                set_temp_min, 1);
 
263
static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
 
264
static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO, show_temp_max,
 
265
                                set_temp_max, 2);
 
266
static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO, show_temp_min,
 
267
                                set_temp_min, 2);
 
268
static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
 
269
static SENSOR_DEVICE_ATTR(temp4_max, S_IRUGO, show_temp_max,
 
270
                                set_temp_max, 3);
 
271
static SENSOR_DEVICE_ATTR(temp4_min, S_IRUGO, show_temp_min,
 
272
                                set_temp_min, 3);
 
273
static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp, NULL, 4);
 
274
static SENSOR_DEVICE_ATTR(temp5_max, S_IRUGO, show_temp_max,
 
275
                                set_temp_max, 4);
 
276
static SENSOR_DEVICE_ATTR(temp5_min, S_IRUGO, show_temp_min,
 
277
                                set_temp_min, 4);
 
278
 
 
279
static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 14);
 
280
static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 13);
 
281
static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 7);
 
282
static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 6);
 
283
static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 5);
 
284
static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 4);
 
285
static SENSOR_DEVICE_ATTR(temp4_min_alarm, S_IRUGO, show_alarm, NULL, 3);
 
286
static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_alarm, NULL, 2);
 
287
static SENSOR_DEVICE_ATTR(temp5_min_alarm, S_IRUGO, show_alarm, NULL, 1);
 
288
static SENSOR_DEVICE_ATTR(temp5_max_alarm, S_IRUGO, show_alarm, NULL, 0);
 
289
 
 
290
static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_fault, NULL, 1);
 
291
static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_fault, NULL, 2);
 
292
static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_fault, NULL, 3);
 
293
static SENSOR_DEVICE_ATTR(temp5_fault, S_IRUGO, show_fault, NULL, 4);
 
294
 
 
295
/* Attributes common to MAX1668, MAX1989 and MAX1805 */
 
296
static struct attribute *max1668_attribute_common[] = {
 
297
        &sensor_dev_attr_temp1_max.dev_attr.attr,
 
298
        &sensor_dev_attr_temp1_min.dev_attr.attr,
 
299
        &sensor_dev_attr_temp1_input.dev_attr.attr,
 
300
        &sensor_dev_attr_temp2_max.dev_attr.attr,
 
301
        &sensor_dev_attr_temp2_min.dev_attr.attr,
 
302
        &sensor_dev_attr_temp2_input.dev_attr.attr,
 
303
        &sensor_dev_attr_temp3_max.dev_attr.attr,
 
304
        &sensor_dev_attr_temp3_min.dev_attr.attr,
 
305
        &sensor_dev_attr_temp3_input.dev_attr.attr,
 
306
 
 
307
        &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 
308
        &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 
309
        &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 
310
        &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
 
311
        &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
 
312
        &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
 
313
 
 
314
        &sensor_dev_attr_temp2_fault.dev_attr.attr,
 
315
        &sensor_dev_attr_temp3_fault.dev_attr.attr,
 
316
        NULL
 
317
};
 
318
 
 
319
/* Attributes not present on MAX1805 */
 
320
static struct attribute *max1668_attribute_unique[] = {
 
321
        &sensor_dev_attr_temp4_max.dev_attr.attr,
 
322
        &sensor_dev_attr_temp4_min.dev_attr.attr,
 
323
        &sensor_dev_attr_temp4_input.dev_attr.attr,
 
324
        &sensor_dev_attr_temp5_max.dev_attr.attr,
 
325
        &sensor_dev_attr_temp5_min.dev_attr.attr,
 
326
        &sensor_dev_attr_temp5_input.dev_attr.attr,
 
327
 
 
328
        &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
 
329
        &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
 
330
        &sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
 
331
        &sensor_dev_attr_temp5_min_alarm.dev_attr.attr,
 
332
 
 
333
        &sensor_dev_attr_temp4_fault.dev_attr.attr,
 
334
        &sensor_dev_attr_temp5_fault.dev_attr.attr,
 
335
        NULL
 
336
};
 
337
 
 
338
static mode_t max1668_attribute_mode(struct kobject *kobj,
 
339
                                     struct attribute *attr, int index)
 
340
{
 
341
        int ret = S_IRUGO;
 
342
        if (read_only)
 
343
                return ret;
 
344
        if (attr == &sensor_dev_attr_temp1_max.dev_attr.attr ||
 
345
            attr == &sensor_dev_attr_temp2_max.dev_attr.attr ||
 
346
            attr == &sensor_dev_attr_temp3_max.dev_attr.attr ||
 
347
            attr == &sensor_dev_attr_temp4_max.dev_attr.attr ||
 
348
            attr == &sensor_dev_attr_temp5_max.dev_attr.attr ||
 
349
            attr == &sensor_dev_attr_temp1_min.dev_attr.attr ||
 
350
            attr == &sensor_dev_attr_temp2_min.dev_attr.attr ||
 
351
            attr == &sensor_dev_attr_temp3_min.dev_attr.attr ||
 
352
            attr == &sensor_dev_attr_temp4_min.dev_attr.attr ||
 
353
            attr == &sensor_dev_attr_temp5_min.dev_attr.attr)
 
354
                ret |= S_IWUSR;
 
355
        return ret;
 
356
}
 
357
 
 
358
static const struct attribute_group max1668_group_common = {
 
359
        .attrs = max1668_attribute_common,
 
360
        .is_visible = max1668_attribute_mode
 
361
};
 
362
 
 
363
static const struct attribute_group max1668_group_unique = {
 
364
        .attrs = max1668_attribute_unique,
 
365
        .is_visible = max1668_attribute_mode
 
366
};
 
367
 
 
368
/* Return 0 if detection is successful, -ENODEV otherwise */
 
369
static int max1668_detect(struct i2c_client *client,
 
370
                          struct i2c_board_info *info)
 
371
{
 
372
        struct i2c_adapter *adapter = client->adapter;
 
373
        const char *type_name;
 
374
        int man_id, dev_id;
 
375
 
 
376
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 
377
                return -ENODEV;
 
378
 
 
379
        /* Check for unsupported part */
 
380
        man_id = i2c_smbus_read_byte_data(client, MAX1668_REG_MAN_ID);
 
381
        if (man_id != MAN_ID_MAXIM)
 
382
                return -ENODEV;
 
383
 
 
384
        dev_id = i2c_smbus_read_byte_data(client, MAX1668_REG_DEV_ID);
 
385
        if (dev_id < 0)
 
386
                return -ENODEV;
 
387
 
 
388
        type_name = NULL;
 
389
        if (dev_id == DEV_ID_MAX1668)
 
390
                type_name = "max1668";
 
391
        else if (dev_id == DEV_ID_MAX1805)
 
392
                type_name = "max1805";
 
393
        else if (dev_id == DEV_ID_MAX1989)
 
394
                type_name = "max1989";
 
395
 
 
396
        if (!type_name)
 
397
                return -ENODEV;
 
398
 
 
399
        strlcpy(info->type, type_name, I2C_NAME_SIZE);
 
400
 
 
401
        return 0;
 
402
}
 
403
 
 
404
static int max1668_probe(struct i2c_client *client,
 
405
                         const struct i2c_device_id *id)
 
406
{
 
407
        struct i2c_adapter *adapter = client->adapter;
 
408
        struct max1668_data *data;
 
409
        int err;
 
410
 
 
411
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 
412
                return -ENODEV;
 
413
 
 
414
        data = kzalloc(sizeof(struct max1668_data), GFP_KERNEL);
 
415
        if (!data)
 
416
                return -ENOMEM;
 
417
 
 
418
        i2c_set_clientdata(client, data);
 
419
        data->type = id->driver_data;
 
420
        mutex_init(&data->update_lock);
 
421
 
 
422
        /* Register sysfs hooks */
 
423
        err = sysfs_create_group(&client->dev.kobj, &max1668_group_common);
 
424
        if (err)
 
425
                goto error_free;
 
426
 
 
427
        if (data->type == max1668 || data->type == max1989) {
 
428
                err = sysfs_create_group(&client->dev.kobj,
 
429
                                         &max1668_group_unique);
 
430
                if (err)
 
431
                        goto error_sysrem0;
 
432
        }
 
433
 
 
434
        data->hwmon_dev = hwmon_device_register(&client->dev);
 
435
        if (IS_ERR(data->hwmon_dev)) {
 
436
                err = PTR_ERR(data->hwmon_dev);
 
437
                goto error_sysrem1;
 
438
        }
 
439
 
 
440
        return 0;
 
441
 
 
442
error_sysrem1:
 
443
        if (data->type == max1668 || data->type == max1989)
 
444
                sysfs_remove_group(&client->dev.kobj, &max1668_group_unique);
 
445
error_sysrem0:
 
446
        sysfs_remove_group(&client->dev.kobj, &max1668_group_common);
 
447
error_free:
 
448
        kfree(data);
 
449
        return err;
 
450
}
 
451
 
 
452
static int max1668_remove(struct i2c_client *client)
 
453
{
 
454
        struct max1668_data *data = i2c_get_clientdata(client);
 
455
 
 
456
        hwmon_device_unregister(data->hwmon_dev);
 
457
        if (data->type == max1668 || data->type == max1989)
 
458
                sysfs_remove_group(&client->dev.kobj, &max1668_group_unique);
 
459
 
 
460
        sysfs_remove_group(&client->dev.kobj, &max1668_group_common);
 
461
 
 
462
        kfree(data);
 
463
        return 0;
 
464
}
 
465
 
 
466
static const struct i2c_device_id max1668_id[] = {
 
467
        { "max1668", max1668 },
 
468
        { "max1805", max1805 },
 
469
        { "max1989", max1989 },
 
470
        { }
 
471
};
 
472
MODULE_DEVICE_TABLE(i2c, max1668_id);
 
473
 
 
474
/* This is the driver that will be inserted */
 
475
static struct i2c_driver max1668_driver = {
 
476
        .class = I2C_CLASS_HWMON,
 
477
        .driver = {
 
478
                  .name = "max1668",
 
479
                  },
 
480
        .probe = max1668_probe,
 
481
        .remove = max1668_remove,
 
482
        .id_table = max1668_id,
 
483
        .detect = max1668_detect,
 
484
        .address_list = max1668_addr_list,
 
485
};
 
486
 
 
487
static int __init sensors_max1668_init(void)
 
488
{
 
489
        return i2c_add_driver(&max1668_driver);
 
490
}
 
491
 
 
492
static void __exit sensors_max1668_exit(void)
 
493
{
 
494
        i2c_del_driver(&max1668_driver);
 
495
}
 
496
 
 
497
MODULE_AUTHOR("David George <david.george@ska.ac.za>");
 
498
MODULE_DESCRIPTION("MAX1668 remote temperature sensor driver");
 
499
MODULE_LICENSE("GPL");
 
500
 
 
501
module_init(sensors_max1668_init)
 
502
module_exit(sensors_max1668_exit)