hci.c

blue tooth 核心协议栈在linux上的实现

		      hci_handle(&buf[1]));
		break;

	case RETURN_LINK_KEYS:
		D_CMD(__FUNCTION__ ": RETURN_LINK_KEYS event\n");
#ifdef CONFIG_BLUETOOTH_USE_SECURITY_MANAGER
                {
                        u8 tmp_str[23];

                        for (i = 0; i < buf[0]; i++) {
                                D_CMD("%d: ", i);
                                tmp_str[0] = i;
                                memcpy(tmp_str + 1, (buf + 1) + (i * 6), 6);
                                memcpy(tmp_str + 7, (buf + 1) + (buf[0] * 6) + (i * 16), 16);
                                sec_man_event(HCI, buf + 1, RETURN_LINK_KEYS, tmp_str, 17);
                        }
                }
#endif
		break;
	
	case PIN_CODE_REQUEST:
		D_CMD(__FUNCTION__ ": PIN_CODE_REQUEST forwarding event to security manager\n");
#ifdef CONFIG_BLUETOOTH_USE_SECURITY_MANAGER
		sec_man_event(HCI, buf, PIN_CODE_REQUEST, NULL, 0);
#endif
		break;
	
	case LINK_KEY_REQUEST:
                D_CMD(__FUNCTION__ ": LINK_KEY_REQUEST\n");
#ifdef CONFIG_BLUETOOTH_USE_SECURITY_MANAGER
		sec_man_event(HCI, buf, LINK_KEY_REQUEST, NULL, 0);
#endif
		break;

	case LINK_KEY_NOTIFICATION:
		D_CMD(__FUNCTION__ ": LINK_KEY_NOTIFICATION forwarding event to security manager\n");
#ifdef CONFIG_BLUETOOTH_USE_SECURITY_MANAGER
		sec_man_event(HCI, buf, LINK_KEY_NOTIFICATION, buf + 6, 16);
#endif
		break;

	case LOOPBACK_COMMAND:
		DSYS(__FUNCTION__ ": LOOPBACK_COMMAND, loopback mode not supported\n");
		break;

	case DATA_BUFFER_OVERFLOW:
		D_ERR(__FUNCTION__ ": DATA_BUFFER_OVERFLOW\n");
		break;

	case MAX_SLOTS_CHANGE:
		D_CMD(__FUNCTION__ ": MAX_SLOTS_CHANGE to %d\n", (u32) buf[2]);
		break;

	case READ_CLOCK_OFFSET_COMPLETE:
		D_CMD(__FUNCTION__ ": READ_CLOCK_OFFSET_COMPLETE\n");
		break;

	case CONNECTION_PACKET_TYPE_CHANGED:
		D_CMD(__FUNCTION__ ": CHANGE_CONNECTION_PACKET_TYPE\n");
		break;

	case QOS_VIOLATION:
		D_CMD(__FUNCTION__ ": QOS_VIOLATION\n");
		break;

	case PAGE_SCAN_MODE_CHANGE:
		DSYS(__FUNCTION__ ": PAGE_SCAN_MODE_CHANGE Not implemented\n");
		break;

	case PAGE_SCAN_REPETITION_MODE_CHANGE:
		DSYS(__FUNCTION__ ": PAGE_SCAN_REPETITION_MODE_CHANGE Not implemented\n");
		break;	

	case VENDOR_EVENT:
                process_vendor_event(buf, len, event_code);
		break;

	default:
		DSYS(__FUNCTION__ ": UNKNOWN EVENT CODE 0x%x\n", event_code);
		break;
	}
}


/* Parses the return parameters from the command complete event, see the
   bluetooth baseband specification part H:1, chapter 5.2.14 for a further
   description of the command complete event. */

