Eliminate unused 'stack' concept for GKI tasks.

This change also fixes the type for task names: should be a const
string, not a mutable INT8*.

diff --git a/btif/src/btif_core.c b/btif/src/btif_core.c
index ff41af8..ef01476 100644 (file)
--- a/btif/src/btif_core.c
+++ b/btif/src/btif_core.c
@@ -58,16 +58,10 @@
 **  Constants & Macros
 ************************************************************************************/
 
-#ifndef BTIF_TASK_STACK_SIZE
-#define BTIF_TASK_STACK_SIZE       0x2000         /* In bytes */
-#endif
-
 #ifndef BTE_DID_CONF_FILE
 #define BTE_DID_CONF_FILE "/etc/bluetooth/bt_did.conf"
 #endif
 
-#define BTIF_TASK_STR        ((INT8 *) "BTIF")
-
 /************************************************************************************
 **  Local type definitions
 ************************************************************************************/
@@ -103,8 +97,6 @@ typedef enum {
 
 bt_bdaddr_t btif_local_bd_addr;
 
-static UINT32 btif_task_stack[(BTIF_TASK_STACK_SIZE + 3) / 4];
-
 /* holds main adapter state */
 static btif_core_state_t btif_core_state = BTIF_CORE_STATE_DISABLED;
 
@@ -491,9 +483,7 @@ bt_status_t btif_init_bluetooth()
     btif_fetch_local_bdaddr(&btif_local_bd_addr);
 
     /* start btif task */
-    status = GKI_create_task(btif_task, BTIF_TASK, BTIF_TASK_STR,
-                (UINT16 *) ((UINT8 *)btif_task_stack + BTIF_TASK_STACK_SIZE),
-                sizeof(btif_task_stack));
+    status = GKI_create_task(btif_task, BTIF_TASK, "BTIF");
 
     if (status != GKI_SUCCESS)
         return BT_STATUS_FAIL;

diff --git a/btif/src/btif_media_task.c b/btif/src/btif_media_task.c
index d1d8d56..79d986b 100644 (file)
--- a/btif/src/btif_media_task.c
+++ b/btif/src/btif_media_task.c
@@ -176,13 +176,6 @@ enum {
 #define BTIF_A2DP_NON_EDR_MAX_RATE 229
 #endif
 
-#ifndef A2DP_MEDIA_TASK_STACK_SIZE
-#define A2DP_MEDIA_TASK_STACK_SIZE       0x2000         /* In bytes */
-#endif
-
-#define A2DP_MEDIA_TASK_TASK_STR        ((INT8 *) "A2DP-MEDIA")
-static UINT32 a2dp_media_task_stack[(A2DP_MEDIA_TASK_STACK_SIZE + 3) / 4];
-
 #define BT_MEDIA_TASK A2DP_MEDIA_TASK
 
 #define USEC_PER_SEC 1000000L
@@ -779,10 +772,7 @@ int btif_a2dp_start_media_task(void)
     btif_media_data_msg_queue = fixed_queue_new(SIZE_MAX);
 
     /* start a2dp media task */
-    retval = GKI_create_task((TASKPTR)btif_media_task, A2DP_MEDIA_TASK,
-                A2DP_MEDIA_TASK_TASK_STR,
-                (UINT16 *) ((UINT8 *)a2dp_media_task_stack + A2DP_MEDIA_TASK_STACK_SIZE),
-                sizeof(a2dp_media_task_stack));
+    retval = GKI_create_task((TASKPTR)btif_media_task, A2DP_MEDIA_TASK, "A2DP-MEDIA");
 
     if (retval != GKI_SUCCESS)
         return retval;

diff --git a/gki/common/gki.h b/gki/common/gki.h
index 8cc12e5..94b0ded 100644 (file)
--- a/gki/common/gki.h
+++ b/gki/common/gki.h
@@ -138,14 +138,14 @@ extern "C" {
 
 /* Task management
 */
-GKI_API extern UINT8   GKI_create_task (TASKPTR, UINT8, INT8 *, UINT16 *, UINT16);
+GKI_API extern UINT8   GKI_create_task(TASKPTR, UINT8, const char *);
 GKI_API extern void    GKI_destroy_task(UINT8 task_id);
 GKI_API extern void    GKI_task_self_cleanup(UINT8 task_id);
 GKI_API extern void    GKI_exit_task(UINT8);
 GKI_API extern UINT8   GKI_get_taskid(void);
 GKI_API extern void    GKI_init(void);
 GKI_API extern void    GKI_shutdown(void);
-GKI_API extern INT8   *GKI_map_taskname(UINT8);
+GKI_API extern const char *GKI_map_taskname(UINT8);
 GKI_API extern void    GKI_run(void);
 GKI_API extern void    GKI_stop(void);
 

diff --git a/gki/common/gki_common.h b/gki/common/gki_common.h
index 64c9f69..3c1f9d1 100644 (file)
--- a/gki/common/gki_common.h
+++ b/gki/common/gki_common.h
@@ -255,7 +255,7 @@ typedef struct
     UINT16  OSStackSize[GKI_MAX_TASKS];     /* stack size available to each task */
 
 
-    INT8   *OSTName[GKI_MAX_TASKS];         /* name of the task */
+    const char *OSTName[GKI_MAX_TASKS];         /* name of the task */
 
     UINT8   OSRdyTbl[GKI_MAX_TASKS];        /* current state of the task */
     UINT16  OSWaitEvt[GKI_MAX_TASKS];       /* events that have to be processed by the task */

diff --git a/gki/ulinux/gki_ulinux.c b/gki/ulinux/gki_ulinux.c
index ec2d98b..ad0eae1 100644 (file)
--- a/gki/ulinux/gki_ulinux.c
+++ b/gki/ulinux/gki_ulinux.c
@@ -201,8 +201,6 @@ UINT32 GKI_get_os_tick_count(void)
 ** Parameters:      task_entry  - (input) pointer to the entry function of the task
 **                  task_id     - (input) Task id is mapped to priority
 **                  taskname    - (input) name given to the task
-**                  stack       - (input) pointer to the top of the stack (highest memory location)
-**                  stacksize   - (input) size of the stack allocated for the task
 **
 ** Returns          GKI_SUCCESS if all OK, GKI_FAILURE if any problem
 **
@@ -211,18 +209,15 @@ UINT32 GKI_get_os_tick_count(void)
 **                  of the function prototype.
 **
 *******************************************************************************/
-UINT8 GKI_create_task (TASKPTR task_entry, UINT8 task_id, INT8 *taskname, UINT16 *stack, UINT16 stacksize)
+UINT8 GKI_create_task(TASKPTR task_entry, UINT8 task_id, const char *taskname)
 {
     UINT16  i;
     UINT8   *p;
     struct sched_param param;
     int policy, ret = 0;
     pthread_attr_t attr1;
-    UNUSED(stack);
-    UNUSED(stacksize);
 
-    GKI_TRACE( "GKI_create_task %x %d %s %x %d", (int)task_entry, (int)task_id,
-            (char*) taskname, (int) stack, (int)stacksize);
+    GKI_TRACE( "GKI_create_task %x %d %s", (int)task_entry, (int)task_id, taskname);
 
     if (task_id >= GKI_MAX_TASKS)
     {
@@ -230,7 +225,6 @@ UINT8 GKI_create_task (TASKPTR task_entry, UINT8 task_id, INT8 *taskname, UINT16
         return (GKI_FAILURE);
     }
 
-
     gki_cb.com.OSRdyTbl[task_id]    = TASK_READY;
     gki_cb.com.OSTName[task_id]     = taskname;
     gki_cb.com.OSWaitTmr[task_id]   = 0;
@@ -297,13 +291,11 @@ UINT8 GKI_create_task (TASKPTR task_entry, UINT8 task_id, INT8 *taskname, UINT16
          pthread_setschedparam(gki_cb.os.thread_id[task_id], policy, &param);
      }
 
-    GKI_TRACE( "Leaving GKI_create_task %x %d %x %s %x %d\n",
+    GKI_TRACE( "Leaving GKI_create_task %x %d %x %s\n",
               (int)task_entry,
               (int)task_id,
               (int)gki_cb.os.thread_id[task_id],
-              (char*)taskname,
-              (int)stack,
-              (int)stacksize);
+              taskname);
 
     return (GKI_SUCCESS);
 }
@@ -818,25 +810,14 @@ UINT8 GKI_get_taskid (void)
 **
 *******************************************************************************/
 
-INT8 *GKI_map_taskname (UINT8 task_id)
-{
-    GKI_TRACE("GKI_map_taskname %d", task_id);
+const char *GKI_map_taskname(UINT8 task_id) {
+  assert(task_id <= GKI_MAX_TASKS);
 
-    if (task_id < GKI_MAX_TASKS)
-    {
-        GKI_TRACE("GKI_map_taskname %d %s done", task_id, gki_cb.com.OSTName[task_id]);
-         return (gki_cb.com.OSTName[task_id]);
-    }
-    else if (task_id == GKI_MAX_TASKS )
-    {
-        return (gki_cb.com.OSTName[GKI_get_taskid()]);
-    }
-    else
-    {
-        return (INT8*)"BAD";
-    }
-}
+  if (task_id == GKI_MAX_TASKS)
+    task_id = GKI_get_taskid();
 
+  return gki_cb.com.OSTName[task_id];
+}
 
 /*******************************************************************************
 **

diff --git a/stack/btu/btu_init.c b/stack/btu/btu_init.c
index f79b2af..4e5c4fa 100644 (file)
--- a/stack/btu/btu_init.c
+++ b/stack/btu/btu_init.c
@@ -126,7 +126,7 @@ void BTU_StartUp(void)
       btu_cb.hci_cmd_cb[i].cmd_window = 1;
     }
 
-    GKI_create_task(btu_task, BTU_TASK, (INT8 *)"BTU", NULL, 0);
+    GKI_create_task(btu_task, BTU_TASK, "BTU");
 }
 
 void BTU_ShutDown(void) {