![[BACK]](/icons/back.gif){kind=icon}
Return to ses.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / scsi|
Return to ses.c CVS log | Up to [local] / sys / scsi |
1.1 nbrk 1: /* $OpenBSD: ses.c,v 1.45 2007/06/24 05:34:35 dlg Exp $ */
2:
3: /*
4: * Copyright (c) 2005 David Gwynne <dlg@openbsd.org>
5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: #include "bio.h"
20:
21: #include <sys/param.h>
22: #include <sys/systm.h>
23: #include <sys/device.h>
24: #include <sys/scsiio.h>
25: #include <sys/malloc.h>
26: #include <sys/proc.h>
27: #include <sys/rwlock.h>
28: #include <sys/queue.h>
29: #include <sys/sensors.h>
30:
31: #if NBIO > 0
32: #include <dev/biovar.h>
33: #endif
34:
35: #include <scsi/scsi_all.h>
36: #include <scsi/scsiconf.h>
37:
38: #include <scsi/ses.h>
39:
40: #ifdef SES_DEBUG
41: #define DPRINTF(x...) do { if (sesdebug) printf(x); } while (0)
42: #define DPRINTFN(n, x...) do { if (sesdebug > (n)) printf(x); } while (0)
43: int sesdebug = 2;
44: #else
45: #define DPRINTF(x...) /* x */
46: #define DPRINTFN(n,x...) /* n: x */
47: #endif
48:
49: int ses_match(struct device *, void *, void *);
50: void ses_attach(struct device *, struct device *, void *);
51: int ses_detach(struct device *, int);
52:
53: struct ses_sensor {
54: struct ksensor se_sensor;
55: u_int8_t se_type;
56: struct ses_status *se_stat;
57:
58: TAILQ_ENTRY(ses_sensor) se_entry;
59: };
60:
61: #if NBIO > 0
62: struct ses_slot {
63: struct ses_status *sl_stat;
64:
65: TAILQ_ENTRY(ses_slot) sl_entry;
66: };
67: #endif
68:
69: struct ses_softc {
70: struct device sc_dev;
71: struct scsi_link *sc_link;
72: struct rwlock sc_lock;
73:
74: enum {
75: SES_ENC_STD,
76: SES_ENC_DELL
77: } sc_enctype;
78:
79: u_char *sc_buf;
80: ssize_t sc_buflen;
81:
82: #if NBIO > 0
83: TAILQ_HEAD(, ses_slot) sc_slots;
84: #endif
85: TAILQ_HEAD(, ses_sensor) sc_sensors;
86: struct ksensordev sc_sensordev;
87: struct sensor_task *sc_sensortask;
88: };
89:
90: struct cfattach ses_ca = {
91: sizeof(struct ses_softc), ses_match, ses_attach, ses_detach
92: };
93:
94: struct cfdriver ses_cd = {
95: NULL, "ses", DV_DULL
96: };
97:
98: #define DEVNAME(s) ((s)->sc_dev.dv_xname)
99:
100: #define SES_BUFLEN 2048 /* XXX is this enough? */
101:
102: int ses_read_config(struct ses_softc *);
103: int ses_read_status(struct ses_softc *);
104: int ses_make_sensors(struct ses_softc *, struct ses_type_desc *, int);
105: void ses_refresh_sensors(void *);
106:
107: #if NBIO > 0
108: int ses_ioctl(struct device *, u_long, caddr_t);
109: int ses_write_config(struct ses_softc *);
110: int ses_bio_blink(struct ses_softc *, struct bioc_blink *);
111: #endif
112:
113: void ses_psu2sensor(struct ses_softc *, struct ses_sensor *);
114: void ses_cool2sensor(struct ses_softc *, struct ses_sensor *);
115: void ses_temp2sensor(struct ses_softc *, struct ses_sensor *);
116:
117: #ifdef SES_DEBUG
118: void ses_dump_enc_desc(struct ses_enc_desc *);
119: char *ses_dump_enc_string(u_char *, ssize_t);
120: #endif
121:
122: int
123: ses_match(struct device *parent, void *match, void *aux)
124: {
125: struct scsi_attach_args *sa = aux;
126: struct scsi_inquiry_data *inq = sa->sa_inqbuf;
127:
128: if (inq == NULL)
129: return (0);
130:
131: if ((inq->device & SID_TYPE) == T_ENCLOSURE &&
132: SCSISPC(inq->version) >= 2)
133: return (2);
134:
135: /* match on dell enclosures */
136: if ((inq->device & SID_TYPE) == T_PROCESSOR &&
137: SCSISPC(inq->version) == 3)
138: return (3);
139:
140: return (0);
141: }
142:
143: void
144: ses_attach(struct device *parent, struct device *self, void *aux)
145: {
146: struct ses_softc *sc = (struct ses_softc *)self;
147: struct scsi_attach_args *sa = aux;
148: char vendor[33];
149: struct ses_sensor *sensor;
150: #if NBIO > 0
151: struct ses_slot *slot;
152: #endif
153:
154: sc->sc_link = sa->sa_sc_link;
155: sa->sa_sc_link->device_softc = sc;
156: rw_init(&sc->sc_lock, DEVNAME(sc));
157:
158: scsi_strvis(vendor, sc->sc_link->inqdata.vendor,
159: sizeof(sc->sc_link->inqdata.vendor));
160: if (strncasecmp(vendor, "Dell", sizeof(vendor)) == 0)
161: sc->sc_enctype = SES_ENC_DELL;
162: else
163: sc->sc_enctype = SES_ENC_STD;
164:
165: printf("\n");
166:
167: if (ses_read_config(sc) != 0) {
168: printf("%s: unable to read enclosure configuration\n",
169: DEVNAME(sc));
170: return;
171: }
172:
173: if (!TAILQ_EMPTY(&sc->sc_sensors)) {
174: sc->sc_sensortask = sensor_task_register(sc,
175: ses_refresh_sensors, 10);
176: if (sc->sc_sensortask == NULL) {
177: printf("%s: unable to register update task\n",
178: DEVNAME(sc));
179: while (!TAILQ_EMPTY(&sc->sc_sensors)) {
180: sensor = TAILQ_FIRST(&sc->sc_sensors);
181: TAILQ_REMOVE(&sc->sc_sensors, sensor,
182: se_entry);
183: free(sensor, M_DEVBUF);
184: }
185: } else {
186: TAILQ_FOREACH(sensor, &sc->sc_sensors, se_entry)
187: sensor_attach(&sc->sc_sensordev,
188: &sensor->se_sensor);
189: sensordev_install(&sc->sc_sensordev);
190: }
191: }
192:
193: #if NBIO > 0
194: if (!TAILQ_EMPTY(&sc->sc_slots) &&
195: bio_register(self, ses_ioctl) != 0) {
196: printf("%s: unable to register ioctl\n", DEVNAME(sc));
197: while (!TAILQ_EMPTY(&sc->sc_slots)) {
198: slot = TAILQ_FIRST(&sc->sc_slots);
199: TAILQ_REMOVE(&sc->sc_slots, slot, sl_entry);
200: free(slot, M_DEVBUF);
201: }
202: }
203: #endif
204:
205: if (TAILQ_EMPTY(&sc->sc_sensors)
206: #if NBIO > 0
207: && TAILQ_EMPTY(&sc->sc_slots)
208: #endif
209: ) {
210: free(sc->sc_buf, M_DEVBUF);
211: sc->sc_buf = NULL;
212: }
213: }
214:
215: int
216: ses_detach(struct device *self, int flags)
217: {
218: struct ses_softc *sc = (struct ses_softc *)self;
219: struct ses_sensor *sensor;
220: #if NBIO > 0
221: struct ses_slot *slot;
222: #endif
223:
224: rw_enter_write(&sc->sc_lock);
225:
226: #if NBIO > 0
227: if (!TAILQ_EMPTY(&sc->sc_slots)) {
228: bio_unregister(self);
229: while (!TAILQ_EMPTY(&sc->sc_slots)) {
230: slot = TAILQ_FIRST(&sc->sc_slots);
231: TAILQ_REMOVE(&sc->sc_slots, slot, sl_entry);
232: free(slot, M_DEVBUF);
233: }
234: }
235: #endif
236:
237: if (!TAILQ_EMPTY(&sc->sc_sensors)) {
238: sensordev_deinstall(&sc->sc_sensordev);
239: sensor_task_unregister(sc->sc_sensortask);
240:
241: while (!TAILQ_EMPTY(&sc->sc_sensors)) {
242: sensor = TAILQ_FIRST(&sc->sc_sensors);
243: sensor_detach(&sc->sc_sensordev, &sensor->se_sensor);
244: TAILQ_REMOVE(&sc->sc_sensors, sensor, se_entry);
245: free(sensor, M_DEVBUF);
246: }
247: }
248:
249: if (sc->sc_buf != NULL)
250: free(sc->sc_buf, M_DEVBUF);
251:
252: rw_exit_write(&sc->sc_lock);
253:
254: return (0);
255: }
256:
257: int
258: ses_read_config(struct ses_softc *sc)
259: {
260: struct ses_scsi_diag cmd;
261: int flags;
262:
263: u_char *buf, *p;
264:
265: struct ses_config_hdr *cfg;
266: struct ses_enc_hdr *enc;
267: #ifdef SES_DEBUG
268: struct ses_enc_desc *desc;
269: #endif
270: struct ses_type_desc *tdh, *tdlist;
271:
272: int i, ntypes = 0, nelems = 0;
273:
274: buf = malloc(SES_BUFLEN, M_DEVBUF, M_NOWAIT);
275: if (buf == NULL)
276: return (1);
277:
278: memset(buf, 0, SES_BUFLEN);
279: memset(&cmd, 0, sizeof(cmd));
280: cmd.opcode = RECEIVE_DIAGNOSTIC;
281: cmd.flags |= SES_DIAG_PCV;
282: cmd.pgcode = SES_PAGE_CONFIG;
283: cmd.length = htobe16(SES_BUFLEN);
284: flags = SCSI_DATA_IN;
285: #ifndef SCSIDEBUG
286: flags |= SCSI_SILENT;
287: #endif
288:
289: if (cold)
290: flags |= SCSI_AUTOCONF;
291:
292: if (scsi_scsi_cmd(sc->sc_link, (struct scsi_generic *)&cmd,
293: sizeof(cmd), buf, SES_BUFLEN, 2, 3000, NULL, flags) != 0) {
294: free(buf, M_DEVBUF);
295: return (1);
296: }
297:
298: cfg = (struct ses_config_hdr *)buf;
299: if (cfg->pgcode != cmd.pgcode || betoh16(cfg->length) > SES_BUFLEN) {
300: free(buf, M_DEVBUF);
301: return (1);
302: }
303:
304: DPRINTF("%s: config: n_subenc: %d length: %d\n", DEVNAME(sc),
305: cfg->n_subenc, betoh16(cfg->length));
306:
307: p = buf + SES_CFG_HDRLEN;
308: for (i = 0; i <= cfg->n_subenc; i++) {
309: enc = (struct ses_enc_hdr *)p;
310: #ifdef SES_DEBUG
311: DPRINTF("%s: enclosure %d enc_id: 0x%02x n_types: %d\n",
312: DEVNAME(sc), i, enc->enc_id, enc->n_types);
313: desc = (struct ses_enc_desc *)(p + SES_ENC_HDRLEN);
314: ses_dump_enc_desc(desc);
315: #endif /* SES_DEBUG */
316:
317: ntypes += enc->n_types;
318:
319: p += SES_ENC_HDRLEN + enc->vendor_len;
320: }
321:
322: tdlist = (struct ses_type_desc *)p; /* stash this for later */
323:
324: for (i = 0; i < ntypes; i++) {
325: tdh = (struct ses_type_desc *)p;
326: DPRINTF("%s: td %d subenc_id: %d type 0x%02x n_elem: %d\n",
327: DEVNAME(sc), i, tdh->subenc_id, tdh->type, tdh->n_elem);
328:
329: nelems += tdh->n_elem;
330:
331: p += SES_TYPE_DESCLEN;
332: }
333:
334: #ifdef SES_DEBUG
335: for (i = 0; i < ntypes; i++) {
336: DPRINTF("%s: td %d '%s'\n", DEVNAME(sc), i,
337: ses_dump_enc_string(p, tdlist[i].desc_len));
338:
339: p += tdlist[i].desc_len;
340: }
341: #endif /* SES_DEBUG */
342:
343: sc->sc_buflen = SES_STAT_LEN(ntypes, nelems);
344: sc->sc_buf = malloc(sc->sc_buflen, M_DEVBUF, M_NOWAIT);
345: if (sc->sc_buf == NULL) {
346: free(buf, M_DEVBUF);
347: return (1);
348: }
349:
350: /* get the status page and then use it to generate a list of sensors */
351: if (ses_make_sensors(sc, tdlist, ntypes) != 0) {
352: free(buf, M_DEVBUF);
353: free(sc->sc_buf, M_DEVBUF);
354: return (1);
355: }
356:
357: free(buf, M_DEVBUF);
358: return (0);
359: }
360:
361: int
362: ses_read_status(struct ses_softc *sc)
363: {
364: struct ses_scsi_diag cmd;
365: int flags;
366:
367: memset(&cmd, 0, sizeof(cmd));
368: cmd.opcode = RECEIVE_DIAGNOSTIC;
369: cmd.flags |= SES_DIAG_PCV;
370: cmd.pgcode = SES_PAGE_STATUS;
371: cmd.length = htobe16(sc->sc_buflen);
372: flags = SCSI_DATA_IN;
373: #ifndef SCSIDEBUG
374: flags |= SCSI_SILENT;
375: #endif
376: if (cold)
377: flags |= SCSI_AUTOCONF;
378:
379: if (scsi_scsi_cmd(sc->sc_link, (struct scsi_generic *)&cmd,
380: sizeof(cmd), sc->sc_buf, sc->sc_buflen, 2, 3000, NULL, flags) != 0)
381: return (1);
382:
383: return (0);
384: }
385:
386: int
387: ses_make_sensors(struct ses_softc *sc, struct ses_type_desc *types, int ntypes)
388: {
389: struct ses_status *status;
390: struct ses_sensor *sensor;
391: #if NBIO > 0
392: struct ses_slot *slot;
393: #endif
394: enum sensor_type stype;
395: char *fmt;
396: int i, j;
397:
398: if (ses_read_status(sc) != 0)
399: return (1);
400:
401: strlcpy(sc->sc_sensordev.xname, DEVNAME(sc),
402: sizeof(sc->sc_sensordev.xname));
403:
404: TAILQ_INIT(&sc->sc_sensors);
405: #if NBIO > 0
406: TAILQ_INIT(&sc->sc_slots);
407: #endif
408:
409: status = (struct ses_status *)(sc->sc_buf + SES_STAT_HDRLEN);
410: for (i = 0; i < ntypes; i++) {
411: /* ignore the overall status element for this type */
412: DPRINTFN(1, "%s: %3d:- 0x%02x 0x%02x%02x%02x type: 0x%02x\n",
413: DEVNAME(sc), i, status->com, status->f1, status->f2,
414: status->f3, types[i].type);
415:
416: for (j = 0; j < types[i].n_elem; j++) {
417: /* move to the current status element */
418: status++;
419:
420: DPRINTFN(1, "%s: %3d:%-3d 0x%02x 0x%02x%02x%02x\n",
421: DEVNAME(sc), i, j, status->com, status->f1,
422: status->f2, status->f3);
423:
424: if (SES_STAT_CODE(status->com) == SES_STAT_CODE_NOTINST)
425: continue;
426:
427: switch (types[i].type) {
428: #if NBIO > 0
429: case SES_T_DEVICE:
430: slot = malloc(sizeof(struct ses_slot),
431: M_DEVBUF, M_NOWAIT);
432: if (slot == NULL)
433: goto error;
434:
435: memset(slot, 0, sizeof(struct ses_slot));
436: slot->sl_stat = status;
437:
438: TAILQ_INSERT_TAIL(&sc->sc_slots, slot,
439: sl_entry);
440:
441: continue;
442: #endif
443:
444: case SES_T_POWERSUPPLY:
445: stype = SENSOR_INDICATOR;
446: fmt = "PSU";
447: break;
448:
449: case SES_T_COOLING:
450: stype = SENSOR_PERCENT;
451: fmt = "Fan";
452: break;
453:
454: case SES_T_TEMP:
455: stype = SENSOR_TEMP;
456: fmt = "";
457: break;
458:
459: default:
460: continue;
461: }
462:
463: sensor = malloc(sizeof(struct ses_sensor), M_DEVBUF,
464: M_NOWAIT);
465: if (sensor == NULL)
466: goto error;
467:
468: memset(sensor, 0, sizeof(struct ses_sensor));
469: sensor->se_type = types[i].type;
470: sensor->se_stat = status;
471: sensor->se_sensor.type = stype;
472: strlcpy(sensor->se_sensor.desc, fmt,
473: sizeof(sensor->se_sensor.desc));
474:
475: TAILQ_INSERT_TAIL(&sc->sc_sensors, sensor, se_entry);
476: }
477:
478: /* move to the overall status element of the next type */
479: status++;
480: }
481:
482: return (0);
483: error:
484: #if NBIO > 0
485: while (!TAILQ_EMPTY(&sc->sc_slots)) {
486: slot = TAILQ_FIRST(&sc->sc_slots);
487: TAILQ_REMOVE(&sc->sc_slots, slot, sl_entry);
488: free(slot, M_DEVBUF);
489: }
490: #endif
491: while (!TAILQ_EMPTY(&sc->sc_sensors)) {
492: sensor = TAILQ_FIRST(&sc->sc_sensors);
493: TAILQ_REMOVE(&sc->sc_sensors, sensor, se_entry);
494: free(sensor, M_DEVBUF);
495: }
496: return (1);
497: }
498:
499: void
500: ses_refresh_sensors(void *arg)
501: {
502: struct ses_softc *sc = (struct ses_softc *)arg;
503: struct ses_sensor *sensor;
504: int ret = 0;
505:
506: rw_enter_write(&sc->sc_lock);
507:
508: if (ses_read_status(sc) != 0) {
509: rw_exit_write(&sc->sc_lock);
510: return;
511: }
512:
513: TAILQ_FOREACH(sensor, &sc->sc_sensors, se_entry) {
514: DPRINTFN(10, "%s: %s 0x%02x 0x%02x%02x%02x\n", DEVNAME(sc),
515: sensor->se_sensor.desc, sensor->se_stat->com,
516: sensor->se_stat->f1, sensor->se_stat->f2,
517: sensor->se_stat->f3);
518:
519: switch (SES_STAT_CODE(sensor->se_stat->com)) {
520: case SES_STAT_CODE_OK:
521: sensor->se_sensor.status = SENSOR_S_OK;
522: break;
523:
524: case SES_STAT_CODE_CRIT:
525: case SES_STAT_CODE_UNREC:
526: sensor->se_sensor.status = SENSOR_S_CRIT;
527: break;
528:
529: case SES_STAT_CODE_NONCRIT:
530: sensor->se_sensor.status = SENSOR_S_WARN;
531: break;
532:
533: case SES_STAT_CODE_NOTINST:
534: case SES_STAT_CODE_UNKNOWN:
535: case SES_STAT_CODE_NOTAVAIL:
536: sensor->se_sensor.status = SENSOR_S_UNKNOWN;
537: break;
538: }
539:
540: switch (sensor->se_type) {
541: case SES_T_POWERSUPPLY:
542: ses_psu2sensor(sc, sensor);
543: break;
544:
545: case SES_T_COOLING:
546: ses_cool2sensor(sc, sensor);
547: break;
548:
549: case SES_T_TEMP:
550: ses_temp2sensor(sc, sensor);
551: break;
552:
553: default:
554: ret = 1;
555: break;
556: }
557: }
558:
559: rw_exit_write(&sc->sc_lock);
560:
561: if (ret)
562: printf("%s: error in sensor data\n", DEVNAME(sc));
563: }
564:
565: #if NBIO > 0
566: int
567: ses_ioctl(struct device *dev, u_long cmd, caddr_t addr)
568: {
569: struct ses_softc *sc = (struct ses_softc *)dev;
570: int error = 0;
571:
572: switch (cmd) {
573: case BIOCBLINK:
574: error = ses_bio_blink(sc, (struct bioc_blink *)addr);
575: break;
576:
577: default:
578: error = EINVAL;
579: break;
580: }
581:
582: return (error);
583: }
584:
585: int
586: ses_write_config(struct ses_softc *sc)
587: {
588: struct ses_scsi_diag cmd;
589: int flags;
590:
591: memset(&cmd, 0, sizeof(cmd));
592: cmd.opcode = SEND_DIAGNOSTIC;
593: cmd.flags |= SES_DIAG_PF;
594: cmd.length = htobe16(sc->sc_buflen);
595: flags = SCSI_DATA_OUT;
596: #ifndef SCSIDEBUG
597: flags |= SCSI_SILENT;
598: #endif
599:
600: if (cold)
601: flags |= SCSI_AUTOCONF;
602:
603: if (scsi_scsi_cmd(sc->sc_link, (struct scsi_generic *)&cmd,
604: sizeof(cmd), sc->sc_buf, sc->sc_buflen, 2, 3000, NULL, flags) != 0)
605: return (1);
606:
607: return (0);
608: }
609:
610: int
611: ses_bio_blink(struct ses_softc *sc, struct bioc_blink *blink)
612: {
613: struct ses_slot *slot;
614:
615: rw_enter_write(&sc->sc_lock);
616:
617: if (ses_read_status(sc) != 0) {
618: rw_exit_write(&sc->sc_lock);
619: return (EIO);
620: }
621:
622: TAILQ_FOREACH(slot, &sc->sc_slots, sl_entry) {
623: if (slot->sl_stat->f1 == blink->bb_target)
624: break;
625: }
626:
627: if (slot == TAILQ_END(&sc->sc_slots)) {
628: rw_exit_write(&sc->sc_lock);
629: return (EINVAL);
630: }
631:
632: DPRINTFN(3, "%s: 0x%02x 0x%02x 0x%02x 0x%02x\n", DEVNAME(sc),
633: slot->sl_stat->com, slot->sl_stat->f1, slot->sl_stat->f2,
634: slot->sl_stat->f3);
635:
636: slot->sl_stat->com = SES_STAT_SELECT;
637: slot->sl_stat->f2 &= SES_C_DEV_F2MASK;
638: slot->sl_stat->f3 &= SES_C_DEV_F3MASK;
639:
640: switch (blink->bb_status) {
641: case BIOC_SBUNBLINK:
642: slot->sl_stat->f2 &= ~SES_C_DEV_IDENT;
643: break;
644:
645: case BIOC_SBBLINK:
646: slot->sl_stat->f2 |= SES_C_DEV_IDENT;
647: break;
648:
649: default:
650: rw_exit_write(&sc->sc_lock);
651: return (EINVAL);
652: }
653:
654: DPRINTFN(3, "%s: 0x%02x 0x%02x 0x%02x 0x%02x\n", DEVNAME(sc),
655: slot->sl_stat->com, slot->sl_stat->f1, slot->sl_stat->f2,
656: slot->sl_stat->f3);
657:
658: if (ses_write_config(sc) != 0) {
659: rw_exit_write(&sc->sc_lock);
660: return (EIO);
661: }
662:
663: rw_exit_write(&sc->sc_lock);
664:
665: return (0);
666: }
667: #endif
668:
669: void
670: ses_psu2sensor(struct ses_softc *sc, struct ses_sensor *s)
671: {
672: s->se_sensor.value = SES_S_PSU_OFF(s->se_stat) ? 0 : 1;
673: }
674:
675: void
676: ses_cool2sensor(struct ses_softc *sc, struct ses_sensor *s)
677: {
678: switch (sc->sc_enctype) {
679: case SES_ENC_STD:
680: switch (SES_S_COOL_CODE(s->se_stat)) {
681: case SES_S_COOL_C_STOPPED:
682: s->se_sensor.value = 0;
683: break;
684: case SES_S_COOL_C_LOW1:
685: case SES_S_COOL_C_LOW2:
686: case SES_S_COOL_C_LOW3:
687: s->se_sensor.value = 33333;
688: break;
689: case SES_S_COOL_C_INTER:
690: case SES_S_COOL_C_HI3:
691: case SES_S_COOL_C_HI2:
692: s->se_sensor.value = 66666;
693: break;
694: case SES_S_COOL_C_HI1:
695: s->se_sensor.value = 100000;
696: break;
697: }
698: break;
699:
700: /* Dell only use the first three codes to represent speed */
701: case SES_ENC_DELL:
702: switch (SES_S_COOL_CODE(s->se_stat)) {
703: case SES_S_COOL_C_STOPPED:
704: s->se_sensor.value = 0;
705: break;
706: case SES_S_COOL_C_LOW1:
707: s->se_sensor.value = 33333;
708: break;
709: case SES_S_COOL_C_LOW2:
710: s->se_sensor.value = 66666;
711: break;
712: case SES_S_COOL_C_LOW3:
713: case SES_S_COOL_C_INTER:
714: case SES_S_COOL_C_HI3:
715: case SES_S_COOL_C_HI2:
716: case SES_S_COOL_C_HI1:
717: s->se_sensor.value = 100000;
718: break;
719: }
720: break;
721: }
722: }
723:
724: void
725: ses_temp2sensor(struct ses_softc *sc, struct ses_sensor *s)
726: {
727: s->se_sensor.value = (int64_t)SES_S_TEMP(s->se_stat);
728: s->se_sensor.value += SES_S_TEMP_OFFSET;
729: s->se_sensor.value *= 1000000; /* convert to micro (mu) degrees */
730: s->se_sensor.value += 273150000; /* convert to kelvin */
731: }
732:
733: #ifdef SES_DEBUG
734: void
735: ses_dump_enc_desc(struct ses_enc_desc *desc)
736: {
737: char str[32];
738:
739: #if 0
740: /* XXX not a string. wwn? */
741: memset(str, 0, sizeof(str));
742: memcpy(str, desc->logical_id, sizeof(desc->logical_id));
743: DPRINTF("logical_id: %s", str);
744: #endif
745:
746: memset(str, 0, sizeof(str));
747: memcpy(str, desc->vendor_id, sizeof(desc->vendor_id));
748: DPRINTF(" vendor_id: %s", str);
749:
750: memset(str, 0, sizeof(str));
751: memcpy(str, desc->prod_id, sizeof(desc->prod_id));
752: DPRINTF(" prod_id: %s", str);
753:
754: memset(str, 0, sizeof(str));
755: memcpy(str, desc->prod_rev, sizeof(desc->prod_rev));
756: DPRINTF(" prod_rev: %s\n", str);
757: }
758:
759: char *
760: ses_dump_enc_string(u_char *buf, ssize_t len)
761: {
762: static char str[256];
763:
764: memset(str, 0, sizeof(str));
765: if (len > 0)
766: memcpy(str, buf, len);
767:
768: return (str);
769: }
770: #endif /* SES_DEBUG */