if_fwip.c revision 1.21 1 1.21 mrg /* $NetBSD: if_fwip.c,v 1.21 2010/03/11 04:00:37 mrg Exp $ */
2 1.1 kiyohara /*-
3 1.1 kiyohara * Copyright (c) 2004
4 1.1 kiyohara * Doug Rabson
5 1.1 kiyohara * Copyright (c) 2002-2003
6 1.1 kiyohara * Hidetoshi Shimokawa. All rights reserved.
7 1.1 kiyohara *
8 1.1 kiyohara * Redistribution and use in source and binary forms, with or without
9 1.1 kiyohara * modification, are permitted provided that the following conditions
10 1.1 kiyohara * are met:
11 1.1 kiyohara * 1. Redistributions of source code must retain the above copyright
12 1.1 kiyohara * notice, this list of conditions and the following disclaimer.
13 1.1 kiyohara * 2. Redistributions in binary form must reproduce the above copyright
14 1.1 kiyohara * notice, this list of conditions and the following disclaimer in the
15 1.1 kiyohara * documentation and/or other materials provided with the distribution.
16 1.1 kiyohara * 3. All advertising materials mentioning features or use of this software
17 1.1 kiyohara * must display the following acknowledgement:
18 1.1 kiyohara *
19 1.1 kiyohara * This product includes software developed by Hidetoshi Shimokawa.
20 1.1 kiyohara *
21 1.1 kiyohara * 4. Neither the name of the author nor the names of its contributors
22 1.1 kiyohara * may be used to endorse or promote products derived from this software
23 1.1 kiyohara * without specific prior written permission.
24 1.1 kiyohara *
25 1.1 kiyohara * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26 1.1 kiyohara * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 1.1 kiyohara * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 1.1 kiyohara * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 1.1 kiyohara * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 1.1 kiyohara * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 1.1 kiyohara * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 1.1 kiyohara * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 1.1 kiyohara * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 1.1 kiyohara * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 1.1 kiyohara * SUCH DAMAGE.
36 1.1 kiyohara *
37 1.10 kiyohara * $FreeBSD: src/sys/dev/firewire/if_fwip.c,v 1.16 2007/06/06 14:31:36 simokawa Exp $
38 1.1 kiyohara */
39 1.1 kiyohara
40 1.12 lukem #include <sys/cdefs.h>
41 1.21 mrg __KERNEL_RCSID(0, "$NetBSD: if_fwip.c,v 1.21 2010/03/11 04:00:37 mrg Exp $");
42 1.12 lukem
43 1.8 kiyohara #ifdef HAVE_KERNEL_OPTION_HEADERS
44 1.8 kiyohara #include "opt_device_polling.h"
45 1.1 kiyohara #include "opt_inet.h"
46 1.8 kiyohara #endif
47 1.1 kiyohara
48 1.1 kiyohara #if defined(__FreeBSD__)
49 1.1 kiyohara #include <sys/param.h>
50 1.1 kiyohara #include <sys/kernel.h>
51 1.1 kiyohara #include <sys/malloc.h>
52 1.1 kiyohara #include <sys/mbuf.h>
53 1.1 kiyohara #include <sys/socket.h>
54 1.1 kiyohara #include <sys/sockio.h>
55 1.1 kiyohara #include <sys/sysctl.h>
56 1.1 kiyohara #include <sys/systm.h>
57 1.1 kiyohara #include <sys/taskqueue.h>
58 1.1 kiyohara #include <sys/module.h>
59 1.1 kiyohara #include <sys/bus.h>
60 1.9 ad #include <sys/bus.h>
61 1.1 kiyohara
62 1.1 kiyohara #include <net/bpf.h>
63 1.1 kiyohara #include <net/if.h>
64 1.1 kiyohara #include <net/firewire.h>
65 1.1 kiyohara #include <net/if_arp.h>
66 1.8 kiyohara #include <net/if_types.h>
67 1.1 kiyohara #ifdef __DragonFly__
68 1.1 kiyohara #include <bus/firewire/fw_port.h>
69 1.1 kiyohara #include <bus/firewire/firewire.h>
70 1.1 kiyohara #include <bus/firewire/firewirereg.h>
71 1.1 kiyohara #include "if_fwipvar.h"
72 1.1 kiyohara #else
73 1.1 kiyohara #include <dev/firewire/fw_port.h>
74 1.1 kiyohara #include <dev/firewire/firewire.h>
75 1.1 kiyohara #include <dev/firewire/firewirereg.h>
76 1.1 kiyohara #include <dev/firewire/iec13213.h>
77 1.1 kiyohara #include <dev/firewire/if_fwipvar.h>
78 1.1 kiyohara #endif
79 1.1 kiyohara #elif defined(__NetBSD__)
80 1.1 kiyohara #include <sys/param.h>
81 1.1 kiyohara #include <sys/device.h>
82 1.1 kiyohara #include <sys/errno.h>
83 1.1 kiyohara #include <sys/malloc.h>
84 1.1 kiyohara #include <sys/mbuf.h>
85 1.1 kiyohara #include <sys/sysctl.h>
86 1.1 kiyohara
87 1.9 ad #include <sys/bus.h>
88 1.1 kiyohara
89 1.1 kiyohara #include <net/if.h>
90 1.1 kiyohara #include <net/if_ieee1394.h>
91 1.8 kiyohara #include <net/if_types.h>
92 1.1 kiyohara
93 1.1 kiyohara #include <dev/ieee1394/fw_port.h>
94 1.1 kiyohara #include <dev/ieee1394/firewire.h>
95 1.1 kiyohara #include <dev/ieee1394/firewirereg.h>
96 1.1 kiyohara #include <dev/ieee1394/iec13213.h>
97 1.1 kiyohara #include <dev/ieee1394/if_fwipvar.h>
98 1.1 kiyohara #endif
99 1.1 kiyohara
100 1.1 kiyohara /*
101 1.1 kiyohara * We really need a mechanism for allocating regions in the FIFO
102 1.1 kiyohara * address space. We pick a address in the OHCI controller's 'middle'
103 1.1 kiyohara * address space. This means that the controller will automatically
104 1.1 kiyohara * send responses for us, which is fine since we don't have any
105 1.1 kiyohara * important information to put in the response anyway.
106 1.1 kiyohara */
107 1.1 kiyohara #define INET_FIFO 0xfffe00000000LL
108 1.1 kiyohara
109 1.1 kiyohara #if defined(__FreeBSD__)
110 1.1 kiyohara #define FWIPDEBUG if (fwipdebug) if_printf
111 1.1 kiyohara #elif defined(__NetBSD__)
112 1.15 gmcgarry #define FWIPDEBUG if (fwipdebug) aprint_debug_ifnet
113 1.1 kiyohara #endif
114 1.1 kiyohara #define TX_MAX_QUEUE (FWMAXQUEUE - 1)
115 1.1 kiyohara
116 1.1 kiyohara #if defined(__NetBSD__)
117 1.19 cegger int fwipmatch (device_t, cfdata_t, void *);
118 1.14 kiyohara void fwipattach (device_t, device_t, void *);
119 1.14 kiyohara int fwipdetach (device_t, int);
120 1.14 kiyohara int fwipactivate (device_t, enum devact);
121 1.1 kiyohara
122 1.1 kiyohara #endif
123 1.1 kiyohara /* network interface */
124 1.1 kiyohara static void fwip_start (struct ifnet *);
125 1.7 christos static int fwip_ioctl (struct ifnet *, u_long, void *);
126 1.10 kiyohara #if defined(__FreeBSD__)
127 1.10 kiyohara static void fwip_init(void *);
128 1.10 kiyohara static void fwip_stop(struct fwip_softc *);
129 1.10 kiyohara #elif defined(__NetBSD__)
130 1.10 kiyohara static int fwip_init(struct ifnet *);
131 1.10 kiyohara static void fwip_stop(struct ifnet *, int);
132 1.10 kiyohara #endif
133 1.1 kiyohara
134 1.1 kiyohara static void fwip_post_busreset (void *);
135 1.1 kiyohara static void fwip_output_callback (struct fw_xfer *);
136 1.1 kiyohara static void fwip_async_output (struct fwip_softc *, struct ifnet *);
137 1.1 kiyohara static void fwip_start_send (void *, int);
138 1.1 kiyohara static void fwip_stream_input (struct fw_xferq *);
139 1.1 kiyohara static void fwip_unicast_input(struct fw_xfer *);
140 1.1 kiyohara
141 1.1 kiyohara static int fwipdebug = 0;
142 1.1 kiyohara static int broadcast_channel = 0xc0 | 0x1f; /* tag | channel(XXX) */
143 1.1 kiyohara static int tx_speed = 2;
144 1.1 kiyohara static int rx_queue_len = FWMAXQUEUE;
145 1.1 kiyohara
146 1.1 kiyohara #if defined(__FreeBSD__)
147 1.1 kiyohara MALLOC_DEFINE(M_FWIP, "if_fwip", "IP over FireWire interface");
148 1.1 kiyohara SYSCTL_INT(_debug, OID_AUTO, if_fwip_debug, CTLFLAG_RW, &fwipdebug, 0, "");
149 1.1 kiyohara SYSCTL_DECL(_hw_firewire);
150 1.1 kiyohara SYSCTL_NODE(_hw_firewire, OID_AUTO, fwip, CTLFLAG_RD, 0,
151 1.1 kiyohara "Firewire ip subsystem");
152 1.1 kiyohara SYSCTL_INT(_hw_firewire_fwip, OID_AUTO, rx_queue_len, CTLFLAG_RW, &rx_queue_len,
153 1.1 kiyohara 0, "Length of the receive queue");
154 1.1 kiyohara
155 1.1 kiyohara TUNABLE_INT("hw.firewire.fwip.rx_queue_len", &rx_queue_len);
156 1.1 kiyohara #elif defined(__NetBSD__)
157 1.1 kiyohara MALLOC_DEFINE(M_FWIP, "if_fwip", "IP over IEEE1394 interface");
158 1.1 kiyohara /*
159 1.1 kiyohara * Setup sysctl(3) MIB, hw.fwip.*
160 1.1 kiyohara *
161 1.17 ad * TBD condition CTLFLAG_PERMANENT on being a module or not
162 1.1 kiyohara */
163 1.1 kiyohara SYSCTL_SETUP(sysctl_fwip, "sysctl fwip(4) subtree setup")
164 1.1 kiyohara {
165 1.1 kiyohara int rc, fwip_node_num;
166 1.1 kiyohara const struct sysctlnode *node;
167 1.1 kiyohara
168 1.1 kiyohara if ((rc = sysctl_createv(clog, 0, NULL, NULL,
169 1.1 kiyohara CTLFLAG_PERMANENT, CTLTYPE_NODE, "hw", NULL,
170 1.1 kiyohara NULL, 0, NULL, 0, CTL_HW, CTL_EOL)) != 0) {
171 1.1 kiyohara goto err;
172 1.1 kiyohara }
173 1.1 kiyohara
174 1.1 kiyohara if ((rc = sysctl_createv(clog, 0, NULL, &node,
175 1.1 kiyohara CTLFLAG_PERMANENT, CTLTYPE_NODE, "fwip",
176 1.1 kiyohara SYSCTL_DESCR("fwip controls"),
177 1.1 kiyohara NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) {
178 1.1 kiyohara goto err;
179 1.1 kiyohara }
180 1.1 kiyohara fwip_node_num = node->sysctl_num;
181 1.1 kiyohara
182 1.1 kiyohara /* fwip RX queue length */
183 1.1 kiyohara if ((rc = sysctl_createv(clog, 0, NULL, &node,
184 1.1 kiyohara CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT,
185 1.1 kiyohara "rx_queue_len", SYSCTL_DESCR("Length of the receive queue"),
186 1.1 kiyohara NULL, 0, &rx_queue_len,
187 1.1 kiyohara 0, CTL_HW, fwip_node_num, CTL_CREATE, CTL_EOL)) != 0) {
188 1.1 kiyohara goto err;
189 1.1 kiyohara }
190 1.1 kiyohara
191 1.1 kiyohara /* fwip RX queue length */
192 1.1 kiyohara if ((rc = sysctl_createv(clog, 0, NULL, &node,
193 1.1 kiyohara CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT,
194 1.1 kiyohara "if_fwip_debug", SYSCTL_DESCR("fwip driver debug flag"),
195 1.1 kiyohara NULL, 0, &fwipdebug,
196 1.1 kiyohara 0, CTL_HW, fwip_node_num, CTL_CREATE, CTL_EOL)) != 0) {
197 1.1 kiyohara goto err;
198 1.1 kiyohara }
199 1.1 kiyohara
200 1.1 kiyohara return;
201 1.1 kiyohara
202 1.1 kiyohara err:
203 1.1 kiyohara printf("%s: sysctl_createv failed (rc = %d)\n", __func__, rc);
204 1.1 kiyohara }
205 1.1 kiyohara #endif
206 1.1 kiyohara
207 1.1 kiyohara #ifdef DEVICE_POLLING
208 1.1 kiyohara static poll_handler_t fwip_poll;
209 1.1 kiyohara
210 1.1 kiyohara static void
211 1.1 kiyohara fwip_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
212 1.1 kiyohara {
213 1.1 kiyohara struct fwip_softc *fwip;
214 1.1 kiyohara struct firewire_comm *fc;
215 1.1 kiyohara
216 1.8 kiyohara if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
217 1.8 kiyohara return;
218 1.8 kiyohara
219 1.1 kiyohara fwip = ((struct fwip_eth_softc *)ifp->if_softc)->fwip;
220 1.1 kiyohara fc = fwip->fd.fc;
221 1.1 kiyohara fc->poll(fc, (cmd == POLL_AND_CHECK_STATUS)?0:1, count);
222 1.1 kiyohara }
223 1.8 kiyohara #endif /* DEVICE_POLLING */
224 1.1 kiyohara #if defined(__FreeBSD__)
225 1.1 kiyohara static void
226 1.1 kiyohara fwip_identify(driver_t *driver, device_t parent)
227 1.1 kiyohara {
228 1.10 kiyohara BUS_ADD_CHILD(parent, 0, "fwip", fw_get_unit(parent));
229 1.1 kiyohara }
230 1.1 kiyohara
231 1.1 kiyohara static int
232 1.1 kiyohara fwip_probe(device_t dev)
233 1.1 kiyohara {
234 1.1 kiyohara device_t pa;
235 1.1 kiyohara
236 1.1 kiyohara pa = device_get_parent(dev);
237 1.10 kiyohara if(fw_get_unit(dev) != fw_get_unit(pa)){
238 1.1 kiyohara return(ENXIO);
239 1.1 kiyohara }
240 1.1 kiyohara
241 1.1 kiyohara device_set_desc(dev, "IP over FireWire");
242 1.1 kiyohara return (0);
243 1.1 kiyohara }
244 1.1 kiyohara #elif defined(__NetBSD__)
245 1.1 kiyohara int
246 1.19 cegger fwipmatch(device_t parent, cfdata_t cf, void *aux)
247 1.1 kiyohara {
248 1.1 kiyohara struct fw_attach_args *fwa = aux;
249 1.1 kiyohara
250 1.1 kiyohara if (strcmp(fwa->name, "fwip") == 0)
251 1.1 kiyohara return (1);
252 1.1 kiyohara return (0);
253 1.1 kiyohara }
254 1.1 kiyohara #endif
255 1.1 kiyohara
256 1.1 kiyohara FW_ATTACH(fwip)
257 1.1 kiyohara {
258 1.1 kiyohara FW_ATTACH_START(fwip, fwip, fwa);
259 1.1 kiyohara FWIP_ATTACH_START;
260 1.1 kiyohara struct ifnet *ifp;
261 1.1 kiyohara int s;
262 1.1 kiyohara
263 1.1 kiyohara FWIP_ATTACH_SETUP;
264 1.1 kiyohara
265 1.8 kiyohara ifp = fwip->fw_softc.fwip_ifp;
266 1.8 kiyohara if (ifp == NULL)
267 1.8 kiyohara FW_ATTACH_RETURN(ENOSPC);
268 1.8 kiyohara
269 1.21 mrg #ifdef __NetBSD__
270 1.21 mrg aprint_naive("\n");
271 1.21 mrg #endif
272 1.21 mrg
273 1.10 kiyohara fw_mtx_init(&fwip->mtx, "fwip", NULL, MTX_DEF);
274 1.1 kiyohara /* XXX */
275 1.1 kiyohara fwip->dma_ch = -1;
276 1.1 kiyohara
277 1.1 kiyohara fwip->fd.fc = fwa->fc;
278 1.1 kiyohara if (tx_speed < 0)
279 1.1 kiyohara tx_speed = fwip->fd.fc->speed;
280 1.1 kiyohara
281 1.1 kiyohara fwip->fd.post_explore = NULL;
282 1.1 kiyohara fwip->fd.post_busreset = fwip_post_busreset;
283 1.1 kiyohara fwip->fw_softc.fwip = fwip;
284 1.10 kiyohara FW_TASK_INIT(&fwip->start_send, 0, fwip_start_send, fwip);
285 1.1 kiyohara
286 1.1 kiyohara /*
287 1.1 kiyohara * Encode our hardware the way that arp likes it.
288 1.1 kiyohara */
289 1.1 kiyohara hwaddr->sender_unique_ID_hi = htonl(fwip->fd.fc->eui.hi);
290 1.1 kiyohara hwaddr->sender_unique_ID_lo = htonl(fwip->fd.fc->eui.lo);
291 1.1 kiyohara hwaddr->sender_max_rec = fwip->fd.fc->maxrec;
292 1.1 kiyohara hwaddr->sspd = fwip->fd.fc->speed;
293 1.1 kiyohara hwaddr->sender_unicast_FIFO_hi = htons((uint16_t)(INET_FIFO >> 32));
294 1.1 kiyohara hwaddr->sender_unicast_FIFO_lo = htonl((uint32_t)INET_FIFO);
295 1.1 kiyohara
296 1.1 kiyohara /* fill the rest and attach interface */
297 1.1 kiyohara ifp->if_softc = &fwip->fw_softc;
298 1.1 kiyohara
299 1.1 kiyohara #if __FreeBSD_version >= 501113 || defined(__DragonFly__) || defined(__NetBSD__)
300 1.1 kiyohara IF_INITNAME(ifp, dev, unit);
301 1.1 kiyohara #else
302 1.1 kiyohara ifp->if_unit = unit;
303 1.1 kiyohara ifp->if_name = "fwip";
304 1.1 kiyohara #endif
305 1.1 kiyohara #if defined(__NetBSD__)
306 1.1 kiyohara IFQ_SET_READY(&ifp->if_snd);
307 1.1 kiyohara #endif
308 1.1 kiyohara SET_IFFUNC(ifp, fwip_start, fwip_ioctl, fwip_init, fwip_stop);
309 1.10 kiyohara ifp->if_flags = (IFF_BROADCAST|IFF_SIMPLEX|IFF_MULTICAST);
310 1.1 kiyohara ifp->if_snd.ifq_maxlen = TX_MAX_QUEUE;
311 1.8 kiyohara #ifdef DEVICE_POLLING
312 1.8 kiyohara ifp->if_capabilities |= IFCAP_POLLING;
313 1.8 kiyohara #endif
314 1.1 kiyohara
315 1.1 kiyohara s = splfwnet();
316 1.1 kiyohara FIREWIRE_IFATTACH(ifp, hwaddr);
317 1.1 kiyohara splx(s);
318 1.1 kiyohara
319 1.11 jmcneill #if defined(__NetBSD__)
320 1.11 jmcneill if (!pmf_device_register(self, NULL, NULL))
321 1.11 jmcneill aprint_error_dev(self, "couldn't establish power handler\n");
322 1.11 jmcneill else
323 1.11 jmcneill pmf_class_network_register(self, ifp);
324 1.11 jmcneill #endif
325 1.11 jmcneill
326 1.1 kiyohara FWIPDEBUG(ifp, "interface created\n");
327 1.1 kiyohara FW_ATTACH_RETURN(0);
328 1.1 kiyohara }
329 1.1 kiyohara
330 1.1 kiyohara IF_STOP(fwip)
331 1.1 kiyohara {
332 1.1 kiyohara IF_STOP_START(fwip, ifp, fwip);
333 1.1 kiyohara struct firewire_comm *fc;
334 1.1 kiyohara struct fw_xferq *xferq;
335 1.1 kiyohara struct fw_xfer *xfer, *next;
336 1.1 kiyohara int i;
337 1.1 kiyohara
338 1.1 kiyohara fc = fwip->fd.fc;
339 1.1 kiyohara
340 1.1 kiyohara if (fwip->dma_ch >= 0) {
341 1.1 kiyohara xferq = fc->ir[fwip->dma_ch];
342 1.1 kiyohara
343 1.1 kiyohara if (xferq->flag & FWXFERQ_RUNNING)
344 1.1 kiyohara fc->irx_disable(fc, fwip->dma_ch);
345 1.1 kiyohara xferq->flag &=
346 1.1 kiyohara ~(FWXFERQ_MODEMASK | FWXFERQ_OPEN | FWXFERQ_STREAM |
347 1.1 kiyohara FWXFERQ_EXTBUF | FWXFERQ_HANDLER | FWXFERQ_CHTAGMASK);
348 1.1 kiyohara xferq->hand = NULL;
349 1.1 kiyohara
350 1.1 kiyohara for (i = 0; i < xferq->bnchunk; i ++)
351 1.1 kiyohara m_freem(xferq->bulkxfer[i].mbuf);
352 1.1 kiyohara free(xferq->bulkxfer, M_FWIP);
353 1.1 kiyohara
354 1.1 kiyohara fw_bindremove(fc, &fwip->fwb);
355 1.1 kiyohara for (xfer = STAILQ_FIRST(&fwip->fwb.xferlist); xfer != NULL;
356 1.1 kiyohara xfer = next) {
357 1.1 kiyohara next = STAILQ_NEXT(xfer, link);
358 1.1 kiyohara fw_xfer_free(xfer);
359 1.1 kiyohara }
360 1.1 kiyohara
361 1.1 kiyohara for (xfer = STAILQ_FIRST(&fwip->xferlist); xfer != NULL;
362 1.1 kiyohara xfer = next) {
363 1.1 kiyohara next = STAILQ_NEXT(xfer, link);
364 1.1 kiyohara fw_xfer_free(xfer);
365 1.1 kiyohara }
366 1.1 kiyohara STAILQ_INIT(&fwip->xferlist);
367 1.1 kiyohara
368 1.1 kiyohara xferq->bulkxfer = NULL;
369 1.1 kiyohara fwip->dma_ch = -1;
370 1.1 kiyohara }
371 1.1 kiyohara
372 1.8 kiyohara #if defined(__FreeBSD__)
373 1.8 kiyohara ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
374 1.8 kiyohara #elif defined(__NetBSD__)
375 1.1 kiyohara ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
376 1.8 kiyohara #endif
377 1.1 kiyohara }
378 1.1 kiyohara
379 1.1 kiyohara FW_DETACH(fwip)
380 1.1 kiyohara {
381 1.1 kiyohara IF_DETACH_START(fwip, fwip);
382 1.8 kiyohara struct ifnet *ifp;
383 1.1 kiyohara int s;
384 1.1 kiyohara
385 1.8 kiyohara ifp = fwip->fw_softc.fwip_ifp;
386 1.8 kiyohara
387 1.8 kiyohara #ifdef DEVICE_POLLING
388 1.8 kiyohara if (ifp->if_capenable & IFCAP_POLLING)
389 1.8 kiyohara ether_poll_deregister(ifp);
390 1.8 kiyohara #endif
391 1.8 kiyohara
392 1.1 kiyohara s = splfwnet();
393 1.1 kiyohara
394 1.1 kiyohara FWIP_STOP(fwip);
395 1.8 kiyohara FIREWIRE_IFDETACH(ifp);
396 1.10 kiyohara fw_mtx_destroy(&fwip->mtx);
397 1.1 kiyohara
398 1.1 kiyohara splx(s);
399 1.1 kiyohara return 0;
400 1.1 kiyohara }
401 1.1 kiyohara
402 1.1 kiyohara int
403 1.14 kiyohara fwipactivate(device_t self, enum devact act)
404 1.1 kiyohara {
405 1.14 kiyohara struct fwip_softc *fwip = device_private(self);
406 1.1 kiyohara
407 1.1 kiyohara switch (act) {
408 1.1 kiyohara case DVACT_DEACTIVATE:
409 1.8 kiyohara if_deactivate(fwip->fw_softc.fwip_ifp);
410 1.20 dyoung return 0;
411 1.20 dyoung default:
412 1.20 dyoung return EOPNOTSUPP;
413 1.1 kiyohara }
414 1.1 kiyohara }
415 1.1 kiyohara
416 1.1 kiyohara IF_INIT(fwip)
417 1.1 kiyohara {
418 1.1 kiyohara IF_INIT_START(fwip, fwip, ifp);
419 1.1 kiyohara struct firewire_comm *fc;
420 1.1 kiyohara struct fw_xferq *xferq;
421 1.1 kiyohara struct fw_xfer *xfer;
422 1.1 kiyohara struct mbuf *m;
423 1.1 kiyohara int i;
424 1.1 kiyohara
425 1.1 kiyohara FWIPDEBUG(ifp, "initializing\n");
426 1.1 kiyohara
427 1.1 kiyohara fc = fwip->fd.fc;
428 1.1 kiyohara #define START 0
429 1.1 kiyohara if (fwip->dma_ch < 0) {
430 1.10 kiyohara fwip->dma_ch = fw_open_isodma(fc, /* tx */0);
431 1.10 kiyohara if (fwip->dma_ch < 0)
432 1.10 kiyohara IF_INIT_RETURN(ENXIO);
433 1.10 kiyohara xferq = fc->ir[fwip->dma_ch];
434 1.10 kiyohara xferq->flag |=
435 1.10 kiyohara FWXFERQ_EXTBUF | FWXFERQ_HANDLER | FWXFERQ_STREAM;
436 1.1 kiyohara xferq->flag &= ~0xff;
437 1.1 kiyohara xferq->flag |= broadcast_channel & 0xff;
438 1.1 kiyohara /* register fwip_input handler */
439 1.7 christos xferq->sc = (void *) fwip;
440 1.1 kiyohara xferq->hand = fwip_stream_input;
441 1.1 kiyohara xferq->bnchunk = rx_queue_len;
442 1.1 kiyohara xferq->bnpacket = 1;
443 1.1 kiyohara xferq->psize = MCLBYTES;
444 1.1 kiyohara xferq->queued = 0;
445 1.1 kiyohara xferq->buf = NULL;
446 1.1 kiyohara xferq->bulkxfer = (struct fw_bulkxfer *) malloc(
447 1.1 kiyohara sizeof(struct fw_bulkxfer) * xferq->bnchunk,
448 1.1 kiyohara M_FWIP, M_WAITOK);
449 1.1 kiyohara if (xferq->bulkxfer == NULL) {
450 1.1 kiyohara printf("if_fwip: malloc failed\n");
451 1.1 kiyohara IF_INIT_RETURN(ENOMEM);
452 1.1 kiyohara }
453 1.1 kiyohara STAILQ_INIT(&xferq->stvalid);
454 1.1 kiyohara STAILQ_INIT(&xferq->stfree);
455 1.1 kiyohara STAILQ_INIT(&xferq->stdma);
456 1.1 kiyohara xferq->stproc = NULL;
457 1.1 kiyohara for (i = 0; i < xferq->bnchunk; i ++) {
458 1.1 kiyohara m =
459 1.1 kiyohara #if defined(__DragonFly__) || __FreeBSD_version < 500000
460 1.1 kiyohara m_getcl(M_WAIT, MT_DATA, M_PKTHDR);
461 1.1 kiyohara #else
462 1.1 kiyohara m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
463 1.1 kiyohara #endif
464 1.1 kiyohara xferq->bulkxfer[i].mbuf = m;
465 1.1 kiyohara if (m != NULL) {
466 1.1 kiyohara m->m_len = m->m_pkthdr.len = m->m_ext.ext_size;
467 1.1 kiyohara STAILQ_INSERT_TAIL(&xferq->stfree,
468 1.1 kiyohara &xferq->bulkxfer[i], link);
469 1.1 kiyohara } else
470 1.1 kiyohara printf("fwip_as_input: m_getcl failed\n");
471 1.1 kiyohara }
472 1.1 kiyohara
473 1.1 kiyohara fwip->fwb.start = INET_FIFO;
474 1.1 kiyohara fwip->fwb.end = INET_FIFO + 16384; /* S3200 packet size */
475 1.1 kiyohara
476 1.1 kiyohara /* pre-allocate xfer */
477 1.1 kiyohara STAILQ_INIT(&fwip->fwb.xferlist);
478 1.1 kiyohara for (i = 0; i < rx_queue_len; i ++) {
479 1.1 kiyohara xfer = fw_xfer_alloc(M_FWIP);
480 1.1 kiyohara if (xfer == NULL)
481 1.1 kiyohara break;
482 1.1 kiyohara m = m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
483 1.1 kiyohara xfer->recv.payload = mtod(m, uint32_t *);
484 1.1 kiyohara xfer->recv.pay_len = MCLBYTES;
485 1.1 kiyohara xfer->hand = fwip_unicast_input;
486 1.1 kiyohara xfer->fc = fc;
487 1.7 christos xfer->sc = (void *)fwip;
488 1.1 kiyohara xfer->mbuf = m;
489 1.1 kiyohara STAILQ_INSERT_TAIL(&fwip->fwb.xferlist, xfer, link);
490 1.1 kiyohara }
491 1.1 kiyohara fw_bindadd(fc, &fwip->fwb);
492 1.1 kiyohara
493 1.1 kiyohara STAILQ_INIT(&fwip->xferlist);
494 1.1 kiyohara for (i = 0; i < TX_MAX_QUEUE; i++) {
495 1.1 kiyohara xfer = fw_xfer_alloc(M_FWIP);
496 1.1 kiyohara if (xfer == NULL)
497 1.1 kiyohara break;
498 1.1 kiyohara xfer->send.spd = tx_speed;
499 1.1 kiyohara xfer->fc = fwip->fd.fc;
500 1.7 christos xfer->sc = (void *)fwip;
501 1.1 kiyohara xfer->hand = fwip_output_callback;
502 1.1 kiyohara STAILQ_INSERT_TAIL(&fwip->xferlist, xfer, link);
503 1.1 kiyohara }
504 1.1 kiyohara } else
505 1.1 kiyohara xferq = fc->ir[fwip->dma_ch];
506 1.1 kiyohara
507 1.1 kiyohara fwip->last_dest.hi = 0;
508 1.1 kiyohara fwip->last_dest.lo = 0;
509 1.1 kiyohara
510 1.1 kiyohara /* start dma */
511 1.1 kiyohara if ((xferq->flag & FWXFERQ_RUNNING) == 0)
512 1.1 kiyohara fc->irx_enable(fc, fwip->dma_ch);
513 1.1 kiyohara
514 1.8 kiyohara #if defined(__FreeBSD__)
515 1.8 kiyohara ifp->if_drv_flags |= IFF_DRV_RUNNING;
516 1.8 kiyohara ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
517 1.8 kiyohara #elif defined(__NetBSD__)
518 1.1 kiyohara ifp->if_flags |= IFF_RUNNING;
519 1.1 kiyohara ifp->if_flags &= ~IFF_OACTIVE;
520 1.8 kiyohara #endif
521 1.1 kiyohara
522 1.1 kiyohara #if 0
523 1.1 kiyohara /* attempt to start output */
524 1.1 kiyohara fwip_start(ifp);
525 1.1 kiyohara #endif
526 1.1 kiyohara IF_INIT_RETURN(0);
527 1.1 kiyohara }
528 1.1 kiyohara
529 1.1 kiyohara static int
530 1.7 christos fwip_ioctl(struct ifnet *ifp, u_long cmd, void *data)
531 1.1 kiyohara {
532 1.1 kiyohara IF_IOCTL_START(fwip, fwip);
533 1.13 dyoung int s, error = 0;
534 1.1 kiyohara
535 1.1 kiyohara switch (cmd) {
536 1.1 kiyohara case SIOCSIFFLAGS:
537 1.1 kiyohara s = splfwnet();
538 1.16 dyoung if ((error = ifioctl_common(ifp, cmd, data)) != 0)
539 1.16 dyoung ;
540 1.16 dyoung else if (ifp->if_flags & IFF_UP) {
541 1.1 kiyohara if (!(ifp->if_flags & IFF_RUNNING))
542 1.1 kiyohara FWIP_INIT(fwip);
543 1.1 kiyohara } else {
544 1.1 kiyohara if (ifp->if_flags & IFF_RUNNING)
545 1.1 kiyohara FWIP_STOP(fwip);
546 1.1 kiyohara }
547 1.1 kiyohara splx(s);
548 1.1 kiyohara break;
549 1.1 kiyohara case SIOCADDMULTI:
550 1.1 kiyohara case SIOCDELMULTI:
551 1.1 kiyohara break;
552 1.8 kiyohara case SIOCSIFCAP:
553 1.13 dyoung if ((error = FIREWIRE_IOCTL(ifp, cmd, data)) != ENETRESET)
554 1.13 dyoung break;
555 1.13 dyoung error = 0;
556 1.8 kiyohara #ifdef DEVICE_POLLING
557 1.8 kiyohara {
558 1.8 kiyohara struct ifreq *ifr = (struct ifreq *) data;
559 1.8 kiyohara struct firewire_comm *fc = fc = fwip->fd.fc;
560 1.8 kiyohara
561 1.8 kiyohara if (ifr->ifr_reqcap & IFCAP_POLLING &&
562 1.8 kiyohara !(ifp->if_capenable & IFCAP_POLLING)) {
563 1.8 kiyohara error = ether_poll_register(fwip_poll, ifp);
564 1.8 kiyohara if (error)
565 1.8 kiyohara return(error);
566 1.8 kiyohara /* Disable interrupts */
567 1.8 kiyohara fc->set_intr(fc, 0);
568 1.8 kiyohara ifp->if_capenable |= IFCAP_POLLING;
569 1.8 kiyohara return (error);
570 1.8 kiyohara
571 1.8 kiyohara }
572 1.8 kiyohara if (!(ifr->ifr_reqcap & IFCAP_POLLING) &&
573 1.8 kiyohara ifp->if_capenable & IFCAP_POLLING) {
574 1.8 kiyohara error = ether_poll_deregister(ifp);
575 1.8 kiyohara /* Enable interrupts. */
576 1.8 kiyohara fc->set_intr(fc, 1);
577 1.8 kiyohara ifp->if_capenable &= ~IFCAP_POLLING;
578 1.8 kiyohara return (error);
579 1.8 kiyohara }
580 1.8 kiyohara }
581 1.8 kiyohara #endif /* DEVICE_POLLING */
582 1.8 kiyohara break;
583 1.1 kiyohara
584 1.1 kiyohara default:
585 1.1 kiyohara s = splfwnet();
586 1.1 kiyohara error = FIREWIRE_IOCTL(ifp, cmd, data);
587 1.1 kiyohara splx(s);
588 1.1 kiyohara return (error);
589 1.1 kiyohara }
590 1.1 kiyohara
591 1.13 dyoung return error;
592 1.1 kiyohara }
593 1.1 kiyohara
594 1.1 kiyohara static void
595 1.1 kiyohara fwip_post_busreset(void *arg)
596 1.1 kiyohara {
597 1.1 kiyohara struct fwip_softc *fwip = arg;
598 1.1 kiyohara struct crom_src *src;
599 1.1 kiyohara struct crom_chunk *root;
600 1.1 kiyohara
601 1.1 kiyohara src = fwip->fd.fc->crom_src;
602 1.1 kiyohara root = fwip->fd.fc->crom_root;
603 1.1 kiyohara
604 1.1 kiyohara /* RFC2734 IPv4 over IEEE1394 */
605 1.18 cegger memset(&fwip->unit4, 0, sizeof(struct crom_chunk));
606 1.1 kiyohara crom_add_chunk(src, root, &fwip->unit4, CROM_UDIR);
607 1.1 kiyohara crom_add_entry(&fwip->unit4, CSRKEY_SPEC, CSRVAL_IETF);
608 1.1 kiyohara crom_add_simple_text(src, &fwip->unit4, &fwip->spec4, "IANA");
609 1.1 kiyohara crom_add_entry(&fwip->unit4, CSRKEY_VER, 1);
610 1.1 kiyohara crom_add_simple_text(src, &fwip->unit4, &fwip->ver4, "IPv4");
611 1.1 kiyohara
612 1.1 kiyohara /* RFC3146 IPv6 over IEEE1394 */
613 1.18 cegger memset(&fwip->unit6, 0, sizeof(struct crom_chunk));
614 1.1 kiyohara crom_add_chunk(src, root, &fwip->unit6, CROM_UDIR);
615 1.1 kiyohara crom_add_entry(&fwip->unit6, CSRKEY_SPEC, CSRVAL_IETF);
616 1.1 kiyohara crom_add_simple_text(src, &fwip->unit6, &fwip->spec6, "IANA");
617 1.1 kiyohara crom_add_entry(&fwip->unit6, CSRKEY_VER, 2);
618 1.1 kiyohara crom_add_simple_text(src, &fwip->unit6, &fwip->ver6, "IPv6");
619 1.1 kiyohara
620 1.1 kiyohara fwip->last_dest.hi = 0;
621 1.1 kiyohara fwip->last_dest.lo = 0;
622 1.8 kiyohara FIREWIRE_BUSRESET(fwip->fw_softc.fwip_ifp);
623 1.1 kiyohara }
624 1.1 kiyohara
625 1.1 kiyohara static void
626 1.1 kiyohara fwip_output_callback(struct fw_xfer *xfer)
627 1.1 kiyohara {
628 1.1 kiyohara struct fwip_softc *fwip;
629 1.1 kiyohara struct ifnet *ifp;
630 1.1 kiyohara int s;
631 1.1 kiyohara
632 1.1 kiyohara fwip = (struct fwip_softc *)xfer->sc;
633 1.8 kiyohara ifp = fwip->fw_softc.fwip_ifp;
634 1.1 kiyohara /* XXX error check */
635 1.1 kiyohara FWIPDEBUG(ifp, "resp = %d\n", xfer->resp);
636 1.1 kiyohara if (xfer->resp != 0)
637 1.1 kiyohara ifp->if_oerrors ++;
638 1.1 kiyohara
639 1.1 kiyohara m_freem(xfer->mbuf);
640 1.1 kiyohara fw_xfer_unload(xfer);
641 1.1 kiyohara
642 1.1 kiyohara s = splfwnet();
643 1.10 kiyohara FWIP_LOCK(fwip);
644 1.1 kiyohara STAILQ_INSERT_TAIL(&fwip->xferlist, xfer, link);
645 1.10 kiyohara FWIP_UNLOCK(fwip);
646 1.1 kiyohara splx(s);
647 1.1 kiyohara
648 1.1 kiyohara /* for queue full */
649 1.10 kiyohara if (ifp->if_snd.ifq_head != NULL) {
650 1.1 kiyohara fwip_start(ifp);
651 1.10 kiyohara }
652 1.1 kiyohara }
653 1.1 kiyohara
654 1.1 kiyohara static void
655 1.1 kiyohara fwip_start(struct ifnet *ifp)
656 1.1 kiyohara {
657 1.8 kiyohara struct fwip_softc *fwip =
658 1.8 kiyohara ((struct fwip_eth_softc *)ifp->if_softc)->fwip;
659 1.1 kiyohara int s;
660 1.1 kiyohara
661 1.1 kiyohara FWIPDEBUG(ifp, "starting\n");
662 1.1 kiyohara
663 1.1 kiyohara if (fwip->dma_ch < 0) {
664 1.1 kiyohara struct mbuf *m = NULL;
665 1.1 kiyohara
666 1.1 kiyohara FWIPDEBUG(ifp, "not ready\n");
667 1.1 kiyohara
668 1.1 kiyohara s = splfwnet();
669 1.1 kiyohara do {
670 1.1 kiyohara IF_DEQUEUE(&ifp->if_snd, m);
671 1.1 kiyohara if (m != NULL)
672 1.1 kiyohara m_freem(m);
673 1.1 kiyohara ifp->if_oerrors ++;
674 1.1 kiyohara } while (m != NULL);
675 1.1 kiyohara splx(s);
676 1.1 kiyohara
677 1.1 kiyohara return;
678 1.1 kiyohara }
679 1.1 kiyohara
680 1.1 kiyohara s = splfwnet();
681 1.8 kiyohara #if defined(__FreeBSD__)
682 1.8 kiyohara ifp->if_drv_flags |= IFF_DRV_OACTIVE;
683 1.8 kiyohara #elif defined(__NetBSD__)
684 1.1 kiyohara ifp->if_flags |= IFF_OACTIVE;
685 1.8 kiyohara #endif
686 1.1 kiyohara
687 1.1 kiyohara if (ifp->if_snd.ifq_len != 0)
688 1.1 kiyohara fwip_async_output(fwip, ifp);
689 1.1 kiyohara
690 1.8 kiyohara #if defined(__FreeBSD__)
691 1.8 kiyohara ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
692 1.8 kiyohara #elif defined(__NetBSD__)
693 1.1 kiyohara ifp->if_flags &= ~IFF_OACTIVE;
694 1.8 kiyohara #endif
695 1.1 kiyohara splx(s);
696 1.1 kiyohara }
697 1.1 kiyohara
698 1.1 kiyohara /* Async. stream output */
699 1.1 kiyohara static void
700 1.1 kiyohara fwip_async_output(struct fwip_softc *fwip, struct ifnet *ifp)
701 1.1 kiyohara {
702 1.1 kiyohara struct firewire_comm *fc = fwip->fd.fc;
703 1.1 kiyohara struct mbuf *m;
704 1.1 kiyohara struct m_tag *mtag;
705 1.1 kiyohara struct fw_hwaddr *destfw;
706 1.1 kiyohara struct fw_xfer *xfer;
707 1.1 kiyohara struct fw_xferq *xferq;
708 1.1 kiyohara struct fw_pkt *fp;
709 1.1 kiyohara uint16_t nodeid;
710 1.1 kiyohara int error;
711 1.1 kiyohara int i = 0;
712 1.1 kiyohara
713 1.1 kiyohara xfer = NULL;
714 1.10 kiyohara xferq = fc->atq;
715 1.10 kiyohara while ((xferq->queued < xferq->maxq - 1) &&
716 1.10 kiyohara (ifp->if_snd.ifq_head != NULL)) {
717 1.10 kiyohara FWIP_LOCK(fwip);
718 1.1 kiyohara xfer = STAILQ_FIRST(&fwip->xferlist);
719 1.1 kiyohara if (xfer == NULL) {
720 1.10 kiyohara FWIP_UNLOCK(fwip);
721 1.10 kiyohara #if 0
722 1.1 kiyohara printf("if_fwip: lack of xfer\n");
723 1.10 kiyohara #endif
724 1.10 kiyohara break;
725 1.1 kiyohara }
726 1.10 kiyohara STAILQ_REMOVE_HEAD(&fwip->xferlist, link);
727 1.10 kiyohara FWIP_UNLOCK(fwip);
728 1.10 kiyohara
729 1.1 kiyohara IF_DEQUEUE(&ifp->if_snd, m);
730 1.10 kiyohara if (m == NULL) {
731 1.10 kiyohara FWIP_LOCK(fwip);
732 1.10 kiyohara STAILQ_INSERT_HEAD(&fwip->xferlist, xfer, link);
733 1.10 kiyohara FWIP_UNLOCK(fwip);
734 1.1 kiyohara break;
735 1.10 kiyohara }
736 1.1 kiyohara
737 1.1 kiyohara /*
738 1.1 kiyohara * Dig out the link-level address which
739 1.1 kiyohara * firewire_output got via arp or neighbour
740 1.1 kiyohara * discovery. If we don't have a link-level address,
741 1.1 kiyohara * just stick the thing on the broadcast channel.
742 1.1 kiyohara */
743 1.1 kiyohara mtag = m_tag_locate(m, MTAG_FIREWIRE, MTAG_FIREWIRE_HWADDR, 0);
744 1.1 kiyohara if (mtag == NULL)
745 1.1 kiyohara destfw = 0;
746 1.1 kiyohara else
747 1.1 kiyohara destfw = (struct fw_hwaddr *) (mtag + 1);
748 1.1 kiyohara
749 1.1 kiyohara /*
750 1.1 kiyohara * We don't do any bpf stuff here - the generic code
751 1.1 kiyohara * in firewire_output gives the packet to bpf before
752 1.1 kiyohara * it adds the link-level encapsulation.
753 1.1 kiyohara */
754 1.1 kiyohara
755 1.1 kiyohara /*
756 1.1 kiyohara * Put the mbuf in the xfer early in case we hit an
757 1.1 kiyohara * error case below - fwip_output_callback will free
758 1.1 kiyohara * the mbuf.
759 1.1 kiyohara */
760 1.1 kiyohara xfer->mbuf = m;
761 1.1 kiyohara
762 1.1 kiyohara /*
763 1.1 kiyohara * We use the arp result (if any) to add a suitable firewire
764 1.1 kiyohara * packet header before handing off to the bus.
765 1.1 kiyohara */
766 1.1 kiyohara fp = &xfer->send.hdr;
767 1.1 kiyohara nodeid = FWLOCALBUS | fc->nodeid;
768 1.1 kiyohara if ((m->m_flags & M_BCAST) || !destfw) {
769 1.1 kiyohara /*
770 1.1 kiyohara * Broadcast packets are sent as GASP packets with
771 1.1 kiyohara * specifier ID 0x00005e, version 1 on the broadcast
772 1.1 kiyohara * channel. To be conservative, we send at the
773 1.1 kiyohara * slowest possible speed.
774 1.1 kiyohara */
775 1.1 kiyohara uint32_t *p;
776 1.1 kiyohara
777 1.1 kiyohara M_PREPEND(m, 2*sizeof(uint32_t), M_DONTWAIT);
778 1.1 kiyohara p = mtod(m, uint32_t *);
779 1.1 kiyohara fp->mode.stream.len = m->m_pkthdr.len;
780 1.1 kiyohara fp->mode.stream.chtag = broadcast_channel;
781 1.1 kiyohara fp->mode.stream.tcode = FWTCODE_STREAM;
782 1.1 kiyohara fp->mode.stream.sy = 0;
783 1.1 kiyohara xfer->send.spd = 0;
784 1.1 kiyohara p[0] = htonl(nodeid << 16);
785 1.1 kiyohara p[1] = htonl((0x5e << 24) | 1);
786 1.1 kiyohara } else {
787 1.1 kiyohara /*
788 1.1 kiyohara * Unicast packets are sent as block writes to the
789 1.1 kiyohara * target's unicast fifo address. If we can't
790 1.1 kiyohara * find the node address, we just give up. We
791 1.1 kiyohara * could broadcast it but that might overflow
792 1.1 kiyohara * the packet size limitations due to the
793 1.1 kiyohara * extra GASP header. Note: the hardware
794 1.1 kiyohara * address is stored in network byte order to
795 1.1 kiyohara * make life easier for ARP.
796 1.1 kiyohara */
797 1.1 kiyohara struct fw_device *fd;
798 1.1 kiyohara struct fw_eui64 eui;
799 1.1 kiyohara
800 1.1 kiyohara eui.hi = ntohl(destfw->sender_unique_ID_hi);
801 1.1 kiyohara eui.lo = ntohl(destfw->sender_unique_ID_lo);
802 1.1 kiyohara if (fwip->last_dest.hi != eui.hi ||
803 1.1 kiyohara fwip->last_dest.lo != eui.lo) {
804 1.1 kiyohara fd = fw_noderesolve_eui64(fc, &eui);
805 1.1 kiyohara if (!fd) {
806 1.1 kiyohara /* error */
807 1.1 kiyohara ifp->if_oerrors ++;
808 1.1 kiyohara /* XXX set error code */
809 1.1 kiyohara fwip_output_callback(xfer);
810 1.1 kiyohara continue;
811 1.1 kiyohara
812 1.1 kiyohara }
813 1.1 kiyohara fwip->last_hdr.mode.wreqb.dst = FWLOCALBUS | fd->dst;
814 1.1 kiyohara fwip->last_hdr.mode.wreqb.tlrt = 0;
815 1.1 kiyohara fwip->last_hdr.mode.wreqb.tcode = FWTCODE_WREQB;
816 1.1 kiyohara fwip->last_hdr.mode.wreqb.pri = 0;
817 1.1 kiyohara fwip->last_hdr.mode.wreqb.src = nodeid;
818 1.1 kiyohara fwip->last_hdr.mode.wreqb.dest_hi =
819 1.1 kiyohara ntohs(destfw->sender_unicast_FIFO_hi);
820 1.1 kiyohara fwip->last_hdr.mode.wreqb.dest_lo =
821 1.1 kiyohara ntohl(destfw->sender_unicast_FIFO_lo);
822 1.1 kiyohara fwip->last_hdr.mode.wreqb.extcode = 0;
823 1.1 kiyohara fwip->last_dest = eui;
824 1.1 kiyohara }
825 1.1 kiyohara
826 1.1 kiyohara fp->mode.wreqb = fwip->last_hdr.mode.wreqb;
827 1.1 kiyohara fp->mode.wreqb.len = m->m_pkthdr.len;
828 1.1 kiyohara xfer->send.spd = min(destfw->sspd, fc->speed);
829 1.1 kiyohara }
830 1.1 kiyohara
831 1.1 kiyohara xfer->send.pay_len = m->m_pkthdr.len;
832 1.1 kiyohara
833 1.1 kiyohara error = fw_asyreq(fc, -1, xfer);
834 1.1 kiyohara if (error == EAGAIN) {
835 1.1 kiyohara /*
836 1.1 kiyohara * We ran out of tlabels - requeue the packet
837 1.1 kiyohara * for later transmission.
838 1.1 kiyohara */
839 1.1 kiyohara xfer->mbuf = 0;
840 1.10 kiyohara FWIP_LOCK(fwip);
841 1.1 kiyohara STAILQ_INSERT_TAIL(&fwip->xferlist, xfer, link);
842 1.10 kiyohara FWIP_UNLOCK(fwip);
843 1.1 kiyohara IF_PREPEND(&ifp->if_snd, m);
844 1.1 kiyohara break;
845 1.1 kiyohara }
846 1.1 kiyohara if (error) {
847 1.1 kiyohara /* error */
848 1.1 kiyohara ifp->if_oerrors ++;
849 1.1 kiyohara /* XXX set error code */
850 1.1 kiyohara fwip_output_callback(xfer);
851 1.1 kiyohara continue;
852 1.1 kiyohara } else {
853 1.1 kiyohara ifp->if_opackets ++;
854 1.1 kiyohara i++;
855 1.1 kiyohara }
856 1.1 kiyohara }
857 1.1 kiyohara #if 0
858 1.1 kiyohara if (i > 1)
859 1.1 kiyohara printf("%d queued\n", i);
860 1.1 kiyohara #endif
861 1.10 kiyohara if (i > 0)
862 1.1 kiyohara xferq->start(fc);
863 1.1 kiyohara }
864 1.1 kiyohara
865 1.1 kiyohara static void
866 1.1 kiyohara fwip_start_send (void *arg, int count)
867 1.1 kiyohara {
868 1.1 kiyohara struct fwip_softc *fwip = arg;
869 1.1 kiyohara
870 1.1 kiyohara fwip->fd.fc->atq->start(fwip->fd.fc);
871 1.1 kiyohara }
872 1.1 kiyohara
873 1.1 kiyohara /* Async. stream output */
874 1.1 kiyohara static void
875 1.1 kiyohara fwip_stream_input(struct fw_xferq *xferq)
876 1.1 kiyohara {
877 1.1 kiyohara struct mbuf *m, *m0;
878 1.1 kiyohara struct m_tag *mtag;
879 1.1 kiyohara struct ifnet *ifp;
880 1.1 kiyohara struct fwip_softc *fwip;
881 1.1 kiyohara struct fw_bulkxfer *sxfer;
882 1.1 kiyohara struct fw_pkt *fp;
883 1.1 kiyohara uint16_t src;
884 1.1 kiyohara uint32_t *p;
885 1.1 kiyohara
886 1.1 kiyohara fwip = (struct fwip_softc *)xferq->sc;
887 1.8 kiyohara ifp = fwip->fw_softc.fwip_ifp;
888 1.1 kiyohara while ((sxfer = STAILQ_FIRST(&xferq->stvalid)) != NULL) {
889 1.1 kiyohara STAILQ_REMOVE_HEAD(&xferq->stvalid, link);
890 1.1 kiyohara fp = mtod(sxfer->mbuf, struct fw_pkt *);
891 1.1 kiyohara if (fwip->fd.fc->irx_post != NULL)
892 1.1 kiyohara fwip->fd.fc->irx_post(fwip->fd.fc, fp->mode.ld);
893 1.1 kiyohara m = sxfer->mbuf;
894 1.1 kiyohara
895 1.1 kiyohara /* insert new rbuf */
896 1.1 kiyohara sxfer->mbuf = m0 = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
897 1.1 kiyohara if (m0 != NULL) {
898 1.1 kiyohara m0->m_len = m0->m_pkthdr.len = m0->m_ext.ext_size;
899 1.1 kiyohara STAILQ_INSERT_TAIL(&xferq->stfree, sxfer, link);
900 1.1 kiyohara } else
901 1.1 kiyohara printf("fwip_as_input: m_getcl failed\n");
902 1.1 kiyohara
903 1.1 kiyohara /*
904 1.1 kiyohara * We must have a GASP header - leave the
905 1.1 kiyohara * encapsulation sanity checks to the generic
906 1.1 kiyohara * code. Remeber that we also have the firewire async
907 1.1 kiyohara * stream header even though that isn't accounted for
908 1.1 kiyohara * in mode.stream.len.
909 1.1 kiyohara */
910 1.1 kiyohara if (sxfer->resp != 0 || fp->mode.stream.len <
911 1.1 kiyohara 2*sizeof(uint32_t)) {
912 1.1 kiyohara m_freem(m);
913 1.1 kiyohara ifp->if_ierrors ++;
914 1.1 kiyohara continue;
915 1.1 kiyohara }
916 1.1 kiyohara m->m_len = m->m_pkthdr.len = fp->mode.stream.len
917 1.1 kiyohara + sizeof(fp->mode.stream);
918 1.1 kiyohara
919 1.1 kiyohara /*
920 1.1 kiyohara * If we received the packet on the broadcast channel,
921 1.1 kiyohara * mark it as broadcast, otherwise we assume it must
922 1.1 kiyohara * be multicast.
923 1.1 kiyohara */
924 1.1 kiyohara if (fp->mode.stream.chtag == broadcast_channel)
925 1.1 kiyohara m->m_flags |= M_BCAST;
926 1.1 kiyohara else
927 1.1 kiyohara m->m_flags |= M_MCAST;
928 1.1 kiyohara
929 1.1 kiyohara /*
930 1.1 kiyohara * Make sure we recognise the GASP specifier and
931 1.1 kiyohara * version.
932 1.1 kiyohara */
933 1.1 kiyohara p = mtod(m, uint32_t *);
934 1.1 kiyohara if ((((ntohl(p[1]) & 0xffff) << 8) | ntohl(p[2]) >> 24) != 0x00005e
935 1.1 kiyohara || (ntohl(p[2]) & 0xffffff) != 1) {
936 1.1 kiyohara FWIPDEBUG(ifp, "Unrecognised GASP header %#08x %#08x\n",
937 1.1 kiyohara ntohl(p[1]), ntohl(p[2]));
938 1.1 kiyohara m_freem(m);
939 1.1 kiyohara ifp->if_ierrors ++;
940 1.1 kiyohara continue;
941 1.1 kiyohara }
942 1.1 kiyohara
943 1.1 kiyohara /*
944 1.1 kiyohara * Record the sender ID for possible BPF usage.
945 1.1 kiyohara */
946 1.1 kiyohara src = ntohl(p[1]) >> 16;
947 1.8 kiyohara if (bpf_peers_present(ifp->if_bpf)) {
948 1.1 kiyohara mtag = m_tag_alloc(MTAG_FIREWIRE,
949 1.1 kiyohara MTAG_FIREWIRE_SENDER_EUID,
950 1.1 kiyohara 2*sizeof(uint32_t), M_NOWAIT);
951 1.1 kiyohara if (mtag) {
952 1.1 kiyohara /* bpf wants it in network byte order */
953 1.1 kiyohara struct fw_device *fd;
954 1.1 kiyohara uint32_t *p2 = (uint32_t *) (mtag + 1);
955 1.1 kiyohara fd = fw_noderesolve_nodeid(fwip->fd.fc,
956 1.1 kiyohara src & 0x3f);
957 1.1 kiyohara if (fd) {
958 1.1 kiyohara p2[0] = htonl(fd->eui.hi);
959 1.1 kiyohara p2[1] = htonl(fd->eui.lo);
960 1.1 kiyohara } else {
961 1.1 kiyohara p2[0] = 0;
962 1.1 kiyohara p2[1] = 0;
963 1.1 kiyohara }
964 1.1 kiyohara m_tag_prepend(m, mtag);
965 1.1 kiyohara }
966 1.1 kiyohara }
967 1.1 kiyohara
968 1.1 kiyohara /*
969 1.1 kiyohara * Trim off the GASP header
970 1.1 kiyohara */
971 1.1 kiyohara m_adj(m, 3*sizeof(uint32_t));
972 1.1 kiyohara m->m_pkthdr.rcvif = ifp;
973 1.1 kiyohara FIREWIRE_INPUT(ifp, m, src);
974 1.1 kiyohara ifp->if_ipackets ++;
975 1.1 kiyohara }
976 1.1 kiyohara if (STAILQ_FIRST(&xferq->stfree) != NULL)
977 1.1 kiyohara fwip->fd.fc->irx_enable(fwip->fd.fc, fwip->dma_ch);
978 1.1 kiyohara }
979 1.1 kiyohara
980 1.4 perry static inline void
981 1.1 kiyohara fwip_unicast_input_recycle(struct fwip_softc *fwip, struct fw_xfer *xfer)
982 1.1 kiyohara {
983 1.1 kiyohara struct mbuf *m;
984 1.1 kiyohara
985 1.1 kiyohara /*
986 1.1 kiyohara * We have finished with a unicast xfer. Allocate a new
987 1.1 kiyohara * cluster and stick it on the back of the input queue.
988 1.1 kiyohara */
989 1.2 kiyohara m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
990 1.2 kiyohara if (m == NULL)
991 1.2 kiyohara printf("fwip_unicast_input_recycle: m_getcl failed\n");
992 1.1 kiyohara xfer->mbuf = m;
993 1.1 kiyohara xfer->recv.payload = mtod(m, uint32_t *);
994 1.1 kiyohara xfer->recv.pay_len = MCLBYTES;
995 1.1 kiyohara xfer->mbuf = m;
996 1.1 kiyohara STAILQ_INSERT_TAIL(&fwip->fwb.xferlist, xfer, link);
997 1.1 kiyohara }
998 1.1 kiyohara
999 1.1 kiyohara static void
1000 1.1 kiyohara fwip_unicast_input(struct fw_xfer *xfer)
1001 1.1 kiyohara {
1002 1.1 kiyohara uint64_t address;
1003 1.1 kiyohara struct mbuf *m;
1004 1.1 kiyohara struct m_tag *mtag;
1005 1.1 kiyohara struct ifnet *ifp;
1006 1.1 kiyohara struct fwip_softc *fwip;
1007 1.1 kiyohara struct fw_pkt *fp;
1008 1.1 kiyohara //struct fw_pkt *sfp;
1009 1.1 kiyohara int rtcode;
1010 1.1 kiyohara
1011 1.1 kiyohara fwip = (struct fwip_softc *)xfer->sc;
1012 1.8 kiyohara ifp = fwip->fw_softc.fwip_ifp;
1013 1.1 kiyohara m = xfer->mbuf;
1014 1.1 kiyohara xfer->mbuf = 0;
1015 1.1 kiyohara fp = &xfer->recv.hdr;
1016 1.1 kiyohara
1017 1.1 kiyohara /*
1018 1.1 kiyohara * Check the fifo address - we only accept addresses of
1019 1.1 kiyohara * exactly INET_FIFO.
1020 1.1 kiyohara */
1021 1.1 kiyohara address = ((uint64_t)fp->mode.wreqb.dest_hi << 32)
1022 1.1 kiyohara | fp->mode.wreqb.dest_lo;
1023 1.1 kiyohara if (fp->mode.wreqb.tcode != FWTCODE_WREQB) {
1024 1.1 kiyohara rtcode = FWRCODE_ER_TYPE;
1025 1.1 kiyohara } else if (address != INET_FIFO) {
1026 1.1 kiyohara rtcode = FWRCODE_ER_ADDR;
1027 1.1 kiyohara } else {
1028 1.1 kiyohara rtcode = FWRCODE_COMPLETE;
1029 1.1 kiyohara }
1030 1.1 kiyohara
1031 1.1 kiyohara /*
1032 1.1 kiyohara * Pick up a new mbuf and stick it on the back of the receive
1033 1.1 kiyohara * queue.
1034 1.1 kiyohara */
1035 1.1 kiyohara fwip_unicast_input_recycle(fwip, xfer);
1036 1.1 kiyohara
1037 1.1 kiyohara /*
1038 1.1 kiyohara * If we've already rejected the packet, give up now.
1039 1.1 kiyohara */
1040 1.1 kiyohara if (rtcode != FWRCODE_COMPLETE) {
1041 1.1 kiyohara m_freem(m);
1042 1.1 kiyohara ifp->if_ierrors ++;
1043 1.1 kiyohara return;
1044 1.1 kiyohara }
1045 1.1 kiyohara
1046 1.8 kiyohara if (bpf_peers_present(ifp->if_bpf)) {
1047 1.1 kiyohara /*
1048 1.1 kiyohara * Record the sender ID for possible BPF usage.
1049 1.1 kiyohara */
1050 1.1 kiyohara mtag = m_tag_alloc(MTAG_FIREWIRE, MTAG_FIREWIRE_SENDER_EUID,
1051 1.1 kiyohara 2*sizeof(uint32_t), M_NOWAIT);
1052 1.1 kiyohara if (mtag) {
1053 1.1 kiyohara /* bpf wants it in network byte order */
1054 1.1 kiyohara struct fw_device *fd;
1055 1.1 kiyohara uint32_t *p = (uint32_t *) (mtag + 1);
1056 1.1 kiyohara fd = fw_noderesolve_nodeid(fwip->fd.fc,
1057 1.1 kiyohara fp->mode.wreqb.src & 0x3f);
1058 1.1 kiyohara if (fd) {
1059 1.1 kiyohara p[0] = htonl(fd->eui.hi);
1060 1.1 kiyohara p[1] = htonl(fd->eui.lo);
1061 1.1 kiyohara } else {
1062 1.1 kiyohara p[0] = 0;
1063 1.1 kiyohara p[1] = 0;
1064 1.1 kiyohara }
1065 1.1 kiyohara m_tag_prepend(m, mtag);
1066 1.1 kiyohara }
1067 1.1 kiyohara }
1068 1.1 kiyohara
1069 1.1 kiyohara /*
1070 1.1 kiyohara * Hand off to the generic encapsulation code. We don't use
1071 1.1 kiyohara * ifp->if_input so that we can pass the source nodeid as an
1072 1.1 kiyohara * argument to facilitate link-level fragment reassembly.
1073 1.1 kiyohara */
1074 1.1 kiyohara m->m_len = m->m_pkthdr.len = fp->mode.wreqb.len;
1075 1.1 kiyohara m->m_pkthdr.rcvif = ifp;
1076 1.1 kiyohara FIREWIRE_INPUT(ifp, m, fp->mode.wreqb.src);
1077 1.1 kiyohara ifp->if_ipackets ++;
1078 1.1 kiyohara }
1079 1.1 kiyohara
1080 1.1 kiyohara #if defined(__FreeBSD__)
1081 1.1 kiyohara static devclass_t fwip_devclass;
1082 1.1 kiyohara
1083 1.1 kiyohara static device_method_t fwip_methods[] = {
1084 1.1 kiyohara /* device interface */
1085 1.1 kiyohara DEVMETHOD(device_identify, fwip_identify),
1086 1.1 kiyohara DEVMETHOD(device_probe, fwip_probe),
1087 1.1 kiyohara DEVMETHOD(device_attach, fwip_attach),
1088 1.1 kiyohara DEVMETHOD(device_detach, fwip_detach),
1089 1.1 kiyohara { 0, 0 }
1090 1.1 kiyohara };
1091 1.1 kiyohara
1092 1.1 kiyohara static driver_t fwip_driver = {
1093 1.1 kiyohara "fwip",
1094 1.1 kiyohara fwip_methods,
1095 1.1 kiyohara sizeof(struct fwip_softc),
1096 1.1 kiyohara };
1097 1.1 kiyohara
1098 1.1 kiyohara
1099 1.1 kiyohara #ifdef __DragonFly__
1100 1.1 kiyohara DECLARE_DUMMY_MODULE(fwip);
1101 1.1 kiyohara #endif
1102 1.1 kiyohara DRIVER_MODULE(fwip, firewire, fwip_driver, fwip_devclass, 0, 0);
1103 1.1 kiyohara MODULE_VERSION(fwip, 1);
1104 1.1 kiyohara MODULE_DEPEND(fwip, firewire, 1, 1, 1);
1105 1.1 kiyohara #elif defined(__NetBSD__)
1106 1.14 kiyohara CFATTACH_DECL_NEW(fwip, sizeof(struct fwip_softc),
1107 1.1 kiyohara fwipmatch, fwipattach, fwipdetach, NULL);
1108 1.1 kiyohara #endif
1109