Subversion Repositories svn.mios32

Rev

Rev 2405 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1284 tk 1
// $Id: uip_task.c 2425 2016-11-03 00:44:22Z tk $
2
/*
3
 * uIP handler as FreeRTOS task
4
 *
5
 * Framework taken from $MIOS32_PATH/modules/uip/doc/example-mainloop-with-arp.c
6
 *
7
 * ==========================================================================
8
 *
9
 *  Copyright (C) 2009 Thorsten Klose (tk@midibox.org)
10
 *  Licensed for personal non-commercial use only.
11
 *  All other rights reserved.
12
 *
13
 * ==========================================================================
14
 */
15
 
16
/////////////////////////////////////////////////////////////////////////////
17
// Include files
18
/////////////////////////////////////////////////////////////////////////////
19
#include <mios32.h>
20
 
21
#include <FreeRTOS.h>
22
#include <task.h>
23
#include <queue.h>
24
 
25
//#include "app.h"
26
 
27
#include "uip.h"
28
#include "uip_arp.h"
29
#include "network-device.h"
30
#include "timer.h"
31
 
32
#include "uip_task.h"
1311 tk 33
//#include "telnetd.h"
1284 tk 34
#include "osc_server.h"
1311 tk 35
#include "osc_client.h"
1284 tk 36
#include "dhcpc.h"
37
 
2405 tk 38
#if OSC_SERVER_ESP8266_ENABLED
39
#include <esp8266.h>
40
#endif
1284 tk 41
 
2405 tk 42
 
1284 tk 43
/////////////////////////////////////////////////////////////////////////////
44
// for optional debugging messages via MIOS32_MIDI_SendDebug*
45
/////////////////////////////////////////////////////////////////////////////
46
 
47
#define DEBUG_VERBOSE_LEVEL 1
48
 
49
#ifndef DEBUG_MSG
50
# define DEBUG_MSG MIOS32_MIDI_SendDebugMessage
51
#endif
52
 
53
 
54
/////////////////////////////////////////////////////////////////////////////
55
// Task Priorities
56
/////////////////////////////////////////////////////////////////////////////
57
 
58
#define PRIORITY_TASK_UIP       ( tskIDLE_PRIORITY + 3 )
59
 
60
 
61
// for mutual exclusive access to uIP functions
62
// The mutex is handled with MUTEX_UIP_TAKE and MUTEX_UIP_GIVE macros
63
xSemaphoreHandle xUIPSemaphore;
64
 
65
 
66
/////////////////////////////////////////////////////////////////////////////
67
// Local defines
68
/////////////////////////////////////////////////////////////////////////////
69
 
70
#define BUF ((struct uip_eth_hdr *)&uip_buf[0])
71
 
72
 
73
/////////////////////////////////////////////////////////////////////////////
74
// Local prototypes
75
/////////////////////////////////////////////////////////////////////////////
76
static void UIP_TASK_Handler(void *pvParameters);
77
static s32 UIP_TASK_StartServices(void);
78
static s32 UIP_TASK_StopServices(void);
79
static s32 UIP_TASK_SendDebugMessage_IP(void);
80
 
81
 
82
/////////////////////////////////////////////////////////////////////////////
83
// Local variables
84
/////////////////////////////////////////////////////////////////////////////
85
static u8 services_running;
86
static u8 dhcp_enabled = 1;
87
static u8 udp_monitor_level;
88
static u32 my_ip_address = MY_IP_ADDRESS;
89
static u32 my_netmask = MY_NETMASK;
90
static u32 my_gateway = MY_GATEWAY;
91
 
92
 
