[Commit-gnuradio] r5895 - gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband

[gnychis]

Author: gnychis
Date: 2007-07-03 09:13:18 -0600 (Tue, 03 Jul 2007)
New Revision: 5895

Modified:
   
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_inband_usb_packet.h
Log:
Adding in constants for CS subpacket lengths instead of hardcoding numbers all
around the code to make it more readable.


Modified: 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_inband_usb_packet.h
===================================================================
--- 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_inband_usb_packet.h
   2007-07-03 06:37:25 UTC (rev 5894)
+++ 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_inband_usb_packet.h
   2007-07-03 15:13:18 UTC (rev 5895)
@@ -86,21 +86,30 @@
   static const int PAYLOAD_LEN_MASK = 0x1ff;
   static const int PAYLOAD_LEN_SHIFT = 0;
 
+  // Fixed size for opcode and length fields
+  static const int CS_FIXED_LEN = 2;
+
   static const int CS_OPCODE_MASK = 0xff;
   static const int CS_OPCODE_SHIFT = 24;
 
-  static const int CS_LENGTH_MASK = 0xff;
-  static const int CS_LENGTH_SHIFT = 16;
+  static const int CS_LEN_MASK = 0xff;
+  static const int CS_LEN_SHIFT = 16;
 
   static const int CS_RID_MASK = 0x3f;
   static const int CS_RID_SHIFT = 10;
 
+  static const int CS_PING_LEN = 2;
   static const int CS_PINGVAL_MASK = 0x3ff;
   static const int CS_PINGVAL_SHIFT = 0;
 
+  static const int CS_WRITEREG_LEN = 6;
+  static const int CS_WRITEREGMASKED_LEN = 10;
+  static const int CS_READREG_LEN = 2;
+  static const int CS_READREGREPLY_LEN = 6;
   static const int CS_REGNUM_MASK = 0x3ff;
   static const int CS_REGNUM_SHIFT = 0;
 
+  static const int CS_DELAY_LEN = 2;
   static const int CS_DELAY_MASK = 0xffff;
   static const int CS_DELAY_SHIFT = 0;
 
@@ -186,17 +195,22 @@
     return USB_PKT_SIZE;
   }
 