void 
process_return_param(u8 *buf)
{
	u32 ogf,ocf;
	u8 *r_val;

	/* buf points at the start of the event parameters of the command
	   complete event. The second and third byte (buf[1] and buf[2])
	   contains the op-code, which consists of the OGF and the OCF values,
	   see the baseband specification part H:1, chapter 4.4.1 for a
	   description of these.

	   r_val is set to point at the beginning of the return parameters at
	   the command complete event */

	ogf = (u32) buf[2] >> 2;
	ocf = le16_to_cpuu(&buf[1]) & 0x03FF;
	r_val = buf + 3;

	switch (ogf) {
	case HCI_LC:
		switch (ocf) {
		case LINK_KEY_REQUEST_REPLY:
			release_cmd_timer();
			
			D_CMD(__FUNCTION__ ": LINK_KEY_REQUEST_REPLY\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": LINK_KEY_REQUEST_REPLY %s\n", get_err_msg(r_val[0]));
				result_param = -r_val[0]; 
			}
			else {
				D_CMD(__FUNCTION__ ": LINK_KEY_REQUEST_REPLY Success\n");
				result_param = 0;
			}
			
			wake_up_interruptible(&hci_wq);
			break;
		
		case LINK_KEY_REQUEST_NEGATIVE_REPLY:
			release_cmd_timer();
			
			D_CMD(__FUNCTION__ ": LINK_KEY_REQUEST_NEGATIVE_REPLY\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": LINK_KEY_REQUEST_NEGATIVE_REPLY %s\n", get_err_msg(r_val[0]));
				result_param = -r_val[0]; 
			}
			else {
				D_CMD(__FUNCTION__ ": LINK_KEY_REQUEST_NEGATIVE_REPLY Success\n");
				result_param = 0;
			}
			
			wake_up_interruptible(&hci_wq);
			break;
		
		case PIN_CODE_REQUEST_REPLY:
			release_cmd_timer();
					
			D_CMD(__FUNCTION__ ": PIN_CODE_REQUEST_REPLY\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": PIN_CODE_REQUEST_REPLY %s\n", get_err_msg(r_val[0]));
				result_param = -r_val[0]; 
			}
			else {
				D_CMD(__FUNCTION__ ": PIN_CODE_REQUEST_REPLY  Success\n");
				result_param = 0;
			}

			wake_up_interruptible(&hci_wq);
			break;


		case PIN_CODE_REQUEST_NEGATIVE_REPLY:
			release_cmd_timer();
			
			D_CMD(__FUNCTION__ ": PIN_CODE_REQUEST_NEGATIVE_REPLY\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": PIN_CODE_REQUEST_NEGATIVE_REPLY %s\n", get_err_msg(r_val[0]));
				result_param = -r_val[0]; 
			}
			else {
				D_CMD(__FUNCTION__ ": PIN_CODE_REQUEST_NEGATIVE_REPLY Success\n");
				result_param = 0;
			}

			wake_up_interruptible(&hci_wq);
			break;	

		default:
			D_CMD(__FUNCTION__ ": HCI_LC, ocf %d not recognised!\n", ocf);
			break;
		}
		break;

	case HCI_HC:                 /* Host Controller commands */
		release_cmd_timer();
		/* FIXME -- correct timer should be released */
          
		switch (ocf) {
		case CREATE_NEW_UNIT_KEY:
			D_CMD(__FUNCTION__ ": CREATE_NEW_UNIT_KEY\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": CREATE_NEW_UNIT_KEY %s\n", get_err_msg(r_val[0]));
				result_param = -r_val[0]; 
			} else {
				D_CMD(__FUNCTION__ ": CREATE_NEW_UNIT_KEY Success\n");
				result_param = 0;
			}
			break;
			
			
		case READ_STORED_LINK_KEY:
			DSYS(__FUNCTION__ ": READ_STORED_LINK_KEY\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": READ_STORED_LINK_KEY %s\n", get_err_msg(r_val[0]));
				result_param = -r_val[0];
			} else {
				D_CMD(__FUNCTION__ ": READ_STORED_LINK_KEY Success\n");
				result_param = le32_to_cpuu(&r_val[1]);
			}
			DSYS(__FUNCTION__ ": Max number of Linkkeys: %d\n",
			     le16_to_cpuu(&r_val[1]));
			DSYS(__FUNCTION__ ": Number of Linkkeys read: %d\n",
			     le16_to_cpuu(&r_val[3]));
			break;

		case WRITE_STORED_LINK_KEY:
			D_CMD(__FUNCTION__ ": WRITE_STORED_LINK_KEY\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": WRITE_STORED_LINK_KEY %s\n", get_err_msg(r_val[0]));
				result_param = -r_val[0]; 
			}
			else {
				D_CMD(__FUNCTION__ ": WRITE_STORED_LINK_KEY Success\n");
				result_param = 0;
			}
			break;

		case DELETE_STORED_LINK_KEY:
			D_CMD(__FUNCTION__ ": DELETE_STORED_LINK_KEY\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": DELETE_STORED_LINK_KEY %s\n", get_err_msg(r_val[0]));
				result_param = -r_val[0];
			} else {
				D_CMD(__FUNCTION__ ": DELETE_STORED_LINK_KEY Success\n");
				result_param = le16_to_cpuu(&r_val[1]);
			}
			
			D_CMD(__FUNCTION__ ": Number of Linkkeys deleted: %d\n",
			      le16_to_cpuu(&r_val[1]));
			break;	
            
		case READ_TRANSMIT_POWER_LEVEL:                                
		  
			printk(__FUNCTION__ ": READ_TRANSMIT_POWER_LEVEL\n");
			if (r_val[0]) {
			D_ERR(__FUNCTION__ ": READ_TRANSMIT_POWER_LEVEL: %s\n",
				      get_err_msg(r_val[0]));
				break;
			} else {
				DSYS("READ_TRANSMIT_POWER_LEVEL: handle %d, %d dBm\n", hci_handle(&r_val[1]), r_val[3]);
			}
			break;

		case SET_HOST_CONTROLLER_TO_HOST_FLOW_CONTROL:
			D_CMD(__FUNCTION__ ": SET_HOST_CONTROLLER_TO_HOST_FLOW_CONTROL\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": SET_HOST_CONTROLLER_TO_HOST_FLOW_CONTROL: %s\n",
				      get_err_msg(r_val[0]));
				break;
			}
			break;
            
		case HOST_BUFFER_SIZE:  
			D_CMD(__FUNCTION__ ": HOST_BUFFER_SIZE\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": HOST_BUFFER_SIZE: %s\n",
				      get_err_msg(r_val[0]));
			}
			break;
            
		case CHANGE_LOCAL_NAME:
			D_CMD(__FUNCTION__ ": CHANGE_LOCAL_NAME\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": CHANGE_LOCAL_NAME: %s\n",
				      get_err_msg(r_val[0]));
			}
			break;

		case READ_SCAN_ENABLE:
			D_CMD(__FUNCTION__ ": READ_SCAN_ENABLE\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": READ_SCAN_ENABLE: %s\n",
				      get_err_msg(r_val[0]));
				result_param = -r_val[0];
			} else {
				result_param = r_val[1];
			}
			printk("READ_SCAN_ENABLE %d\n", result_param);
			break;
			
		case WRITE_SCAN_ENABLE:
			D_CMD(__FUNCTION__ ": WRITE_SCAN_ENABLE\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": WRITE_SCAN_ENABLE: %s\n",
				      get_err_msg(r_val[0]));
			}
			break;
            
		case WRITE_PAGESCAN_ACTIVITY:
			D_CMD(__FUNCTION__ ": WRITE_PAGESCAN_ACTIVITY\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": WRITE_PAGESCAN_ACTIVITY: %s\n",
				      get_err_msg(r_val[0]));
			}
			break;
            
		case WRITE_INQUIRYSCAN_ACTIVITY:
			D_CMD(__FUNCTION__ ": WRITE_INQUIRYSCAN_ACTIVITY\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": WRITE_INQUIRYSCAN_ACTIVITY: %s\n",
				      get_err_msg(r_val[0]));
				result_param = -r_val[0];
			}
			break;

		case READ_AUTHENTICATION_ENABLE:
			D_CMD(__FUNCTION__ ": READ_AUTHENTICATION_ENABLE\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": READ_AUTHENTICATION_ENABLE: %s\n", get_err_msg(r_val[0]));
				result_param = -r_val[0];
			} else {
				result_param = r_val[1];
			}
			break;
			
		case WRITE_AUTHENTICATION_ENABLE:
			D_CMD(__FUNCTION__ ": WRITE_AUTHENTICATION_ENABLE\n");
			if(r_val[0]) {
				D_ERR(__FUNCTION__ ": WRITE_AUTHENTICATION_ENABLE: %s\n",
				      get_err_msg(r_val[0]));
				result_param = -r_val[0];
			} 
			break;
			
		case READ_ENCRYPTION_MODE:
			D_CMD(__FUNCTION__ ": READ_ENCRYPTION_MODE\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": READ_ENCRYPTION_MODE: %s\n", get_err_msg(r_val[0]));
				result_param = -r_val[0];
			} else {
				result_param = r_val[1];
			}
			break;
			
		case WRITE_ENCRYPTION_MODE:
			D_CMD(__FUNCTION__ ": WRITE_AUTHENTICATION_ENABLE\n");
			if(r_val[0]) {
				D_ERR(__FUNCTION__ ": WRITE_AUTHENTICATION_ENABLE: %s\n",
				      get_err_msg(r_val[0]));
				result_param = -r_val[0];
			}
			break;
			
		case WRITE_CLASS_OF_DEVICE:
			D_CMD(__FUNCTION__ ": WRITE_CLASS_OF_DEVICE\n");
			if(r_val[0]) {
				D_ERR(__FUNCTION__ ": WRITE_CLASS_OF_DEVICE: %s\n",
				      get_err_msg(r_val[0]));
			}
			break;

		case WRITE_AUTOMATIC_FLUSH_TIMEOUT:
			D_CMD(__FUNCTION__ ": WRITE_AUTOMATIC_FLUSH_TIMEOUT\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": WRITE_AUTOMATIC_FLUSH_TIMEOUT: %s\n",
				      get_err_msg(r_val[0]));
			} else {
				D_CMD(__FUNCTION__ ": WRITE_AUTOMATIC_FLUSH_TIMEOUT Success\n");
			}
			
			break;

            
		case READ_LINK_SUPERVISION_TIMEOUT:
			D_CMD(__FUNCTION__ ": Link supervision timeout is: %d\n",
			      le16_to_cpuu(&buf[3]));
			break;
            
		case WRITE_LINK_SUPERVISION_TIMEOUT:
			D_CMD(__FUNCTION__ ": WRITE_LINK_SUPERVISION_TO (%d)\n", r_val[0]);
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": WRITE_LINK_SUPERVISION_TO: %s\n",
				      get_err_msg(r_val[0]));
			}
			break;
            
		case RESET:
			D_CMD(__FUNCTION__ ": RESET\n");
			break;
            
		case SET_EVENT_FILTER:
			D_CMD(__FUNCTION__ ": SET_EVENT_FILTER\n");
			break;
            
		default:
			D_CMD(__FUNCTION__ ": HCI_HC, ocf %d not recognised!\n", ocf);
			break;
		}
                /* FIX ME : Wake up from the correct queue */
		wake_up_interruptible(&hci_wq);
		break;

	case HCI_LP:                 /* Link policy commands */
		switch (ocf) {
		case ROLE_DISCOVERY:
			D_CMD(__FUNCTION__ ": ROLE_DISCOVERY: ");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": ROLE_DISCOVERY: %s\n",
				      get_err_msg(r_val[0]));
				break;
			}
			if (r_val[3])
				printk("Connected as Slave.\n");
			else
				printk("Connected as Master. \n");
			break;
		case WRITE_LINK_POLICY_SETTINGS:
			D_CMD(__FUNCTION__ ": WRITE_LINK_POLICY_SETTINGS \n ");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": WRITE_LINK_POLICY_SETTINGS: %s\n",
				      get_err_msg(r_val[0]));
				break;
			}
			break;
		default:
			D_CMD(__FUNCTION__ ": HCI_LP, ocf %d not recognised!\n", ocf);
			break;
		}
		break;
		
	case HCI_IP:                 /* Informational parameters */
		release_cmd_timer();

		switch (ocf) {
		case READ_COUNTRY_CODE:
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": READ_COUNTRY_CODE : %s\n",
				      get_err_msg(r_val[0]));
				result_param = -r_val[0];
			} else {
				result_param = r_val[1];
				D_CMD(__FUNCTION__ ": READ_COUNTRY_CODE : %d\n",
				      result_param);
			}
			break;
			

		case READ_LOCAL_VERSION_INFORMATION:
			D_CMD(__FUNCTION__ ": READ_LOCAL_VERSION_INFORMATION\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": READ_LOCAL_VERSION_INFORMATION: %s\n",
				      get_err_msg(r_val[0]));
				break;
			}

			break;

		case READ_BUFFER_SIZE:
			D_CMD(__FUNCTION__ ": READ_BUFFER_SIZE\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": READ_BUFFER_SIZE: %s\n",
				      get_err_msg(r_val[0]));
				break;
			}
			hci_ctrl.hc_buf.acl_len = le16_to_cpuu(&r_val[1]);
			hci_ctrl.hc_buf.sco_len = (u32) r_val[3];
			hci_ctrl.hc_buf.acl_num = le16_to_cpuu(&r_val[4]);
			hci_ctrl.hc_buf.sco_num = le16_to_cpuu(&r_val[6]);
                        printk("\nHW module contains...\n");
			printk("%d ACL buffers at %d bytes\n%d SCO buffers at %d bytes\n\n",
			       hci_ctrl.hc_buf.acl_num, hci_ctrl.hc_buf.acl_len,
			       hci_ctrl.hc_buf.sco_num, hci_ctrl.hc_buf.sco_len);

