xref: /titanic_50/usr/src/uts/sun4/sys/fcode.h (revision a0563a48b6bba0177dc249048ea515ca080c73af)
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  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #ifndef	_SYS_FCODE_H
27 #define	_SYS_FCODE_H
28 
29 #include <sys/sysmacros.h>
30 #include <sys/ddi.h>
31 #include <sys/sunddi.h>
32 #include <sys/fc_plat.h>
33 #include <sys/pci.h>
34 
35 #ifdef	__cplusplus
36 extern "C" {
37 #endif
38 
39 /*
40  * The FCode driver presents a private interface to the fcode
41  * user level interpreter.  This interface is subject to change
42  * at any time and is only provided for use by the fcode interpreter.
43  *
44  * The user program opens the device, causing a new instance of
45  * the driver to be cloned.  This instance is specific to a specific
46  * instance of a new device managed by the kernel and driver framework.
47  *
48  * The interpreter does an FC_GET_PARAMETERS ioctl to get the fcode
49  * length, which can be mmap-ed (at offset 0) to provide access to a copy
50  * of the device's fcode.
51  *
52  * The interpreter uses the FC_RUN_PRIV ioctl to request privileged
53  * operations to be run by the driver.
54  *
55  * The interpreter sends an FC_VALIDATE ioctl to notify the
56  * driver that it's done interpreting FCode to signify a normal
57  * ending sequence when the interpreter later closes the device.
58  * This way the driver can easily distinguish between the user
59  * level interpreter failing and finishing normally, thus validating
60  * the interpreters actions and the state it downloads to the driver.
61  * The 'arg' value in the FC_VALIDATE ioctl is ignored, there
62  * are no arguments to this ioctl.
63  */
64 
65 #define	FCIOC			(0xfc<<8)
66 #define	FC_GET_PARAMETERS	(FCIOC | 1)
67 #define	FC_RUN_PRIV		(FCIOC | 2)
68 #define	FC_VALIDATE		(FCIOC | 3)
69 #define	FC_GET_MY_ARGS		(FCIOC | 4)
70 #define	FC_GET_FCODE_DATA	(FCIOC | 5)
71 #define	FC_SET_FCODE_ERROR	(FCIOC | 6)
72 
73 #define	FC_GET_MY_ARGS_BUFLEN	256	/* Max my-args length */
74 
75 /*
76  * FC_GET_PARAMETERS: Expected as the first ioctl after a successful
77  * open and blocking read (the read returns 0 when there's something
78  * to interpret).  The ioctl arg is a pointer to an fc_parameters
79  * data structure which is filled in by the driver with the fcode
80  * len (if any) and unit address of the new device.
81  * Offset 0 .. fcode len may be used as the offset to an mmap call to
82  * provide access to a copy of the device fcode. The unit address is
83  * returned as a NULL terminated string.
84  */
85 
86 struct fc_parameters {
87 	int32_t	fcode_size;
88 	char	unit_address[OBP_MAXPATHLEN];
89 	int	config_address;
90 };
91 
92 
93 
94 /*
95  * FC_RUN_PRIV: The ioctl 'arg' is a pointer to an array of fc_cell_t's
96  * in the following format:
97  *
98  * fc_cell_t[0]: Pointer to a NULL terminated string: service name
99  * fc_cell_t[1]: Number of input arguments (Call this value 'A')
100  * fc_cell_t[2]: Number of output result cells allocated (Call this val 'R')
101  * fc_cell_t[3]: Error Cell (See below)
102  * fc_cell_t[4]: Priv Violation Cell (non-zero if priv. violation)
103  * fc_cell_t[5]: Argument cell[0] (Possibly none)
104  * fc_cell_t[5 + 'A']: Result cell[0] (Possibly none)
105  *
106  * The array is variable sized, and must contain a minimum of 5 fc_cell_t's.
107  * The size (in fc_cell_t's) is 5 + 'A' + 'R'.
108  *
109  * The argument cells are filled in by the caller.  The result cells
110  * (if any) and error cell are returned to the caller by the driver.
111  * The error cell and priv violation cell are filled in and returned
112  * to the caller by the driver.
113  *
114  * Error Cell Values:
115  *
116  *	-1:	The call itself failed (the service name was unknown).
117  *
118  *	0:	No error (though the result cells may indicate results
119  *		that signify an error consistent with the service request.)
120  *
121  * Priv Violation Cell Values:
122  *
123  *	0:	No priv violation
124  *
125  *	-1:	Executing the request caused a priv. violation.
126  *		For example, an rl@ from an address not mapped in
127  *		by the interpreter.
128  */
129 
130 #define	FC_ERR_NONE	fc_int2cell(0)
131 #define	FC_ERR_SVC_NAME	fc_int2cell(-1)
132 
133 #define	FC_PRIV_OK	fc_intcell(0)
134 #define	FC_PRIV_ERROR	fc_int2cell(-1)
135 
136 /*
137  * Client interface template:
138  * The actual number of arguments is nargs.
139  * The actual number of results is nresults.
140  * The variable array 'v' contains 'nargs + nresults' elements
141  */
142 struct fc_client_interface {
143 	fc_cell_t	svc_name;
144 	fc_cell_t	nargs;
145 	fc_cell_t	nresults;
146 	fc_cell_t	error;
147 	fc_cell_t	priv_error;
148 	fc_cell_t	v[1];	/* variable array of args and results */
149 };
150 
151 typedef	struct fc_client_interface fc_ci_t;
152 
153 #define	fc_arg(cp, i)		(cp->v[(i)])
154 #define	fc_result(cp, i)	(cp->v[fc_cell2int(cp->nargs) + (i)])
155 
156 #define	FCC_FIXED_CELLS			5
157 
158 /*
159  * FC_GET_FCODE_DATA: This ioctl allows userland portion of the fcode
160  * interpreter to get the fcode into a local buffer without having
161  * to use mmap() interface.
162  * This allows DR kernel cage memory to be relocated while this
163  * fcode buffer is allocated.
164  *
165  * The ioctl arg is a pointer to an fc_fcode_info structure which
166  * has the fcode_size field set with the expected fcode length.
167  * The driver uses this field to validate correct size before using
168  * copyout() to fill in the fcode_ptr buffer with fcode data.
169  */
170 typedef struct fc_fcode_info {
171 	int32_t	fcode_size;
172 	char	*fcode_ptr;
173 } fc_fcode_info_t;
174 
175 /*
176  * The service name len (max) is limited by the size of a method name
177  */
178 #define	FC_SVC_NAME_LEN		OBP_MAXPROPNAME
179 
180 /*
181  * "Internally" generated service names ...
182  */
183 #define	FC_SVC_VALIDATE		"sunos,validate"
184 #define	FC_SVC_INVALIDATE	"sunos,invalidate"
185 #define	FC_SVC_EXIT		"sunos,exit"
186 
187 #define	FC_OPEN_METHOD		"open"
188 #define	FC_CLOSE_METHOD		"close"
189 #define	FC_FIND_FCODE		"$find"
190 
191 /*
192  * Property related group:
193  *
194  * sunos,get*proplen ( propname-cstr phandle -- proplen )
195  * sunos,get*prop ( propname-cstr buf phandle -- proplen )
196  *
197  * sunos,property ( propname-cstr buf len phandle -- )
198  */
199 
200 #define	FC_GET_MY_PROPLEN	"sunos,get-my-proplen"
201 #define	FC_GET_MY_PROP		"sunos,get-my-prop"
202 
203 #define	FC_GET_IN_PROPLEN	"sunos,get-inherited-proplen"
204 #define	FC_GET_IN_PROP		"sunos,get-inherited-prop"
205 
206 #define	FC_GET_PKG_PROPLEN	"sunos,get-package-proplen"
207 #define	FC_GET_PKG_PROP		"sunos,get-package-prop"
208 
209 #define	FC_CREATE_PROPERTY	"sunos,property"
210 
211 /*
212  * Register access and dma ... same as 1275
213  *
214  * dma-map-in maps in a suitable aligned user address.
215  */
216 #define	FC_RL_FETCH		"rl@"
217 #define	FC_RW_FETCH		"rw@"
218 #define	FC_RB_FETCH		"rb@"
219 
220 #define	FC_RL_STORE		"rl!"
221 #define	FC_RW_STORE		"rw!"
222 #define	FC_RB_STORE		"rb!"
223 
224 #define	FC_MAP_IN		"map-in"
225 #define	FC_MAP_OUT		"map-out"
226 #define	FC_DMA_MAP_IN		"dma-map-in"
227 #define	FC_DMA_MAP_OUT		"dma-map-out"
228 
229 /*
230  * PCI configuration space access methods ... same as pci binding
231  */
232 #define	FC_PCI_CFG_L_FETCH	"config-l@"
233 #define	FC_PCI_CFG_W_FETCH	"config-w@"
234 #define	FC_PCI_CFG_B_FETCH	"config-b@"
235 
236 #define	FC_PCI_CFG_L_STORE	"config-l!"
237 #define	FC_PCI_CFG_W_STORE	"config-w!"
238 #define	FC_PCI_CFG_B_STORE	"config-b!"
239 
240 /*
241  * Device node creation ...
242  *
243  * Create a new device with the given name, unit-address, parent.phandle
244  * with a phandle that must have been previously allocated using
245  * sunos,alloc-phandle.  finish-device marks the device creation and
246  * the creation of its properties as complete. (It's a signal to the
247  * the OS that the node is now reasonably complete.)
248  *
249  * sunos,new-device ( name-cstr unit-addr-cstr parent.phandle phandle -- )
250  * finish-device ( phandle  -- )
251  */
252 #define	FC_NEW_DEVICE		"sunos,new-device"
253 #define	FC_FINISH_DEVICE	"sunos,finish-device"
254 
255 /*
256  * Navigation and configuration:
257  *
258  * sunos,probe-address ( -- phys.lo ... )
259  * sunos,probe-space ( -- phys.hi )
260  *
261  * sunos,ap-phandle ( -- ap.phandle )
262  *	Return attachment point phandle
263  *
264  * sunos,parent ( child.phandle -- parent.phandle )
265  *
266  * child ( parent.phandle -- child.phandle )
267  * peer ( phandle -- phandle.sibling )
268  *
269  * sunos,alloc-phandle ( -- phandle )
270  * Allocates a unique phandle, not associated with the device tree
271  *
272  * sunos,config-child ( -- child.phandle )
273  * Return the phandle of the child being configured.
274  */
275 
276 #define	FC_PROBE_ADDRESS	"sunos,probe-address"
277 #define	FC_PROBE_SPACE		"sunos,probe-space"
278 #define	FC_AP_PHANDLE		"sunos,ap-phandle"
279 #define	FC_PARENT		"sunos,parent"
280 #define	FC_CHILD_FCODE		"child"
281 #define	FC_PEER_FCODE		"peer"
282 #define	FC_ALLOC_PHANDLE	"sunos,alloc-phandle"
283 #define	FC_CONFIG_CHILD		"sunos,config-child"
284 
285 /*
286  * Fcode Drop In Routines:
287  * sunos,get_fcode_size ( cstr -- len )
288  * Returns the size in bytes of the Fcode for a given drop in.
289  * sunos,get_fcode (cstr buf len -- status? )
290  * Returns the Fcode image for a given drop in.
291  */
292 #define	FC_GET_FCODE_SIZE	"sunos,get-fcode-size"
293 #define	FC_GET_FCODE		"sunos,get-fcode"
294 
295 /*
296  * Values for fc_request 'error'. This has been moved from the _KERNEL
297  * area to allow the FC_SET_FCODE_ERROR ioctl to use these values to
298  * signal the kernel as to the disposition of the userland interpreter.
299  * NOTE: Positive values are used to indicate a kernel error,
300  * negative values are used to identify userland interpreter errors.
301  */
302 #define	FC_SUCCESS	0		/* FCode interpreted successfully */
303 #define	FC_TIMEOUT	1		/* Timer expired */
304 #define	FC_ERROR	-1		/* Interpreter error */
305 #define	FC_EXEC_FAILED	-2		/* Interpreter failed to exec */
306 #define	FC_NO_FCODE	-3		/* Interpreter couldn't find fcode */
307 #define	FC_FCODE_ABORT	-4		/* Interpreter called exit(1) */
308 #define	FC_ERROR_VALID(s) ((s) >= FC_FCODE_ABORT) && ((s) <= FC_TIMEOUT)
309 
310 /*
311  * kernel internal data structures and interfaces
312  * for the fcode interpreter.
313  */
314 #if defined(_KERNEL)
315 
316 /*
317  * PCI bus-specific arguments.
318  *
319  * We can't get the physical config address of the child from the
320  * unit address, so we supply it here, along with the child's dip
321  * as the bus specific argument to pci_ops_alloc_handle.
322  */
323 
324 struct pci_ops_bus_args {
325 	int32_t config_address;		/* phys.hi config addr component */
326 };
327 
328 /*
329  * Define data structures for resource lists and handle management
330  *
331  * 'untyped' resources are managed by the provider.
332  */
333 struct fc_dma_resource {
334 	void *virt;
335 	size_t len;
336 	ddi_dma_handle_t h;
337 	uint32_t devaddr;
338 	struct buf *bp;
339 };
340 
341 struct fc_map_resource {
342 	void *virt;
343 	size_t len;
344 	ddi_acc_handle_t h;
345 	void *regspec;
346 };
347 
348 struct fc_nodeid_resource {
349 	int nodeid;		/* An allocated nodeid */
350 };
351 
352 struct fc_contigious_resource {
353 	void *virt;
354 	size_t len;
355 };
356 struct fc_untyped_resource {
357 	int utype;		/* providers private type field */
358 	void (*free)(void *);	/* function to free the resource */
359 	void *resource;		/* Pointer to the resource */
360 };
361 
362 typedef enum {
363 	RT_DMA = 0,
364 	RT_MAP,
365 	RT_NODEID,
366 	RT_CONTIGIOUS,
367 	RT_UNTYPED
368 } fc_resource_type_t;
369 
370 struct fc_resource {
371 	struct fc_resource *next;
372 	fc_resource_type_t type;
373 	union {
374 		struct fc_dma_resource d;
375 		struct fc_map_resource m;
376 		struct fc_nodeid_resource n;
377 		struct fc_contigious_resource c;
378 		struct fc_untyped_resource r;
379 	} un;
380 };
381 
382 #define	fc_dma_virt	un.d.virt
383 #define	fc_dma_len	un.d.len
384 #define	fc_dma_handle	un.d.h
385 #define	fc_dma_devaddr	un.d.devaddr
386 #define	fc_dma_bp	un.d.bp
387 
388 #define	fc_map_virt	un.m.virt
389 #define	fc_map_len	un.m.len
390 #define	fc_map_handle	un.m.h
391 #define	fc_regspec	un.m.regspec
392 
393 #define	fc_nodeid_r	un.n.nodeid
394 
395 #define	fc_contig_virt	un.c.virt
396 #define	fc_contig_len	un.c.len
397 
398 #define	fc_untyped_type	un.r.utype
399 #define	fc_untyped_free	un.r.free
400 #define	fc_untyped_r	un.r.resource
401 
402 struct fc_phandle_entry {
403 	struct fc_phandle_entry *next;
404 	dev_info_t	*dip;
405 	fc_phandle_t	h;
406 };
407 
408 extern void fc_phandle_table_alloc(struct fc_phandle_entry **);
409 extern void fc_phandle_table_free(struct fc_phandle_entry **);
410 extern dev_info_t *fc_phandle_to_dip(struct fc_phandle_entry **, fc_phandle_t);
411 extern fc_phandle_t fc_dip_to_phandle(struct fc_phandle_entry **, dev_info_t *);
412 extern void fc_add_dip_to_phandle(struct fc_phandle_entry **, dev_info_t *,
413     fc_phandle_t);
414 
415 /*
416  * Structures and functions for managing our own subtree rooted
417  * at the attachment point. The parent linkage is established
418  * at node creation time.  The 'downwards' linkage isn't established
419  * until the node is bound.
420  */
421 struct fc_device_tree {
422 	dev_info_t *dip;
423 	struct fc_device_tree *child;
424 	struct fc_device_tree *peer;
425 };
426 
427 void fc_add_child(dev_info_t *child, dev_info_t *parent,
428     struct fc_device_tree *head);
429 
430 void fc_remove_child(dev_info_t *child, struct fc_device_tree *head);
431 
432 dev_info_t *fc_child_node(dev_info_t *parent, struct fc_device_tree *head);
433 dev_info_t *fc_peer_node(dev_info_t *devi, struct fc_device_tree *head);
434 struct fc_device_tree *fc_find_node(dev_info_t *, struct fc_device_tree *);
435 
436 void fc_create_device_tree(dev_info_t *ap, struct fc_device_tree **head);
437 void fc_remove_device_tree(struct fc_device_tree **head);
438 
439 /*
440  * Our handles represent a list of resources associated with an
441  * attachment point.  The handles chain, just as the ops functions
442  * do, with the ops caller responsible for remembering the handle
443  * of the ops function below it. NB: Externally, this data structure
444  * is opaque. (Not all members may be present in each chained cookie.)
445  * For example, the dtree head is valid in only a single instance
446  * of a set of chained cookies, so use the access function to find it.)
447  */
448 struct fc_resource_list {
449 	struct fc_resource *head;
450 	void *next_handle;		/* next handle in chain */
451 	dev_info_t *ap;			/* Attachment point dip */
452 	dev_info_t *child;		/* Child being configured, if any */
453 	dev_info_t *cdip;		/* Current node, if any */
454 	int cdip_state;			/* node creation state - see below */
455 	void *fcode;			/* fcode kernel address */
456 	size_t fcode_size;		/* fcode size or zero */
457 	char *unit_address;		/* childs unit address */
458 	char *my_args;			/* initial setting for my-args */
459 	void *bus_args;			/* bus dependent arguments */
460 	struct fc_phandle_entry *ptable; /* devinfo/phandle table */
461 	struct fc_device_tree *dtree;	/* Our subtree (leaf cookie only) */
462 };
463 
464 typedef struct fc_resource_list *fco_handle_t;
465 
466 /*
467  * Values for cdip_state:
468  */
469 #define	FC_CDIP_NOSTATE		0x00	/* No state - no nodes created */
470 #define	FC_CDIP_STARTED		0x01	/* Node started - dip in cdip */
471 #define	FC_CDIP_DONE		0x02	/* Node finished - last dip in cdip */
472 #define	FC_CDIP_CONFIG		0x10	/* subtree configured */
473 
474 /*
475  * Functions to allocate handles for the fcode_interpreter.
476  *
477  * This function allocates a handle, used to store resources
478  * associated with this fcode request including the address of
479  * the mapped in and copied in fcode and it's size or NULL, 0
480  * if there is no fcode (the interpreter may look for a drop-in
481  * driver if there is no fcode), the unit address of child and
482  * bus specific arguments.  For PCI, the bus specific arguments
483  * include the child's prototype dip and the config address of
484  * the child, which can't be derived from the unit address.
485  *
486  * The 'handle' returned also contains resource information
487  * about any allocations of kernel resources that the fcode
488  * may have created.  Thus, the handle's life is the life
489  * of the plug-in card and can't be released until the card
490  * is removed.  Upon release, the resources are released.
491  */
492 extern fco_handle_t
493 fc_ops_alloc_handle(dev_info_t *ap, dev_info_t *config_child,
494     void *fcode, size_t fcode_size, char *unit_address, void *bus_args);
495 
496 extern fco_handle_t
497 pci_fc_ops_alloc_handle(dev_info_t *ap, dev_info_t *config_child,
498     void *fcode, size_t fcode_size, char *unit_address,
499     struct pci_ops_bus_args *bus_args);
500 
501 extern fco_handle_t
502 gp2_fc_ops_alloc_handle(dev_info_t *ap, dev_info_t *config_child,
503     void *fcode, size_t fcode_size, char *unit_address,
504     char *my_args);
505 
506 extern void pci_fc_ops_free_handle(fco_handle_t handle);
507 extern void gp2_fc_ops_free_handle(fco_handle_t handle);
508 extern void fc_ops_free_handle(fco_handle_t handle);
509 
510 extern struct fc_phandle_entry **fc_handle_to_phandle_head(fco_handle_t rp);
511 
512 struct fc_device_tree **fc_handle_to_dtree_head(fco_handle_t);
513 struct fc_device_tree *fc_handle_to_dtree(fco_handle_t);
514 
515 /*
516  * fc_ops_t is the main glue back to the framework and attachment point driver
517  * for privileged driver operations.  The framework/driver provides a pointer
518  * to the fc_ops function to handle the request given in the args.  The dip
519  * and handle are passed back to the framework/driver to distinguish
520  * requests, if necessary.  The argument array is an array of fc_cell_t's
521  * and is defined in fcode.h
522  *
523  * The ops function should return -1 to indicate that the service name is
524  * unknown and return the value 0 to indicate that the service name was known
525  * and processed (even if it failed).  ops functions may chain, using the
526  * return code to communicate if the current function handled the service
527  * request. Using this technique, the driver can provide certain ops functions
528  * and allow a framework ops function to handle standardized ops functions,
529  * or work hand in hand with a framework function so both can handle an op.
530  * If an ops function is not handled, thus returning -1 to the driver, the
531  * driver will log an error noting the name of the service and return the
532  * error to the caller.
533  */
534 typedef int (fc_ops_t)(dev_info_t *, fco_handle_t, fc_ci_t *);
535 
536 extern fc_ops_t fc_ops;
537 extern fc_ops_t pci_fc_ops;
538 extern fc_ops_t gp2_fc_ops;
539 
540 /*
541  * Internal structure used to enque an fcode request
542  * The 'next' and 'busy' fields are protected by a mutex.
543  * Thread synchronization is accomplished via use of the 'busy' field.
544  */
545 struct fc_request {
546 	struct fc_request *next;	/* Next in chain (private) */
547 	int		busy;		/* Waiters flag (private; see below) */
548 	int		error;		/* Interpreter return code (private) */
549 	dev_info_t	*ap_dip;	/* Attachment point. ie: pci nexus */
550 	fc_ops_t	*ap_ops;	/* driver's fcode ops function */
551 	fco_handle_t	handle;		/* Caller's private identifier */
552 	timeout_id_t	timeout;	/* Timeout identifier */
553 };
554 
555 /*
556  * Values for 'busy'.  The requester initializes the field to FC_R_INIT (0),
557  * then waits for it be set to FC_R_DONE.  The framework sets it to
558  * FC_R_BUSY while working on the request so it can distinguish between
559  * an inactive and an active request.
560  */
561 #define	FC_R_INIT	0		/* initialized, on queue */
562 #define	FC_R_BUSY	1		/* request is active, busy */
563 #define	FC_R_DONE	2		/* request is done and may be deq'd */
564 
565 /*
566  * Function to call to invoke the fcode interpreter.
567  *
568  * This function will wait and return when the interpreter either
569  * completes successfully or fails, returning pass/fail status as
570  * the return code.  Interim calls to the driver's ops function will
571  * be made for both priv. ops and to create device nodes and properties.
572  *
573  * Calling this function will log a message to userland to request the
574  * eventd to start the userland fcode interpreter process. The interpreter
575  * opens /dev/fcode, which clones an instance of the driver, and then
576  * waits in a 'read' until there's an active request.
577  * XXX: For the prototype, we can start it manually or use an init.d script.
578  *
579  * 'ap' is the attachment point dip: that is, the driving parent's dev_info_t
580  * ie: for pci devices, this will be the dip of the pci nexus.
581  *
582  * The 'handle' is provided for the caller, and can be used to
583  * identify the request along with the attachment point dip, both
584  * of which will be passed back to the driver's ops function.
585  * The handle is allocated first by calling a bus-specific
586  * <bus>_ops_handle_alloc function.
587  *
588  * ops functions may chain; an ops function should return -1 if
589  * the call was not recognized, or 0 if the call was recognized.
590  */
591 extern int fcode_interpreter(dev_info_t *, fc_ops_t *, fco_handle_t);
592 
593 /*
594  * The fcode implementation uses this function to wait for and 'de-queue'
595  * an fcode request.  It's triggered by a 'read' request from the
596  * userland interpreter. It uses a 'sig' form of waiting (cv_wait_sig),
597  * so the interpreter can interrupt the read.
598  */
599 extern struct fc_request *fc_get_request(void);
600 
601 /*
602  * When the fcode implementation is finished servicing a request, it calls this
603  * function to mark the request as done and to signal the originating thread
604  * (now waiting in fcode_interpreter) that the request is done.
605  */
606 extern void fc_finish_request(struct fc_request *);
607 
608 /*
609  * The fcode implementation uses these functions to manage
610  * resource items and resource lists ...
611  */
612 extern void fc_add_resource(fco_handle_t, struct fc_resource *);
613 extern void fc_rem_resource(fco_handle_t, struct fc_resource *);
614 extern void fc_lock_resource_list(fco_handle_t);
615 extern void fc_unlock_resource_list(fco_handle_t);
616 
617 /*
618  * ops common and helper functions
619  */
620 extern int fc_fail_op(dev_info_t *, fco_handle_t, fc_ci_t *);
621 extern int fc_success_op(dev_info_t *, fco_handle_t, fc_ci_t *);
622 
623 extern int fc_syntax_error(fc_ci_t *, char *);
624 extern int fc_priv_error(fc_ci_t *, char *);
625 
626 /*
627  * Recharacterized ddi functions we need to define ...
628  *
629  * The only difference is we call through the attachment point driver,
630  * as a proxy for the child that isn't yet attached. The ddi functions
631  * optimize these functions by not necessarily calling through the
632  * attachment point driver.
633  */
634 int fc_ddi_dma_alloc_handle(dev_info_t *dip, ddi_dma_attr_t *attr,
635     int (*waitfp)(caddr_t), caddr_t arg, ddi_dma_handle_t *handlep);
636 int fc_ddi_dma_buf_bind_handle(ddi_dma_handle_t handle, struct buf *bp,
637     uint_t flags, int (*waitfp)(caddr_t), caddr_t arg,
638     ddi_dma_cookie_t *cookiep, uint_t *ccountp);
639 int fc_ddi_dma_unbind_handle(ddi_dma_handle_t handle);
640 void fc_ddi_dma_free_handle(ddi_dma_handle_t *handlep);
641 int fc_ddi_dma_sync(ddi_dma_handle_t h, off_t o, size_t l, uint_t whom);
642 
643 /*
644  * The ndi prop functions aren't appropriate for the interpreter.
645  * We create byte-array, untyped properties.
646  */
647 
648 int fc_ndi_prop_update(dev_t, dev_info_t *, char *, uchar_t *, uint_t);
649 
650 /*
651  * The setup and teardown parts of physio()
652  */
653 int fc_physio_setup(struct buf **bpp, void *io_base, size_t io_len);
654 void fc_physio_free(struct buf **bpp, void *io_base, size_t io_len);
655 
656 /*
657  * debugging macros
658  */
659 extern int fcode_debug;
660 #define	dcmn_err(level, args) if (fcode_debug >= level) cmn_err args
661 
662 #ifdef DEBUG
663 
664 void fc_debug(char *, uintptr_t, uintptr_t,
665     uintptr_t, uintptr_t, uintptr_t);
666 
667 #define	FC_DEBUG0(level, flag, s) if (fcode_debug >= level) \
668     fc_debug(s, 0, 0, 0, 0, 0)
669 #define	FC_DEBUG1(level, flag, fmt, a1) if (fcode_debug >= level) \
670     fc_debug(fmt, (uintptr_t)(a1), 0, 0, 0, 0);
671 #define	FC_DEBUG2(level, flag, fmt, a1, a2) if (fcode_debug >= level) \
672     fc_debug(fmt, (uintptr_t)(a1), (uintptr_t)(a2), 0, 0, 0);
673 #define	FC_DEBUG3(level, flag, fmt, a1, a2, a3) \
674     if (fcode_debug >= level) \
675     fc_debug(fmt, (uintptr_t)(a1), (uintptr_t)(a2), (uintptr_t)(a3), 0, 0);
676 #else
677 #define	FC_DEBUG0(level, flag, s)
678 #define	FC_DEBUG1(level, flag, fmt, a1)
679 #define	FC_DEBUG2(level, flag, fmt, a1, a2)
680 #define	FC_DEBUG3(level, flag, fmt, a1, a2, a3)
681 #endif
682 
683 
684 #endif	/* defined(_KERNEL) */
685 
686 #ifdef	__cplusplus
687 }
688 #endif
689 
690 #endif	/* _SYS_FCODE_H */
691