93
/////////////////////////////////////////////////////////////////////////////
94
// Initialize the uIP task
95
/////////////////////////////////////////////////////////////////////////////
96
s32 UIP_TASK_Init(u32 mode)
97
{
98
  if( mode > 0 )
99
    return -1; // only mode 0 supported yet
100
 
1311 tk 101
  // initialize OSC client (in distance to OSC server: only once after startup...)
102
  OSC_CLIENT_Init(0);
103
 
1284 tk 104
  xUIPSemaphore = xSemaphoreCreateRecursiveMutex();
105
 
2425 tk 106
  xTaskCreate(UIP_TASK_Handler, "uIP", UIP_TASK_STACK_SIZE/4, NULL, PRIORITY_TASK_UIP, NULL);
1284 tk 107
 
108
  services_running = 0;
109
 
110
  udp_monitor_level = UDP_MONITOR_LEVEL_0_OFF;
111
 
2405 tk 112
#if OSC_SERVER_ESP8266_ENABLED
113
  // init ESP8266
114
  ESP8266_Init(0);
115
  ESP8266_InitUart(UART2, 115200); // MIDI IN/OUT 3 port is sacrificed
116
#endif
117
 
1284 tk 118
  return 0; // no error
119
}
120
 
121
 
122
/////////////////////////////////////////////////////////////////////////////
123
// Init function for presets (read before UIP_TASKS_Init()
124
/////////////////////////////////////////////////////////////////////////////
125
s32 UIP_TASK_InitFromPresets(u8 _dhcp_enabled, u32 _my_ip_address, u32 _my_netmask, u32 _my_gateway)
126
{
127
  dhcp_enabled = _dhcp_enabled;
128
  my_ip_address = _my_ip_address;
129
  my_netmask = _my_netmask;
130
  my_gateway = _my_gateway;
131
 
132
  return 0; // no error
133
}
134
 
135
 
