Rename the LED stuff from PDB to PDBS

It's not general-purpose PD Buddy code, but rather PD Buddy Sink code.
Therefore it gets the pdbs namespace.

src/device_policy_manager.c

 
     /* Make the LED blink to indicate ongoing power negotiations */
     if (pdb_dpm_led_pd_status) {
-        chEvtSignal(pdb_led_thread, PDB_EVT_LED_NEGOTIATING);
+        chEvtSignal(pdbs_led_thread, PDBS_EVT_LED_NEGOTIATING);
     }
 
     /* Get whether or not the power supply is constrained */
 void pdbs_dpm_pd_start(struct pdb_config *cfg)
 {
     if (pdb_dpm_led_pd_status) {
-        chEvtSignal(pdb_led_thread, PDB_EVT_LED_NEGOTIATING);
+        chEvtSignal(pdbs_led_thread, PDBS_EVT_LED_NEGOTIATING);
     }
 }
 
     if (state && pdb_dpm_output_enabled) {
         /* Turn the output on */
         if (pdb_dpm_led_pd_status) {
-            chEvtSignal(pdb_led_thread, PDB_EVT_LED_OUTPUT_ON);
+            chEvtSignal(pdbs_led_thread, PDBS_EVT_LED_OUTPUT_ON);
         }
         palSetLine(LINE_OUT_CTRL);
     } else {
         /* Turn the output off */
         if (pdb_dpm_led_pd_status) {
-            chEvtSignal(pdb_led_thread, PDB_EVT_LED_OUTPUT_OFF);
+            chEvtSignal(pdbs_led_thread, PDBS_EVT_LED_OUTPUT_OFF);
         }
         palClearLine(LINE_OUT_CTRL);
     }

src/led.c

 #define LED_FAST_BLINKS 8
 
 
-thread_t *pdb_led_thread;
+thread_t *pdbs_led_thread;
 
 /*
  * LED blinker thread.
 static THD_FUNCTION(LED, arg) {
     (void) arg;
     /* LED starts turned off */
-    eventmask_t state = PDB_EVT_LED_OFF;
+    eventmask_t state = PDBS_EVT_LED_OFF;
     /* The event just received */
     eventmask_t newstate;
     /* Timeout.  TIME_INFINITE for steady modes, other values for blinking
         }
 
         switch (state) {
-            case PDB_EVT_LED_OFF:
+            case PDBS_EVT_LED_OFF:
                 timeout = TIME_INFINITE;
                 palClearLine(LINE_LED);
                 break;
-            case PDB_EVT_LED_ON:
+            case PDBS_EVT_LED_ON:
                 timeout = TIME_INFINITE;
                 palSetLine(LINE_LED);
                 break;
-            case PDB_EVT_LED_FAST_BLINK:
+            case PDBS_EVT_LED_FAST_BLINK:
                 timeout = LED_FAST;
                 if (i == 0) {
                     palSetLine(LINE_LED);
                     palToggleLine(LINE_LED);
                 }
                 break;
-            case PDB_EVT_LED_MEDIUM_BLINK_OFF:
+            case PDBS_EVT_LED_MEDIUM_BLINK_OFF:
                 timeout = LED_MEDIUM;
                 if (i == 0) {
                     palSetLine(LINE_LED);
                     timeout = TIME_INFINITE;
                 }
                 break;
-            case PDB_EVT_LED_SLOW_BLINK:
+            case PDBS_EVT_LED_SLOW_BLINK:
                 timeout = LED_SLOW;
                 if (i == 0) {
                     palSetLine(LINE_LED);
                     palToggleLine(LINE_LED);
                 }
                 break;
-            case PDB_EVT_LED_FAST_BLINK_SLOW:
+            case PDBS_EVT_LED_FAST_BLINK_SLOW:
                 timeout = LED_FAST;
                 if (i == 0) {
                     palSetLine(LINE_LED);
                 } else {
                     palClearLine(LINE_LED);
                     timeout = TIME_INFINITE;
-                    chEvtSignal(pdb_led_thread, PDB_EVT_LED_SLOW_BLINK);
+                    chEvtSignal(pdbs_led_thread, PDBS_EVT_LED_SLOW_BLINK);
                 }
                 break;
             default:
     }
 }
 
-void pdb_led_run(void)
+void pdbs_led_run(void)
 {
-    pdb_led_thread = chThdCreateStatic(waLED, sizeof(waLED), PDBS_PRIO_LED, LED,
-            NULL);
+    pdbs_led_thread = chThdCreateStatic(waLED, sizeof(waLED), PDBS_PRIO_LED,
+            LED, NULL);
 }

src/led.h

  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef PDB_LED_H
-#define PDB_LED_H
+#ifndef PDBS_LED_H
+#define PDBS_LED_H
 
 #include <ch.h>
 
 
 /* Events for the LED thread */
