Lines Matching refs:dev
96 static void heci_check_asf_mode(struct iamt_heci_device *dev);
97 static int host_start_message(struct iamt_heci_device *dev);
98 static int host_enum_clients_message(struct iamt_heci_device *dev);
99 static int allocate_me_clients_storage(struct iamt_heci_device *dev);
100 static void host_init_wd(struct iamt_heci_device *dev);
101 static void host_init_iamthif(struct iamt_heci_device *dev);
111 * @dev: Device object for our driver
115 struct iamt_heci_device *dev)
120 list->device_extension = dev;
126 * @dev: Device object for our driver
131 heci_flush_queues(struct iamt_heci_device *dev,
136 if (!dev || !file_ext)
142 heci_flush_list(dev->io_list_array[i], file_ext);
185 * @dev: The heci device structure
187 static void heci_reset_iamthif_params(struct iamt_heci_device *dev)
190 dev->iamthif_current_cb = NULL;
191 dev->iamthif_msg_buf_size = 0;
192 dev->iamthif_msg_buf_index = 0;
193 dev->iamthif_canceled = 0;
194 dev->iamthif_file_ext.file = NULL;
195 dev->iamthif_ioctl = 0;
196 dev->iamthif_state = HECI_IAMTHIF_IDLE;
197 dev->iamthif_timer = 0;
275 * @dev: Device object for our driver
280 heci_hw_init(struct iamt_heci_device *dev)
284 mutex_enter(&dev->device_lock);
285 dev->host_hw_state = read_heci_register(dev, H_CSR);
286 dev->me_hw_state = read_heci_register(dev, ME_CSR_HA);
288 dev->host_hw_state, dev->me_hw_state);
290 if ((dev->host_hw_state & H_IS) == H_IS) {
292 heci_set_csr_register(dev);
294 dev->recvd_msg = 0;
297 heci_reset(dev, 1);
300 dev->host_hw_state, dev->me_hw_state);
304 while (!dev->recvd_msg && err != -1) {
305 err = cv_reltimedwait(&dev->wait_recvd_msg,
306 &dev->device_lock, HECI_INTEROP_TIMEOUT, TR_CLOCK_TICK);
309 if (err == -1 && !dev->recvd_msg) {
310 dev->heci_state = HECI_DISABLED;
313 mutex_exit(&dev->device_lock);
316 if (!(((dev->host_hw_state & H_RDY) == H_RDY) &&
317 ((dev->me_hw_state & ME_RDY_HRA) == ME_RDY_HRA))) {
318 dev->heci_state = HECI_DISABLED;
320 dev->host_hw_state,
321 dev->me_hw_state);
323 if (!(dev->host_hw_state & H_RDY) != H_RDY)
326 if (!(dev->me_hw_state & ME_RDY_HRA) != ME_RDY_HRA)
331 mutex_exit(&dev->device_lock);
335 dev->recvd_msg = 0;
337 dev->host_hw_state, dev->me_hw_state);
340 mutex_exit(&dev->device_lock);
347 * @dev: Device object for our driver
350 static void heci_hw_reset(struct iamt_heci_device *dev, int interrupts)
352 dev->host_hw_state |= (H_RST | H_IG);
355 heci_csr_enable_interrupts(dev);
357 heci_csr_disable_interrupts(dev);
364 * @dev: Device object for our driver
368 heci_reset(struct iamt_heci_device *dev, int interrupts)
376 if (dev->heci_state == HECI_RECOVERING_FROM_RESET) {
377 dev->need_reset = 1;
381 if (dev->heci_state != HECI_INITIALIZING &&
382 dev->heci_state != HECI_DISABLED &&
383 dev->heci_state != HECI_POWER_DOWN &&
384 dev->heci_state != HECI_POWER_UP)
387 if (dev->reinit_tsk != NULL) {
388 mutex_exit(&dev->device_lock);
389 (void) ddi_taskq_wait(dev->reinit_tsk);
390 mutex_enter(&dev->device_lock);
393 dev->host_hw_state = read_heci_register(dev, H_CSR);
396 dev->host_hw_state);
398 heci_hw_reset(dev, interrupts);
400 dev->host_hw_state &= ~H_RST;
401 dev->host_hw_state |= H_IG;
403 write_heci_register(dev, H_CSR, dev->host_hw_state);
406 dev->host_hw_state);
408 dev->need_reset = 0;
410 if (dev->heci_state != HECI_INITIALIZING) {
411 if ((dev->heci_state != HECI_DISABLED) &&
412 (dev->heci_state != HECI_POWER_DOWN))
413 dev->heci_state = HECI_RESETING;
416 file_next, &dev->file_list, link,
425 heci_remove_client_from_file_list(dev,
426 dev->wd_file_ext.host_client_id);
428 heci_remove_client_from_file_list(dev,
429 dev->iamthif_file_ext.host_client_id);
431 heci_reset_iamthif_params(dev);
432 dev->wd_due_counter = 0;
433 dev->extra_write_index = 0;
436 dev->num_heci_me_clients = 0;
437 dev->rd_msg_hdr = 0;
438 dev->stop = 0;
439 dev->wd_pending = 0;
442 dev->host_hw_state = read_heci_register(dev, H_CSR);
443 dev->me_hw_state = read_heci_register(dev, ME_CSR_HA);
446 dev->host_hw_state, dev->me_hw_state);
452 list_for_each_entry_safe(file_pos, file_next, &dev->file_list, link,
458 if (dev->write_list.status == 0 &&
459 !list_empty(&dev->write_list.heci_cb.cb_list)) {
461 &dev->write_list.heci_cb.cb_list, cb_list,
474 * @dev: Device object for our driver
478 heci_initialize_clients(struct iamt_heci_device *dev)
486 status = host_start_message(dev);
488 mutex_enter(&dev->device_lock);
489 dev->heci_state = HECI_DISABLED;
490 mutex_exit(&dev->device_lock);
496 status = host_enum_clients_message(dev);
498 mutex_enter(&dev->device_lock);
499 dev->heci_state = HECI_DISABLED;
500 mutex_exit(&dev->device_lock);
505 status = allocate_me_clients_storage(dev);
507 mutex_enter(&dev->device_lock);
508 dev->num_heci_me_clients = 0;
509 dev->heci_state = HECI_DISABLED;
510 mutex_exit(&dev->device_lock);
515 heci_check_asf_mode(dev);
517 host_init_wd(dev);
519 host_init_iamthif(dev);
521 mutex_enter(&dev->device_lock);
522 if (dev->need_reset) {
523 dev->need_reset = 0;
524 dev->heci_state = HECI_DISABLED;
525 mutex_exit(&dev->device_lock);
529 (void) memset(dev->heci_host_clients, 0,
530 sizeof (dev->heci_host_clients));
531 dev->open_handle_count = 0;
532 dev->heci_host_clients[0] |= 7;
533 dev->current_host_client_id = 3;
534 dev->heci_state = HECI_ENABLED;
535 mutex_exit(&dev->device_lock);
550 struct iamt_heci_device *dev = (struct iamt_heci_device *)data;
552 ret = heci_initialize_clients(dev);
560 * @dev: Device object for our driver
565 host_start_message(struct iamt_heci_device *dev)
575 mutex_enter(&dev->device_lock);
576 heci_hdr = (struct heci_msg_hdr *)&dev->wr_msg_buf[0];
584 (struct hbm_host_version_request *)&dev->wr_msg_buf[1];
590 dev->recvd_msg = 0;
591 if (!heci_write_message(dev, heci_hdr,
595 mutex_exit(&dev->device_lock);
600 while (err != -1 && !dev->recvd_msg) {
601 err = cv_reltimedwait(&dev->wait_recvd_msg, &dev->device_lock,
604 if (err == -1 && !dev->recvd_msg) {
606 mutex_exit(&dev->device_lock);
609 dev->recvd_msg = 0;
611 if ((dev->version.major_version != HBM_MAJOR_VERSION) ||
612 (dev->version.minor_version != HBM_MINOR_VERSION)) {
621 (struct hbm_host_stop_request *)&dev->wr_msg_buf[1];
627 if (!heci_write_message(dev, heci_hdr,
633 mutex_exit(&dev->device_lock);
636 mutex_exit(&dev->device_lock);
643 * @dev: Device object for our driver
647 host_enum_clients_message(struct iamt_heci_device *dev)
656 mutex_enter(&dev->device_lock);
658 heci_hdr = (struct heci_msg_hdr *)&dev->wr_msg_buf[0];
666 host_enum_req = (struct hbm_host_enum_request *)&dev->wr_msg_buf[1];
669 if (!heci_write_message(dev, heci_hdr,
673 mutex_exit(&dev->device_lock);
677 dev->recvd_msg = 0;
679 while (!dev->recvd_msg && err != -1) {
680 err = cv_reltimedwait(&dev->wait_recvd_msg, &dev->device_lock,
683 if (err == -1 && !dev->recvd_msg) {
686 mutex_exit(&dev->device_lock);
689 dev->recvd_msg = 0;
692 for (i = 0; i < sizeof (dev->heci_me_clients); i++) {
694 if ((dev->heci_me_clients[i] & (1 << j)) != 0)
695 dev->num_heci_me_clients++;
699 mutex_exit(&dev->device_lock);
707 * @dev: Device object for our driver
714 host_client_properties(struct iamt_heci_device *dev,
722 mutex_enter(&dev->device_lock);
723 heci_hdr = (struct heci_msg_hdr *)&dev->wr_msg_buf[0];
730 host_cli_req = (struct hbm_props_request *)&dev->wr_msg_buf[1];
734 if (!heci_write_message(dev, heci_hdr,
737 mutex_exit(&dev->device_lock);
741 dev->recvd_msg = 0;
744 while (!dev->recvd_msg && err != -1) {
745 err = cv_reltimedwait(&dev->wait_recvd_msg, &dev->device_lock,
748 if (err == -1 && !dev->recvd_msg) {
750 mutex_exit(&dev->device_lock);
753 dev->recvd_msg = 0;
754 mutex_exit(&dev->device_lock);
761 * @dev: Device object for our driver
766 allocate_me_clients_storage(struct iamt_heci_device *dev)
773 if (dev->num_heci_me_clients == 0)
776 mutex_enter(&dev->device_lock);
777 if (dev->me_clients) {
778 kmem_free(dev->me_clients, dev->num_heci_me_clients*
780 dev->me_clients = NULL;
782 mutex_exit(&dev->device_lock);
785 clients = kmem_zalloc(dev->num_heci_me_clients*
792 mutex_enter(&dev->device_lock);
793 dev->me_clients = clients;
794 mutex_exit(&dev->device_lock);
797 for (i = 0; i < sizeof (dev->heci_me_clients); i++) {
799 if ((dev->heci_me_clients[i] & (1 << j)) != 0) {
800 client = &dev->me_clients[num];
803 err = host_client_properties(dev, client);
805 mutex_enter(&dev->device_lock);
806 kmem_free(dev->me_clients,
807 dev->num_heci_me_clients*
809 dev->me_clients = NULL;
810 mutex_exit(&dev->device_lock);
848 * @dev: Device object for our driver
856 heci_find_me_client(struct iamt_heci_device *dev,
862 if ((dev == NULL) || (priv == NULL) || (cguid == NULL))
865 for (i = 0; i < dev->num_heci_me_clients; i++) {
867 &dev->me_clients[i].props.protocol_name,
869 priv->me_client_id = dev->me_clients[i].client_id;
873 list_add_tail(&priv->link, &dev->file_list);
883 * @dev: Device object for our driver
887 heci_check_asf_mode(struct iamt_heci_device *dev)
891 mutex_enter(&dev->device_lock);
892 dev->asf_mode = 0;
895 for (i = 0; i < dev->num_heci_me_clients; i++) {
897 &dev->me_clients[i].props.protocol_name,
899 dev->asf_mode = 1;
900 mutex_exit(&dev->device_lock);
905 mutex_exit(&dev->device_lock);
911 * @dev: Device object for our driver
918 heci_connect_me_client(struct iamt_heci_device *dev,
925 if ((dev == NULL) || (priv == NULL))
928 if (!heci_connect(dev, priv)) {
931 heci_remove_client_from_file_list(dev, priv->host_client_id);
939 err = cv_reltimedwait(&dev->wait_recvd_msg, &dev->device_lock,
943 heci_remove_client_from_file_list(dev, priv->host_client_id);
959 * @dev: Device object for our driver
962 static void host_init_wd(struct iamt_heci_device *dev)
965 mutex_enter(&dev->device_lock);
967 heci_init_file_private(&dev->wd_file_ext, NULL);
970 dev->wd_file_ext.state = HECI_FILE_DISCONNECTED;
971 dev->wd_timeout = 0;
973 if (dev->asf_mode) {
974 (void) memcpy(dev->wd_data, stop_wd_params,
978 dev->wd_timeout = AMT_WD_VALUE;
979 DBG("dev->wd_timeout=%d.\n", dev->wd_timeout);
980 (void) memcpy(dev->wd_data, start_wd_params,
982 (void) memcpy(dev->wd_data + HECI_WD_PARAMS_SIZE,
983 &dev->wd_timeout, sizeof (uint16_t));
987 (void) heci_find_me_client(dev, &dev->wd_file_ext,
991 if (HECI_FILE_CONNECTING == dev->wd_file_ext.state) {
992 if (heci_connect_me_client(dev, &dev->wd_file_ext, 15) == 1) {
993 DBG("dev->wd_timeout=%d.\n", dev->wd_timeout);
994 if (dev->wd_timeout != 0)
995 dev->wd_due_counter = 1;
997 dev->wd_due_counter = 0;
1004 mutex_exit(&dev->device_lock);
1011 * @dev: Device object for our driver
1015 host_init_iamthif(struct iamt_heci_device *dev)
1019 mutex_enter(&dev->device_lock);
1021 heci_init_file_private(&dev->iamthif_file_ext, NULL);
1022 dev->iamthif_file_ext.state = HECI_FILE_DISCONNECTED;
1025 i = heci_find_me_client(dev, &dev->iamthif_file_ext,
1027 if (dev->iamthif_file_ext.state != HECI_FILE_CONNECTING) {
1029 mutex_exit(&dev->device_lock);
1033 ASSERT(dev->me_clients[i].props.max_msg_length == IAMTHIF_MTU);
1035 if (heci_connect_me_client(dev, &dev->iamthif_file_ext, 15) == 1) {
1037 dev->iamthif_state = HECI_IAMTHIF_IDLE;
1039 mutex_exit(&dev->device_lock);
1081 * @dev: Device object for our driver
1087 heci_disconnect_host_client(struct iamt_heci_device *dev,
1095 if ((!dev) || (!file_ext))
1108 mutex_enter(&dev->device_lock);
1109 if (dev->host_buffer_is_empty) {
1110 dev->host_buffer_is_empty = 0;
1111 if (heci_disconnect(dev, file_ext)) {
1113 &dev->ctrl_rd_list.heci_cb.cb_list);
1115 mutex_exit(&dev->device_lock);
1123 &dev->ctrl_wr_list.heci_cb.cb_list);
1130 err = cv_reltimedwait(&dev->wait_recvd_msg, &dev->device_lock,
1133 mutex_exit(&dev->device_lock);
1155 mutex_enter(&dev->device_lock);
1156 heci_flush_list(&dev->ctrl_rd_list, file_ext);
1157 heci_flush_list(&dev->ctrl_wr_list, file_ext);
1158 mutex_exit(&dev->device_lock);
1168 * @dev: Device object for our driver
1173 heci_remove_client_from_file_list(struct iamt_heci_device *dev,
1178 list_for_each_entry_safe(file_pos, file_next, &dev->file_list, link,