-  void cs_ping(long rid, long ping_val)
+  bool cs_ping(long rid, long ping_val)
   {
+    
+    int p_len = payload_len();
+
+    if((MAX_PAYLOAD - p_len) < (CS_PING_LEN + CS_FIXED_LEN))
+      return false;
+
     uint32_t ping = ( 
         ((OP_PING_FIXED & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
-      | ((2 & CS_LENGTH_MASK) << CS_LENGTH_SHIFT)
+      | ((CS_PING_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
       | ((rid & CS_RID_MASK) << CS_RID_SHIFT)
       | (ping_val & CS_PINGVAL_MASK)
 
       );
 
-    int p_len = payload_len();
     uint32_t *payload = (uint32_t *) d_payload + p_len;
     *payload = host_to_usrp_u32(ping);
 
@@ -204,22 +218,28 @@
     int h_flags = flags();
     int h_chan = chan();
     int h_tag = tag();
-    int h_payload_len = payload_len() + 4;  // increased by fixed ping size
+    int h_payload_len = payload_len() + CS_FIXED_LEN + CS_PING_LEN;
 
     set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+    return true;
   }
   
-  uint32_t cs_ping_reply(long rid, long ping_val) 
+  bool cs_ping_reply(long rid, long ping_val) 
   {
+    int p_len = payload_len();
+
+    if((MAX_PAYLOAD - p_len) < (CS_PING_LEN + CS_FIXED_LEN))
+      return false;
+
     uint32_t ping = ( 
         ((OP_PING_FIXED_REPLY & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
-      | ((0x2 & CS_LENGTH_MASK) << CS_LENGTH_SHIFT)
+      | ((CS_PING_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
       | ((rid & CS_RID_MASK) << CS_RID_SHIFT)
       | ((ping_val & CS_PINGVAL_MASK) << CS_PINGVAL_SHIFT)
 
       );
 
-    int p_len = payload_len();
     uint32_t *payload = (uint32_t *) d_payload + p_len;
     *payload = host_to_usrp_u32(ping);
 
@@ -227,54 +247,64 @@
     int h_flags = flags();
     int h_chan = chan();
     int h_tag = tag();
-    int h_payload_len = payload_len() + 4;  // increased by fixed ping size
+    int h_payload_len = payload_len() + CS_FIXED_LEN + CS_PING_LEN;
 
     set_header(h_flags, h_chan, h_tag, h_payload_len);
 
-    return ping;
+    return true;
   }
 
-  void cs_write_reg(long reg_num, long val)
+  bool cs_write_reg(long reg_num, long val)
   {
+    int p_len = payload_len();
+
+    if((MAX_PAYLOAD - p_len) < (CS_WRITEREG_LEN + CS_FIXED_LEN))
+      return false;
+
     uint32_t word0 = 0;
 
     // Build the first word which includes the register number
     word0 = (
         ((OP_WRITE_REG & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
-      | ((6 & CS_LENGTH_MASK) << CS_LENGTH_SHIFT)
+      | ((CS_WRITEREG_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
       | ((reg_num & CS_REGNUM_MASK) << CS_REGNUM_SHIFT)
     );
 
-    int p_len = payload_len();
     uint32_t *payload = (uint32_t *) d_payload + p_len;
     *payload = host_to_usrp_u32(word0);
 
     // The second word is solely the register value to be written
     // FIXME: should this be unsigned?
-    payload += 4;  // skip past the first word
+    payload += 4; 
     *payload = host_to_usrp_u32((uint32_t) val);
     
     // Rebuild the header to update the payload length
     int h_flags = flags();
     int h_chan = chan();
     int h_tag = tag();
-    int h_payload_len = payload_len() + 8;  // added 2 words
+    int h_payload_len = payload_len() + CS_FIXED_LEN + CS_WRITEREG_LEN;
 
     set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+    return true;
   }
   
-  void cs_write_reg_masked(long reg_num, long val, long mask)
+  bool cs_write_reg_masked(long reg_num, long val, long mask)
   {
+    int p_len = payload_len();
+
+    if((MAX_PAYLOAD - p_len) < (CS_WRITEREGMASKED_LEN + CS_FIXED_LEN))
+      return false;
+
     uint32_t word0 = 0;
 
     // Build the first word which includes the register number
     word0 = (
         ((OP_WRITE_REG_MASKED & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
-      | ((10 & CS_LENGTH_MASK) << CS_LENGTH_SHIFT)
+      | ((CS_WRITEREGMASKED_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
       | ((reg_num & CS_REGNUM_MASK) << CS_REGNUM_SHIFT)
     );
 
-    int p_len = payload_len();
     uint32_t *payload = (uint32_t *) d_payload + p_len;
     *payload = host_to_usrp_u32(word0);
 
@@ -290,23 +320,28 @@
     int h_flags = flags();
     int h_chan = chan();
     int h_tag = tag();
-    int h_payload_len = payload_len() + 12;  // added 2 words
+    int h_payload_len = payload_len() + CS_FIXED_LEN + CS_WRITEREGMASKED_LEN;
 
     set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+      return true;
   }
   
-  void cs_read_reg(long rid, long reg_num)
+  bool cs_read_reg(long rid, long reg_num)
   {
+    int p_len = payload_len();
 
+    if((MAX_PAYLOAD - p_len) < (CS_READREG_LEN + CS_FIXED_LEN))
+      return false;
+
     uint32_t read_reg = ( 
         ((OP_READ_REG & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
-      | ((2 & CS_LENGTH_MASK) << CS_LENGTH_SHIFT)
+      | ((CS_READREG_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
       | ((rid & CS_RID_MASK) << CS_RID_SHIFT)
       | ((reg_num & CS_REGNUM_MASK) << CS_REGNUM_SHIFT)
 
       );
 
-    int p_len = payload_len();
     uint32_t *payload = (uint32_t *) d_payload + p_len;
     *payload = host_to_usrp_u32(read_reg);
 
@@ -314,23 +349,28 @@
     int h_flags = flags();
     int h_chan = chan();
     int h_tag = tag();
-    int h_payload_len = payload_len() + 4;
+    int h_payload_len = payload_len() + CS_FIXED_LEN + CS_READREG_LEN;
 
     set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+    return true;
   }
   
-  void cs_read_reg_reply(long rid, long reg_num, long reg_val)
+  bool cs_read_reg_reply(long rid, long reg_num, long reg_val)
   {
+    int p_len = payload_len();
 
+    if((MAX_PAYLOAD - p_len) < (CS_READREGREPLY_LEN + CS_FIXED_LEN))
+      return false;
+
     uint32_t word0 = ( 
         ((OP_READ_REG_REPLY & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
-      | ((6 & CS_LENGTH_MASK) << CS_LENGTH_SHIFT)
+      | ((CS_READREGREPLY_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
       | ((rid & CS_RID_MASK) << CS_RID_SHIFT)
       | ((reg_num & CS_REGNUM_MASK) << CS_REGNUM_SHIFT)
 
       );
 
-    int p_len = payload_len();
     uint32_t *payload = (uint32_t *) d_payload + p_len;
     *payload = host_to_usrp_u32(word0);
 
@@ -342,21 +382,27 @@
     int h_flags = flags();
     int h_chan = chan();
     int h_tag = tag();
-    int h_payload_len = payload_len() + 8;
+    int h_payload_len = payload_len() + CS_FIXED_LEN + CS_READREGREPLY_LEN;
 
     set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+    return true;
   }
 
-  void cs_delay(long ticks)
+  bool cs_delay(long ticks)
   {
+    int p_len = payload_len();
+
+    if((MAX_PAYLOAD - p_len) < (CS_DELAY_LEN + CS_FIXED_LEN))
+      return false;
+
     uint32_t delay = ( 
         ((OP_DELAY & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
-      | ((2 & CS_LENGTH_MASK) << CS_LENGTH_SHIFT)
+      | ((CS_DELAY_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
       | ((ticks & CS_DELAY_MASK) << CS_DELAY_SHIFT)
 
       );
 
-    int p_len = payload_len();
     uint32_t *payload = (uint32_t *) d_payload + p_len;
     *payload = host_to_usrp_u32(delay);
 
@@ -364,9 +410,11 @@
     int h_flags = flags();
     int h_chan = chan();
     int h_tag = tag();
-    int h_payload_len = payload_len() + 4;  // increased by fixed ping size
+    int h_payload_len = payload_len() + CS_FIXED_LEN + CS_DELAY_LEN;
 
     set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+    return true;
   }
 
   // The following method takes an offset within the packet payload to extract
@@ -380,7 +428,7 @@
 
     uint32_t subpkt = usrp_to_host_u32(*((uint32_t *)d_payload + 
payload_offset));
     uint32_t opcode = (subpkt >> CS_OPCODE_SHIFT) & CS_OPCODE_MASK;
-    uint32_t len = (subpkt >> CS_LENGTH_SHIFT) & CS_LENGTH_MASK;
+    uint32_t len = (subpkt >> CS_LEN_SHIFT) & CS_LEN_MASK;
 
     switch(opcode) {
       
@@ -479,7 +527,7 @@
   // length of the subpacket
   int cs_len(int payload_offset) {
     uint32_t subpkt = usrp_to_host_u32(*((uint32_t *)d_payload + 
payload_offset));
-    return (subpkt >> CS_LENGTH_SHIFT) & CS_LENGTH_MASK;
+    return (subpkt >> CS_LEN_SHIFT) & CS_LEN_MASK;
   }
 
 };