#ifdef __KERNEL__
#ifdef USE_NCPTIMER
			hw.max_acl_num = hci_ctrl.hc_buf.acl_num;
#endif
#endif
			wake_up_interruptible(&hci_wq);
			break;
            
		case READ_BD_ADDR:
			D_CMD(__FUNCTION__ ": READ_BD_ADDR\n");
			if (r_val[0]) {
				D_ERR(__FUNCTION__ ": READ_BD_ADDR: %s\n",
				      get_err_msg(r_val[0]));
				break;
			}            
			PRINTPKT(__FUNCTION__ ": READ_BD_ADDR : ", &r_val[1], 6);
			memcpy(hci_ctrl.local_bd, &r_val[1],6);
			break;
            
		default:
			D_CMD(__FUNCTION__ ": HCI_IP, ocf %d not recognised!\n", ocf);
			break;
		}
		wake_up_interruptible(&hci_wq);
		break;
          
	case HCI_TC:                 /* Test Commands */
		release_cmd_timer();

		switch (ocf) {  
		case READ_LOOPBACK_MODE:
			D_ERR(__FUNCTION__ ": READ_LOOPBACK_MODE -- not impl\n");
			break;
            
		case WRITE_LOOPBACK_MODE:
			D_ERR(__FUNCTION__ ": WRITE_LOOPBACK_MODE -- not impl\n");
			break;
            
		case ENABLE_DEVICE_UNDER_TEST_MODE: