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