136
/////////////////////////////////////////////////////////////////////////////
137
// The uIP Task is executed each mS
138
/////////////////////////////////////////////////////////////////////////////
139
static void UIP_TASK_Handler(void *pvParameters)
140
{
141
  int i;
142
  struct timer periodic_timer, arp_timer;
143
 
144
  // take over exclusive access to UIP functions
145
  MUTEX_UIP_TAKE;
146
 
147
  // init uIP timers
148
  timer_set(&periodic_timer, CLOCK_SECOND / 2);
149
  timer_set(&arp_timer, CLOCK_SECOND * 10);
150
 
151
  // init the network driver
152
  network_device_init();
153
 
154
  // init uIP
155
  uip_init();
156
  uip_arp_init();
157
 
158
  // set my ethernet address
159
  unsigned char *mac_addr = network_device_mac_addr();
160
  {
161
    int i;
162
    for(i=0; i<6; ++i)
163
      uip_ethaddr.addr[i] = mac_addr[i];
164
  }
165
 
166
  // enable dhcp mode (can be changed during runtime)
167
  UIP_TASK_DHCP_EnableSet(dhcp_enabled);
168
 
169
  // release exclusive access to UIP functions
170
  MUTEX_UIP_GIVE;
171
 
172
#if 0
173
  // wait until HW config has been loaded
174
  do {
175
    vTaskDelay(1 / portTICK_RATE_MS);
176
  } while( !SEQ_FILE_HW_ConfigLocked() );
177
#endif
178
 
179
  // Initialise the xLastExecutionTime variable on task entry
180
  portTickType xLastExecutionTime = xTaskGetTickCount();
181
 
182
  // endless loop
183
  while( 1 ) {
184
#if 0
185
    do {
186
      vTaskDelayUntil(&xLastExecutionTime, 1 / portTICK_RATE_MS);
187
    } while( TASK_MSD_EnableGet() ); // don't service ethernet if MSD mode enabled for faster transfer speed
188
#else
189
    vTaskDelayUntil(&xLastExecutionTime, 1 / portTICK_RATE_MS);
190
#endif
191
 
192
    // take over exclusive access to UIP functions
193
    MUTEX_UIP_TAKE;
194
 
195
    if( !(clock_time_tick() % 100) ) {
196
      // each 100 mS: check availablility of network device
197
#if defined(MIOS32_BOARD_MBHP_CORE_LPC17) || defined(MIOS32_BOARD_LPCXPRESSO)
198
      network_device_check();
199
      // TK: on STM32 no auto-detection for MBSEQ for best performance if no MBHP_ETH module connected
200
      // the user has to reboot MBSEQ to restart module detection
201
#endif
202
    }
203
 
204
    if( network_device_available() ) {
205
      uip_len = network_device_read();
206
 
207
      if( uip_len > 0 ) {
208
    if(BUF->type == HTONS(UIP_ETHTYPE_IP) ) {
209
      uip_arp_ipin();
210
      uip_input();
211
 
212
      /* If the above function invocation resulted in data that
213
         should be sent out on the network, the global variable
214
         uip_len is set to a value > 0. */
215
      if( uip_len > 0 ) {
216
        uip_arp_out();
217
        network_device_send();
218
      }
219
    } else if(BUF->type == HTONS(UIP_ETHTYPE_ARP)) {
220
      uip_arp_arpin();
221
      /* If the above function invocation resulted in data that
222
         should be sent out on the network, the global variable
223
         uip_len is set to a value > 0. */
224
      if(uip_len > 0) {
225
        network_device_send();
226
      }
227
    }
228
 
229
      } else if(timer_expired(&periodic_timer)) {
230
    timer_reset(&periodic_timer);
231
    for(i = 0; i < UIP_CONNS; i++) {
232
      uip_periodic(i);
233
      /* If the above function invocation resulted in data that
234
         should be sent out on the network, the global variable
235
         uip_len is set to a value > 0. */
236
      if(uip_len > 0) {
237
        uip_arp_out();
238
        network_device_send();
239
      }
240
    }
241
 
242
#if UIP_UDP
243
    for(i = 0; i < UIP_UDP_CONNS; i++) {
244
      uip_udp_periodic(i);
245
      /* If the above function invocation resulted in data that
246
         should be sent out on the network, the global variable
247
         uip_len is set to a value > 0. */
248
      if(uip_len > 0) {
249
        uip_arp_out();
250
        network_device_send();
251
      }
252
    }
253
#endif /* UIP_UDP */
254
 
255
    /* Call the ARP timer function every 10 seconds. */
256
    if(timer_expired(&arp_timer)) {
257
      timer_reset(&arp_timer);
258
      uip_arp_timer();
259
    }
260
      }
261
    }
262
 
263
    // release exclusive access to UIP functions
264
    MUTEX_UIP_GIVE;
2405 tk 265
 
266
#if OSC_SERVER_ESP8266_ENABLED
267
    // ESP8266 handling
268
    ESP8266_Periodic_mS();
269
#endif
270
 
1284 tk 271
  }
272
}
273
 
274
 
275
/////////////////////////////////////////////////////////////////////////////
276
// used by uIP to print a debug message
277
/////////////////////////////////////////////////////////////////////////////
278
void uip_log(char *msg)
279
{
280
#if DEBUG_VERBOSE_LEVEL >= 2
281
  UIP_TASK_MUTEX_MIDIOUT_TAKE;
282
  DEBUG_MSG(msg);
283
  UIP_TASK_MUTEX_MIDIOUT_GIVE;
284
#endif
285
}
286
 
287
 
288
/////////////////////////////////////////////////////////////////////////////
289
// Called by UDP handler of uIP
290
/////////////////////////////////////////////////////////////////////////////
291
s32 UIP_TASK_AppCall(void)
292
{
293
  // no TCP service used yet...
294
  return 0; // no error
295
}
296
 
