Quick fix to the compile error.
[akaros.git] / kern / src / eth_audio.c
1 /* Copyright (c) 2010 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * Rimas's Ethernet-Audio device */
6
7 #ifdef __CONFIG_ETH_AUDIO__
8
9 #include <eth_audio.h>
10 #include <string.h>
11 #include <devfs.h>
12 #include <page_alloc.h>
13 #include <pmap.h>
14 #include <arch/nic_common.h>
15 #include <process.h>
16 #include <smp.h>
17
18 struct file_operations ethaud_in_f_op;
19 struct file_operations ethaud_out_f_op;
20 struct page_map_operations ethaud_pm_op;
21
22 /* There is only one packet we'll ever send out.  It's a full ethernet frame
23  * that we build and submit to send_frame() (which does another memcpy). */
24 struct ethaud_udp_packet eth_udp_out;
25
26 /* Consider a lock to protect this */
27 struct proc *active_proc = 0;
28
29 /* Nodes/inodes representing the device */
30 struct inode *ethaud_in, *ethaud_out;
31
32 /* Builds the device nodes in /dev */
33 void eth_audio_init(void)
34 {
35         struct page *page;
36         struct file *in_f, *out_f;
37         in_f = make_device("/dev/eth_audio_in", S_IRUSR, __S_IFBLK,
38                            &ethaud_in_f_op);
39         out_f = make_device("/dev/eth_audio_out", S_IRUSR | S_IWUSR, __S_IFBLK,
40                             &ethaud_out_f_op);
41         /* Grab and save the inodes (might change if we change make_device) */
42         ethaud_in = in_f->f_dentry->d_inode;
43         kref_get(&ethaud_in->i_kref, 1);
44         ethaud_out = out_f->f_dentry->d_inode;
45         kref_get(&ethaud_out->i_kref, 1);
46         /* Let go of the files (mostly used to get the dentry in the right place) */
47         kref_put(&in_f->f_kref);
48         kref_put(&out_f->f_kref);
49         /* make sure the inode tracks the right pm op */
50         ethaud_in->i_mapping->pm_op = &ethaud_pm_op;
51         ethaud_out->i_mapping->pm_op = &ethaud_pm_op;
52         /* zalloc pages and associate them with the devices' inodes */
53         assert(!kpage_alloc(&page));
54         memset(page2kva(page), 0, PGSIZE);
55         ethaud_in->i_fs_info = page;
56         assert(!kpage_alloc(&page));
57         memset(page2kva(page), 0, PGSIZE);
58         ethaud_out->i_fs_info = page;
59 }
60
61 /* Lots of unnecessary copies.  For now, we need to build the ethernet frame,
62  * which means we prepend the ethernet header... */
63 static void eth_audio_sendpacket(void *buf)
64 {
65         int retval;
66         /* Fill the outgoing buffer (Copy #1.  2 is in send_frame, 3 is the DMA). */
67         memcpy(&eth_udp_out.payload, buf, ETH_AUDIO_PAYLOAD_SZ);
68         /* Make sure there is still a reasonable header. */
69         static_assert(sizeof(eth_udp_out) == ETH_AUDIO_FRAME_SZ);
70         /* Should compute the UDP checksum before sending the frame out.  The
71          * Eth-audio device shouldn't care (and Linux seems to be okay with packets
72          * that have no checksum (but not a wrong checksum)).  Technically, this
73          * hurts our performance a bit (and some NICs can offload this). */
74         eth_udp_out.udp_hdr.checksum = htons(udp_checksum(&eth_udp_out.ip_hdr,
75                                                           &eth_udp_out.udp_hdr));
76         /* Send it out */
77         retval = send_frame((const char*)&eth_udp_out, ETH_AUDIO_FRAME_SZ);
78         assert(retval >= 0);
79 }
80
81 /* This is how we know who to send the packet back to, since we have no real
82  * networking stack.  Lots of assumptions about how things stay in sync. */
83 static void eth_audio_prep_response(struct ethaud_udp_packet *incoming,
84                                     struct ethaud_udp_packet *outgoing)
85 {
86         /* If you're looking for optimizations, we can do this just once */
87         memcpy(&outgoing->eth_hdr.dst_mac, &incoming->eth_hdr.src_mac, 6); 
88         memcpy(&outgoing->eth_hdr.src_mac, device_mac, 6); 
89         outgoing->eth_hdr.eth_type = htons(IP_ETH_TYPE);
90         outgoing->ip_hdr.version = IPPROTO_IPV4;
91         outgoing->ip_hdr.hdr_len = ETH_AUDIO_IP_HDR_SZ >> 2;
92         outgoing->ip_hdr.tos = 0;
93         outgoing->ip_hdr.packet_len = htons(ETH_AUDIO_PAYLOAD_SZ + UDP_HDR_SZ +
94                                             ETH_AUDIO_IP_HDR_SZ);
95         outgoing->ip_hdr.id = htons(0);
96         outgoing->ip_hdr.flags_frags = htons(0);
97         outgoing->ip_hdr.ttl = DEFAULT_TTL;
98         outgoing->ip_hdr.protocol = IPPROTO_UDP;
99         /* Need a non-broadcast IP.  Picking one higher than the sender's */
100         outgoing->ip_hdr.src_addr = htonl(ntohl(incoming->ip_hdr.src_addr) + 1);
101         outgoing->ip_hdr.dst_addr = incoming->ip_hdr.src_addr;
102         /* Since the IP header is set already, we can compute the checksum. */
103         outgoing->ip_hdr.checksum = htons(ip_checksum(&outgoing->ip_hdr));
104         outgoing->udp_hdr.src_port = htons(ETH_AUDIO_SRC_PORT);
105         outgoing->udp_hdr.dst_port = htons(ETH_AUDIO_DST_PORT);
106         outgoing->udp_hdr.length = htons(ETH_AUDIO_PAYLOAD_SZ + UDP_HDR_SZ);
107         outgoing->udp_hdr.checksum = htons(0);
108
109         /* Debugging */
110         static int once = 0;
111         if (!once++)
112                 printd("I will send %d bytes from %08p:%d to %08p:%d, iplen %04p, "
113                        "udplen %04p\n",
114                        ntohs(outgoing->udp_hdr.length),
115                        ntohl(outgoing->ip_hdr.src_addr),
116                        ntohs(outgoing->udp_hdr.src_port), 
117                        ntohl(outgoing->ip_hdr.dst_addr),
118                        ntohs(outgoing->udp_hdr.dst_port),
119                        ntohs(outgoing->ip_hdr.packet_len),
120                        ntohs(outgoing->udp_hdr.length)
121                            ); 
122 }
123
124 /* This is called by net subsys when it detects an ethernet audio packet.  Make
125  * sure the in device has the contents, and send out the old frame. */
126 void eth_audio_newpacket(void *buf)
127 {
128         struct page *in_page, *out_page;
129         /* Bail out if these two haven't been initialized yet */
130         if (!ethaud_in || !ethaud_out)
131                 return;
132         /* Put info from the packet into the outgoing packet */
133         eth_audio_prep_response((struct ethaud_udp_packet*)buf, &eth_udp_out);
134         in_page = (struct page*)ethaud_in->i_fs_info;
135         out_page = (struct page*)ethaud_out->i_fs_info;
136         /* third copy (1st being the NIC to RAM). */
137         memcpy(page2kva(in_page), buf + ETH_AUDIO_HEADER_OFF, ETH_AUDIO_PAYLOAD_SZ);
138         /* Send the current outbound packet (can consider doing this by fsync) */
139         eth_audio_sendpacket(page2kva(out_page));
140         if (active_proc)
141                 proc_notify(active_proc, 0);
142 }
143
144 /* mmap() calls this to do any FS specific mmap() work.  Since our files are
145  * defined to be only one page, we need to make sure they aren't mmapping too
146  * much, and that it isn't a PRIVATE mapping.
147  *
148  * Then we need to make sure the one page of the VMR is mapped in the page table
149  * (circumventing handle_page_fault and the page cache).  Avoiding the page
150  * cache means we won't need to worry about accidentally unmapping this under
151  * pressure and having to remap it (which will cause a readpage). */
152 int eth_audio_mmap(struct file *file, struct vm_region *vmr)
153 {
154         struct page *page = (struct page*)file->f_dentry->d_inode->i_fs_info;
155         /* Only allow mmaping from the start of the file */
156         if (vmr->vm_foff)
157                 return -1;
158         /* Only allow mmaping of a page */
159         if (vmr->vm_end - vmr->vm_base != PGSIZE)
160                 return -1;
161         /* No private mappings (would be ignored anyway) */
162         if (vmr->vm_flags & MAP_PRIVATE)
163                 return -1;
164         /* Only one proc can use it at a time (we need to know who to notify, since
165          * we don't have any sockets or other abstractions to work with).  Note we
166          * are storing a reference. */
167         if (active_proc && active_proc != vmr->vm_proc)
168                 return -1;
169         if (!active_proc) {
170                 kref_get(&vmr->vm_proc->kref, 1);
171                 active_proc = vmr->vm_proc;
172         }
173         assert(page);
174         /* Get the PTE for the page this VMR represents */
175         pte_t *pte = pgdir_walk(vmr->vm_proc->env_pgdir, (void*)vmr->vm_base, 1);
176         if (!pte)
177                 return -ENOMEM;
178         /* If there was a page there, it should have be munmapp()d. */
179         assert(!PAGE_PRESENT(*pte));
180         /* update the page table */
181         int pte_prot = (vmr->vm_prot & PROT_WRITE) ? PTE_USER_RW :
182                        (vmr->vm_prot & (PROT_READ|PROT_EXEC)) ? PTE_USER_RO : 0;
183         /* Storing a reference to the page in the PTE */
184         page_incref(page);
185         *pte = PTE(page2ppn(page), PTE_P | pte_prot);
186         return 0;
187 }
188
189 /* This shouldn't be called.  It could be if we ever handled a PF on the device,
190  * and the device wasn't present in the page table.  This should not happen,
191  * since ea_mmap() should have sorted that out.  Even if there was an unmap()
192  * then a new mmap(), it still shouldn't happen. */
193 int eth_audio_readpage(struct page_map *pm, struct page *page)
194 {
195         warn("Eth audio readpage!  (Did you page fault?)");
196         return -1;
197 }
198
199 /* Called when the file is about to be closed (file obj freed).  This is the
200  * least intrusive way to find out when the device is unmapped and closed, so we
201  * can let go of the proc.  TODO: Note that currently, the kernel will not be
202  * able to unmap the file by itself, due to the circular dependence of the kref,
203  * proc_free, and destroy_vmr.  Programs have to unmap it themselves.  Since
204  * this device is a bit of a hack anyway, I'm okay with not making big changes
205  * to the kernel to support this yet. */
206 int eth_audio_release(struct inode *inode, struct file *file)
207 {
208         /* Disconnect the proc from the device, decref. */
209         if (active_proc && current) {
210                 assert(active_proc == current);
211                 kref_put(&active_proc->kref);
212                 active_proc = 0;
213         }
214         return 0;
215 }
216
217 /* File operations */
218 struct file_operations ethaud_in_f_op = {
219         dev_c_llseek,   /* Errors out, can't llseek */
220         0,                              /* Can't read, only mmap */
221         0,                              /* Can't write, only mmap */
222         kfs_readdir,    /* this will fail gracefully */
223         eth_audio_mmap,
224         kfs_open,
225         kfs_flush,
226         eth_audio_release,
227         0,                              /* fsync - makes no sense */
228         kfs_poll,
229         0,      /* readv */
230         0,      /* writev */
231         kfs_sendpage,
232         kfs_check_flags,
233 };
234
235 struct file_operations ethaud_out_f_op = {
236         dev_c_llseek,   /* Errors out, can't llseek */
237         0,                              /* Can't read, only mmap */
238         0,                              /* Can't write, only mmap */
239         kfs_readdir,    /* this will fail gracefully */
240         eth_audio_mmap,
241         kfs_open,
242         kfs_flush,
243         eth_audio_release,
244         0,                              /* fsync - TODO: make this send the packet */
245         kfs_poll,
246         0,      /* readv */
247         0,      /* writev */
248         kfs_sendpage,
249         kfs_check_flags,
250 };
251
252 /* Eth audio page map ops: */
253 struct page_map_operations ethaud_pm_op = {
254         eth_audio_readpage,
255 };
256
257 #endif /* __CONFIG_ETH_AUDIO__ */