-#define PDB_EVT_LED_OFF EVENT_MASK(0)
-#define PDB_EVT_LED_ON EVENT_MASK(1)
-#define PDB_EVT_LED_FAST_BLINK EVENT_MASK(2)
-#define PDB_EVT_LED_MEDIUM_BLINK_OFF EVENT_MASK(3)
-#define PDB_EVT_LED_SLOW_BLINK EVENT_MASK(4)
-#define PDB_EVT_LED_FAST_BLINK_SLOW EVENT_MASK(5)
+#define PDBS_EVT_LED_OFF EVENT_MASK(0)
+#define PDBS_EVT_LED_ON EVENT_MASK(1)
+#define PDBS_EVT_LED_FAST_BLINK EVENT_MASK(2)
+#define PDBS_EVT_LED_MEDIUM_BLINK_OFF EVENT_MASK(3)
+#define PDBS_EVT_LED_SLOW_BLINK EVENT_MASK(4)
+#define PDBS_EVT_LED_FAST_BLINK_SLOW EVENT_MASK(5)
 
 /* Semantic LED event names */
-#define PDB_EVT_LED_CONFIG PDB_EVT_LED_SLOW_BLINK
-#define PDB_EVT_LED_IDENTIFY PDB_EVT_LED_FAST_BLINK_SLOW
-#define PDB_EVT_LED_NEGOTIATING PDB_EVT_LED_FAST_BLINK
-#define PDB_EVT_LED_OUTPUT_ON PDB_EVT_LED_MEDIUM_BLINK_OFF
-#define PDB_EVT_LED_OUTPUT_OFF PDB_EVT_LED_ON
+#define PDBS_EVT_LED_CONFIG PDBS_EVT_LED_SLOW_BLINK
+#define PDBS_EVT_LED_IDENTIFY PDBS_EVT_LED_FAST_BLINK_SLOW
+#define PDBS_EVT_LED_NEGOTIATING PDBS_EVT_LED_FAST_BLINK
+#define PDBS_EVT_LED_OUTPUT_ON PDBS_EVT_LED_MEDIUM_BLINK_OFF
+#define PDBS_EVT_LED_OUTPUT_OFF PDBS_EVT_LED_ON
 
 /* The LED thread object */
-extern thread_t *pdb_led_thread;
+extern thread_t *pdbs_led_thread;
 
 /*
  * Start the LED thread
  */
-void pdb_led_run(void);
+void pdbs_led_run(void);
 
 
-#endif /* PDB_LED_H */
+#endif /* PDBS_LED_H */

src/main.c

     pdb_init(&pdb_config);
 
     /* Indicate that we're in setup mode */
-    chEvtSignal(pdb_led_thread, PDB_EVT_LED_CONFIG);
+    chEvtSignal(pdbs_led_thread, PDBS_EVT_LED_CONFIG);
 
     /* Disconnect from USB */
     usbDisconnectBus(serusbcfg.usbp);
     pdb_msg_pool_init();
 
     /* Create the LED thread. */
-    pdb_led_run();
+    pdbs_led_run();
 
     /* Start I2C2 to make communication with the PHY possible */
     i2cStart(&I2CD2, &i2c2config);

src/shell.c

         return;
     }
 
-    chEvtSignal(pdb_led_thread, PDB_EVT_LED_IDENTIFY);
+    chEvtSignal(pdbs_led_thread, PDBS_EVT_LED_IDENTIFY);
 }
 
 static void cmd_output(BaseSequentialStream *chp, int argc, char *argv[])