xref: /titanic_50/usr/src/cmd/sf880drd/sf880drd.c (revision b1dd958f54f8bfa984d306bb8ca8264855761d7b)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2000, 2003 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 #include <sys/types.h>
29 #include <sys/sunddi.h>
30 #include <sys/stat.h>
31 #include <sys/i2c/clients/i2c_client.h>
32 #include <sys/hpc3130_events.h>
33 #include <values.h>		/* for BITSPERBYTE */
34 #include <unistd.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <fcntl.h>
38 #include <strings.h>
39 #include <poll.h>
40 #include <libintl.h>
41 #include <errno.h>
42 #include <assert.h>
43 #include <config_admin.h>
44 #include <sys/daktari.h>
45 #include "sf880drd.h"
46 
47 /*
48  * Hotplug Controller addresses.
49  */
50 static const unsigned char controller_names[NUM_CONTROLLERS] =
51 	{ 0xe2, 0xe6, 0xe8, 0xec };
52 
53 #define	INDEX2SLOT(INDEX)	((INDEX)%4) /* cf init_poll_events() */
54 #define	INDEX2CONTROLLER(INDEX)	((INDEX)/4) /* cf init_poll_events() */
55 
56 /*
57  *  Local variables.
58  */
59 static struct pollfd fds[NUM_FDS];
60 static unsigned int fault_leds[2];
61 static unsigned int ok2rem_leds[2];
62 
63 /*
64  *  Local prototypes.
65  */
66 static void init_poll_events(void);
67 static void process_event(int);
68 static void report_cfgadm_error(int, char *);
69 static void set_front_panel_led(uint8_t, boolean_t);
70 
71 static int i2c_set_bit(int, int, uint8_t);
72 static void report_syscall_error(char *);
73 
74 static void pushbutton_event(char *);
75 static void fault_led_event(hpc3130_event_type_t, int);
76 static void removable_led_event(hpc3130_event_type_t, int);
77 
78 /*
79  * main(): loops forever looking for events.
80  */
81 int
82 main()
83 {
84 	int	i;
85 	int	rv;
86 
87 	init_poll_events();
88 	for (;;) {
89 		/* sleep in poll() waiting an event */
90 		rv = poll(fds, NUM_FDS, -1);
91 		if (rv < 0) {
92 			report_syscall_error("poll");
93 			continue;
94 		}
95 
96 		/* woken up from poll() process the event */
97 		for (i = 0; i < NUM_FDS; ++i) {
98 			if (fds[i].revents == POLLIN)
99 				process_event(i);
100 		}
101 	}
102 	/* NOTREACHED */
103 	return (0);
104 }
105 
106 /*
107  * Set up poll fds.
108  */
109 static void
110 init_poll_events()
111 {
112 	int c;
113 	int p;
114 	int i = 0;
115 	char buf[sizeof (HPC3130_DEV_FMT)+8];
116 
117 	for (c = 0; c < NUM_CONTROLLERS; ++c) {
118 		for (p = 0; p < SLOTS_PER_CONTROLLER; ++p) {
119 			(void) sprintf(buf, HPC3130_DEV_FMT,
120 			    controller_names[c], p);
121 			fds[i].events = POLLIN;
122 			fds[i].fd = open(buf, O_RDWR);
123 			if (fds[i].fd == -1) {
124 				report_syscall_error(buf);
125 				exit(-1);
126 			}
127 			i++;
128 		}
129 	}
130 }
131 
132 /*
133  * Process poll events.
134  */
135 static void
136 process_event(int fdi)
137 {
138 	struct hpc3130_event e;
139 	int rv;
140 	int slot = INDEX2SLOT(fdi);
141 	int cntr = INDEX2CONTROLLER(fdi);
142 
143 	rv = ioctl(fds[fdi].fd, HPC3130_GET_EVENT, &e);
144 	if (rv == -1) {
145 		report_syscall_error("HPC3130_GET_EVENT");
146 		return;
147 	}
148 
149 	switch (e.id) {
150 	case HPC3130_EVENT_INSERTION:
151 	case HPC3130_EVENT_REMOVAL:
152 	case HPC3130_EVENT_POWERON:
153 	case HPC3130_EVENT_POWEROFF:
154 		break;
155 	case HPC3130_EVENT_BUTTON:
156 		DPRINTF(("\nBUTTON EVENT slot (%s)\n", e.name));
157 		pushbutton_event(e.name);
158 		break;
159 	case HPC3130_LED_FAULT_ON:
160 		DPRINTF(("\nFAULT LED ON EVENT\n"));
161 		fault_led_event(e.id, fdi);
162 		break;
163 	case HPC3130_LED_FAULT_OFF:
164 		DPRINTF(("\nFAULT LED OFF EVENT\n"));
165 		fault_led_event(e.id, fdi);
166 		break;
167 	case HPC3130_LED_REMOVABLE_ON:
168 		DPRINTF(("\nREMOVABLE LED ON EVENT\n"));
169 		removable_led_event(e.id, fdi);
170 		break;
171 	case HPC3130_LED_REMOVABLE_OFF:
172 		DPRINTF(("\nREMOVABLE LED OFF EVENT\n"));
173 		removable_led_event(e.id, fdi);
174 		break;
175 	default:
176 		(void) fprintf(stderr, "WARNING: bogus event: %x\n", e.id);
177 	}
178 }
179 
180 /*
181  * Button Event handler.
182  */
183 static void
184 pushbutton_event(char *ap_id)
185 {
186 	char			*errstr = NULL;
187 	struct cfga_list_data	*stat = NULL;
188 	int			nlist;
189 	cfga_cmd_t		cmd;
190 	cfga_err_t		rv;
191 
192 	rv = config_list_ext(1, &ap_id, &stat, &nlist,
193 	    NULL, NULL, &errstr, 0);
194 	if (rv != CFGA_OK) {
195 		report_cfgadm_error(rv, errstr);
196 		goto out;
197 	}
198 	assert(nlist == 1);
199 
200 	/* The only types of hotplug with buttons */
201 	assert(!(strcmp(stat->ap_class, "pci")));
202 
203 	switch (stat->ap_o_state) {
204 	case CFGA_STAT_UNCONFIGURED:
205 		cmd = CFGA_CMD_CONFIGURE;
206 		break;
207 	case CFGA_STAT_CONFIGURED:
208 		cmd = CFGA_CMD_DISCONNECT;
209 		break;
210 	default:
211 		/* Should never get here */
212 		assert(0);
213 	}
214 
215 	/*
216 	 * confp & msgp are NULL: when using the pushbutton,
217 	 * simply fail if prompting is required.
218 	 */
219 	rv = config_change_state(cmd, 1, &ap_id, NULL, NULL, NULL, &errstr, 0);
220 	if (rv != CFGA_OK) {
221 		report_cfgadm_error(rv, errstr);
222 		/* FALLTHRU to "out" */
223 	}
224 
225 out:
226 	if (errstr)
227 		free(errstr);
228 	if (stat)
229 		free(stat);
230 }
231 
232 static void
233 fault_led_event(hpc3130_event_type_t event, int fdi)
234 {
235 	int		side = 0;
236 	unsigned int	old;
237 
238 	if (INDEX2CONTROLLER(fdi) != GPTWO_CONTROLLER) {
239 		/* It's a PCI slot; left side of chassis */
240 		side = 1;
241 	}
242 
243 	old = fault_leds[side];
244 
245 	assert(fdi <= sizeof (fault_leds[side]) * BITSPERBYTE);
246 
247 	switch (event) {
248 	case HPC3130_LED_FAULT_ON:
249 		fault_leds[side] |= (1<<fdi);
250 		DPRINTF(("fault_led_event: HPC3130_LED_FAULT_ON\n"));
251 		break;
252 	case HPC3130_LED_FAULT_OFF:
253 		fault_leds[side] &= ~(1<<fdi);
254 		DPRINTF(("fault_led_event: HPC3130_LED_FAULT_OFF\n"));
255 		break;
256 	}
257 
258 	DPRINTF(("fault_led_event: old(0x%x), fault_leds[%d](0x%x)\n",
259 	    old, side, fault_leds[side]));
260 
261 	if ((old == 0) != (fault_leds[side] == 0) && ok2rem_leds[side] == 0) {
262 		/*
263 		 * The first FAULT LED has come on, or the last one has gone
264 		 * off on this side, and all the OK2REMOVE LEDS are off on this
265 		 * side.  So we have to update the front panel ARROW LED.
266 		 */
267 		set_front_panel_led(side ? LEFT_DOOR_ATTEN_LED :
268 		    RIGHT_DOOR_ATTEN_LED,
269 		    fault_leds[side] ? LED_ON : LED_OFF);
270 	}
271 }
272 
273 static void
274 removable_led_event(hpc3130_event_type_t event, int fdi)
275 {
276 	int		side = 0;
277 	unsigned int	old;
278 
279 	if (INDEX2CONTROLLER(fdi) != GPTWO_CONTROLLER) {
280 		/* It's a PCI slot; left side of chassis */
281 		side = 1;
282 	}
283 
284 	old = ok2rem_leds[side];
285 
286 	assert(fdi <= sizeof (ok2rem_leds[side]) * BITSPERBYTE);
287 
288 	switch (event) {
289 	case HPC3130_LED_REMOVABLE_ON:
290 		ok2rem_leds[side] |= (1<<fdi);
291 		DPRINTF(("removable_led_event: HPC3130_LED_REMOVABLE_ON\n"));
292 		break;
293 	case HPC3130_LED_REMOVABLE_OFF:
294 		ok2rem_leds[side] &= ~(1<<fdi);
295 		DPRINTF(("removable_led_event: HPC3130_LED_REMOVABLE_OFF\n"));
296 		break;
297 	}
298 
299 	DPRINTF(("removable_led_event: old(0x%x), ok2rem_leds[%d](0x%x)\n",
300 	    old, side, ok2rem_leds[side]));
301 
302 	if ((old == 0) != (ok2rem_leds[side] == 0)) {
303 		/*
304 		 * The first OKAY2REMOVE LED has come on, or the last
305 		 * one has gone off (on this side).  We may have to update
306 		 * the front panel LEDs.
307 		 */
308 		if (ok2rem_leds[!side] == 0) {
309 			/*
310 			 * The OK2REMOVE LEDs are all off on the other
311 			 * side of the chassis, so this side determines
312 			 * whether the front OK2REMOVE is on or off.
313 			 */
314 			set_front_panel_led(SYS_OK2REMOVE_LED,
315 			    ok2rem_leds[side] ? LED_ON : LED_OFF);
316 		}
317 		if (fault_leds[side] == 0) {
318 			/*
319 			 * All the FAULT LEDs are off on this side.  So the
320 			 * OK2REMOVE LEDs determine whether the ARROW LED is on.
321 			 */
322 		set_front_panel_led(side ? LEFT_DOOR_ATTEN_LED :
323 		    RIGHT_DOOR_ATTEN_LED,
324 		    ok2rem_leds[side] ? LED_ON : LED_OFF);
325 		}
326 	}
327 }
328 
329 /*
330  * Set front panel system leds either on or off.
331  */
332 static void
333 set_front_panel_led(uint8_t bit_num, boolean_t on_off)
334 {
335 	int		fd;
336 	int		rv;
337 	i2c_bit_t	arg;
338 
339 	fd = open(SSC050_LED_PORT, O_RDWR);
340 	if (fd == -1) {
341 		report_syscall_error("ssc050");
342 		return;
343 	}
344 
345 	arg.bit_num = bit_num;
346 	arg.bit_value = on_off;
347 
348 	rv = ioctl(fd, I2C_SET_BIT, &arg);
349 	if (rv == -1)
350 		report_syscall_error("LED I2C_SET_BIT");
351 
352 	(void) close(fd);
353 }
354 
355 static int
356 i2c_set_bit(int fp, int bit, uint8_t value)
357 {
358 	int		rv;
359 	i2c_bit_t	passin;
360 
361 	passin.bit_num = (uchar_t)bit;
362 	passin.bit_value = value;
363 	rv = ioctl(fp, I2C_SET_BIT, &passin);
364 	return (rv);
365 }
366 
367 static void
368 report_cfgadm_error(int cfgerrnum, char *errstr)
369 {
370 	const char	*ep;
371 
372 	ep = config_strerror(cfgerrnum);
373 
374 	if (ep == NULL)
375 		ep = gettext("configuration administration unknown error");
376 
377 	if (errstr != NULL && *errstr != '\0') {
378 		(void) fprintf(stderr, "%s: %s\n", ep, errstr);
379 	} else {
380 		(void) fprintf(stderr, "%s\n", ep);
381 	}
382 }
383 
384 static void
385 report_syscall_error(char *msg)
386 {
387 	if (errno != EINTR)
388 		perror(msg);
389 }
390