297
/////////////////////////////////////////////////////////////////////////////
298
// Prints current IP settings
299
/////////////////////////////////////////////////////////////////////////////
300
static s32 UIP_TASK_SendDebugMessage_IP(void)
301
{
302
  uip_ipaddr_t ipaddr;
303
  uip_gethostaddr(&ipaddr);
304
 
305
#if DEBUG_VERBOSE_LEVEL >= 1
306
  UIP_TASK_MUTEX_MIDIOUT_TAKE;
307
  DEBUG_MSG("[UIP_TASK] IP address: %d.%d.%d.%d\n",
308
        uip_ipaddr1(ipaddr), uip_ipaddr2(ipaddr),
309
        uip_ipaddr3(ipaddr), uip_ipaddr4(ipaddr));
310
 
311
  uip_ipaddr_t netmask;
312
  uip_getnetmask(&netmask);
313
  DEBUG_MSG("[UIP_TASK] Netmask: %d.%d.%d.%d\n",
314
        uip_ipaddr1(netmask), uip_ipaddr2(netmask),
315
        uip_ipaddr3(netmask), uip_ipaddr4(netmask));
316
 
317
  uip_ipaddr_t draddr;
318
  uip_getdraddr(&draddr);
319
  DEBUG_MSG("[UIP_TASK] Default Router (Gateway): %d.%d.%d.%d\n",
320
        uip_ipaddr1(draddr), uip_ipaddr2(draddr),
321
        uip_ipaddr3(draddr), uip_ipaddr4(draddr));
322
  UIP_TASK_MUTEX_MIDIOUT_GIVE;
323
#endif
324
 
325
  return 0; // no error
326
}
327
 
328
 
329
/////////////////////////////////////////////////////////////////////////////
330
// Configure DHCP mode (can be changed during runtime)
331
/////////////////////////////////////////////////////////////////////////////
332
s32 UIP_TASK_DHCP_EnableSet(u8 _dhcp_enabled)
333
{
334
  uip_ipaddr_t ipaddr;
335
 
336
  dhcp_enabled = _dhcp_enabled;
337
 
338
  // branch depending on DHCP mode
339
  if( dhcp_enabled ) {
340
    // stop all services, will be started once we got the IP
341
    UIP_TASK_StopServices();
342
 
343
    // IP address/netmask/router must be 0
344
    uip_ipaddr(ipaddr, 0x00, 0x00, 0x00, 0x00);
345
    uip_sethostaddr(ipaddr);
346
    uip_setnetmask(ipaddr);
347
    uip_setdraddr(ipaddr);
348
 
349
    dhcpc_init(uip_ethaddr.addr, sizeof(uip_ethaddr.addr));
350
#if DEBUG_VERBOSE_LEVEL >= 1
351
    if( network_device_available() ) { // don't print message if ethernet device is not available, the message could confuse "normal users"
352
      UIP_TASK_MUTEX_MIDIOUT_TAKE;
353
      DEBUG_MSG("[UIP_TASK] DHCP Client requests the IP settings...\n");
354
      UIP_TASK_MUTEX_MIDIOUT_GIVE;
355
    }
356
#endif
357
  } else {
358
    // set my IP address
359
    uip_ipaddr(ipaddr,
360
           ((my_ip_address)>>24) & 0xff,
361
           ((my_ip_address)>>16) & 0xff,
362
           ((my_ip_address)>> 8) & 0xff,
363
           ((my_ip_address)>> 0) & 0xff);
364
    uip_sethostaddr(ipaddr);
365
 
366
    // set my netmask
367
    uip_ipaddr(ipaddr,
368
           ((my_netmask)>>24) & 0xff,
369
           ((my_netmask)>>16) & 0xff,
370
           ((my_netmask)>> 8) & 0xff,
371
           ((my_netmask)>> 0) & 0xff);
372
    uip_setnetmask(ipaddr);
373
 
374
    // default router
375
    uip_ipaddr(ipaddr,
376
           ((my_gateway)>>24) & 0xff,
377
           ((my_gateway)>>16) & 0xff,
378
           ((my_gateway)>> 8) & 0xff,
379
           ((my_gateway)>> 0) & 0xff);
380
    uip_setdraddr(ipaddr);
381
 
382
#if DEBUG_VERBOSE_LEVEL >= 1
383
    if( network_device_available() ) { // don't print message if ethernet device is not available, the message could confuse "normal users"
384
      UIP_TASK_MUTEX_MIDIOUT_TAKE;
385
      DEBUG_MSG("[UIP_TASK] IP Address statically set:\n");
386
      UIP_TASK_MUTEX_MIDIOUT_GIVE;
387
    }
388
#endif
389
 
390
    // start services immediately
391
    UIP_TASK_StartServices();
392
  }
393
 
394
  return 0; // no error
395
}
396
 
