![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to i386at_ds_routines.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at|
Return to i386at_ds_routines.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at |
1.1 root 1: /*
2: * Mach device server routines (i386at version).
3: *
4: * Copyright (c) 1996 The University of Utah and
5: * the Computer Systems Laboratory at the University of Utah (CSL).
6: * All rights reserved.
7: *
8: * Permission to use, copy, modify and distribute this software is hereby
9: * granted provided that (1) source code retains these copyright, permission,
10: * and disclaimer notices, and (2) redistributions including binaries
11: * reproduce the notices in supporting documentation, and (3) all advertising
12: * materials mentioning features or use of this software display the following
13: * acknowledgement: ``This product includes software developed by the
14: * Computer Systems Laboratory at the University of Utah.''
15: *
16: * THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
17: * IS" CONDITION. THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF
18: * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
19: *
20: * CSL requests users of this software to return to [email protected] any
21: * improvements that they make and grant CSL redistribution rights.
22: *
23: * Author: Shantanu Goel, University of Utah CSL
24: */
25:
26: #include <mach/boolean.h>
27: #include <mach/kern_return.h>
28: #include <mach/mig_errors.h>
29: #include <mach/port.h>
30: #include <mach/notify.h>
31:
32: #include <device/device_types.h>
33: #include <device/device_port.h>
34: #include "device_interface.h"
35:
36: #include <i386at/dev_hdr.h>
37: #include <i386at/device_emul.h>
38: #include <i386/device-drivers.h>
39:
40: extern struct device_emulation_ops mach_device_emulation_ops;
41: #ifdef LINUX_DEV
42: extern struct device_emulation_ops linux_block_emulation_ops;
43: #ifdef CONFIG_INET
44: extern struct device_emulation_ops linux_net_emulation_ops;
45: #endif
46: #endif
47:
48: /* List of emulations. */
49: static struct device_emulation_ops *emulation_list[] =
50: {
51: #ifdef LINUX_DEV
52: &linux_block_emulation_ops,
53: #ifdef CONFIG_INET
54: &linux_net_emulation_ops,
55: #endif
56: #endif
57: &mach_device_emulation_ops,
58: };
59:
60: #define NUM_EMULATION (sizeof (emulation_list) / sizeof (emulation_list[0]))
61:
62: io_return_t
63: ds_device_open (ipc_port_t open_port, ipc_port_t reply_port,
64: mach_msg_type_name_t reply_port_type, dev_mode_t mode,
65: char *name, device_t *devp)
66: {
67: int i;
68: device_t dev;
69: io_return_t err;
70:
71: /* Open must be called on the master device port. */
72: if (open_port != master_device_port)
73: return D_INVALID_OPERATION;
74:
75: /* There must be a reply port. */
76: if (! IP_VALID (reply_port))
77: {
78: printf ("ds_* invalid reply port\n");
79: Debugger ("ds_* reply_port");
80: return MIG_NO_REPLY;
81: }
82:
83: /* Call each emulation's open routine to find the device. */
84: for (i = 0; i < NUM_EMULATION; i++)
85: {
86: err = (*emulation_list[i]->open) (reply_port, reply_port_type,
87: mode, name, devp);
88: if (err != D_NO_SUCH_DEVICE)
89: break;
90: }
91:
92: return err;
93: }
94:
95: io_return_t
96: ds_device_close (device_t dev)
97: {
98: if (dev == DEVICE_NULL)
99: return D_NO_SUCH_DEVICE;
100: return (dev->emul_ops->close
101: ? (*dev->emul_ops->close) (dev->emul_data)
102: : D_SUCCESS);
103: }
104:
105: io_return_t
106: ds_device_write (device_t dev, ipc_port_t reply_port,
107: mach_msg_type_name_t reply_port_type, dev_mode_t mode,
108: recnum_t recnum, io_buf_ptr_t data, unsigned int count,
109: int *bytes_written)
110: {
111: if (dev == DEVICE_NULL)
112: return D_NO_SUCH_DEVICE;
113: if (! data)
114: return D_INVALID_SIZE;
115: if (! dev->emul_ops->write)
116: return D_INVALID_OPERATION;
117: return (*dev->emul_ops->write) (dev->emul_data, reply_port,
118: reply_port_type, mode, recnum,
119: data, count, bytes_written);
120: }
121:
122: io_return_t
123: ds_device_write_inband (device_t dev, ipc_port_t reply_port,
124: mach_msg_type_name_t reply_port_type,
125: dev_mode_t mode, recnum_t recnum,
126: io_buf_ptr_inband_t data, unsigned count,
127: int *bytes_written)
128: {
129: if (dev == DEVICE_NULL)
130: return D_NO_SUCH_DEVICE;
131: if (! data)
132: return D_INVALID_SIZE;
133: if (! dev->emul_ops->write_inband)
134: return D_INVALID_OPERATION;
135: return (*dev->emul_ops->write_inband) (dev->emul_data, reply_port,
136: reply_port_type, mode, recnum,
137: data, count, bytes_written);
138: }
139:
140: io_return_t
141: ds_device_read (device_t dev, ipc_port_t reply_port,
142: mach_msg_type_name_t reply_port_type, dev_mode_t mode,
143: recnum_t recnum, int count, io_buf_ptr_t *data,
144: unsigned *bytes_read)
145: {
146: if (dev == DEVICE_NULL)
147: return D_NO_SUCH_DEVICE;
148: if (! dev->emul_ops->read)
149: return D_INVALID_OPERATION;
150: return (*dev->emul_ops->read) (dev->emul_data, reply_port,
151: reply_port_type, mode, recnum,
152: count, data, bytes_read);
153: }
154:
155: io_return_t
156: ds_device_read_inband (device_t dev, ipc_port_t reply_port,
157: mach_msg_type_name_t reply_port_type, dev_mode_t mode,
158: recnum_t recnum, int count, char *data,
159: unsigned *bytes_read)
160: {
161: if (dev == DEVICE_NULL)
162: return D_NO_SUCH_DEVICE;
163: if (! dev->emul_ops->read_inband)
164: return D_INVALID_OPERATION;
165: return (*dev->emul_ops->read_inband) (dev->emul_data, reply_port,
166: reply_port_type, mode, recnum,
167: count, data, bytes_read);
168: }
169:
170: io_return_t
171: ds_device_set_status (device_t dev, dev_flavor_t flavor,
172: dev_status_t status, mach_msg_type_number_t status_count)
173: {
174: if (dev == DEVICE_NULL)
175: return D_NO_SUCH_DEVICE;
176: if (! dev->emul_ops->set_status)
177: return D_INVALID_OPERATION;
178:
179: return (*dev->emul_ops->set_status) (dev->emul_data, flavor, status,
180: status_count);
181: }
182:
183: io_return_t
184: ds_device_get_status (device_t dev, dev_flavor_t flavor, dev_status_t status,
185: mach_msg_type_number_t *status_count)
186: {
187: if (dev == DEVICE_NULL)
188: return D_NO_SUCH_DEVICE;
189: if (! dev->emul_ops->get_status)
190: return D_INVALID_OPERATION;
191:
192: return (*dev->emul_ops->get_status) (dev->emul_data, flavor, status,
193: status_count);
194: }
195:
196: io_return_t
197: ds_device_set_filter (device_t dev, ipc_port_t receive_port, int priority,
198: filter_t *filter, unsigned filter_count)
199: {
200: if (dev == DEVICE_NULL)
201: return D_NO_SUCH_DEVICE;
202: if (! dev->emul_ops->set_filter)
203: return D_INVALID_OPERATION;
204: return (*dev->emul_ops->set_filter) (dev->emul_data, receive_port,
205: priority, filter, filter_count);
206: }
207:
208: io_return_t
209: ds_device_map (device_t dev, vm_prot_t prot, vm_offset_t offset,
210: vm_size_t size, ipc_port_t *pager, boolean_t unmap)
211: {
212: if (dev == DEVICE_NULL)
213: return D_NO_SUCH_DEVICE;
214: if (! dev->emul_ops->map)
215: return D_INVALID_OPERATION;
216: return (*dev->emul_ops->map) (dev->emul_data, prot,
217: offset, size, pager, unmap);
218: }
219:
220: boolean_t
221: ds_notify (mach_msg_header_t *msg)
222: {
223: if (msg->msgh_id == MACH_NOTIFY_NO_SENDERS)
224: {
225: device_t dev;
226: mach_no_senders_notification_t *ns;
227:
228: ns = (mach_no_senders_notification_t *) msg;
229: dev = (device_t) ns->not_header.msgh_remote_port;
230: if (dev->emul_ops->no_senders)
231: (*dev->emul_ops->no_senders) (ns);
232: return TRUE;
233: }
234:
235: printf ("ds_notify: strange notification %d\n", msg->msgh_id);
236: return FALSE;
237: }
238:
239: io_return_t
240: ds_device_write_trap (device_t dev, dev_mode_t mode,
241: recnum_t recnum, vm_offset_t data, vm_size_t count)
242: {
243: if (dev == DEVICE_NULL)
244: return D_NO_SUCH_DEVICE;
245: if (! dev->emul_ops->write_trap)
246: return D_INVALID_OPERATION;
247: return (*dev->emul_ops->write_trap) (dev->emul_data,
248: mode, recnum, data, count);
249: }
250:
251: io_return_t
252: ds_device_writev_trap (device_t dev, dev_mode_t mode,
253: recnum_t recnum, io_buf_vec_t *iovec, vm_size_t count)
254: {
255: if (dev == DEVICE_NULL)
256: return D_NO_SUCH_DEVICE;
257: if (! dev->emul_ops->writev_trap)
258: return D_INVALID_OPERATION;
259: return (*dev->emul_ops->writev_trap) (dev->emul_data,
260: mode, recnum, iovec, count);
261: }
262:
263: void
264: device_reference (device_t dev)
265: {
266: if (dev->emul_ops->reference)
267: (*dev->emul_ops->reference) (dev->emul_data);
268: }
269:
270: void
271: device_deallocate (device_t dev)
272: {
273: if (dev->emul_ops->dealloc)
274: (*dev->emul_ops->dealloc) (dev->emul_data);
275: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.