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 (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
24 * Use is subject to license terms.
25 */
26
27/*
28 * I/O support routines for DR
29 */
30
31#include <sys/debug.h>
32#include <sys/types.h>
33#include <sys/errno.h>
34#include <sys/cred.h>
35#include <sys/dditypes.h>
36#include <sys/devops.h>
37#include <sys/modctl.h>
38#include <sys/poll.h>
39#include <sys/conf.h>
40#include <sys/ddi.h>
41#include <sys/sunddi.h>
42#include <sys/sunndi.h>
43#include <sys/ndi_impldefs.h>
44#include <sys/stat.h>
45#include <sys/kmem.h>
46#include <sys/processor.h>
47#include <sys/cpuvar.h>
48#include <sys/mem_config.h>
49#include <sys/promif.h>
50#include <sys/x_call.h>
51#include <sys/cpu_sgnblk_defs.h>
52#include <sys/membar.h>
53#include <sys/stack.h>
54#include <sys/sysmacros.h>
55#include <sys/machsystm.h>
56#include <sys/spitregs.h>
57#include <sys/cpupart.h>
58
59#include <sys/archsystm.h>
60#include <vm/hat_sfmmu.h>
61#include <sys/pte.h>
62#include <sys/mmu.h>
63#include <sys/x_call.h>
64#include <sys/cpu_module.h>
65
66#include <sys/cmn_err.h>
67
68#include <sys/dr.h>
69#include <sys/dr_util.h>
70#include <sys/drmach.h>
71
72void
73dr_init_io_unit(dr_io_unit_t *ip)
74{
75	dr_state_t	new_state;
76
77	if (DR_DEV_IS_ATTACHED(&ip->sbi_cm)) {
78		new_state = DR_STATE_CONFIGURED;
79		ip->sbi_cm.sbdev_cond = SBD_COND_OK;
80	} else if (DR_DEV_IS_PRESENT(&ip->sbi_cm)) {
81		new_state = DR_STATE_CONNECTED;
82		ip->sbi_cm.sbdev_cond = SBD_COND_OK;
83	} else {
84		new_state = DR_STATE_EMPTY;
85	}
86	dr_device_transition(&ip->sbi_cm, new_state);
87}
88
89/*ARGSUSED*/
90void
91dr_attach_io(dr_handle_t *hp, dr_common_unit_t *cp)
92{
93	sbd_error_t *err;
94
95	dr_lock_status(hp->h_bd);
96	err = drmach_configure(cp->sbdev_id, 0);
97	dr_unlock_status(hp->h_bd);
98
99	if (!err)
100		err = drmach_io_post_attach(cp->sbdev_id);
101
102	if (err)
103		DRERR_SET_C(&cp->sbdev_error, &err);
104}
105
106/*
107 * remove device nodes for the branch indicated by cp
108 */
109/*ARGSUSED*/
110void
111dr_detach_io(dr_handle_t *hp, dr_common_unit_t *cp)
112{
113	sbd_error_t *err;
114
115	err = drmach_unconfigure(cp->sbdev_id, 0);
116
117	if (!err)
118		err = drmach_unconfigure(cp->sbdev_id, DEVI_BRANCH_DESTROY);
119
120	if (!err)
121		err = drmach_io_post_release(cp->sbdev_id);
122
123	if (err) {
124		dr_device_transition(cp, DR_STATE_CONFIGURED);
125		DRERR_SET_C(&cp->sbdev_error, &err);
126	}
127}
128
129/*ARGSUSED*/
130int
131dr_disconnect_io(dr_io_unit_t *ip)
132{
133	return (0);
134}
135
136/*ARGSUSED*/
137int
138dr_pre_attach_io(dr_handle_t *hp,
139	dr_common_unit_t **devlist, int devnum)
140{
141	int		d;
142
143	for (d = 0; d < devnum; d++) {
144		dr_common_unit_t *cp = devlist[d];
145
146		cmn_err(CE_CONT, "OS configure %s", cp->sbdev_path);
147	}
148
149	return (0);
150}
151
152/*ARGSUSED*/
153int
154dr_post_attach_io(dr_handle_t *hp,
155	dr_common_unit_t **devlist, int devnum)
156{
157	return (0);
158}
159
160static int
161dr_check_io_refs(dr_handle_t *hp, dr_common_unit_t **devlist, int devnum)
162{
163	register int	i, reftotal = 0;
164	static fn_t	f = "dr_check_io_refs";
165
166	for (i = 0; i < devnum; i++) {
167		dr_io_unit_t	*ip = (dr_io_unit_t *)devlist[i];
168		dev_info_t	*dip;
169		int		ref;
170		int		refcount_non_gldv3;
171		sbd_error_t	*err;
172
173		err = drmach_get_dip(ip->sbi_cm.sbdev_id, &dip);
174		if (err)
175			DRERR_SET_C(&ip->sbi_cm.sbdev_error, &err);
176		else if (dip != NULL) {
177			ref = 0;
178			refcount_non_gldv3 = 0;
179			ASSERT(e_ddi_branch_held(dip));
180			dr_check_devices(dip, &ref, hp, NULL, NULL,
181			    0, &refcount_non_gldv3);
182			ASSERT(refcount_non_gldv3 >= 0);
183			ASSERT(ref >= refcount_non_gldv3);
184			/*
185			 * Ignore reference counts of non-gldv3 network devices
186			 * as Crossbow creates reference counts for non-active
187			 * (unplumbed) instances.  Reference count check in
188			 * detach() known to prevent device from detaching
189			 * as necessary.
190			 */
191			ref -= refcount_non_gldv3;
192			hp->h_err = NULL;
193			if (ref) {
194				dr_dev_err(CE_WARN, &ip->sbi_cm, ESBD_BUSY);
195			}
196			PR_IO("%s: dip(%s) ref = %d\n",
197			    f, ddi_get_name(dip), ref);
198			reftotal += ref;
199		} else {
200			PR_IO("%s: NO dip for id (0x%x)\n",
201			    f, (uint_t)(uintptr_t)ip->sbi_cm.sbdev_id);
202		}
203	}
204
205	return (reftotal);
206}
207
208int
209dr_pre_release_io(dr_handle_t *hp,
210	dr_common_unit_t **devlist, int devnum)
211{
212	static fn_t	f = "dr_pre_release_io";
213	int	d;
214
215	ASSERT(devnum > 0);
216
217	/* fail if any I/O device pre-release fails */
218	for (d = 0; d < devnum; d++) {
219		dr_io_unit_t *ip = (dr_io_unit_t *)devlist[d];
220
221		if ((hp->h_err = drmach_io_pre_release(
222		    ip->sbi_cm.sbdev_id)) != 0) {
223			return (-1);
224		}
225	}
226
227	for (d = 0; d < devnum; d++) {
228		dr_io_unit_t *ip = (dr_io_unit_t *)devlist[d];
229		sbd_error_t *err;
230
231		err = drmach_release(ip->sbi_cm.sbdev_id);
232		if (err) {
233			DRERR_SET_C(&ip->sbi_cm.sbdev_error,
234			    &err);
235			return (-1);
236		}
237	}
238
239	/* fail if any I/O devices are still referenced */
240	if (dr_check_io_refs(hp, devlist, devnum) > 0) {
241		PR_IO("%s: failed - I/O devices ref'd\n", f);
242
243		/* recover before return error */
244		for (d = 0; d < devnum; d++) {
245			dr_io_unit_t *ip = (dr_io_unit_t *)devlist[d];
246			sbd_error_t *err;
247			err = drmach_io_unrelease(ip->sbi_cm.sbdev_id);
248			if (err) {
249				DRERR_SET_C(&ip->sbi_cm.sbdev_error, &err);
250				return (-1);
251			}
252		}
253		return (-1);
254	}
255	return (0);
256}
257
258/*ARGSUSED*/
259int
260dr_pre_detach_io(dr_handle_t *hp,
261	dr_common_unit_t **devlist, int devnum)
262{
263	int		d;
264
265	ASSERT(devnum > 0);
266
267	for (d = 0; d < devnum; d++) {
268		dr_common_unit_t *cp = devlist[d];
269
270		cmn_err(CE_CONT, "OS unconfigure %s", cp->sbdev_path);
271	}
272
273	return (0);
274}
275
276/*ARGSUSED*/
277int
278dr_post_detach_io(dr_handle_t *hp, dr_common_unit_t **devlist, int devnum)
279{
280	register int	i;
281	int		rv = 0;
282	static fn_t	f = "dr_post_detach_io";
283
284	ASSERT(devnum > 0);
285	for (i = 0; i < devnum; i++) {
286		dr_common_unit_t	*cp = devlist[i];
287		if (cp->sbdev_error != NULL) {
288			PR_IO("%s: Failed\n", f);
289			rv = -1;
290			break;
291		}
292	}
293	return (rv);
294}
295
296static void
297dr_get_comp_cond(dr_io_unit_t *ip, dev_info_t *dip)
298{
299	if (dip == NULL) {
300		ip->sbi_cm.sbdev_cond = SBD_COND_UNKNOWN;
301		return;
302	}
303
304	if (DEVI(dip)->devi_flags & DEVI_RETIRED) {
305		ip->sbi_cm.sbdev_cond = SBD_COND_FAILED;
306		return;
307	}
308
309	if (DR_DEV_IS_ATTACHED(&ip->sbi_cm)) {
310		ip->sbi_cm.sbdev_cond = SBD_COND_OK;
311	} else if (DR_DEV_IS_PRESENT(&ip->sbi_cm)) {
312		ip->sbi_cm.sbdev_cond = SBD_COND_OK;
313	}
314}
315
316int
317dr_io_status(dr_handle_t *hp, dr_devset_t devset, sbd_dev_stat_t *dsp)
318{
319	int		i, ix;
320	dr_board_t	*bp;
321	sbd_io_stat_t	*isp;
322	dr_io_unit_t	*ip;
323
324	bp = hp->h_bd;
325
326	/*
327	 * Only look for requested devices that are actually present.
328	 */
329	devset &= DR_DEVS_PRESENT(bp);
330
331	for (i = ix = 0; i < MAX_IO_UNITS_PER_BOARD; i++) {
332		drmachid_t	 id;
333		dev_info_t	*dip;
334		sbd_error_t	*err;
335		drmach_status_t	 pstat;
336
337		if (DEVSET_IN_SET(devset, SBD_COMP_IO, i) == 0)
338			continue;
339
340		ip = dr_get_io_unit(bp, i);
341
342		if (ip->sbi_cm.sbdev_state == DR_STATE_EMPTY) {
343			/* present, but not fully initialized */
344			continue;
345		}
346
347		id = ip->sbi_cm.sbdev_id;
348		if (id == (drmachid_t)0)
349			continue;
350
351		err = drmach_status(ip->sbi_cm.sbdev_id, &pstat);
352		if (err) {
353			DRERR_SET_C(&ip->sbi_cm.sbdev_error, &err);
354			return (-1);
355		}
356
357		dip = NULL;
358		err = drmach_get_dip(id, &dip);
359		if (err) {
360			/* catch this in debug kernels */
361			ASSERT(0);
362
363			sbd_err_clear(&err);
364			continue;
365		}
366
367		isp = &dsp->d_io;
368		bzero((caddr_t)isp, sizeof (*isp));
369
370		isp->is_cm.c_id.c_type = ip->sbi_cm.sbdev_type;
371		isp->is_cm.c_id.c_unit = ip->sbi_cm.sbdev_unum;
372		(void) strncpy(isp->is_cm.c_id.c_name, pstat.type,
373		    sizeof (isp->is_cm.c_id.c_name));
374
375		dr_get_comp_cond(ip, dip);
376		isp->is_cm.c_cond = ip->sbi_cm.sbdev_cond;
377		isp->is_cm.c_busy = ip->sbi_cm.sbdev_busy | pstat.busy;
378		isp->is_cm.c_time = ip->sbi_cm.sbdev_time;
379		isp->is_cm.c_ostate = ip->sbi_cm.sbdev_ostate;
380		isp->is_cm.c_sflags = 0;
381
382		if (dip == NULL) {
383			isp->is_pathname[0] = '\0';
384			isp->is_referenced = 0;
385			isp->is_unsafe_count = 0;
386		} else {
387			int		refcount = 0, idx = 0;
388			uint64_t	unsafe_devs[SBD_MAX_UNSAFE];
389
390			ASSERT(e_ddi_branch_held(dip));
391			(void) ddi_pathname(dip, isp->is_pathname);
392
393			/* check reference and unsafe counts on devices */
394			isp->is_unsafe_count = 0;
395			dr_check_devices(dip, &refcount, hp, unsafe_devs,
396			    &idx, SBD_MAX_UNSAFE, NULL);
397			while (idx > 0) {
398				isp->is_unsafe_list[idx-1] = unsafe_devs[idx-1];
399				--idx;
400			}
401
402			isp->is_referenced = (refcount == 0) ? 0 : 1;
403
404			hp->h_err = NULL;
405		}
406		ix++;
407		dsp++;
408	}
409
410	return (ix);
411}
412