397
s32 UIP_TASK_DHCP_EnableGet(void)
398
{
399
  return dhcp_enabled;
400
}
401
 
402
 
403
/////////////////////////////////////////////////////////////////////////////
404
// Set/Get IP values
405
/////////////////////////////////////////////////////////////////////////////
406
s32 UIP_TASK_IP_AddressSet(u32 ip)
407
{
408
  uip_ipaddr_t ipaddr;
409
 
410
  my_ip_address = ip;
411
  uip_ipaddr(ipaddr,
412
         ((ip)>>24) & 0xff,
413
         ((ip)>>16) & 0xff,
414
         ((ip)>> 8) & 0xff,
415
         ((ip)>> 0) & 0xff);
416
  uip_sethostaddr(ipaddr);
417
 
418
  return 0; // no error
419
}
420
 
421
s32 UIP_TASK_IP_AddressGet(void)
422
{
423
  return my_ip_address;
424
}
425
 
1294 tk 426
s32 UIP_TASK_IP_EffectiveAddressGet(void)
427
{
428
  uip_ipaddr_t ipaddr;
429
  uip_gethostaddr(&ipaddr);
430
  return
431
    (uip_ipaddr1(ipaddr) << 24) |
432
    (uip_ipaddr2(ipaddr) << 16) |
433
    (uip_ipaddr3(ipaddr) <<  8) |
434
    (uip_ipaddr4(ipaddr) <<  0);
435
}
1284 tk 436
 
437
s32 UIP_TASK_NetmaskSet(u32 mask)
438
{
439
  uip_ipaddr_t ipaddr;
440
 
441
  my_netmask = mask;
442
  uip_ipaddr(ipaddr,
443
         ((mask)>>24) & 0xff,
444
         ((mask)>>16) & 0xff,
445
         ((mask)>> 8) & 0xff,
446
         ((mask)>> 0) & 0xff);
447
  uip_setnetmask(ipaddr);
448
 
449
  return 0; // no error
450
}
451
 
452
s32 UIP_TASK_NetmaskGet(void)
453
{
454
  return my_netmask;
455
}
456
 
1294 tk 457
s32 UIP_TASK_EffectiveNetmaskGet(void)
458
{
459
  uip_ipaddr_t ipaddr;
460
  uip_getnetmask(&ipaddr);
461
  return
462
    (uip_ipaddr1(ipaddr) << 24) |
463
    (uip_ipaddr2(ipaddr) << 16) |
464
    (uip_ipaddr3(ipaddr) <<  8) |
465
    (uip_ipaddr4(ipaddr) <<  0);
466
}
1284 tk 467
 
468
s32 UIP_TASK_GatewaySet(u32 ip)
469
{
470
  uip_ipaddr_t ipaddr;
471
 
472
  my_gateway = ip;
473
  uip_ipaddr(ipaddr,
474
         ((ip)>>24) & 0xff,
475
         ((ip)>>16) & 0xff,
476
         ((ip)>> 8) & 0xff,
477
         ((ip)>> 0) & 0xff);
478
  uip_setdraddr(ipaddr);
479
 
480
  return 0; // no error
481
}
482
 
483
s32 UIP_TASK_GatewayGet(void)
484
{
485
  return my_gateway;
486
}
487
 
1294 tk 488
s32 UIP_TASK_EffectiveGatewayGet(void)
489
{
490
  uip_ipaddr_t ipaddr;
491
  uip_getdraddr(&ipaddr);
492
  return
493
    (uip_ipaddr1(ipaddr) << 24) |
494
    (uip_ipaddr2(ipaddr) << 16) |
495
    (uip_ipaddr3(ipaddr) <<  8) |
496
    (uip_ipaddr4(ipaddr) <<  0);
497
}
1284 tk 498
 
