Commit | Line | Data |
---|---|---|
5b46903d GR |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * Hwmon client for disk and solid state drives with temperature sensors | |
4 | * Copyright (C) 2019 Zodiac Inflight Innovations | |
5 | * | |
6 | * With input from: | |
7 | * Hwmon client for S.M.A.R.T. hard disk drives with temperature sensors. | |
8 | * (C) 2018 Linus Walleij | |
9 | * | |
10 | * hwmon: Driver for SCSI/ATA temperature sensors | |
11 | * by Constantin Baranov <const@mimas.ru>, submitted September 2009 | |
12 | * | |
13 | * This drive supports reporting the temperatire of SATA drives. It can be | |
14 | * easily extended to report the temperature of SCSI drives. | |
15 | * | |
16 | * The primary means to read drive temperatures and temperature limits | |
17 | * for ATA drives is the SCT Command Transport feature set as specified in | |
18 | * ATA8-ACS. | |
19 | * It can be used to read the current drive temperature, temperature limits, | |
20 | * and historic minimum and maximum temperatures. The SCT Command Transport | |
21 | * feature set is documented in "AT Attachment 8 - ATA/ATAPI Command Set | |
22 | * (ATA8-ACS)". | |
23 | * | |
24 | * If the SCT Command Transport feature set is not available, drive temperatures | |
25 | * may be readable through SMART attributes. Since SMART attributes are not well | |
26 | * defined, this method is only used as fallback mechanism. | |
27 | * | |
28 | * There are three SMART attributes which may report drive temperatures. | |
29 | * Those are defined as follows (from | |
30 | * http://www.cropel.com/library/smart-attribute-list.aspx). | |
31 | * | |
32 | * 190 Temperature Temperature, monitored by a sensor somewhere inside | |
33 | * the drive. Raw value typicaly holds the actual | |
34 | * temperature (hexadecimal) in its rightmost two digits. | |
35 | * | |
36 | * 194 Temperature Temperature, monitored by a sensor somewhere inside | |
37 | * the drive. Raw value typicaly holds the actual | |
38 | * temperature (hexadecimal) in its rightmost two digits. | |
39 | * | |
40 | * 231 Temperature Temperature, monitored by a sensor somewhere inside | |
41 | * the drive. Raw value typicaly holds the actual | |
42 | * temperature (hexadecimal) in its rightmost two digits. | |
43 | * | |
44 | * Wikipedia defines attributes a bit differently. | |
45 | * | |
46 | * 190 Temperature Value is equal to (100-temp. °C), allowing manufacturer | |
47 | * Difference or to set a minimum threshold which corresponds to a | |
48 | * Airflow maximum temperature. This also follows the convention of | |
49 | * Temperature 100 being a best-case value and lower values being | |
50 | * undesirable. However, some older drives may instead | |
51 | * report raw Temperature (identical to 0xC2) or | |
52 | * Temperature minus 50 here. | |
53 | * 194 Temperature or Indicates the device temperature, if the appropriate | |
54 | * Temperature sensor is fitted. Lowest byte of the raw value contains | |
55 | * Celsius the exact temperature value (Celsius degrees). | |
56 | * 231 Life Left Indicates the approximate SSD life left, in terms of | |
57 | * (SSDs) or program/erase cycles or available reserved blocks. | |
58 | * Temperature A normalized value of 100 represents a new drive, with | |
59 | * a threshold value at 10 indicating a need for | |
60 | * replacement. A value of 0 may mean that the drive is | |
61 | * operating in read-only mode to allow data recovery. | |
62 | * Previously (pre-2010) occasionally used for Drive | |
63 | * Temperature (more typically reported at 0xC2). | |
64 | * | |
65 | * Common denominator is that the first raw byte reports the temperature | |
66 | * in degrees C on almost all drives. Some drives may report a fractional | |
67 | * temperature in the second raw byte. | |
68 | * | |
69 | * Known exceptions (from libatasmart): | |
70 | * - SAMSUNG SV0412H and SAMSUNG SV1204H) report the temperature in 10th | |
71 | * degrees C in the first two raw bytes. | |
72 | * - A few Maxtor drives report an unknown or bad value in attribute 194. | |
73 | * - Certain Apple SSD drives report an unknown value in attribute 190. | |
74 | * Only certain firmware versions are affected. | |
75 | * | |
76 | * Those exceptions affect older ATA drives and are currently ignored. | |
77 | * Also, the second raw byte (possibly reporting the fractional temperature) | |
78 | * is currently ignored. | |
79 | * | |
80 | * Many drives also report temperature limits in additional SMART data raw | |
81 | * bytes. The format of those is not well defined and varies widely. | |
82 | * The driver does not currently attempt to report those limits. | |
83 | * | |
84 | * According to data in smartmontools, attribute 231 is rarely used to report | |
85 | * drive temperatures. At the same time, several drives report SSD life left | |
86 | * in attribute 231, but do not support temperature sensors. For this reason, | |
87 | * attribute 231 is currently ignored. | |
88 | * | |
89 | * Following above definitions, temperatures are reported as follows. | |
90 | * If SCT Command Transport is supported, it is used to read the | |
91 | * temperature and, if available, temperature limits. | |
92 | * - Otherwise, if SMART attribute 194 is supported, it is used to read | |
93 | * the temperature. | |
94 | * - Otherwise, if SMART attribute 190 is supported, it is used to read | |
95 | * the temperature. | |
96 | */ | |
97 | ||
98 | #include <linux/ata.h> | |
99 | #include <linux/bits.h> | |
100 | #include <linux/device.h> | |
101 | #include <linux/hwmon.h> | |
102 | #include <linux/kernel.h> | |
103 | #include <linux/list.h> | |
104 | #include <linux/module.h> | |
105 | #include <linux/mutex.h> | |
106 | #include <scsi/scsi_cmnd.h> | |
107 | #include <scsi/scsi_device.h> | |
108 | #include <scsi/scsi_driver.h> | |
109 | #include <scsi/scsi_proto.h> | |
110 | ||
111 | struct drivetemp_data { | |
112 | struct list_head list; /* list of instantiated devices */ | |
113 | struct mutex lock; /* protect data buffer accesses */ | |
114 | struct scsi_device *sdev; /* SCSI device */ | |
115 | struct device *dev; /* instantiating device */ | |
116 | struct device *hwdev; /* hardware monitoring device */ | |
117 | u8 smartdata[ATA_SECT_SIZE]; /* local buffer */ | |
118 | int (*get_temp)(struct drivetemp_data *st, u32 attr, long *val); | |
119 | bool have_temp_lowest; /* lowest temp in SCT status */ | |
120 | bool have_temp_highest; /* highest temp in SCT status */ | |
121 | bool have_temp_min; /* have min temp */ | |
122 | bool have_temp_max; /* have max temp */ | |
123 | bool have_temp_lcrit; /* have lower critical limit */ | |
124 | bool have_temp_crit; /* have critical limit */ | |
125 | int temp_min; /* min temp */ | |
126 | int temp_max; /* max temp */ | |
127 | int temp_lcrit; /* lower critical limit */ | |
128 | int temp_crit; /* critical limit */ | |
129 | }; | |
130 | ||
131 | static LIST_HEAD(drivetemp_devlist); | |
132 | ||
133 | #define ATA_MAX_SMART_ATTRS 30 | |
134 | #define SMART_TEMP_PROP_190 190 | |
135 | #define SMART_TEMP_PROP_194 194 | |
136 | ||
137 | #define SCT_STATUS_REQ_ADDR 0xe0 | |
138 | #define SCT_STATUS_VERSION_LOW 0 /* log byte offsets */ | |
139 | #define SCT_STATUS_VERSION_HIGH 1 | |
140 | #define SCT_STATUS_TEMP 200 | |
141 | #define SCT_STATUS_TEMP_LOWEST 201 | |
142 | #define SCT_STATUS_TEMP_HIGHEST 202 | |
143 | #define SCT_READ_LOG_ADDR 0xe1 | |
144 | #define SMART_READ_LOG 0xd5 | |
145 | #define SMART_WRITE_LOG 0xd6 | |
146 | ||
147 | #define INVALID_TEMP 0x80 | |
148 | ||
149 | #define temp_is_valid(temp) ((temp) != INVALID_TEMP) | |
150 | #define temp_from_sct(temp) (((s8)(temp)) * 1000) | |
151 | ||
152 | static inline bool ata_id_smart_supported(u16 *id) | |
153 | { | |
154 | return id[ATA_ID_COMMAND_SET_1] & BIT(0); | |
155 | } | |
156 | ||
157 | static inline bool ata_id_smart_enabled(u16 *id) | |
158 | { | |
159 | return id[ATA_ID_CFS_ENABLE_1] & BIT(0); | |
160 | } | |
161 | ||
162 | static int drivetemp_scsi_command(struct drivetemp_data *st, | |
163 | u8 ata_command, u8 feature, | |
164 | u8 lba_low, u8 lba_mid, u8 lba_high) | |
165 | { | |
166 | u8 scsi_cmd[MAX_COMMAND_SIZE]; | |
167 | int data_dir; | |
168 | ||
169 | memset(scsi_cmd, 0, sizeof(scsi_cmd)); | |
170 | scsi_cmd[0] = ATA_16; | |
171 | if (ata_command == ATA_CMD_SMART && feature == SMART_WRITE_LOG) { | |
172 | scsi_cmd[1] = (5 << 1); /* PIO Data-out */ | |
173 | /* | |
174 | * No off.line or cc, write to dev, block count in sector count | |
175 | * field. | |
176 | */ | |
177 | scsi_cmd[2] = 0x06; | |
178 | data_dir = DMA_TO_DEVICE; | |
179 | } else { | |
180 | scsi_cmd[1] = (4 << 1); /* PIO Data-in */ | |
181 | /* | |
182 | * No off.line or cc, read from dev, block count in sector count | |
183 | * field. | |
184 | */ | |
185 | scsi_cmd[2] = 0x0e; | |
186 | data_dir = DMA_FROM_DEVICE; | |
187 | } | |
188 | scsi_cmd[4] = feature; | |
189 | scsi_cmd[6] = 1; /* 1 sector */ | |
190 | scsi_cmd[8] = lba_low; | |
191 | scsi_cmd[10] = lba_mid; | |
192 | scsi_cmd[12] = lba_high; | |
193 | scsi_cmd[14] = ata_command; | |
194 | ||
195 | return scsi_execute_req(st->sdev, scsi_cmd, data_dir, | |
196 | st->smartdata, ATA_SECT_SIZE, NULL, HZ, 5, | |
197 | NULL); | |
198 | } | |
199 | ||
200 | static int drivetemp_ata_command(struct drivetemp_data *st, u8 feature, | |
201 | u8 select) | |
202 | { | |
203 | return drivetemp_scsi_command(st, ATA_CMD_SMART, feature, select, | |
204 | ATA_SMART_LBAM_PASS, ATA_SMART_LBAH_PASS); | |
205 | } | |
206 | ||
207 | static int drivetemp_get_smarttemp(struct drivetemp_data *st, u32 attr, | |
208 | long *temp) | |
209 | { | |
210 | u8 *buf = st->smartdata; | |
211 | bool have_temp = false; | |
212 | u8 temp_raw; | |
213 | u8 csum; | |
214 | int err; | |
215 | int i; | |
216 | ||
217 | err = drivetemp_ata_command(st, ATA_SMART_READ_VALUES, 0); | |
218 | if (err) | |
219 | return err; | |
220 | ||
221 | /* Checksum the read value table */ | |
222 | csum = 0; | |
223 | for (i = 0; i < ATA_SECT_SIZE; i++) | |
224 | csum += buf[i]; | |
225 | if (csum) { | |
226 | dev_dbg(&st->sdev->sdev_gendev, | |
227 | "checksum error reading SMART values\n"); | |
228 | return -EIO; | |
229 | } | |
230 | ||
231 | for (i = 0; i < ATA_MAX_SMART_ATTRS; i++) { | |
232 | u8 *attr = buf + i * 12; | |
233 | int id = attr[2]; | |
234 | ||
235 | if (!id) | |
236 | continue; | |
237 | ||
238 | if (id == SMART_TEMP_PROP_190) { | |
239 | temp_raw = attr[7]; | |
240 | have_temp = true; | |
241 | } | |
242 | if (id == SMART_TEMP_PROP_194) { | |
243 | temp_raw = attr[7]; | |
244 | have_temp = true; | |
245 | break; | |
246 | } | |
247 | } | |
248 | ||
249 | if (have_temp) { | |
250 | *temp = temp_raw * 1000; | |
251 | return 0; | |
252 | } | |
253 | ||
254 | return -ENXIO; | |
255 | } | |
256 | ||
257 | static int drivetemp_get_scttemp(struct drivetemp_data *st, u32 attr, long *val) | |
258 | { | |
259 | u8 *buf = st->smartdata; | |
260 | int err; | |
261 | ||
262 | err = drivetemp_ata_command(st, SMART_READ_LOG, SCT_STATUS_REQ_ADDR); | |
263 | if (err) | |
264 | return err; | |
265 | switch (attr) { | |
266 | case hwmon_temp_input: | |
267 | *val = temp_from_sct(buf[SCT_STATUS_TEMP]); | |
268 | break; | |
269 | case hwmon_temp_lowest: | |
270 | *val = temp_from_sct(buf[SCT_STATUS_TEMP_LOWEST]); | |
271 | break; | |
272 | case hwmon_temp_highest: | |
273 | *val = temp_from_sct(buf[SCT_STATUS_TEMP_HIGHEST]); | |
274 | break; | |
275 | default: | |
276 | err = -EINVAL; | |
277 | break; | |
278 | } | |
279 | return err; | |
280 | } | |
281 | ||
282 | static int drivetemp_identify_sata(struct drivetemp_data *st) | |
283 | { | |
284 | struct scsi_device *sdev = st->sdev; | |
285 | u8 *buf = st->smartdata; | |
286 | struct scsi_vpd *vpd; | |
287 | bool is_ata, is_sata; | |
288 | bool have_sct_data_table; | |
289 | bool have_sct_temp; | |
290 | bool have_smart; | |
291 | bool have_sct; | |
292 | u16 *ata_id; | |
293 | u16 version; | |
294 | long temp; | |
295 | int err; | |
296 | ||
297 | /* SCSI-ATA Translation present? */ | |
298 | rcu_read_lock(); | |
299 | vpd = rcu_dereference(sdev->vpd_pg89); | |
300 | ||
301 | /* | |
302 | * Verify that ATA IDENTIFY DEVICE data is included in ATA Information | |
303 | * VPD and that the drive implements the SATA protocol. | |
304 | */ | |
305 | if (!vpd || vpd->len < 572 || vpd->data[56] != ATA_CMD_ID_ATA || | |
306 | vpd->data[36] != 0x34) { | |
307 | rcu_read_unlock(); | |
308 | return -ENODEV; | |
309 | } | |
310 | ata_id = (u16 *)&vpd->data[60]; | |
311 | is_ata = ata_id_is_ata(ata_id); | |
312 | is_sata = ata_id_is_sata(ata_id); | |
313 | have_sct = ata_id_sct_supported(ata_id); | |
314 | have_sct_data_table = ata_id_sct_data_tables(ata_id); | |
315 | have_smart = ata_id_smart_supported(ata_id) && | |
316 | ata_id_smart_enabled(ata_id); | |
317 | ||
318 | rcu_read_unlock(); | |
319 | ||
320 | /* bail out if this is not a SATA device */ | |
321 | if (!is_ata || !is_sata) | |
322 | return -ENODEV; | |
323 | if (!have_sct) | |
324 | goto skip_sct; | |
325 | ||
326 | err = drivetemp_ata_command(st, SMART_READ_LOG, SCT_STATUS_REQ_ADDR); | |
327 | if (err) | |
328 | goto skip_sct; | |
329 | ||
330 | version = (buf[SCT_STATUS_VERSION_HIGH] << 8) | | |
331 | buf[SCT_STATUS_VERSION_LOW]; | |
332 | if (version != 2 && version != 3) | |
333 | goto skip_sct; | |
334 | ||
335 | have_sct_temp = temp_is_valid(buf[SCT_STATUS_TEMP]); | |
336 | if (!have_sct_temp) | |
337 | goto skip_sct; | |
338 | ||
339 | st->have_temp_lowest = temp_is_valid(buf[SCT_STATUS_TEMP_LOWEST]); | |
340 | st->have_temp_highest = temp_is_valid(buf[SCT_STATUS_TEMP_HIGHEST]); | |
341 | ||
342 | if (!have_sct_data_table) | |
343 | goto skip_sct; | |
344 | ||
345 | /* Request and read temperature history table */ | |
346 | memset(buf, '\0', sizeof(st->smartdata)); | |
347 | buf[0] = 5; /* data table command */ | |
348 | buf[2] = 1; /* read table */ | |
349 | buf[4] = 2; /* temperature history table */ | |
350 | ||
351 | err = drivetemp_ata_command(st, SMART_WRITE_LOG, SCT_STATUS_REQ_ADDR); | |
352 | if (err) | |
353 | goto skip_sct_data; | |
354 | ||
355 | err = drivetemp_ata_command(st, SMART_READ_LOG, SCT_READ_LOG_ADDR); | |
356 | if (err) | |
357 | goto skip_sct_data; | |
358 | ||
359 | /* | |
360 | * Temperature limits per AT Attachment 8 - | |
361 | * ATA/ATAPI Command Set (ATA8-ACS) | |
362 | */ | |
363 | st->have_temp_max = temp_is_valid(buf[6]); | |
364 | st->have_temp_crit = temp_is_valid(buf[7]); | |
365 | st->have_temp_min = temp_is_valid(buf[8]); | |
366 | st->have_temp_lcrit = temp_is_valid(buf[9]); | |
367 | ||
368 | st->temp_max = temp_from_sct(buf[6]); | |
369 | st->temp_crit = temp_from_sct(buf[7]); | |
370 | st->temp_min = temp_from_sct(buf[8]); | |
371 | st->temp_lcrit = temp_from_sct(buf[9]); | |
372 | ||
373 | skip_sct_data: | |
374 | if (have_sct_temp) { | |
375 | st->get_temp = drivetemp_get_scttemp; | |
376 | return 0; | |
377 | } | |
378 | skip_sct: | |
379 | if (!have_smart) | |
380 | return -ENODEV; | |
381 | st->get_temp = drivetemp_get_smarttemp; | |
382 | return drivetemp_get_smarttemp(st, hwmon_temp_input, &temp); | |
383 | } | |
384 | ||
385 | static int drivetemp_identify(struct drivetemp_data *st) | |
386 | { | |
387 | struct scsi_device *sdev = st->sdev; | |
388 | ||
389 | /* Bail out immediately if there is no inquiry data */ | |
390 | if (!sdev->inquiry || sdev->inquiry_len < 16) | |
391 | return -ENODEV; | |
392 | ||
393 | /* Disk device? */ | |
394 | if (sdev->type != TYPE_DISK && sdev->type != TYPE_ZBC) | |
395 | return -ENODEV; | |
396 | ||
397 | return drivetemp_identify_sata(st); | |
398 | } | |
399 | ||
400 | static int drivetemp_read(struct device *dev, enum hwmon_sensor_types type, | |
401 | u32 attr, int channel, long *val) | |
402 | { | |
403 | struct drivetemp_data *st = dev_get_drvdata(dev); | |
404 | int err = 0; | |
405 | ||
406 | if (type != hwmon_temp) | |
407 | return -EINVAL; | |
408 | ||
409 | switch (attr) { | |
410 | case hwmon_temp_input: | |
411 | case hwmon_temp_lowest: | |
412 | case hwmon_temp_highest: | |
413 | mutex_lock(&st->lock); | |
414 | err = st->get_temp(st, attr, val); | |
415 | mutex_unlock(&st->lock); | |
416 | break; | |
417 | case hwmon_temp_lcrit: | |
418 | *val = st->temp_lcrit; | |
419 | break; | |
420 | case hwmon_temp_min: | |
421 | *val = st->temp_min; | |
422 | break; | |
423 | case hwmon_temp_max: | |
424 | *val = st->temp_max; | |
425 | break; | |
426 | case hwmon_temp_crit: | |
427 | *val = st->temp_crit; | |
428 | break; | |
429 | default: | |
430 | err = -EINVAL; | |
431 | break; | |
432 | } | |
433 | return err; | |
434 | } | |
435 | ||
436 | static umode_t drivetemp_is_visible(const void *data, | |
437 | enum hwmon_sensor_types type, | |
438 | u32 attr, int channel) | |
439 | { | |
440 | const struct drivetemp_data *st = data; | |
441 | ||
442 | switch (type) { | |
443 | case hwmon_temp: | |
444 | switch (attr) { | |
445 | case hwmon_temp_input: | |
446 | return 0444; | |
447 | case hwmon_temp_lowest: | |
448 | if (st->have_temp_lowest) | |
449 | return 0444; | |
450 | break; | |
451 | case hwmon_temp_highest: | |
452 | if (st->have_temp_highest) | |
453 | return 0444; | |
454 | break; | |
455 | case hwmon_temp_min: | |
456 | if (st->have_temp_min) | |
457 | return 0444; | |
458 | break; | |
459 | case hwmon_temp_max: | |
460 | if (st->have_temp_max) | |
461 | return 0444; | |
462 | break; | |
463 | case hwmon_temp_lcrit: | |
464 | if (st->have_temp_lcrit) | |
465 | return 0444; | |
466 | break; | |
467 | case hwmon_temp_crit: | |
468 | if (st->have_temp_crit) | |
469 | return 0444; | |
470 | break; | |
471 | default: | |
472 | break; | |
473 | } | |
474 | break; | |
475 | default: | |
476 | break; | |
477 | } | |
478 | return 0; | |
479 | } | |
480 | ||
481 | static const struct hwmon_channel_info *drivetemp_info[] = { | |
482 | HWMON_CHANNEL_INFO(chip, | |
483 | HWMON_C_REGISTER_TZ), | |
484 | HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT | | |
485 | HWMON_T_LOWEST | HWMON_T_HIGHEST | | |
486 | HWMON_T_MIN | HWMON_T_MAX | | |
487 | HWMON_T_LCRIT | HWMON_T_CRIT), | |
488 | NULL | |
489 | }; | |
490 | ||
491 | static const struct hwmon_ops drivetemp_ops = { | |
492 | .is_visible = drivetemp_is_visible, | |
493 | .read = drivetemp_read, | |
494 | }; | |
495 | ||
496 | static const struct hwmon_chip_info drivetemp_chip_info = { | |
497 | .ops = &drivetemp_ops, | |
498 | .info = drivetemp_info, | |
499 | }; | |
500 | ||
501 | /* | |
502 | * The device argument points to sdev->sdev_dev. Its parent is | |
503 | * sdev->sdev_gendev, which we can use to get the scsi_device pointer. | |
504 | */ | |
505 | static int drivetemp_add(struct device *dev, struct class_interface *intf) | |
506 | { | |
507 | struct scsi_device *sdev = to_scsi_device(dev->parent); | |
508 | struct drivetemp_data *st; | |
509 | int err; | |
510 | ||
511 | st = kzalloc(sizeof(*st), GFP_KERNEL); | |
512 | if (!st) | |
513 | return -ENOMEM; | |
514 | ||
515 | st->sdev = sdev; | |
516 | st->dev = dev; | |
517 | mutex_init(&st->lock); | |
518 | ||
519 | if (drivetemp_identify(st)) { | |
520 | err = -ENODEV; | |
521 | goto abort; | |
522 | } | |
523 | ||
524 | st->hwdev = hwmon_device_register_with_info(dev->parent, "drivetemp", | |
525 | st, &drivetemp_chip_info, | |
526 | NULL); | |
527 | if (IS_ERR(st->hwdev)) { | |
528 | err = PTR_ERR(st->hwdev); | |
529 | goto abort; | |
530 | } | |
531 | ||
532 | list_add(&st->list, &drivetemp_devlist); | |
533 | return 0; | |
534 | ||
535 | abort: | |
536 | kfree(st); | |
537 | return err; | |
538 | } | |
539 | ||
540 | static void drivetemp_remove(struct device *dev, struct class_interface *intf) | |
541 | { | |
542 | struct drivetemp_data *st, *tmp; | |
543 | ||
544 | list_for_each_entry_safe(st, tmp, &drivetemp_devlist, list) { | |
545 | if (st->dev == dev) { | |
546 | list_del(&st->list); | |
547 | hwmon_device_unregister(st->hwdev); | |
548 | kfree(st); | |
549 | break; | |
550 | } | |
551 | } | |
552 | } | |
553 | ||
554 | static struct class_interface drivetemp_interface = { | |
555 | .add_dev = drivetemp_add, | |
556 | .remove_dev = drivetemp_remove, | |
557 | }; | |
558 | ||
559 | static int __init drivetemp_init(void) | |
560 | { | |
561 | return scsi_register_interface(&drivetemp_interface); | |
562 | } | |
563 | ||
564 | static void __exit drivetemp_exit(void) | |
565 | { | |
566 | scsi_unregister_interface(&drivetemp_interface); | |
567 | } | |
568 | ||
569 | module_init(drivetemp_init); | |
570 | module_exit(drivetemp_exit); | |
571 | ||
572 | MODULE_AUTHOR("Guenter Roeck <linus@roeck-us.net>"); | |
573 | MODULE_DESCRIPTION("Hard drive temperature monitor"); | |
574 | MODULE_LICENSE("GPL"); |