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
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <strings.h>
32
33 #include <fcode/private.h>
34 #include <fcode/log.h>
35
36 #include <fcdriver/fcdriver.h>
37
38 static fstack_t
mem_map_in(fcode_env_t * env,fstack_t hi,fstack_t mid,fstack_t lo,fstack_t requested_len)39 mem_map_in(fcode_env_t *env, fstack_t hi, fstack_t mid, fstack_t lo,
40 fstack_t requested_len)
41 {
42 private_data_t *cdp = DEVICE_PRIVATE(env);
43 int error;
44 fc_cell_t requested_virt, adjusted_virt;
45 char *service = "map-in";
46 fstack_t mcookie = NULL;
47 int pa_offset = 0, va_offset = 0;
48 fstack_t adjusted_len = 0;
49
50 pa_offset = lo & PAGEOFFSET;
51 lo &= PAGEMASK;
52
53 /* adjust the requested_len to a multiple of a pagesize */
54 requested_len = (requested_len + pa_offset + PAGEOFFSET) & PAGEMASK;
55
56 error = fc_run_priv(cdp->common, service, 4, 1,
57 fc_size2cell(requested_len), fc_uint32_t2cell(hi),
58 fc_uint32_t2cell(mid), fc_uint32_t2cell(lo), &requested_virt);
59
60 if (error)
61 throw_from_fclib(env, 1, "pci:%s: failed\n", service);
62
63 /*
64 * Check the requested_virt address and ensure that
65 * it starts at a page boundary.
66 */
67
68 va_offset = requested_virt & PAGEOFFSET;
69
70 if (va_offset != 0) {
71
72 /*
73 * Align the virtual address to a page boundary
74 * before mapping it to a mcookie. Recalcuate the
75 * length and round it up to the next multiple of a pagesize.
76 */
77
78 adjusted_virt = requested_virt & PAGEMASK;
79 adjusted_len = (requested_len + va_offset + PAGEOFFSET)
80 & PAGEMASK;
81 }
82
83 mcookie = mapping_to_mcookie(requested_virt, requested_len,
84 adjusted_virt, adjusted_len);
85
86 if (mcookie == NULL)
87 throw_from_fclib(env, 1, "pci-mapin-> pci:%s:"
88 " mapping_to_mcookie failed\n", service);
89 /*
90 * Recalculate the address of the mcookie.
91 */
92
93 mcookie += va_offset + pa_offset;
94
95 debug_msg(DEBUG_REG_ACCESS, "pci:map-in: %llx -> %x\n",
96 (uint64_t)requested_virt, (uint32_t)mcookie);
97
98 return (mcookie);
99 }
100
101 static void
mem_map_out(fcode_env_t * env,fstack_t mcookie,fstack_t requested_len)102 mem_map_out(fcode_env_t *env, fstack_t mcookie, fstack_t requested_len)
103 {
104 private_data_t *cdp = DEVICE_PRIVATE(env);
105 char *service = "map-out";
106 fc_cell_t requested_virt;
107 int error;
108
109 if (!is_mcookie(mcookie)) {
110 log_message(MSG_ERROR, "pci:%s: %x not mcookie!\n", service,
111 (uint32_t)mcookie);
112 requested_virt = mcookie;
113 } else {
114 requested_virt = mcookie_to_rvirt(mcookie);
115 requested_len = mcookie_to_rlen(mcookie);
116 delete_mapping(mcookie);
117 debug_msg(DEBUG_REG_ACCESS, "pci:%s: %x -> %llx\n", service,
118 (uint32_t)mcookie, (uint64_t)requested_virt);
119 }
120
121 error = fc_run_priv(cdp->common, service, 2, 0,
122 fc_size2cell(requested_len), requested_virt);
123
124 if (error)
125 log_message(MSG_ERROR, "pci:%s: failed\n", service);
126 }
127
128 static void
pci_config_fetch(fcode_env_t * env,char * service)129 pci_config_fetch(fcode_env_t *env, char *service)
130 {
131 uint32_t cfgadd;
132 fc_cell_t value;
133 private_data_t *h = DEVICE_PRIVATE(env);
134 int error;
135
136 ASSERT(h);
137 CHECK_DEPTH(env, 1, service);
138 cfgadd = POP(DS);
139 error = fc_run_priv(h->common, service, 1, 1, fc_uint32_t2cell(cfgadd),
140 &value);
141
142 if (error)
143 throw_from_fclib(env, 1, "pci:%s ( %x ) FAIL\n", service,
144 cfgadd);
145
146 PUSH(DS, value);
147 }
148
149 static void
pci_config_store(fcode_env_t * env,char * service)150 pci_config_store(fcode_env_t *env, char *service)
151 {
152 uint32_t cfgadd;
153 fc_cell_t value;
154 private_data_t *h = DEVICE_PRIVATE(env);
155 int error;
156
157 ASSERT(h);
158 CHECK_DEPTH(env, 2, service);
159 cfgadd = POP(DS);
160 value = POP(DS);
161 error = fc_run_priv(h->common, service, 2, 0, fc_uint32_t2cell(cfgadd),
162 fc_uint32_t2cell(value));
163
164 if (error)
165 throw_from_fclib(env, 1, "pci:%s ( %x %x ) FAIL\n", service,
166 cfgadd, value);
167 }
168
169 static void
config_lfetch(fcode_env_t * env)170 config_lfetch(fcode_env_t *env)
171 {
172 pci_config_fetch(env, "config-l@");
173 }
174
175 static void
config_lstore(fcode_env_t * env)176 config_lstore(fcode_env_t *env)
177 {
178 pci_config_store(env, "config-l!");
179 }
180
181 static void
config_wfetch(fcode_env_t * env)182 config_wfetch(fcode_env_t *env)
183 {
184 pci_config_fetch(env, "config-w@");
185 }
186
187 static void
config_wstore(fcode_env_t * env)188 config_wstore(fcode_env_t *env)
189 {
190 pci_config_store(env, "config-w!");
191 }
192
193 static void
config_bfetch(fcode_env_t * env)194 config_bfetch(fcode_env_t *env)
195 {
196 pci_config_fetch(env, "config-b@");
197 }
198
199 static void
config_bstore(fcode_env_t * env)200 config_bstore(fcode_env_t *env)
201 {
202 pci_config_store(env, "config-b!");
203 }
204
205 static void
do_map_in(fcode_env_t * env)206 do_map_in(fcode_env_t *env)
207 {
208 fstack_t phi, pmid, plo, len, addr;
209
210 CHECK_DEPTH(env, 4, "pci:map-in");
211 len = POP(DS);
212 phi = POP(DS);
213 pmid = POP(DS);
214 plo = POP(DS);
215 addr = mem_map_in(env, phi, pmid, plo, len);
216 PUSH(DS, addr);
217 }
218
219 static void
do_map_out(fcode_env_t * env)220 do_map_out(fcode_env_t *env)
221 {
222 fstack_t addr, len;
223
224 CHECK_DEPTH(env, 2, "pci:map-out");
225 len = POP(DS);
226 addr = POP(DS);
227 mem_map_out(env, addr, len);
228 }
229
230 static void
do_encode_unit(fcode_env_t * env)231 do_encode_unit(fcode_env_t *env)
232 {
233 char enc_buf[64];
234 uint32_t hi;
235 int dev, fn;
236
237 CHECK_DEPTH(env, 3, "pci:encode-unit");
238 hi = POP(DS);
239 (void) POP(DS);
240 (void) POP(DS);
241
242 fn = ((hi >> 8) & 0x7);
243 dev = ((hi >> 11) & 0x1f);
244
245 if (fn) {
246 sprintf(enc_buf, "%x,%x", dev, fn);
247 } else {
248 sprintf(enc_buf, "%x", dev);
249 }
250 debug_msg(DEBUG_REG_ACCESS, "pci:encode-unit ( %x ) -> %s\n",
251 hi, enc_buf);
252 push_a_string(env, STRDUP(enc_buf));
253 }
254
255 static void
do_decode_unit(fcode_env_t * env)256 do_decode_unit(fcode_env_t *env)
257 {
258 int lo, hi, unit;
259 char *buf;
260
261 CHECK_DEPTH(env, 2, "pci:decode-unit");
262 buf = pop_a_string(env, NULL);
263 if (sscanf(buf, "%x,%x", &hi, &lo) != 2) {
264 throw_from_fclib(env, 1, "pci:decode-unit: '%s'", buf);
265 }
266 unit = ((hi & 0x1f) << 11);
267 unit |= ((lo & 0x7) << 8);
268 debug_msg(DEBUG_REG_ACCESS, "pci:decode-unit ( '%s' ) -> 0 0 %x\n",
269 buf, unit);
270 PUSH(DS, 0);
271 PUSH(DS, 0);
272 PUSH(DS, unit);
273 }
274
275 static void
do_device_id(fcode_env_t * env)276 do_device_id(fcode_env_t *env)
277 {
278 uint32_t cfgadd;
279 uint16_t ven_id, dev_id;
280 char buf[40];
281
282 CHECK_DEPTH(env, 3, "pci:device-id");
283 cfgadd = POP(DS);
284 (void) POP(DS);
285 (void) POP(DS);
286 PUSH(DS, cfgadd + PCI_CONF_VENID);
287 config_wfetch(env);
288 ven_id = POP(DS);
289 PUSH(DS, cfgadd + PCI_CONF_DEVID);
290 config_wfetch(env);
291 dev_id = POP(DS);
292 sprintf(buf, "pci%x,%x", ven_id, dev_id);
293 push_a_string(env, STRDUP(buf));
294 }
295
296 static void
do_class_id(fcode_env_t * env)297 do_class_id(fcode_env_t *env)
298 {
299 uint32_t cfgadd;
300 uint8_t basclass, subclass, progclass;
301 char buf[40];
302
303 CHECK_DEPTH(env, 3, "pci:class-id");
304 cfgadd = POP(DS);
305 (void) POP(DS);
306 (void) POP(DS);
307 PUSH(DS, cfgadd + PCI_CONF_BASCLASS);
308 config_bfetch(env);
309 basclass = POP(DS);
310 PUSH(DS, cfgadd + PCI_CONF_SUBCLASS);
311 config_bfetch(env);
312 subclass = POP(DS);
313 PUSH(DS, cfgadd + PCI_CONF_PROGCLASS);
314 config_bfetch(env);
315 progclass = POP(DS);
316 sprintf(buf, "pciclass%02x%02x%02x", basclass, subclass, progclass);
317 push_a_string(env, STRDUP(buf));
318 }
319
320 #pragma init(_init)
321
322 static void
_init(void)323 _init(void)
324 {
325 fcode_env_t *env = initial_env;
326
327 ASSERT(env);
328 ASSERT(env->current_device);
329 NOTICE;
330
331 FORTH(0, "config-l@", config_lfetch);
332 FORTH(0, "config-l!", config_lstore);
333 FORTH(0, "config-w@", config_wfetch);
334 FORTH(0, "config-w!", config_wstore);
335 FORTH(0, "config-b@", config_bfetch);
336 FORTH(0, "config-b!", config_bstore);
337 FORTH(0, "map-in", do_map_in);
338 FORTH(0, "map-out", do_map_out);
339 FORTH(0, "decode-unit", do_decode_unit);
340 FORTH(0, "encode-unit", do_encode_unit);
341 FORTH(0, "device-id", do_device_id);
342 FORTH(0, "class-id", do_class_id);
343
344 install_dma_methods(env);
345 }
346