499
/////////////////////////////////////////////////////////////////////////////
500
// start services
501
/////////////////////////////////////////////////////////////////////////////
502
static s32 UIP_TASK_StartServices(void)
503
{
504
  // print IP settings
505
  UIP_TASK_MUTEX_MIDIOUT_TAKE;
506
  UIP_TASK_SendDebugMessage_IP();
507
  UIP_TASK_MUTEX_MIDIOUT_GIVE;
508
 
509
  // start telnet daemon
1311 tk 510
  //telnetd_init();
1284 tk 511
 
512
  // start OSC daemon
513
  OSC_SERVER_Init(0);
514
 
515
  // services available now
516
  services_running = 1;
517
 
518
  return 0; // no error
519
}
520
 
521
 
522
/////////////////////////////////////////////////////////////////////////////
523
// stop services
524
/////////////////////////////////////////////////////////////////////////////
525
static s32 UIP_TASK_StopServices(void)
526
{
527
  // stop all services
528
  services_running = 0;
529
 
530
  return 0; // no error
531
}
532
 
533
 
534
/////////////////////////////////////////////////////////////////////////////
535
// Status flag for external functions
536
/////////////////////////////////////////////////////////////////////////////
537
s32 UIP_TASK_ServicesRunning(void)
538
{
539
  return services_running;
540
}
541
 
542
 
543
/////////////////////////////////////////////////////////////////////////////
544
// network device connected to core?
545
/////////////////////////////////////////////////////////////////////////////
546
s32 UIP_TASK_NetworkDeviceAvailable(void)
547
{
548
  return network_device_available();
549
}
550
 
551
 
552
/////////////////////////////////////////////////////////////////////////////
553
// Called by UDP handler of uIP
554
/////////////////////////////////////////////////////////////////////////////
555
s32 UIP_TASK_UDP_AppCall(void)
556
{
557
  // DHCP client
558
  if( uip_udp_conn->rport == HTONS(DHCPC_SERVER_PORT) || uip_udp_conn->rport == HTONS(DHCPC_CLIENT_PORT) ) {
559
    dhcpc_appcall();
560
 
561
    // monitor option
562
    if( udp_monitor_level >= UDP_MONITOR_LEVEL_4_ALL )
563
      UIP_TASK_UDP_MonitorPacket(UDP_MONITOR_RECEIVED, "DHCP"); // should we differ between send/receive?
564
 
565
  } else {
566
    // OSC Server checks for IP/port locally
567
    OSC_SERVER_AppCall();
568
 
569
    // MonitorPacket called from OSC_SERVER
570
  }
571
 
572
  return 0; // no error
573
}
574
 
575
 
576
/////////////////////////////////////////////////////////////////////////////
577
// This function optionally outputs the current UDP packet to the MIOS terminal
578
/////////////////////////////////////////////////////////////////////////////
579
extern u16_t uip_slen; // allows to access a variable which is part of uip.c
580
#define TCPIPBUF ((struct uip_tcpip_hdr *)&uip_buf[UIP_LLH_LEN])
581
#define UDPBUF ((struct uip_udpip_hdr *)&uip_buf[UIP_LLH_LEN])
582
s32 UIP_TASK_UDP_MonitorPacket(u8 received, char* prefix)
583
{
584
  UIP_TASK_MUTEX_MIDIOUT_TAKE;
585
  int len;
586
  if( received ) {
587
    len = uip_len;
588
 
589
    DEBUG_MSG("[UDP:%s] from %d.%d.%d.%d:%d to port %d (%d bytes)\n",
590
          prefix,
591
          (TCPIPBUF->srcipaddr[0]>>0)&0xff, (TCPIPBUF->srcipaddr[0]>>8)&0xff, (TCPIPBUF->srcipaddr[1]>>0)&0xff, (TCPIPBUF->srcipaddr[1]>>8)&0xff,
592
          HTONS(UDPBUF->srcport), HTONS(UDPBUF->destport),
593
          len);
594
  } else {
595
    len = uip_slen;
596
 
597
    DEBUG_MSG("[UDP:%s] to %d.%d.%d.%d:%d from port %d (%d bytes)\n",
598
          prefix,
599
          (TCPIPBUF->srcipaddr[0]>>0)&0xff, (TCPIPBUF->srcipaddr[0]>>8)&0xff, (TCPIPBUF->srcipaddr[1]>>0)&0xff, (TCPIPBUF->srcipaddr[1]>>8)&0xff,
600
          HTONS(UDPBUF->destport), HTONS(UDPBUF->srcport),
601
          len);
602
  }
603
  MIOS32_MIDI_SendDebugHexDump((u8 *)uip_appdata, len);
604
  UIP_TASK_MUTEX_MIDIOUT_GIVE;
605
 
606
  return 0; // no error
607
}
608
 
