if_fwip.c revision 1.14 1 1.14 kiyohara /* $NetBSD: if_fwip.c,v 1.14 2008/03/29 16:22:53 kiyohara 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.14 kiyohara __KERNEL_RCSID(0, "$NetBSD: if_fwip.c,v 1.14 2008/03/29 16:22:53 kiyohara 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.10 kiyohara #define FWIPDEBUG(ifp, fmt, ...) \
113 1.10 kiyohara if (fwipdebug) { \
114 1.10 kiyohara printf("%s: ", (ifp)->if_xname);\
115 1.10 kiyohara printf((fmt) , ##__VA_ARGS__); \
116 1.1 kiyohara }
117 1.1 kiyohara #endif
118 1.1 kiyohara #define TX_MAX_QUEUE (FWMAXQUEUE - 1)
119 1.1 kiyohara
120 1.1 kiyohara #if defined(__NetBSD__)
121 1.14 kiyohara int fwipmatch (device_t, struct cfdata *, void *);
122 1.14 kiyohara void fwipattach (device_t, device_t, void *);
123 1.14 kiyohara int fwipdetach (device_t, int);
124 1.14 kiyohara int fwipactivate (device_t, enum devact);
125 1.1 kiyohara
126 1.1 kiyohara #endif
127 1.1 kiyohara /* network interface */
128 1.1 kiyohara static void fwip_start (struct ifnet *);
129 1.7 christos static int fwip_ioctl (struct ifnet *, u_long, void *);
130 1.10 kiyohara #if defined(__FreeBSD__)
131 1.10 kiyohara static void fwip_init(void *);
132 1.10 kiyohara static void fwip_stop(struct fwip_softc *);
133 1.10 kiyohara #elif defined(__NetBSD__)
134 1.10 kiyohara static int fwip_init(struct ifnet *);
135 1.10 kiyohara static void fwip_stop(struct ifnet *, int);
136 1.10 kiyohara #endif
137 1.1 kiyohara
138 1.1 kiyohara static void fwip_post_busreset (void *);
139 1.1 kiyohara static void fwip_output_callback (struct fw_xfer *);
140 1.1 kiyohara static void fwip_async_output (struct fwip_softc *, struct ifnet *);
141 1.1 kiyohara static void fwip_start_send (void *, int);
142 1.1 kiyohara static void fwip_stream_input (struct fw_xferq *);
143 1.1 kiyohara static void fwip_unicast_input(struct fw_xfer *);
144 1.1 kiyohara
145 1.1 kiyohara static int fwipdebug = 0;
146 1.1 kiyohara static int broadcast_channel = 0xc0 | 0x1f; /* tag | channel(XXX) */
147 1.1 kiyohara static int tx_speed = 2;
148 1.1 kiyohara static int rx_queue_len = FWMAXQUEUE;
149 1.1 kiyohara
150 1.1 kiyohara #if defined(__FreeBSD__)
151 1.1 kiyohara MALLOC_DEFINE(M_FWIP, "if_fwip", "IP over FireWire interface");
152 1.1 kiyohara SYSCTL_INT(_debug, OID_AUTO, if_fwip_debug, CTLFLAG_RW, &fwipdebug, 0, "");
153 1.1 kiyohara SYSCTL_DECL(_hw_firewire);
154 1.1 kiyohara SYSCTL_NODE(_hw_firewire, OID_AUTO, fwip, CTLFLAG_RD, 0,
155 1.1 kiyohara "Firewire ip subsystem");
156 1.1 kiyohara SYSCTL_INT(_hw_firewire_fwip, OID_AUTO, rx_queue_len, CTLFLAG_RW, &rx_queue_len,
157 1.1 kiyohara 0, "Length of the receive queue");
158 1.1 kiyohara
159 1.1 kiyohara TUNABLE_INT("hw.firewire.fwip.rx_queue_len", &rx_queue_len);
160 1.1 kiyohara #elif defined(__NetBSD__)
161 1.1 kiyohara MALLOC_DEFINE(M_FWIP, "if_fwip", "IP over IEEE1394 interface");
162 1.1 kiyohara /*
163 1.1 kiyohara * Setup sysctl(3) MIB, hw.fwip.*
164 1.1 kiyohara *
165 1.1 kiyohara * TBD condition CTLFLAG_PERMANENT on being an LKM or not
166 1.1 kiyohara */
167 1.1 kiyohara SYSCTL_SETUP(sysctl_fwip, "sysctl fwip(4) subtree setup")
168 1.1 kiyohara {
169 1.1 kiyohara int rc, fwip_node_num;
170 1.1 kiyohara const struct sysctlnode *node;
171 1.1 kiyohara
172 1.1 kiyohara if ((rc = sysctl_createv(clog, 0, NULL, NULL,
173 1.1 kiyohara CTLFLAG_PERMANENT, CTLTYPE_NODE, "hw", NULL,
174 1.1 kiyohara NULL, 0, NULL, 0, CTL_HW, CTL_EOL)) != 0) {
175 1.1 kiyohara goto err;
176 1.1 kiyohara }
177 1.1 kiyohara
178 1.1 kiyohara if ((rc = sysctl_createv(clog, 0, NULL, &node,
179 1.1 kiyohara CTLFLAG_PERMANENT, CTLTYPE_NODE, "fwip",
180 1.1 kiyohara SYSCTL_DESCR("fwip controls"),
181 1.1 kiyohara NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) {
182 1.1 kiyohara goto err;
183 1.1 kiyohara }
184 1.1 kiyohara fwip_node_num = node->sysctl_num;
185 1.1 kiyohara
186 1.1 kiyohara /* fwip RX queue length */
187 1.1 kiyohara if ((rc = sysctl_createv(clog, 0, NULL, &node,
188 1.1 kiyohara CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT,
189 1.1 kiyohara "rx_queue_len", SYSCTL_DESCR("Length of the receive queue"),
190 1.1 kiyohara NULL, 0, &rx_queue_len,
191 1.1 kiyohara 0, CTL_HW, fwip_node_num, CTL_CREATE, CTL_EOL)) != 0) {
192 1.1 kiyohara goto err;
193 1.1 kiyohara }
194 1.1 kiyohara
195 1.1 kiyohara /* fwip RX queue length */
196 1.1 kiyohara if ((rc = sysctl_createv(clog, 0, NULL, &node,
197 1.1 kiyohara CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT,
198 1.1 kiyohara "if_fwip_debug", SYSCTL_DESCR("fwip driver debug flag"),
199 1.1 kiyohara NULL, 0, &fwipdebug,
200 1.1 kiyohara 0, CTL_HW, fwip_node_num, CTL_CREATE, CTL_EOL)) != 0) {
201 1.1 kiyohara goto err;
202 1.1 kiyohara }
203 1.1 kiyohara
204 1.1 kiyohara return;
205 1.1 kiyohara
206 1.1 kiyohara err:
207 1.1 kiyohara printf("%s: sysctl_createv failed (rc = %d)\n", __func__, rc);
208 1.1 kiyohara }
209 1.1 kiyohara #endif
210 1.1 kiyohara
211 1.1 kiyohara #ifdef DEVICE_POLLING
212 1.1 kiyohara static poll_handler_t fwip_poll;
213 1.1 kiyohara
214 1.1 kiyohara static void
215 1.1 kiyohara fwip_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
216 1.1 kiyohara {
217 1.1 kiyohara struct fwip_softc *fwip;
218 1.1 kiyohara struct firewire_comm *fc;
219 1.1 kiyohara
220 1.8 kiyohara if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
221 1.8 kiyohara return;
222 1.8 kiyohara
223 1.1 kiyohara fwip = ((struct fwip_eth_softc *)ifp->if_softc)->fwip;
224 1.1 kiyohara fc = fwip->fd.fc;
225 1.1 kiyohara fc->poll(fc, (cmd == POLL_AND_CHECK_STATUS)?0:1, count);
226 1.1 kiyohara }
227 1.8 kiyohara #endif /* DEVICE_POLLING */
228 1.1 kiyohara #if defined(__FreeBSD__)
229 1.1 kiyohara static void
230 1.1 kiyohara fwip_identify(driver_t *driver, device_t parent)
231 1.1 kiyohara {
232 1.10 kiyohara BUS_ADD_CHILD(parent, 0, "fwip", fw_get_unit(parent));
233 1.1 kiyohara }
234 1.1 kiyohara
235 1.1 kiyohara static int
236 1.1 kiyohara fwip_probe(device_t dev)
237 1.1 kiyohara {
238 1.1 kiyohara device_t pa;
239 1.1 kiyohara
240 1.1 kiyohara pa = device_get_parent(dev);
241 1.10 kiyohara if(fw_get_unit(dev) != fw_get_unit(pa)){
242 1.1 kiyohara return(ENXIO);
243 1.1 kiyohara }
244 1.1 kiyohara
245 1.1 kiyohara device_set_desc(dev, "IP over FireWire");
246 1.1 kiyohara return (0);
247 1.1 kiyohara }
248 1.1 kiyohara #elif defined(__NetBSD__)
249 1.1 kiyohara int
250 1.14 kiyohara fwipmatch(device_t parent, struct cfdata *cf, void *aux)
251 1.1 kiyohara {
252 1.1 kiyohara struct fw_attach_args *fwa = aux;
253 1.1 kiyohara
254 1.1 kiyohara if (strcmp(fwa->name, "fwip") == 0)
255 1.1 kiyohara return (1);
256 1.1 kiyohara return (0);
257 1.1 kiyohara }
258 1.1 kiyohara #endif
259 1.1 kiyohara
260 1.1 kiyohara FW_ATTACH(fwip)
261 1.1 kiyohara {
262 1.1 kiyohara FW_ATTACH_START(fwip, fwip, fwa);
263 1.1 kiyohara FWIP_ATTACH_START;
264 1.1 kiyohara struct ifnet *ifp;
265 1.1 kiyohara int s;
266 1.1 kiyohara
267 1.1 kiyohara FWIP_ATTACH_SETUP;
268 1.1 kiyohara
269 1.8 kiyohara ifp = fwip->fw_softc.fwip_ifp;
270 1.8 kiyohara if (ifp == NULL)
271 1.8 kiyohara FW_ATTACH_RETURN(ENOSPC);
272 1.8 kiyohara
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 #if defined(__NetBSD__)
403 1.1 kiyohara int
404 1.14 kiyohara fwipactivate(device_t self, enum devact act)
405 1.1 kiyohara {
406 1.14 kiyohara struct fwip_softc *fwip = device_private(self);
407 1.1 kiyohara int s, error = 0;
408 1.1 kiyohara
409 1.1 kiyohara s = splfwnet();
410 1.1 kiyohara switch (act) {
411 1.1 kiyohara case DVACT_ACTIVATE:
412 1.1 kiyohara error = EOPNOTSUPP;
413 1.1 kiyohara break;
414 1.1 kiyohara
415 1.1 kiyohara case DVACT_DEACTIVATE:
416 1.8 kiyohara if_deactivate(fwip->fw_softc.fwip_ifp);
417 1.1 kiyohara break;
418 1.1 kiyohara }
419 1.1 kiyohara splx(s);
420 1.1 kiyohara
421 1.1 kiyohara return (error);
422 1.1 kiyohara }
423 1.1 kiyohara
424 1.1 kiyohara #endif
425 1.1 kiyohara IF_INIT(fwip)
426 1.1 kiyohara {
427 1.1 kiyohara IF_INIT_START(fwip, fwip, ifp);
428 1.1 kiyohara struct firewire_comm *fc;
429 1.1 kiyohara struct fw_xferq *xferq;
430 1.1 kiyohara struct fw_xfer *xfer;
431 1.1 kiyohara struct mbuf *m;
432 1.1 kiyohara int i;
433 1.1 kiyohara
434 1.1 kiyohara FWIPDEBUG(ifp, "initializing\n");
435 1.1 kiyohara
436 1.1 kiyohara fc = fwip->fd.fc;
437 1.1 kiyohara #define START 0
438 1.1 kiyohara if (fwip->dma_ch < 0) {
439 1.10 kiyohara fwip->dma_ch = fw_open_isodma(fc, /* tx */0);
440 1.10 kiyohara if (fwip->dma_ch < 0)
441 1.10 kiyohara IF_INIT_RETURN(ENXIO);
442 1.10 kiyohara xferq = fc->ir[fwip->dma_ch];
443 1.10 kiyohara xferq->flag |=
444 1.10 kiyohara FWXFERQ_EXTBUF | FWXFERQ_HANDLER | FWXFERQ_STREAM;
445 1.1 kiyohara xferq->flag &= ~0xff;
446 1.1 kiyohara xferq->flag |= broadcast_channel & 0xff;
447 1.1 kiyohara /* register fwip_input handler */
448 1.7 christos xferq->sc = (void *) fwip;
449 1.1 kiyohara xferq->hand = fwip_stream_input;
450 1.1 kiyohara xferq->bnchunk = rx_queue_len;
451 1.1 kiyohara xferq->bnpacket = 1;
452 1.1 kiyohara xferq->psize = MCLBYTES;
453 1.1 kiyohara xferq->queued = 0;
454 1.1 kiyohara xferq->buf = NULL;
455 1.1 kiyohara xferq->bulkxfer = (struct fw_bulkxfer *) malloc(
456 1.1 kiyohara sizeof(struct fw_bulkxfer) * xferq->bnchunk,
457 1.1 kiyohara M_FWIP, M_WAITOK);
458 1.1 kiyohara if (xferq->bulkxfer == NULL) {
459 1.1 kiyohara printf("if_fwip: malloc failed\n");
460 1.1 kiyohara IF_INIT_RETURN(ENOMEM);
461 1.1 kiyohara }
462 1.1 kiyohara STAILQ_INIT(&xferq->stvalid);
463 1.1 kiyohara STAILQ_INIT(&xferq->stfree);
464 1.1 kiyohara STAILQ_INIT(&xferq->stdma);
465 1.1 kiyohara xferq->stproc = NULL;
466 1.1 kiyohara for (i = 0; i < xferq->bnchunk; i ++) {
467 1.1 kiyohara m =
468 1.1 kiyohara #if defined(__DragonFly__) || __FreeBSD_version < 500000
469 1.1 kiyohara m_getcl(M_WAIT, MT_DATA, M_PKTHDR);
470 1.1 kiyohara #else
471 1.1 kiyohara m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
472 1.1 kiyohara #endif
473 1.1 kiyohara xferq->bulkxfer[i].mbuf = m;
474 1.1 kiyohara if (m != NULL) {
475 1.1 kiyohara m->m_len = m->m_pkthdr.len = m->m_ext.ext_size;
476 1.1 kiyohara STAILQ_INSERT_TAIL(&xferq->stfree,
477 1.1 kiyohara &xferq->bulkxfer[i], link);
478 1.1 kiyohara } else
479 1.1 kiyohara printf("fwip_as_input: m_getcl failed\n");
480 1.1 kiyohara }
481 1.1 kiyohara
482 1.1 kiyohara fwip->fwb.start = INET_FIFO;
483 1.1 kiyohara fwip->fwb.end = INET_FIFO + 16384; /* S3200 packet size */
484 1.1 kiyohara
485 1.1 kiyohara /* pre-allocate xfer */
486 1.1 kiyohara STAILQ_INIT(&fwip->fwb.xferlist);
487 1.1 kiyohara for (i = 0; i < rx_queue_len; i ++) {
488 1.1 kiyohara xfer = fw_xfer_alloc(M_FWIP);
489 1.1 kiyohara if (xfer == NULL)
490 1.1 kiyohara break;
491 1.1 kiyohara m = m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
492 1.1 kiyohara xfer->recv.payload = mtod(m, uint32_t *);
493 1.1 kiyohara xfer->recv.pay_len = MCLBYTES;
494 1.1 kiyohara xfer->hand = fwip_unicast_input;
495 1.1 kiyohara xfer->fc = fc;
496 1.7 christos xfer->sc = (void *)fwip;
497 1.1 kiyohara xfer->mbuf = m;
498 1.1 kiyohara STAILQ_INSERT_TAIL(&fwip->fwb.xferlist, xfer, link);
499 1.1 kiyohara }
500 1.1 kiyohara fw_bindadd(fc, &fwip->fwb);
501 1.1 kiyohara
502 1.1 kiyohara STAILQ_INIT(&fwip->xferlist);
503 1.1 kiyohara for (i = 0; i < TX_MAX_QUEUE; i++) {
504 1.1 kiyohara xfer = fw_xfer_alloc(M_FWIP);
505 1.1 kiyohara if (xfer == NULL)
506 1.1 kiyohara break;
507 1.1 kiyohara xfer->send.spd = tx_speed;
508 1.1 kiyohara xfer->fc = fwip->fd.fc;
509 1.7 christos xfer->sc = (void *)fwip;
510 1.1 kiyohara xfer->hand = fwip_output_callback;
511 1.1 kiyohara STAILQ_INSERT_TAIL(&fwip->xferlist, xfer, link);
512 1.1 kiyohara }
513 1.1 kiyohara } else
514 1.1 kiyohara xferq = fc->ir[fwip->dma_ch];
515 1.1 kiyohara
516 1.1 kiyohara fwip->last_dest.hi = 0;
517 1.1 kiyohara fwip->last_dest.lo = 0;
518 1.1 kiyohara
519 1.1 kiyohara /* start dma */
520 1.1 kiyohara if ((xferq->flag & FWXFERQ_RUNNING) == 0)
521 1.1 kiyohara fc->irx_enable(fc, fwip->dma_ch);
522 1.1 kiyohara
523 1.8 kiyohara #if defined(__FreeBSD__)
524 1.8 kiyohara ifp->if_drv_flags |= IFF_DRV_RUNNING;
525 1.8 kiyohara ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
526 1.8 kiyohara #elif defined(__NetBSD__)
527 1.1 kiyohara ifp->if_flags |= IFF_RUNNING;
528 1.1 kiyohara ifp->if_flags &= ~IFF_OACTIVE;
529 1.8 kiyohara #endif
530 1.1 kiyohara
531 1.1 kiyohara #if 0
532 1.1 kiyohara /* attempt to start output */
533 1.1 kiyohara fwip_start(ifp);
534 1.1 kiyohara #endif
535 1.1 kiyohara IF_INIT_RETURN(0);
536 1.1 kiyohara }
537 1.1 kiyohara
538 1.1 kiyohara static int
539 1.7 christos fwip_ioctl(struct ifnet *ifp, u_long cmd, void *data)
540 1.1 kiyohara {
541 1.1 kiyohara IF_IOCTL_START(fwip, fwip);
542 1.13 dyoung int s, error = 0;
543 1.1 kiyohara
544 1.1 kiyohara switch (cmd) {
545 1.1 kiyohara case SIOCSIFFLAGS:
546 1.1 kiyohara s = splfwnet();
547 1.1 kiyohara if (ifp->if_flags & IFF_UP) {
548 1.8 kiyohara #if defined(__FreeBSD__)
549 1.8 kiyohara if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
550 1.8 kiyohara #elif defined(__NetBSD__)
551 1.1 kiyohara if (!(ifp->if_flags & IFF_RUNNING))
552 1.8 kiyohara #endif
553 1.1 kiyohara FWIP_INIT(fwip);
554 1.1 kiyohara } else {
555 1.8 kiyohara #if defined(__FreeBSD__)
556 1.8 kiyohara if (ifp->if_drv_flags & IFF_DRV_RUNNING)
557 1.8 kiyohara #elif defined(__NetBSD__)
558 1.1 kiyohara if (ifp->if_flags & IFF_RUNNING)
559 1.8 kiyohara #endif
560 1.1 kiyohara FWIP_STOP(fwip);
561 1.1 kiyohara }
562 1.1 kiyohara splx(s);
563 1.1 kiyohara break;
564 1.1 kiyohara case SIOCADDMULTI:
565 1.1 kiyohara case SIOCDELMULTI:
566 1.1 kiyohara break;
567 1.8 kiyohara case SIOCSIFCAP:
568 1.13 dyoung if ((error = FIREWIRE_IOCTL(ifp, cmd, data)) != ENETRESET)
569 1.13 dyoung break;
570 1.13 dyoung error = 0;
571 1.8 kiyohara #ifdef DEVICE_POLLING
572 1.8 kiyohara {
573 1.8 kiyohara struct ifreq *ifr = (struct ifreq *) data;
574 1.8 kiyohara struct firewire_comm *fc = fc = fwip->fd.fc;
575 1.8 kiyohara
576 1.8 kiyohara if (ifr->ifr_reqcap & IFCAP_POLLING &&
577 1.8 kiyohara !(ifp->if_capenable & IFCAP_POLLING)) {
578 1.8 kiyohara error = ether_poll_register(fwip_poll, ifp);
579 1.8 kiyohara if (error)
580 1.8 kiyohara return(error);
581 1.8 kiyohara /* Disable interrupts */
582 1.8 kiyohara fc->set_intr(fc, 0);
583 1.8 kiyohara ifp->if_capenable |= IFCAP_POLLING;
584 1.8 kiyohara return (error);
585 1.8 kiyohara
586 1.8 kiyohara }
587 1.8 kiyohara if (!(ifr->ifr_reqcap & IFCAP_POLLING) &&
588 1.8 kiyohara ifp->if_capenable & IFCAP_POLLING) {
589 1.8 kiyohara error = ether_poll_deregister(ifp);
590 1.8 kiyohara /* Enable interrupts. */
591 1.8 kiyohara fc->set_intr(fc, 1);
592 1.8 kiyohara ifp->if_capenable &= ~IFCAP_POLLING;
593 1.8 kiyohara return (error);
594 1.8 kiyohara }
595 1.8 kiyohara }
596 1.8 kiyohara #endif /* DEVICE_POLLING */
597 1.8 kiyohara break;
598 1.1 kiyohara
599 1.1 kiyohara #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__NetBSD__)
600 1.1 kiyohara default:
601 1.1 kiyohara #else
602 1.1 kiyohara case SIOCSIFADDR:
603 1.1 kiyohara case SIOCGIFADDR:
604 1.1 kiyohara case SIOCSIFMTU:
605 1.1 kiyohara #endif
606 1.1 kiyohara s = splfwnet();
607 1.1 kiyohara error = FIREWIRE_IOCTL(ifp, cmd, data);
608 1.1 kiyohara splx(s);
609 1.1 kiyohara return (error);
610 1.1 kiyohara #if defined(__DragonFly__) || \
611 1.1 kiyohara (defined(__FreeBSD__) && __FreeBSD_version < 500000)
612 1.1 kiyohara default:
613 1.1 kiyohara return (EINVAL);
614 1.1 kiyohara #endif
615 1.1 kiyohara }
616 1.1 kiyohara
617 1.13 dyoung return error;
618 1.1 kiyohara }
619 1.1 kiyohara
620 1.1 kiyohara static void
621 1.1 kiyohara fwip_post_busreset(void *arg)
622 1.1 kiyohara {
623 1.1 kiyohara struct fwip_softc *fwip = arg;
624 1.1 kiyohara struct crom_src *src;
625 1.1 kiyohara struct crom_chunk *root;
626 1.1 kiyohara
627 1.1 kiyohara src = fwip->fd.fc->crom_src;
628 1.1 kiyohara root = fwip->fd.fc->crom_root;
629 1.1 kiyohara
630 1.1 kiyohara /* RFC2734 IPv4 over IEEE1394 */
631 1.1 kiyohara bzero(&fwip->unit4, sizeof(struct crom_chunk));
632 1.1 kiyohara crom_add_chunk(src, root, &fwip->unit4, CROM_UDIR);
633 1.1 kiyohara crom_add_entry(&fwip->unit4, CSRKEY_SPEC, CSRVAL_IETF);
634 1.1 kiyohara crom_add_simple_text(src, &fwip->unit4, &fwip->spec4, "IANA");
635 1.1 kiyohara crom_add_entry(&fwip->unit4, CSRKEY_VER, 1);
636 1.1 kiyohara crom_add_simple_text(src, &fwip->unit4, &fwip->ver4, "IPv4");
637 1.1 kiyohara
638 1.1 kiyohara /* RFC3146 IPv6 over IEEE1394 */
639 1.1 kiyohara bzero(&fwip->unit6, sizeof(struct crom_chunk));
640 1.1 kiyohara crom_add_chunk(src, root, &fwip->unit6, CROM_UDIR);
641 1.1 kiyohara crom_add_entry(&fwip->unit6, CSRKEY_SPEC, CSRVAL_IETF);
642 1.1 kiyohara crom_add_simple_text(src, &fwip->unit6, &fwip->spec6, "IANA");
643 1.1 kiyohara crom_add_entry(&fwip->unit6, CSRKEY_VER, 2);
644 1.1 kiyohara crom_add_simple_text(src, &fwip->unit6, &fwip->ver6, "IPv6");
645 1.1 kiyohara
646 1.1 kiyohara fwip->last_dest.hi = 0;
647 1.1 kiyohara fwip->last_dest.lo = 0;
648 1.8 kiyohara FIREWIRE_BUSRESET(fwip->fw_softc.fwip_ifp);
649 1.1 kiyohara }
650 1.1 kiyohara
651 1.1 kiyohara static void
652 1.1 kiyohara fwip_output_callback(struct fw_xfer *xfer)
653 1.1 kiyohara {
654 1.1 kiyohara struct fwip_softc *fwip;
655 1.1 kiyohara struct ifnet *ifp;
656 1.1 kiyohara int s;
657 1.1 kiyohara
658 1.1 kiyohara fwip = (struct fwip_softc *)xfer->sc;
659 1.8 kiyohara ifp = fwip->fw_softc.fwip_ifp;
660 1.1 kiyohara /* XXX error check */
661 1.1 kiyohara FWIPDEBUG(ifp, "resp = %d\n", xfer->resp);
662 1.1 kiyohara if (xfer->resp != 0)
663 1.1 kiyohara ifp->if_oerrors ++;
664 1.1 kiyohara
665 1.1 kiyohara m_freem(xfer->mbuf);
666 1.1 kiyohara fw_xfer_unload(xfer);
667 1.1 kiyohara
668 1.1 kiyohara s = splfwnet();
669 1.10 kiyohara FWIP_LOCK(fwip);
670 1.1 kiyohara STAILQ_INSERT_TAIL(&fwip->xferlist, xfer, link);
671 1.10 kiyohara FWIP_UNLOCK(fwip);
672 1.1 kiyohara splx(s);
673 1.1 kiyohara
674 1.1 kiyohara /* for queue full */
675 1.10 kiyohara if (ifp->if_snd.ifq_head != NULL) {
676 1.1 kiyohara fwip_start(ifp);
677 1.10 kiyohara }
678 1.1 kiyohara }
679 1.1 kiyohara
680 1.1 kiyohara static void
681 1.1 kiyohara fwip_start(struct ifnet *ifp)
682 1.1 kiyohara {
683 1.8 kiyohara struct fwip_softc *fwip =
684 1.8 kiyohara ((struct fwip_eth_softc *)ifp->if_softc)->fwip;
685 1.1 kiyohara int s;
686 1.1 kiyohara
687 1.1 kiyohara FWIPDEBUG(ifp, "starting\n");
688 1.1 kiyohara
689 1.1 kiyohara if (fwip->dma_ch < 0) {
690 1.1 kiyohara struct mbuf *m = NULL;
691 1.1 kiyohara
692 1.1 kiyohara FWIPDEBUG(ifp, "not ready\n");
693 1.1 kiyohara
694 1.1 kiyohara s = splfwnet();
695 1.1 kiyohara do {
696 1.1 kiyohara IF_DEQUEUE(&ifp->if_snd, m);
697 1.1 kiyohara if (m != NULL)
698 1.1 kiyohara m_freem(m);
699 1.1 kiyohara ifp->if_oerrors ++;
700 1.1 kiyohara } while (m != NULL);
701 1.1 kiyohara splx(s);
702 1.1 kiyohara
703 1.1 kiyohara return;
704 1.1 kiyohara }
705 1.1 kiyohara
706 1.1 kiyohara s = splfwnet();
707 1.8 kiyohara #if defined(__FreeBSD__)
708 1.8 kiyohara ifp->if_drv_flags |= IFF_DRV_OACTIVE;
709 1.8 kiyohara #elif defined(__NetBSD__)
710 1.1 kiyohara ifp->if_flags |= IFF_OACTIVE;
711 1.8 kiyohara #endif
712 1.1 kiyohara
713 1.1 kiyohara if (ifp->if_snd.ifq_len != 0)
714 1.1 kiyohara fwip_async_output(fwip, ifp);
715 1.1 kiyohara
716 1.8 kiyohara #if defined(__FreeBSD__)
717 1.8 kiyohara ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
718 1.8 kiyohara #elif defined(__NetBSD__)
719 1.1 kiyohara ifp->if_flags &= ~IFF_OACTIVE;
720 1.8 kiyohara #endif
721 1.1 kiyohara splx(s);
722 1.1 kiyohara }
723 1.1 kiyohara
724 1.1 kiyohara /* Async. stream output */
725 1.1 kiyohara static void
726 1.1 kiyohara fwip_async_output(struct fwip_softc *fwip, struct ifnet *ifp)
727 1.1 kiyohara {
728 1.1 kiyohara struct firewire_comm *fc = fwip->fd.fc;
729 1.1 kiyohara struct mbuf *m;
730 1.1 kiyohara struct m_tag *mtag;
731 1.1 kiyohara struct fw_hwaddr *destfw;
732 1.1 kiyohara struct fw_xfer *xfer;
733 1.1 kiyohara struct fw_xferq *xferq;
734 1.1 kiyohara struct fw_pkt *fp;
735 1.1 kiyohara uint16_t nodeid;
736 1.1 kiyohara int error;
737 1.1 kiyohara int i = 0;
738 1.1 kiyohara
739 1.1 kiyohara xfer = NULL;
740 1.10 kiyohara xferq = fc->atq;
741 1.10 kiyohara while ((xferq->queued < xferq->maxq - 1) &&
742 1.10 kiyohara (ifp->if_snd.ifq_head != NULL)) {
743 1.10 kiyohara FWIP_LOCK(fwip);
744 1.1 kiyohara xfer = STAILQ_FIRST(&fwip->xferlist);
745 1.1 kiyohara if (xfer == NULL) {
746 1.10 kiyohara FWIP_UNLOCK(fwip);
747 1.10 kiyohara #if 0
748 1.1 kiyohara printf("if_fwip: lack of xfer\n");
749 1.10 kiyohara #endif
750 1.10 kiyohara break;
751 1.1 kiyohara }
752 1.10 kiyohara STAILQ_REMOVE_HEAD(&fwip->xferlist, link);
753 1.10 kiyohara FWIP_UNLOCK(fwip);
754 1.10 kiyohara
755 1.1 kiyohara IF_DEQUEUE(&ifp->if_snd, m);
756 1.10 kiyohara if (m == NULL) {
757 1.10 kiyohara FWIP_LOCK(fwip);
758 1.10 kiyohara STAILQ_INSERT_HEAD(&fwip->xferlist, xfer, link);
759 1.10 kiyohara FWIP_UNLOCK(fwip);
760 1.1 kiyohara break;
761 1.10 kiyohara }
762 1.1 kiyohara
763 1.1 kiyohara /*
764 1.1 kiyohara * Dig out the link-level address which
765 1.1 kiyohara * firewire_output got via arp or neighbour
766 1.1 kiyohara * discovery. If we don't have a link-level address,
767 1.1 kiyohara * just stick the thing on the broadcast channel.
768 1.1 kiyohara */
769 1.1 kiyohara mtag = m_tag_locate(m, MTAG_FIREWIRE, MTAG_FIREWIRE_HWADDR, 0);
770 1.1 kiyohara if (mtag == NULL)
771 1.1 kiyohara destfw = 0;
772 1.1 kiyohara else
773 1.1 kiyohara destfw = (struct fw_hwaddr *) (mtag + 1);
774 1.1 kiyohara
775 1.1 kiyohara /*
776 1.1 kiyohara * We don't do any bpf stuff here - the generic code
777 1.1 kiyohara * in firewire_output gives the packet to bpf before
778 1.1 kiyohara * it adds the link-level encapsulation.
779 1.1 kiyohara */
780 1.1 kiyohara
781 1.1 kiyohara /*
782 1.1 kiyohara * Put the mbuf in the xfer early in case we hit an
783 1.1 kiyohara * error case below - fwip_output_callback will free
784 1.1 kiyohara * the mbuf.
785 1.1 kiyohara */
786 1.1 kiyohara xfer->mbuf = m;
787 1.1 kiyohara
788 1.1 kiyohara /*
789 1.1 kiyohara * We use the arp result (if any) to add a suitable firewire
790 1.1 kiyohara * packet header before handing off to the bus.
791 1.1 kiyohara */
792 1.1 kiyohara fp = &xfer->send.hdr;
793 1.1 kiyohara nodeid = FWLOCALBUS | fc->nodeid;
794 1.1 kiyohara if ((m->m_flags & M_BCAST) || !destfw) {
795 1.1 kiyohara /*
796 1.1 kiyohara * Broadcast packets are sent as GASP packets with
797 1.1 kiyohara * specifier ID 0x00005e, version 1 on the broadcast
798 1.1 kiyohara * channel. To be conservative, we send at the
799 1.1 kiyohara * slowest possible speed.
800 1.1 kiyohara */
801 1.1 kiyohara uint32_t *p;
802 1.1 kiyohara
803 1.1 kiyohara M_PREPEND(m, 2*sizeof(uint32_t), M_DONTWAIT);
804 1.1 kiyohara p = mtod(m, uint32_t *);
805 1.1 kiyohara fp->mode.stream.len = m->m_pkthdr.len;
806 1.1 kiyohara fp->mode.stream.chtag = broadcast_channel;
807 1.1 kiyohara fp->mode.stream.tcode = FWTCODE_STREAM;
808 1.1 kiyohara fp->mode.stream.sy = 0;
809 1.1 kiyohara xfer->send.spd = 0;
810 1.1 kiyohara p[0] = htonl(nodeid << 16);
811 1.1 kiyohara p[1] = htonl((0x5e << 24) | 1);
812 1.1 kiyohara } else {
813 1.1 kiyohara /*
814 1.1 kiyohara * Unicast packets are sent as block writes to the
815 1.1 kiyohara * target's unicast fifo address. If we can't
816 1.1 kiyohara * find the node address, we just give up. We
817 1.1 kiyohara * could broadcast it but that might overflow
818 1.1 kiyohara * the packet size limitations due to the
819 1.1 kiyohara * extra GASP header. Note: the hardware
820 1.1 kiyohara * address is stored in network byte order to
821 1.1 kiyohara * make life easier for ARP.
822 1.1 kiyohara */
823 1.1 kiyohara struct fw_device *fd;
824 1.1 kiyohara struct fw_eui64 eui;
825 1.1 kiyohara
826 1.1 kiyohara eui.hi = ntohl(destfw->sender_unique_ID_hi);
827 1.1 kiyohara eui.lo = ntohl(destfw->sender_unique_ID_lo);
828 1.1 kiyohara if (fwip->last_dest.hi != eui.hi ||
829 1.1 kiyohara fwip->last_dest.lo != eui.lo) {
830 1.1 kiyohara fd = fw_noderesolve_eui64(fc, &eui);
831 1.1 kiyohara if (!fd) {
832 1.1 kiyohara /* error */
833 1.1 kiyohara ifp->if_oerrors ++;
834 1.1 kiyohara /* XXX set error code */
835 1.1 kiyohara fwip_output_callback(xfer);
836 1.1 kiyohara continue;
837 1.1 kiyohara
838 1.1 kiyohara }
839 1.1 kiyohara fwip->last_hdr.mode.wreqb.dst = FWLOCALBUS | fd->dst;
840 1.1 kiyohara fwip->last_hdr.mode.wreqb.tlrt = 0;
841 1.1 kiyohara fwip->last_hdr.mode.wreqb.tcode = FWTCODE_WREQB;
842 1.1 kiyohara fwip->last_hdr.mode.wreqb.pri = 0;
843 1.1 kiyohara fwip->last_hdr.mode.wreqb.src = nodeid;
844 1.1 kiyohara fwip->last_hdr.mode.wreqb.dest_hi =
845 1.1 kiyohara ntohs(destfw->sender_unicast_FIFO_hi);
846 1.1 kiyohara fwip->last_hdr.mode.wreqb.dest_lo =
847 1.1 kiyohara ntohl(destfw->sender_unicast_FIFO_lo);
848 1.1 kiyohara fwip->last_hdr.mode.wreqb.extcode = 0;
849 1.1 kiyohara fwip->last_dest = eui;
850 1.1 kiyohara }
851 1.1 kiyohara
852 1.1 kiyohara fp->mode.wreqb = fwip->last_hdr.mode.wreqb;
853 1.1 kiyohara fp->mode.wreqb.len = m->m_pkthdr.len;
854 1.1 kiyohara xfer->send.spd = min(destfw->sspd, fc->speed);
855 1.1 kiyohara }
856 1.1 kiyohara
857 1.1 kiyohara xfer->send.pay_len = m->m_pkthdr.len;
858 1.1 kiyohara
859 1.1 kiyohara error = fw_asyreq(fc, -1, xfer);
860 1.1 kiyohara if (error == EAGAIN) {
861 1.1 kiyohara /*
862 1.1 kiyohara * We ran out of tlabels - requeue the packet
863 1.1 kiyohara * for later transmission.
864 1.1 kiyohara */
865 1.1 kiyohara xfer->mbuf = 0;
866 1.10 kiyohara FWIP_LOCK(fwip);
867 1.1 kiyohara STAILQ_INSERT_TAIL(&fwip->xferlist, xfer, link);
868 1.10 kiyohara FWIP_UNLOCK(fwip);
869 1.1 kiyohara IF_PREPEND(&ifp->if_snd, m);
870 1.1 kiyohara break;
871 1.1 kiyohara }
872 1.1 kiyohara if (error) {
873 1.1 kiyohara /* error */
874 1.1 kiyohara ifp->if_oerrors ++;
875 1.1 kiyohara /* XXX set error code */
876 1.1 kiyohara fwip_output_callback(xfer);
877 1.1 kiyohara continue;
878 1.1 kiyohara } else {
879 1.1 kiyohara ifp->if_opackets ++;
880 1.1 kiyohara i++;
881 1.1 kiyohara }
882 1.1 kiyohara }
883 1.1 kiyohara #if 0
884 1.1 kiyohara if (i > 1)
885 1.1 kiyohara printf("%d queued\n", i);
886 1.1 kiyohara #endif
887 1.10 kiyohara if (i > 0)
888 1.1 kiyohara xferq->start(fc);
889 1.1 kiyohara }
890 1.1 kiyohara
891 1.1 kiyohara static void
892 1.1 kiyohara fwip_start_send (void *arg, int count)
893 1.1 kiyohara {
894 1.1 kiyohara struct fwip_softc *fwip = arg;
895 1.1 kiyohara
896 1.1 kiyohara fwip->fd.fc->atq->start(fwip->fd.fc);
897 1.1 kiyohara }
898 1.1 kiyohara
899 1.1 kiyohara /* Async. stream output */
900 1.1 kiyohara static void
901 1.1 kiyohara fwip_stream_input(struct fw_xferq *xferq)
902 1.1 kiyohara {
903 1.1 kiyohara struct mbuf *m, *m0;
904 1.1 kiyohara struct m_tag *mtag;
905 1.1 kiyohara struct ifnet *ifp;
906 1.1 kiyohara struct fwip_softc *fwip;
907 1.1 kiyohara struct fw_bulkxfer *sxfer;
908 1.1 kiyohara struct fw_pkt *fp;
909 1.1 kiyohara uint16_t src;
910 1.1 kiyohara uint32_t *p;
911 1.1 kiyohara
912 1.1 kiyohara fwip = (struct fwip_softc *)xferq->sc;
913 1.8 kiyohara ifp = fwip->fw_softc.fwip_ifp;
914 1.1 kiyohara while ((sxfer = STAILQ_FIRST(&xferq->stvalid)) != NULL) {
915 1.1 kiyohara STAILQ_REMOVE_HEAD(&xferq->stvalid, link);
916 1.1 kiyohara fp = mtod(sxfer->mbuf, struct fw_pkt *);
917 1.1 kiyohara if (fwip->fd.fc->irx_post != NULL)
918 1.1 kiyohara fwip->fd.fc->irx_post(fwip->fd.fc, fp->mode.ld);
919 1.1 kiyohara m = sxfer->mbuf;
920 1.1 kiyohara
921 1.1 kiyohara /* insert new rbuf */
922 1.1 kiyohara sxfer->mbuf = m0 = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
923 1.1 kiyohara if (m0 != NULL) {
924 1.1 kiyohara m0->m_len = m0->m_pkthdr.len = m0->m_ext.ext_size;
925 1.1 kiyohara STAILQ_INSERT_TAIL(&xferq->stfree, sxfer, link);
926 1.1 kiyohara } else
927 1.1 kiyohara printf("fwip_as_input: m_getcl failed\n");
928 1.1 kiyohara
929 1.1 kiyohara /*
930 1.1 kiyohara * We must have a GASP header - leave the
931 1.1 kiyohara * encapsulation sanity checks to the generic
932 1.1 kiyohara * code. Remeber that we also have the firewire async
933 1.1 kiyohara * stream header even though that isn't accounted for
934 1.1 kiyohara * in mode.stream.len.
935 1.1 kiyohara */
936 1.1 kiyohara if (sxfer->resp != 0 || fp->mode.stream.len <
937 1.1 kiyohara 2*sizeof(uint32_t)) {
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 m->m_len = m->m_pkthdr.len = fp->mode.stream.len
943 1.1 kiyohara + sizeof(fp->mode.stream);
944 1.1 kiyohara
945 1.1 kiyohara /*
946 1.1 kiyohara * If we received the packet on the broadcast channel,
947 1.1 kiyohara * mark it as broadcast, otherwise we assume it must
948 1.1 kiyohara * be multicast.
949 1.1 kiyohara */
950 1.1 kiyohara if (fp->mode.stream.chtag == broadcast_channel)
951 1.1 kiyohara m->m_flags |= M_BCAST;
952 1.1 kiyohara else
953 1.1 kiyohara m->m_flags |= M_MCAST;
954 1.1 kiyohara
955 1.1 kiyohara /*
956 1.1 kiyohara * Make sure we recognise the GASP specifier and
957 1.1 kiyohara * version.
958 1.1 kiyohara */
959 1.1 kiyohara p = mtod(m, uint32_t *);
960 1.1 kiyohara if ((((ntohl(p[1]) & 0xffff) << 8) | ntohl(p[2]) >> 24) != 0x00005e
961 1.1 kiyohara || (ntohl(p[2]) & 0xffffff) != 1) {
962 1.1 kiyohara FWIPDEBUG(ifp, "Unrecognised GASP header %#08x %#08x\n",
963 1.1 kiyohara ntohl(p[1]), ntohl(p[2]));
964 1.1 kiyohara m_freem(m);
965 1.1 kiyohara ifp->if_ierrors ++;
966 1.1 kiyohara continue;
967 1.1 kiyohara }
968 1.1 kiyohara
969 1.1 kiyohara /*
970 1.1 kiyohara * Record the sender ID for possible BPF usage.
971 1.1 kiyohara */
972 1.1 kiyohara src = ntohl(p[1]) >> 16;
973 1.8 kiyohara if (bpf_peers_present(ifp->if_bpf)) {
974 1.1 kiyohara mtag = m_tag_alloc(MTAG_FIREWIRE,
975 1.1 kiyohara MTAG_FIREWIRE_SENDER_EUID,
976 1.1 kiyohara 2*sizeof(uint32_t), M_NOWAIT);
977 1.1 kiyohara if (mtag) {
978 1.1 kiyohara /* bpf wants it in network byte order */
979 1.1 kiyohara struct fw_device *fd;
980 1.1 kiyohara uint32_t *p2 = (uint32_t *) (mtag + 1);
981 1.1 kiyohara fd = fw_noderesolve_nodeid(fwip->fd.fc,
982 1.1 kiyohara src & 0x3f);
983 1.1 kiyohara if (fd) {
984 1.1 kiyohara p2[0] = htonl(fd->eui.hi);
985 1.1 kiyohara p2[1] = htonl(fd->eui.lo);
986 1.1 kiyohara } else {
987 1.1 kiyohara p2[0] = 0;
988 1.1 kiyohara p2[1] = 0;
989 1.1 kiyohara }
990 1.1 kiyohara m_tag_prepend(m, mtag);
991 1.1 kiyohara }
992 1.1 kiyohara }
993 1.1 kiyohara
994 1.1 kiyohara /*
995 1.1 kiyohara * Trim off the GASP header
996 1.1 kiyohara */
997 1.1 kiyohara m_adj(m, 3*sizeof(uint32_t));
998 1.1 kiyohara m->m_pkthdr.rcvif = ifp;
999 1.1 kiyohara FIREWIRE_INPUT(ifp, m, src);
1000 1.1 kiyohara ifp->if_ipackets ++;
1001 1.1 kiyohara }
1002 1.1 kiyohara if (STAILQ_FIRST(&xferq->stfree) != NULL)
1003 1.1 kiyohara fwip->fd.fc->irx_enable(fwip->fd.fc, fwip->dma_ch);
1004 1.1 kiyohara }
1005 1.1 kiyohara
1006 1.4 perry static inline void
1007 1.1 kiyohara fwip_unicast_input_recycle(struct fwip_softc *fwip, struct fw_xfer *xfer)
1008 1.1 kiyohara {
1009 1.1 kiyohara struct mbuf *m;
1010 1.1 kiyohara
1011 1.1 kiyohara /*
1012 1.1 kiyohara * We have finished with a unicast xfer. Allocate a new
1013 1.1 kiyohara * cluster and stick it on the back of the input queue.
1014 1.1 kiyohara */
1015 1.2 kiyohara m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
1016 1.2 kiyohara if (m == NULL)
1017 1.2 kiyohara printf("fwip_unicast_input_recycle: m_getcl failed\n");
1018 1.1 kiyohara xfer->mbuf = m;
1019 1.1 kiyohara xfer->recv.payload = mtod(m, uint32_t *);
1020 1.1 kiyohara xfer->recv.pay_len = MCLBYTES;
1021 1.1 kiyohara xfer->mbuf = m;
1022 1.1 kiyohara STAILQ_INSERT_TAIL(&fwip->fwb.xferlist, xfer, link);
1023 1.1 kiyohara }
1024 1.1 kiyohara
1025 1.1 kiyohara static void
1026 1.1 kiyohara fwip_unicast_input(struct fw_xfer *xfer)
1027 1.1 kiyohara {
1028 1.1 kiyohara uint64_t address;
1029 1.1 kiyohara struct mbuf *m;
1030 1.1 kiyohara struct m_tag *mtag;
1031 1.1 kiyohara struct ifnet *ifp;
1032 1.1 kiyohara struct fwip_softc *fwip;
1033 1.1 kiyohara struct fw_pkt *fp;
1034 1.1 kiyohara //struct fw_pkt *sfp;
1035 1.1 kiyohara int rtcode;
1036 1.1 kiyohara
1037 1.1 kiyohara fwip = (struct fwip_softc *)xfer->sc;
1038 1.8 kiyohara ifp = fwip->fw_softc.fwip_ifp;
1039 1.1 kiyohara m = xfer->mbuf;
1040 1.1 kiyohara xfer->mbuf = 0;
1041 1.1 kiyohara fp = &xfer->recv.hdr;
1042 1.1 kiyohara
1043 1.1 kiyohara /*
1044 1.1 kiyohara * Check the fifo address - we only accept addresses of
1045 1.1 kiyohara * exactly INET_FIFO.
1046 1.1 kiyohara */
1047 1.1 kiyohara address = ((uint64_t)fp->mode.wreqb.dest_hi << 32)
1048 1.1 kiyohara | fp->mode.wreqb.dest_lo;
1049 1.1 kiyohara if (fp->mode.wreqb.tcode != FWTCODE_WREQB) {
1050 1.1 kiyohara rtcode = FWRCODE_ER_TYPE;
1051 1.1 kiyohara } else if (address != INET_FIFO) {
1052 1.1 kiyohara rtcode = FWRCODE_ER_ADDR;
1053 1.1 kiyohara } else {
1054 1.1 kiyohara rtcode = FWRCODE_COMPLETE;
1055 1.1 kiyohara }
1056 1.1 kiyohara
1057 1.1 kiyohara /*
1058 1.1 kiyohara * Pick up a new mbuf and stick it on the back of the receive
1059 1.1 kiyohara * queue.
1060 1.1 kiyohara */
1061 1.1 kiyohara fwip_unicast_input_recycle(fwip, xfer);
1062 1.1 kiyohara
1063 1.1 kiyohara /*
1064 1.1 kiyohara * If we've already rejected the packet, give up now.
1065 1.1 kiyohara */
1066 1.1 kiyohara if (rtcode != FWRCODE_COMPLETE) {
1067 1.1 kiyohara m_freem(m);
1068 1.1 kiyohara ifp->if_ierrors ++;
1069 1.1 kiyohara return;
1070 1.1 kiyohara }
1071 1.1 kiyohara
1072 1.8 kiyohara if (bpf_peers_present(ifp->if_bpf)) {
1073 1.1 kiyohara /*
1074 1.1 kiyohara * Record the sender ID for possible BPF usage.
1075 1.1 kiyohara */
1076 1.1 kiyohara mtag = m_tag_alloc(MTAG_FIREWIRE, MTAG_FIREWIRE_SENDER_EUID,
1077 1.1 kiyohara 2*sizeof(uint32_t), M_NOWAIT);
1078 1.1 kiyohara if (mtag) {
1079 1.1 kiyohara /* bpf wants it in network byte order */
1080 1.1 kiyohara struct fw_device *fd;
1081 1.1 kiyohara uint32_t *p = (uint32_t *) (mtag + 1);
1082 1.1 kiyohara fd = fw_noderesolve_nodeid(fwip->fd.fc,
1083 1.1 kiyohara fp->mode.wreqb.src & 0x3f);
1084 1.1 kiyohara if (fd) {
1085 1.1 kiyohara p[0] = htonl(fd->eui.hi);
1086 1.1 kiyohara p[1] = htonl(fd->eui.lo);
1087 1.1 kiyohara } else {
1088 1.1 kiyohara p[0] = 0;
1089 1.1 kiyohara p[1] = 0;
1090 1.1 kiyohara }
1091 1.1 kiyohara m_tag_prepend(m, mtag);
1092 1.1 kiyohara }
1093 1.1 kiyohara }
1094 1.1 kiyohara
1095 1.1 kiyohara /*
1096 1.1 kiyohara * Hand off to the generic encapsulation code. We don't use
1097 1.1 kiyohara * ifp->if_input so that we can pass the source nodeid as an
1098 1.1 kiyohara * argument to facilitate link-level fragment reassembly.
1099 1.1 kiyohara */
1100 1.1 kiyohara m->m_len = m->m_pkthdr.len = fp->mode.wreqb.len;
1101 1.1 kiyohara m->m_pkthdr.rcvif = ifp;
1102 1.1 kiyohara FIREWIRE_INPUT(ifp, m, fp->mode.wreqb.src);
1103 1.1 kiyohara ifp->if_ipackets ++;
1104 1.1 kiyohara }
1105 1.1 kiyohara
1106 1.1 kiyohara #if defined(__FreeBSD__)
1107 1.1 kiyohara static devclass_t fwip_devclass;
1108 1.1 kiyohara
1109 1.1 kiyohara static device_method_t fwip_methods[] = {
1110 1.1 kiyohara /* device interface */
1111 1.1 kiyohara DEVMETHOD(device_identify, fwip_identify),
1112 1.1 kiyohara DEVMETHOD(device_probe, fwip_probe),
1113 1.1 kiyohara DEVMETHOD(device_attach, fwip_attach),
1114 1.1 kiyohara DEVMETHOD(device_detach, fwip_detach),
1115 1.1 kiyohara { 0, 0 }
1116 1.1 kiyohara };
1117 1.1 kiyohara
1118 1.1 kiyohara static driver_t fwip_driver = {
1119 1.1 kiyohara "fwip",
1120 1.1 kiyohara fwip_methods,
1121 1.1 kiyohara sizeof(struct fwip_softc),
1122 1.1 kiyohara };
1123 1.1 kiyohara
1124 1.1 kiyohara
1125 1.1 kiyohara #ifdef __DragonFly__
1126 1.1 kiyohara DECLARE_DUMMY_MODULE(fwip);
1127 1.1 kiyohara #endif
1128 1.1 kiyohara DRIVER_MODULE(fwip, firewire, fwip_driver, fwip_devclass, 0, 0);
1129 1.1 kiyohara MODULE_VERSION(fwip, 1);
1130 1.1 kiyohara MODULE_DEPEND(fwip, firewire, 1, 1, 1);
1131 1.1 kiyohara #elif defined(__NetBSD__)
1132 1.14 kiyohara CFATTACH_DECL_NEW(fwip, sizeof(struct fwip_softc),
1133 1.1 kiyohara fwipmatch, fwipattach, fwipdetach, NULL);
1134 1.1 kiyohara #endif
1135