1 /***************************************************************************
2 * Copyright (c) 2024 Microsoft Corporation
3 *
4 * This program and the accompanying materials are made available under the
5 * terms of the MIT License which is available at
6 * https://opensource.org/licenses/MIT.
7 *
8 * SPDX-License-Identifier: MIT
9 **************************************************************************/
10
11 /**************************************************************************/
12 /**************************************************************************/
13 /** */
14 /** NetX SRP Component */
15 /** */
16 /** Stream Reservation Protocol (SRP) */
17 /** */
18 /**************************************************************************/
19 /**************************************************************************/
20 #include "nx_srp.h"
21 #include "nx_link.h"
22
23 #ifdef NX_ENABLE_VLAN
24
25 /**************************************************************************/
26 /* */
27 /* FUNCTION RELEASE */
28 /* */
29 /* nx_srp_init PORTABLE C */
30 /* 6.4.0 */
31 /* AUTHOR */
32 /* */
33 /* Wen Wang, Microsoft Corporation */
34 /* */
35 /* DESCRIPTION */
36 /* */
37 /* This function initialize SRP, it initializes MRP, MSRP, MVRP */
38 /* sequencly, and create a thread in MRP initializaton. */
39 /* */
40 /* INPUT */
41 /* */
42 /* srp_ptr SRP instance pointer */
43 /* ip_ptr IP instance pointer */
44 /* interface_index Interface index */
45 /* pkt_pool_ptr Packet pool pointer */
46 /* stack_ptr Stack pointer */
47 /* stack_size Stack size */
48 /* priority SRP thread priority */
49 /* */
50 /* OUTPUT */
51 /* */
52 /* status Completion status */
53 /* */
54 /* CALLS */
55 /* */
56 /* nx_mrp_init MRP initialization */
57 /* nx_msrp_init MSRP initialization */
58 /* nx_mvrp_init MVRP initialization */
59 /* nx_mrp_participant_add ADD mrp participant */
60 /* tx_mutex_put Put protection mutex */
61 /* */
62 /* CALLED BY */
63 /* */
64 /* Application Code */
65 /* */
66 /* RELEASE HISTORY */
67 /* */
68 /* DATE NAME DESCRIPTION */
69 /* */
70 /* 12-31-2023 Wen Wang Initial Version 6.4.0 */
71 /* */
72 /**************************************************************************/
nx_srp_init(NX_SRP * srp_ptr,NX_IP * ip_ptr,UINT interface_index,NX_PACKET_POOL * pkt_pool_ptr,VOID * stack_ptr,ULONG stack_size,UINT priority)73 UINT nx_srp_init(NX_SRP *srp_ptr, NX_IP *ip_ptr, UINT interface_index, NX_PACKET_POOL *pkt_pool_ptr,
74 VOID *stack_ptr, ULONG stack_size, UINT priority)
75 {
76 UINT status;
77
78 status = nx_mrp_init(&srp_ptr -> nx_mrp, ip_ptr, interface_index, pkt_pool_ptr, "MRP thread",
79 stack_ptr, stack_size, priority);
80
81
82 if (status)
83 {
84 return(status);
85 }
86
87 nx_msrp_init(&srp_ptr -> nx_msrp);
88
89 nx_mrp_participant_add(&srp_ptr -> nx_mrp, &srp_ptr -> nx_msrp.nx_msrp_participant);
90
91 nx_mvrp_init(&srp_ptr -> nx_mvrp);
92
93 nx_mrp_participant_add(&srp_ptr -> nx_mrp, &srp_ptr -> nx_mvrp.participant);
94
95 return(NX_SUCCESS);
96 }
97
98 /**************************************************************************/
99 /* */
100 /* FUNCTION RELEASE */
101 /* */
102 /* nx_srp_talker_start PORTABLE C */
103 /* 6.4.0 */
104 /* AUTHOR */
105 /* */
106 /* Wen Wang, Microsoft Corporation */
107 /* */
108 /* DESCRIPTION */
109 /* */
110 /* This function start SRP talker, it sets event callback funtions and */
111 /* register domain, Vlan, stream request. */
112 /* */
113 /* INPUT */
114 /* */
115 /* srp_ptr SRP instance pointer */
116 /* domain Sream properties */
117 /* stream_id Stream ID */
118 /* dst_addr Destination address */
119 /* max_frame_size Max frame size */
120 /* max_interval_frames Max frame interval */
121 /* event_callback Application callback */
122 /* */
123 /* OUTPUT */
124 /* */
125 /* status Completion status */
126 /* */
127 /* CALLS */
128 /* */
129 /* nx_msrp_register_domain_request MSRP domain request register */
130 /* nx_mvrp_action_request MVRP request new */
131 /* nx_msrp_register_stream_request MSRP stream request register */
132 /* nx_link_multicast_join Join link multicast */
133 /* nx_srp_talker_cbs_set Talker set CBS */
134 /* */
135 /* CALLED BY */
136 /* */
137 /* Application Code */
138 /* */
139 /* RELEASE HISTORY */
140 /* */
141 /* DATE NAME DESCRIPTION */
142 /* */
143 /* 12-31-2023 Wen Wang Initial Version 6.4.0 */
144 /* */
145 /**************************************************************************/
nx_srp_talker_start(NX_SRP * srp_ptr,NX_MSRP_DOMAIN * domain,UCHAR * stream_id,UCHAR * dst_addr,UINT max_frame_size,UINT max_interval_frames,NX_MRP_EVENT_CALLBACK event_callback)146 UINT nx_srp_talker_start(NX_SRP *srp_ptr, NX_MSRP_DOMAIN *domain, UCHAR *stream_id, UCHAR *dst_addr,
147 UINT max_frame_size, UINT max_interval_frames, NX_MRP_EVENT_CALLBACK event_callback)
148 {
149 UINT status;
150 NX_MSRP_TALKER_ADVERTISE talker_advertise;
151 UINT index = NX_SRP_TALKER_NUM;
152 CHAR interface_name[32];
153 INT i;
154
155 srp_ptr -> nx_msrp.msrp_event_callback = event_callback;
156
157 srp_ptr -> nx_mvrp.mvrp_event_callback = event_callback;
158
159 /*send register domain request*/
160 status = nx_msrp_register_domain_request(&(srp_ptr -> nx_mrp), &(srp_ptr -> nx_msrp.nx_msrp_participant), domain, NX_MSRP_ACTION_NEW);
161
162 if (status != NX_SUCCESS)
163 {
164
165 return(status);
166 }
167
168 srp_ptr -> nx_mvrp.mvrp_event_callback = event_callback;
169
170 /*send vlan new request*/
171 status = nx_mvrp_action_request(&(srp_ptr -> nx_mrp), &(srp_ptr -> nx_mvrp.participant), domain -> sr_class_vid, NX_MVRP_ACTION_NEW);
172 if (status != NX_SUCCESS)
173 {
174
175 return(status);
176 }
177
178 memcpy(talker_advertise.stream_id, stream_id, 8); /* use case of memcpy is verified. */
179 memcpy(talker_advertise.dest_addr, dst_addr, 6); /* use case of memcpy is verified. */
180 talker_advertise.vlan_identifier = domain -> sr_class_vid;
181 talker_advertise.max_frame_size = (USHORT)max_frame_size;
182 talker_advertise.max_interval_frames = (USHORT)max_interval_frames;
183 talker_advertise.priority = (UCHAR)(domain -> sr_class_priority & 0x07);
184 talker_advertise.accumulated_latency = 0;
185
186 /*send register stream request*/
187 status = nx_msrp_register_stream_request(&(srp_ptr -> nx_mrp), &(srp_ptr -> nx_msrp.nx_msrp_participant), &talker_advertise, NX_MSRP_ACTION_NEW);
188
189 if (status != NX_SUCCESS)
190 {
191
192 return(status);
193 }
194
195 for (i = 0; i < NX_SRP_TALKER_NUM; i++)
196 {
197 if (srp_ptr -> talker[i].in_used == NX_FALSE)
198 {
199 index = (UINT)i;
200 srp_ptr -> talker[i].in_used = NX_TRUE;
201 break;
202 }
203 }
204
205 if (index == NX_SRP_TALKER_NUM)
206 {
207 printf("No resource to allocate for talker with stream ID:%s.\r\n", stream_id);
208 return(NX_NO_MORE_ENTRIES);
209 }
210
211 if (domain -> sr_class_id == NX_SRP_SR_CLASS_A)
212 {
213 srp_ptr -> talker[index].interval = NX_SRP_CLASS_A_INTERVAL;
214 }
215 else if (domain -> sr_class_id == NX_SRP_SR_CLASS_B)
216 {
217 srp_ptr -> talker[index].interval = NX_SRP_CLASS_B_INTERVAL;
218 }
219 else
220 {
221 /* Do not support other kind of SR Class Currently. */
222 return(NX_INVALID_PARAMETERS);
223 }
224
225 memcpy(srp_ptr -> talker[index].stream_id, stream_id, 8); /* use case of memcpy is verified. */
226 srp_ptr -> talker[index].class_id = domain -> sr_class_id;
227 srp_ptr -> talker[index].class_priority = domain -> sr_class_priority;
228 srp_ptr -> talker[index].class_vid = domain -> sr_class_vid;
229 srp_ptr -> talker[index].max_interval_frames = max_interval_frames;
230 srp_ptr -> talker[index].max_frame_size = max_frame_size;
231
232 srp_ptr -> talker[index].physical_address_msw = (ULONG)dst_addr[0] << 8 | dst_addr[1];
233 srp_ptr -> talker[index].physical_address_lsw = (ULONG)dst_addr[2] << 24 | \
234 (ULONG)dst_addr[3] << 16 | \
235 (ULONG)dst_addr[4] << 8 | \
236 (ULONG)dst_addr[5];
237
238 sprintf(interface_name, "NetX IP Interface 0:%u", srp_ptr -> talker[index].class_vid);
239
240 status = nx_link_multicast_join(srp_ptr -> nx_mrp.ip_ptr, srp_ptr -> nx_mrp.interface_index,
241 srp_ptr -> talker[index].physical_address_msw,
242 srp_ptr -> talker[index].physical_address_lsw);
243
244 if (status != NX_SUCCESS)
245 {
246 return(status);
247 }
248 else
249 {
250 printf("[Talker]multicast address join %lx-%lx successful\r\n",
251 srp_ptr -> talker[index].physical_address_msw,
252 srp_ptr -> talker[index].physical_address_lsw);
253 }
254
255 status = nx_srp_talker_cbs_set(srp_ptr, index);
256 if (status != NX_SUCCESS)
257 {
258 return(status);
259 }
260 else
261 {
262 printf("[Talker]CBS set successful\r\n");
263 }
264
265 return(status);
266 }
267
268 /**************************************************************************/
269 /* */
270 /* FUNCTION RELEASE */
271 /* */
272 /* nx_srp_listener_start PORTABLE C */
273 /* 6.4.0 */
274 /* AUTHOR */
275 /* */
276 /* Wen Wang, Microsoft Corporation */
277 /* */
278 /* DESCRIPTION */
279 /* */
280 /* This function start SRP listener. It enables listener and set user */
281 /* date and callback function. */
282 /* */
283 /* INPUT */
284 /* */
285 /* srp_ptr SRP instance pointer */
286 /* event_callback Application callback */
287 /* stream_id Stream ID */
288 /* */
289 /* OUTPUT */
290 /* */
291 /* status Completion status */
292 /* */
293 /* CALLS */
294 /* */
295 /* None */
296 /* */
297 /* CALLED BY */
298 /* */
299 /* Application Code */
300 /* */
301 /* RELEASE HISTORY */
302 /* */
303 /* DATE NAME DESCRIPTION */
304 /* */
305 /* 12-31-2023 Wen Wang Initial Version 6.4.0 */
306 /* */
307 /**************************************************************************/
nx_srp_listener_start(NX_SRP * srp_ptr,NX_MRP_EVENT_CALLBACK event_callback,UCHAR * stream_id)308 UINT nx_srp_listener_start(NX_SRP *srp_ptr, NX_MRP_EVENT_CALLBACK event_callback, UCHAR *stream_id)
309 {
310 /* Allowed to response to talker.*/
311 srp_ptr -> nx_msrp.listener_enable = 1;
312
313 srp_ptr -> nx_msrp.msrp_event_callback = event_callback;
314
315 srp_ptr -> nx_mvrp.mvrp_event_callback = event_callback;
316
317 /* Listener set the stream_id it will accept, it could be NX_NULL.*/
318 srp_ptr -> nx_msrp.msrp_callback_data = stream_id;
319
320 return(NX_MSRP_SUCCESS);
321 }
322
323 /**************************************************************************/
324 /* */
325 /* FUNCTION RELEASE */
326 /* */
327 /* nx_srp_talker_stop PORTABLE C */
328 /* 6.4.0 */
329 /* AUTHOR */
330 /* */
331 /* Wen Wang, Microsoft Corporation */
332 /* */
333 /* DESCRIPTION */
334 /* */
335 /* This function stop SRP talker. It withdraw the domain,Vlan,stream */
336 /* request. */
337 /* */
338 /* INPUT */
339 /* */
340 /* srp_ptr SRP instance pointer */
341 /* stream_id Stream ID */
342 /* domain Stream properties */
343 /* */
344 /* OUTPUT */
345 /* */
346 /* status Completion status */
347 /* */
348 /* CALLS */
349 /* */
350 /* nx_msrp_deregister_domain_request MSRP domain request deregister*/
351 /* nx_mvrp_action_request MVRP request leave */
352 /* nx_msrp_deregister_stream_request MSRP stream request deregister*/
353 /* */
354 /* CALLED BY */
355 /* */
356 /* Application Code */
357 /* */
358 /* RELEASE HISTORY */
359 /* */
360 /* DATE NAME DESCRIPTION */
361 /* */
362 /* 12-31-2023 Wen Wang Initial Version 6.4.0 */
363 /* */
364 /**************************************************************************/
nx_srp_talker_stop(NX_SRP * srp_ptr,UCHAR * stream_id,NX_MSRP_DOMAIN * domain)365 UINT nx_srp_talker_stop(NX_SRP *srp_ptr, UCHAR *stream_id, NX_MSRP_DOMAIN *domain)
366 {
367 UINT status;
368
369 /* Send deregister domain request*/
370 status = nx_msrp_deregister_domain_request(&srp_ptr -> nx_mrp, &srp_ptr -> nx_msrp.nx_msrp_participant, domain);
371
372 if (status != NX_SUCCESS)
373 {
374 return(status);
375 }
376
377 /* Send vlan leave request*/
378 status = nx_mvrp_action_request(&(srp_ptr -> nx_mrp), &(srp_ptr -> nx_mvrp.participant), domain -> sr_class_vid, NX_MVRP_ACTION_TYPE_LEAVE);
379
380 if (status != NX_SUCCESS)
381 {
382 return(status);
383 }
384
385 /* Send deregister stream request*/
386 status = nx_msrp_deregister_stream_request(&srp_ptr -> nx_mrp, &srp_ptr -> nx_msrp.nx_msrp_participant, stream_id);
387
388 return(status);
389 }
390
391 /**************************************************************************/
392 /* */
393 /* FUNCTION RELEASE */
394 /* */
395 /* nx_srp_listener_stop PORTABLE C */
396 /* 6.4.0 */
397 /* AUTHOR */
398 /* */
399 /* Wen Wang, Microsoft Corporation */
400 /* */
401 /* DESCRIPTION */
402 /* */
403 /* This function stop SRP listener. It unregister the domain,Vlan */
404 /* stream attached to talker. */
405 /* */
406 /* INPUT */
407 /* */
408 /* srp_ptr SRP instance pointer */
409 /* stream_id Stream ID */
410 /* domain Stream properties */
411 /* */
412 /* OUTPUT */
413 /* */
414 /* status Completion status */
415 /* */
416 /* CALLS */
417 /* */
418 /* nx_msrp_deregister_domain_request MSRP domain request deregister*/
419 /* nx_mvrp_action_request MVRP request leave */
420 /* nx_msrp_deregister_attach_request MSRP stream attach deregister */
421 /* */
422 /* CALLED BY */
423 /* */
424 /* Application Code */
425 /* */
426 /* RELEASE HISTORY */
427 /* */
428 /* DATE NAME DESCRIPTION */
429 /* */
430 /* 12-31-2023 Wen Wang Initial Version 6.4.0 */
431 /* */
432 /**************************************************************************/
nx_srp_listener_stop(NX_SRP * srp_ptr,UCHAR * stream_id,NX_MSRP_DOMAIN * domain)433 UINT nx_srp_listener_stop(NX_SRP *srp_ptr, UCHAR *stream_id, NX_MSRP_DOMAIN *domain)
434 {
435 UINT status;
436
437 if (stream_id == NX_NULL)
438 {
439 return(NX_SRP_PARAMETER_NULL);
440 }
441
442 if (domain == NX_NULL)
443 {
444 return(NX_SRP_PARAMETER_NULL);
445 }
446
447 /* Send deregister domain request.*/
448 status = nx_msrp_deregister_domain_request(&srp_ptr -> nx_mrp, &srp_ptr -> nx_msrp.nx_msrp_participant, domain);
449
450 if (status != NX_SUCCESS)
451 {
452 return(status);
453 }
454
455 /* Send vlan leave request.*/
456 status = nx_mvrp_action_request(&(srp_ptr -> nx_mrp), &(srp_ptr -> nx_mvrp.participant), domain -> sr_class_vid, NX_MVRP_ACTION_TYPE_LEAVE);
457
458
459 if (status != NX_SUCCESS)
460 {
461 return(status);
462 }
463
464 /* Send deregister attach request.*/
465 status = nx_msrp_deregister_attach_request(&srp_ptr -> nx_mrp, &srp_ptr -> nx_msrp.nx_msrp_participant, stream_id);
466
467 return(status);
468 }
469
470 /**************************************************************************/
471 /* */
472 /* FUNCTION RELEASE */
473 /* */
474 /* nx_srp_cbs_config_get PORTABLE C */
475 /* 6.4.0 */
476 /* AUTHOR */
477 /* */
478 /* Wen Wang, Microsoft Corporation */
479 /* */
480 /* DESCRIPTION */
481 /* */
482 /* This function get CBS parameters from SRP talker parameter. */
483 /* */
484 /* INPUT */
485 /* */
486 /* sr_class Stream class */
487 /* port_rate ethernet port rate */
488 /* frames_per_interval Freames per interval */
489 /* max_frame_size Max frame size */
490 /* non_sr_frame_size Non-stream frame size */
491 /* idle_slope_a stream A class Idle slope */
492 /* max_frame_size_a stream A class Max frame size */
493 /* cbs_param CBS parameter */
494 /* */
495 /* OUTPUT */
496 /* */
497 /* status Completion status */
498 /* */
499 /* CALLS */
500 /* */
501 /* None. */
502 /* */
503 /* CALLED BY */
504 /* */
505 /* nx_srp_talker_cbs_set Set CBS parameter */
506 /* */
507 /* RELEASE HISTORY */
508 /* */
509 /* DATE NAME DESCRIPTION */
510 /* */
511 /* 12-31-2023 Wen Wang Initial Version 6.4.0 */
512 /* */
513 /**************************************************************************/
nx_srp_cbs_config_get(UINT sr_class,INT port_rate,UINT interval,UINT frames_per_interval,UINT max_frame_size,UINT non_sr_frame_size,INT idle_slope_a,UINT max_frame_size_a,NX_SHAPER_CBS_PARAMETER * cbs_param)514 UINT nx_srp_cbs_config_get(UINT sr_class, INT port_rate, UINT interval, UINT frames_per_interval, UINT max_frame_size, UINT non_sr_frame_size, INT idle_slope_a, UINT max_frame_size_a, NX_SHAPER_CBS_PARAMETER *cbs_param)
515 {
516 if (sr_class == NX_SRP_SR_CLASS_A)
517 {
518 cbs_param -> idle_slope = (INT)((long long)1000000 / interval * frames_per_interval * max_frame_size * 8 / 1000000); /* transfer to Mbps */
519 if (cbs_param -> idle_slope >= port_rate)
520 {
521 printf("The Idleslope : %dMbps must be set less than port rate : %dMbps.\n", cbs_param -> idle_slope, port_rate);
522 return(NX_INVALID_PARAMETERS);
523 }
524 cbs_param -> send_slope = cbs_param -> idle_slope - port_rate;
525 cbs_param -> hi_credit = (INT)((long long)cbs_param -> idle_slope * non_sr_frame_size / port_rate);
526 cbs_param -> low_credit = (INT)((long long)cbs_param -> send_slope * max_frame_size / port_rate);
527
528 return(NX_SUCCESS);
529 }
530 else if (sr_class == NX_SRP_SR_CLASS_B)
531 {
532 cbs_param -> idle_slope = (INT)((long long)1000000 / interval * frames_per_interval * max_frame_size * 8 / 1000000); /* transfer to Kbps */
533 if (cbs_param -> idle_slope >= port_rate)
534 {
535 printf("The Idleslope : %dMbps must be set less than port rate : %dMbps.\n", cbs_param -> idle_slope, port_rate);
536 return(NX_INVALID_PARAMETERS);
537 }
538 cbs_param -> send_slope = cbs_param -> idle_slope - port_rate;
539 cbs_param -> hi_credit = (INT)((long long)cbs_param -> idle_slope * non_sr_frame_size / (port_rate - idle_slope_a) + (long long)cbs_param -> idle_slope * max_frame_size_a / port_rate);
540 cbs_param -> low_credit = (INT)((long long)cbs_param -> send_slope * max_frame_size / port_rate);
541
542 return(NX_SUCCESS);
543 }
544 else
545 {
546 return(NX_INVALID_PARAMETERS);
547 }
548 }
549 /**************************************************************************/
550 /* */
551 /* FUNCTION RELEASE */
552 /* */
553 /* nx_srp_talker_cbs_set PORTABLE C */
554 /* 6.4.0 */
555 /* AUTHOR */
556 /* */
557 /* Wen Wang, Microsoft Corporation */
558 /* */
559 /* DESCRIPTION */
560 /* */
561 /* This function get CBS parameters. */
562 /* */
563 /* INPUT */
564 /* */
565 /* srp_ptr SRP instance pointer */
566 /* stream_id Stream ID */
567 /* domain Stream properties */
568 /* */
569 /* OUTPUT */
570 /* */
571 /* status Completion status */
572 /* */
573 /* CALLS */
574 /* */
575 /* nx_srp_cbs_config_get Get CBS parameter */
576 /* nx_shaper_cbs_parameter_set Set CBS parameter to shaper */
577 /* layer. */
578 /* nx_shaper_port_rate_get Get ethernet port rate from */
579 /* shaper layer. */
580 /* */
581 /* CALLED BY */
582 /* */
583 /* nx_srp_talker_start Start SRP talker */
584 /* */
585 /* RELEASE HISTORY */
586 /* */
587 /* DATE NAME DESCRIPTION */
588 /* */
589 /* 12-31-2023 Wen Wang Initial Version 6.4.0 */
590 /* */
591 /**************************************************************************/
nx_srp_talker_cbs_set(NX_SRP * srp_ptr,UINT index)592 UINT nx_srp_talker_cbs_set(NX_SRP *srp_ptr, UINT index)
593 {
594 UINT status;
595 NX_INTERFACE *interface_ptr;
596 UINT port_rate;
597 INT i;
598 INT idle_slope_a = 0;
599 UINT max_frame_size_a = 0;
600
601 interface_ptr = &(srp_ptr -> nx_mrp.ip_ptr -> nx_ip_interface[srp_ptr -> nx_mrp.interface_index]);
602 status = nx_shaper_port_rate_get(interface_ptr, &port_rate);
603 if (status)
604 {
605 return(status);
606 }
607
608 if (srp_ptr -> talker[index].class_id == NX_SRP_SR_CLASS_B)
609 {
610 for (i = 0; i < NX_SRP_TALKER_NUM; i++)
611 {
612 if (srp_ptr -> talker[i].in_used == NX_FALSE)
613 {
614 continue;
615 }
616
617 if (srp_ptr -> talker[i].class_id == NX_SRP_SR_CLASS_A)
618 {
619 idle_slope_a = srp_ptr -> talker[i].cbs_parameters.idle_slope;
620 max_frame_size_a = srp_ptr -> talker[i].max_frame_size;
621 break;
622 }
623 }
624 }
625 /* Get CBS parameters from SRP paramter. */
626 status = nx_srp_cbs_config_get(srp_ptr -> talker[index].class_id,
627 (INT)port_rate,
628 srp_ptr -> talker[index].interval,
629 srp_ptr -> talker[index].max_interval_frames,
630 srp_ptr -> talker[index].max_frame_size,
631 interface_ptr -> nx_interface_ip_mtu_size,
632 idle_slope_a,
633 max_frame_size_a,
634 &(srp_ptr -> talker[index].cbs_parameters));
635 if (status)
636 {
637 return(status);
638 }
639
640 printf("cbs parameters: idle slope: %d, send slope: %d, hi credit: %d, low credit: %d\r\n",
641 srp_ptr -> talker[index].cbs_parameters.idle_slope,
642 srp_ptr -> talker[index].cbs_parameters.send_slope,
643 srp_ptr -> talker[index].cbs_parameters.hi_credit,
644 srp_ptr -> talker[index].cbs_parameters.low_credit);
645
646 /* Set CBS parameters to shaper layer. */
647 if (srp_ptr -> talker[index].class_id == NX_SRP_SR_CLASS_A)
648 {
649 status = nx_shaper_cbs_parameter_set(interface_ptr, &(srp_ptr -> talker[index].cbs_parameters), NX_SHAPER_CLASS_A_PCP);
650 }
651 else
652 {
653 status = nx_shaper_cbs_parameter_set(interface_ptr, &(srp_ptr -> talker[index].cbs_parameters), NX_SHAPER_CLASS_B_PCP);
654 }
655
656 return(status);
657 }
658 #endif /* NX_ENABLE_VLAN */
659