2405 tk 609
s32 UIP_TASK_UDP_ESP8266_MonitorPacket(u8 received, char* prefix, u32 ip, u16 port, u8 *payload, u32 len, u16 port_local)
610
{
611
  UIP_TASK_MUTEX_MIDIOUT_TAKE;
612
  if( received ) {
613
    DEBUG_MSG("[UDP:%s] from %d.%d.%d.%d:%d to port %d (%d bytes)\n",
614
          prefix,
615
          (ip >> 0) & 0xff, (ip >> 8) & 0xff, (ip >> 16) & 0xff, (ip >> 24) & 0xff,
616
          port, port_local,
617
          len);
618
  } else {
619
    DEBUG_MSG("[UDP:%s] to %d.%d.%d.%d:%d from port %d (%d bytes)\n",
620
          prefix,
621
          (ip >> 0) & 0xff, (ip >> 8) & 0xff, (ip >> 16) & 0xff, (ip >> 24) & 0xff,
622
          port, port_local,
623
          len);
624
  }
625
  MIOS32_MIDI_SendDebugHexDump((u8 *)payload, len);
626
  UIP_TASK_MUTEX_MIDIOUT_GIVE;
627
 
628
  return 0; // no error
629
}
630
 
1284 tk 631
/////////////////////////////////////////////////////////////////////////////
632
// Sets/Returns the UDP/OSC monitor level
633
/////////////////////////////////////////////////////////////////////////////
634
s32 UIP_TASK_UDP_MonitorLevelSet(u8 level)
635
{
636
  udp_monitor_level = level;
637
  return 0; // no error
638
}
639
 
640
s32 UIP_TASK_UDP_MonitorLevelGet(void)
641
{
642
  return udp_monitor_level;
643
}
644
 
645
 
646
/////////////////////////////////////////////////////////////////////////////
647
// Called by DHCP client once it got IP addresses
648
/////////////////////////////////////////////////////////////////////////////
649
void dhcpc_configured(const struct dhcpc_state *s)
650
{
651
  // set IP settings
652
  uip_sethostaddr(s->ipaddr);
653
  uip_setnetmask(s->netmask);
654
  uip_setdraddr(s->default_router);
655
 
656
  // start services
657
  UIP_TASK_StartServices();
658
 
659
  // print unused settings
660
#if DEBUG_VERBOSE_LEVEL >= 1
661
  UIP_TASK_MUTEX_MIDIOUT_TAKE;
662
  DEBUG_MSG("[UIP_TASK] Got DNS server %d.%d.%d.%d\n",
663
        uip_ipaddr1(s->dnsaddr), uip_ipaddr2(s->dnsaddr),
664
        uip_ipaddr3(s->dnsaddr), uip_ipaddr4(s->dnsaddr));
665
  DEBUG_MSG("[UIP_TASK] Lease expires in %d hours\n",
666
        (ntohs(s->lease_time[0])*65536ul + ntohs(s->lease_time[1]))/3600);
667
  UIP_TASK_MUTEX_MIDIOUT_GIVE;
668
#endif
669
}