io/heci/heci_main.c

109 static int heci_close(dev_t dev, int flag, int otyp, struct cred *cred);
110 static int heci_read(dev_t dev, struct uio *uio_p, cred_t *cred_p);
111 static int heci_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
113 static int heci_write(dev_t dev, struct uio *uio_p, struct cred *cred);
114 static int heci_poll(dev_t dev, short events, int anyyet,
117 		struct iamt_heci_device *dev,
365 	struct iamt_heci_device	*dev;
368 	dev = ddi_get_soft_state(heci_soft_state_p, ddi_get_instance(dip));
369 	ASSERT(dev != NULL);
386 	if (dev->wd_timer)
387 		(void) untimeout(dev->wd_timer);
389 	mutex_enter(&dev->device_lock);
390 	if (dev->wd_file_ext.state == HECI_FILE_CONNECTED &&
391 	    dev->wd_timeout) {
392 		dev->wd_timeout = 0;
393 		dev->wd_due_counter = 0;
394 		(void) memcpy(dev->wd_data, stop_wd_params,
396 		dev->stop = 1;
397 		if (dev->host_buffer_is_empty &&
398 		    flow_ctrl_creds(dev, &dev->wd_file_ext)) {
399 			dev->host_buffer_is_empty = 0;
401 			if (!heci_send_wd(dev)) {
404 				flow_ctrl_reduce(dev, &dev->wd_file_ext);
406 			dev->wd_pending = 0;
408 			dev->wd_pending = 1;
410 		dev->wd_stoped = 0;
413 		while (!dev->wd_stoped && err != -1) {
414 			err = cv_reltimedwait(&dev->wait_stop_wd,
415 			    &dev->device_lock, 10*HZ, TR_CLOCK_TICK);
418 		if (!dev->wd_stoped) {
426 	mutex_exit(&dev->device_lock);
428 	if (dev->iamthif_file_ext.state == HECI_FILE_CONNECTED) {
429 		dev->iamthif_file_ext.state = HECI_FILE_DISCONNECTING;
430 		(void) heci_disconnect_host_client(dev,
431 		    &dev->iamthif_file_ext);
433 	if (dev->wd_file_ext.state == HECI_FILE_CONNECTED) {
434 		dev->wd_file_ext.state = HECI_FILE_DISCONNECTING;
435 		(void) heci_disconnect_host_client(dev,
436 		    &dev->wd_file_ext);
442 	heci_remove_client_from_file_list(dev, dev->wd_file_ext.
444 	heci_remove_client_from_file_list(dev,
445 	    dev->iamthif_file_ext.host_client_id);
447 	dev->iamthif_current_cb = NULL;
448 	dev->iamthif_file_ext.file = NULL;
451 	heci_csr_disable_interrupts(dev);
453 	ddi_remove_intr(dip, 0, dev->sc_iblk);
455 	if (dev->work)
456 		ddi_taskq_destroy(dev->work);
457 	if (dev->reinit_tsk)
458 		ddi_taskq_destroy(dev->reinit_tsk);
459 	if (dev->mem_addr)
460 		ddi_regs_map_free(&dev->io_handle);
462 	if (dev->me_clients && dev->num_heci_me_clients > 0) {
463 		kmem_free(dev->me_clients, sizeof (struct heci_me_client) *
464 		    dev->num_heci_me_clients);
467 	dev->num_heci_me_clients = 0;
469 	heci_destroy_locks(dev);
520 heci_clear_list(struct iamt_heci_device *dev,
537 			if (dev->iamthif_current_cb == priv_cb_pos) {
538 				dev->iamthif_current_cb = NULL;
540 				if (!heci_send_flow_control(dev,
541 				    &dev->iamthif_file_ext)) {
556  * @dev: device information struct
565 heci_clear_lists(struct iamt_heci_device *dev, struct heci_file *file)
570 	(void) heci_clear_list(dev, file, &dev->pthi_cmd_list.heci_cb.cb_list);
571 	if (heci_clear_list(dev, file,
572 	    &dev->pthi_read_complete_list.heci_cb.cb_list))
575 	(void) heci_clear_list(dev, file, &dev->ctrl_rd_list.heci_cb.cb_list);
577 	if (heci_clear_list(dev, file, &dev->ctrl_wr_list.heci_cb.cb_list))
580 	if (heci_clear_list(dev, file,
581 	    &dev->write_waiting_list.heci_cb.cb_list))
584 	if (heci_clear_list(dev, file, &dev->write_list.heci_cb.cb_list))
588 	if (dev->iamthif_current_cb && (!rets)) {
590 		if (dev->iamthif_current_cb->file_object == file) {
592 			heci_free_cb_private(dev->iamthif_current_cb);
593 			dev->iamthif_current_cb = NULL;
606 	struct iamt_heci_device *dev;
626 	dev = ddi_get_soft_state(heci_soft_state_p, instance);
628 	if ((if_num < HECI_MINOR_NUMBER) || (!dev))
635 	mutex_enter(&dev->device_lock);
636 	if (dev->heci_state != HECI_ENABLED) {
637 		mutex_exit(&dev->device_lock);
642 	if (dev->open_handle_count >= HECI_MAX_OPEN_HANDLE_COUNT) {
643 		mutex_exit(&dev->device_lock);
648 	dev->open_handle_count++;
649 	list_add_tail(&file_ext->link, &dev->file_list);
650 	while ((dev->heci_host_clients[dev->current_host_client_id / 8]
651 	    & (1 << (dev->current_host_client_id % 8))) != 0) {
653 		dev->current_host_client_id++;
654 		dev->current_host_client_id %= HECI_MAX_OPEN_HANDLE_COUNT;
656 		    dev->current_host_client_id);
657 		DBG("dev->open_handle_count = %lu\n",
658 		    dev->open_handle_count);
660 	DBG("current_host_client_id = %d\n", dev->current_host_client_id);
661 	file_ext->host_client_id = dev->current_host_client_id;
663 	    MAKE_MINOR_NUM(dev->current_host_client_id, instance));
664 	file = &dev->files[dev->current_host_client_id];
665 	dev->heci_host_clients[file_ext->host_client_id / 8] |=
667 	mutex_exit(&dev->device_lock);
688 	struct iamt_heci_device *dev;
698 	dev = ddi_get_soft_state(heci_soft_state_p, instance);
700 	file = &dev->files[if_num];
703 	if ((if_num < HECI_MINOR_NUMBER) || (!dev) || (!file_ext))
706 	if (file_ext != &dev->iamthif_file_ext) {
715 			rets = heci_disconnect_host_client(dev, file_ext);
718 		mutex_enter(&dev->device_lock);
719 		heci_flush_queues(dev, file_ext);
724 		if (dev->open_handle_count > 0) {
725 			dev->heci_host_clients[file_ext->host_client_id / 8] &=
727 			dev->open_handle_count--;
729 		heci_remove_client_from_file_list(dev,
734 			priv_cb = find_read_list_entry(dev, file_ext);
743 		mutex_exit(&dev->device_lock);
752 		mutex_enter(&dev->device_lock);
754 		if (dev->open_handle_count > 0)
755 			dev->open_handle_count--;
757 		if (dev->iamthif_file_object == file &&
758 		    dev->iamthif_state != HECI_IAMTHIF_IDLE) {
760 			    dev->iamthif_state);
761 			dev->iamthif_canceled = 1;
762 			if (dev->iamthif_state == HECI_IAMTHIF_READ_COMPLETE) {
764 				run_next_iamthif_cmd(dev);
768 		if (heci_clear_lists(dev, file))
769 			dev->iamthif_state = HECI_IAMTHIF_IDLE;
771 		mutex_exit(&dev->device_lock);
777 find_read_list_entry(struct iamt_heci_device *dev,
784 	if (dev->read_list.status == 0 &&
785 	    !list_empty(&dev->read_list.heci_cb.cb_list)) {
790 		    &dev->read_list.heci_cb.cb_list, cb_list,
819 	struct iamt_heci_device *dev;
828 	dev = ddi_get_soft_state(heci_soft_state_p, instance);
830 	file = &dev->files[if_num];
833 	if ((if_num < HECI_MINOR_NUMBER) || (!dev) || (!file_ext))
836 	mutex_enter(&dev->device_lock);
837 	if (dev->heci_state != HECI_ENABLED) {
838 		mutex_exit(&dev->device_lock);
841 	mutex_exit(&dev->device_lock);
849 		for (i = 0; i < dev->num_heci_me_clients; i++) {
851 			    &dev->me_clients[i].props.protocol_name,
854 				    dev->me_clients[i].client_id)
863 	if (file_ext == &dev->iamthif_file_ext) {
864 		rets = pthi_read(dev, if_num, file, uio_p);
887 	err = heci_start_read(dev, if_num, file_ext);
899 		mutex_enter(&dev->device_lock);
900 		if (cv_wait_sig(&file_ext->rx_wait, &dev->device_lock) == 0) {
901 			mutex_exit(&dev->device_lock);
906 		mutex_exit(&dev->device_lock);
951 	mutex_enter(&dev->device_lock);
952 	priv_cb_pos = find_read_list_entry(dev, file_ext);
956 	mutex_exit(&dev->device_lock);
979 	struct iamt_heci_device *dev;
991 	dev = ddi_get_soft_state(heci_soft_state_p, instance);
993 	file = &dev->files[if_num];
995 	if ((if_num < HECI_MINOR_NUMBER) || (!dev) || (!file_ext))
998 	mutex_enter(&dev->device_lock);
1000 	if (dev->heci_state != HECI_ENABLED) {
1001 		mutex_exit(&dev->device_lock);
1004 	if (file_ext == &dev->iamthif_file_ext) {
1005 		priv_write_cb = find_pthi_read_list_entry(dev, file);
1020 		priv_write_cb = find_read_list_entry(dev, file_ext);
1035 	mutex_exit(&dev->device_lock);
1073 	if (file_ext == &dev->iamthif_file_ext) {
1080 		mutex_enter(&dev->device_lock);
1081 		if (dev->heci_state != HECI_ENABLED) {
1082 			mutex_exit(&dev->device_lock);
1086 		for (i = 0; i < dev->num_heci_me_clients; i++) {
1087 			if (dev->me_clients[i].client_id ==
1088 			    dev->iamthif_file_ext.me_client_id)
1092 		ASSERT(dev->me_clients[i].client_id == file_ext->me_client_id);
1093 		if ((i == dev->num_heci_me_clients) ||
1094 		    (dev->me_clients[i].client_id !=
1095 		    dev->iamthif_file_ext.me_client_id)) {
1097 			mutex_exit(&dev->device_lock);
1101 		    dev->me_clients[i].props.max_msg_length) ||
1103 			mutex_exit(&dev->device_lock);
1113 		if (dev->iamthif_file_ext.state != HECI_FILE_CONNECTED) {
1114 			mutex_exit(&dev->device_lock);
1119 		if (!list_empty(&dev->pthi_cmd_list.heci_cb.cb_list) ||
1120 		    dev->iamthif_state != HECI_IAMTHIF_IDLE) {
1121 			DBG("pthi_state = %d\n", (int)dev->iamthif_state);
1124 			    &dev->pthi_cmd_list.heci_cb.cb_list);
1128 			rets = pthi_write(dev, priv_write_cb);
1133 				mutex_exit(&dev->device_lock);
1138 		mutex_exit(&dev->device_lock);
1148 	mutex_enter(&dev->device_lock);
1160 	for (i = 0; i < dev->num_heci_me_clients; i++) {
1161 		if (dev->me_clients[i].client_id ==
1165 	ASSERT(dev->me_clients[i].client_id == file_ext->me_client_id);
1166 	if (i == dev->num_heci_me_clients) {
1170 	if (length > dev->me_clients[i].props.max_msg_length || length == 0) {
1176 	if (flow_ctrl_creds(dev, file_ext) &&
1177 	    dev->host_buffer_is_empty) {
1178 		dev->host_buffer_is_empty = 0;
1179 		if (length > ((((dev->host_hw_state & H_CBD) >> 24) *
1183 			    (((dev->host_hw_state & H_CBD) >> 24) *
1197 		if (!heci_write_message(dev, &heci_hdr,
1202 			mutex_exit(&dev->device_lock);
1211 			flow_ctrl_reduce(dev, file_ext);
1213 			    &dev->write_waiting_list.heci_cb.cb_list);
1216 			    &dev->write_list.heci_cb.cb_list);
1224 		    &dev->write_list.heci_cb.cb_list);
1227 	mutex_exit(&dev->device_lock);
1232 	mutex_exit(&dev->device_lock);
1250 	struct iamt_heci_device *dev;
1261 	dev = ddi_get_soft_state(heci_soft_state_p, instance);
1263 	file = &dev->files[if_num];
1266 	if ((if_num < HECI_MINOR_NUMBER) || (!dev) || (!file_ext))
1269 	mutex_enter(&dev->device_lock);
1270 	if (dev->heci_state != HECI_ENABLED) {
1271 		mutex_exit(&dev->device_lock);
1274 	mutex_exit(&dev->device_lock);
1293 		rets = heci_ioctl_get_version(dev, if_num, u_msg, k_msg,
1299 		rets = heci_ioctl_connect_client(dev, if_num, u_msg, k_msg,
1305 		rets = heci_ioctl_wd(dev, if_num, k_msg, file_ext, mode);
1310 		rets = heci_ioctl_bypass_wd(dev, if_num, k_msg, file_ext, mode);
1417 	struct iamt_heci_device	*dev;
1419 	dev = ddi_get_soft_state(heci_soft_state_p, ddi_get_instance(dip));
1420 	ASSERT(dev != NULL);
1422 	if (dev->wd_file_ext.state == HECI_FILE_CONNECTED &&
1423 	    dev->wd_timeout) {
1424 		dev->wd_timeout = 0;
1425 		dev->wd_due_counter = 0;
1426 		(void) memcpy(dev->wd_data, stop_wd_params,
1428 		if (!heci_send_wd(dev)) {
1435 	heci_csr_disable_interrupts(dev);