/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 1999-2000 by Sun Microsystems, Inc. * All rights reserved. */ /* * hci1394_tlabel.h * These routines track the tlabel usage for a 1394 adapter. */ #include <sys/kmem.h> #include <sys/types.h> #include <sys/conf.h> #include <sys/ddi.h> #include <sys/sunddi.h> #include <sys/1394/ieee1394.h> #include <sys/1394/adapters/hci1394.h> /* * hci1394_tlabel_init() * Initialize the tlabel structures. These structures will be protected * by a mutex at the iblock_cookie passed in. Bad tlabels will be usable * when > reclaim_time_nS has gone by. init() returns a handle to be used * for the rest of the tlabel functions. */ void hci1394_tlabel_init(hci1394_drvinfo_t *drvinfo, hrtime_t reclaim_time_nS, hci1394_tlabel_handle_t *tlabel_handle) { hci1394_tlabel_t *tstruct; ASSERT(tlabel_handle != NULL); /* alloc space for tlabel data */ tstruct = kmem_alloc(sizeof (hci1394_tlabel_t), KM_SLEEP); /* setup handle which is returned from this function */ *tlabel_handle = tstruct; /* * Initialize tlabel structure. We start with max node set to the * maxiumum node we could have so that we make sure the arrays are * initialized correctly in hci1394_tlabel_reset(). */ tstruct->tb_drvinfo = drvinfo; tstruct->tb_reclaim_time = reclaim_time_nS; tstruct->tb_max_node = TLABEL_RANGE - 1; tstruct->tb_bcast_sent = B_FALSE; mutex_init(&tstruct->tb_mutex, NULL, MUTEX_DRIVER, drvinfo->di_iblock_cookie); /* * The mutex must be initialized before tlabel_reset() * is called. This is because tlabel_reset is also * used in normal tlabel processing (i.e. not just during * initialization) */ hci1394_tlabel_reset(tstruct); } /* * hci1394_tlabel_fini() * Frees up the space allocated in init(). Notice that a pointer to the * handle is used for the parameter. fini() will set your handle to NULL * before returning. */ void hci1394_tlabel_fini(hci1394_tlabel_handle_t *tlabel_handle) { hci1394_tlabel_t *tstruct; ASSERT(tlabel_handle != NULL); tstruct = (hci1394_tlabel_t *)*tlabel_handle; mutex_destroy(&tstruct->tb_mutex); kmem_free(tstruct, sizeof (hci1394_tlabel_t)); /* set handle to null. This helps catch bugs. */ *tlabel_handle = NULL; } /* * hci1394_tlabel_alloc() * alloc a tlabel based on the node id. If alloc fails, we are out of * tlabels for that node. See comments before set_reclaim_time() on when * bad tlabel's are free to be used again. */ int hci1394_tlabel_alloc(hci1394_tlabel_handle_t tlabel_handle, uint_t destination, hci1394_tlabel_info_t *tlabel_info) { uint_t node_number; uint_t index; uint64_t bad; uint64_t free; hrtime_t time; uint8_t last; ASSERT(tlabel_handle != NULL); ASSERT(tlabel_info != NULL); /* copy destination into tlabel_info */ tlabel_info->tbi_destination = destination; /* figure out what node we are going to */ node_number = IEEE1394_NODE_NUM(destination); mutex_enter(&tlabel_handle->tb_mutex); /* * Keep track of if we have sent out a broadcast request and what the * maximum # node we have sent to for reset processing optimization */ if (node_number == IEEE1394_BROADCAST_NODEID) { tlabel_handle->tb_bcast_sent = B_TRUE; } else if (node_number > tlabel_handle->tb_max_node) { tlabel_handle->tb_max_node = node_number; } /* setup copies so we don't take up so much space :-) */ bad = tlabel_handle->tb_bad[node_number]; free = tlabel_handle->tb_free[node_number]; time = tlabel_handle->tb_bad_timestamp[node_number]; last = tlabel_handle->tb_last[node_number]; /* * If there are any bad tlabels, see if the last bad tlabel recorded for * this nodeid is now good to use. If so, add all bad tlabels for that * node id back into the free list * * NOTE: This assumes that bad tlabels are infrequent. */ if (bad != 0) { if (gethrtime() > time) { /* add the bad tlabels back into the free list */ free |= bad; /* clear the bad list */ bad = 0; } } /* * Find a free tlabel. This will break out of the loop once it finds a * tlabel. There are a total of TLABEL_RANGE tlabels. The alloc * rotates the check so that we don't always use the same tlabel. It * stores the last tlabel used in last. */ for (index = 0; index < TLABEL_RANGE; index++) { /* if the next tlabel to check is free */ if ((free & ((uint64_t)1 << last)) != 0) { /* we are using this tlabel */ tlabel_info->tbi_tlabel = last; /* take it out of the free list */ free = free & ~((uint64_t)1 << last); /* * increment the last count so we start checking on the * next tlabel next alloc(). Note the rollover at * TLABEL_RANGE since we only have TLABEL_RANGE tlabels. */ (last)++; if (last >= TLABEL_RANGE) { last = 0; } /* Copy the copies back */ tlabel_handle->tb_bad[node_number] = bad; tlabel_handle->tb_free[node_number] = free; tlabel_handle->tb_bad_timestamp[node_number] = time; tlabel_handle->tb_last[node_number] = last; /* unlock the tlabel structure */ mutex_exit(&tlabel_handle->tb_mutex); return (DDI_SUCCESS); } /* * This tlabel is not free, lets go to the next one. Note the * rollover at TLABEL_RANGE since we only have TLABEL_RANGE * tlabels. */ (last)++; if (last >= TLABEL_RANGE) { last = 0; } } /* Copy the copies back */ tlabel_handle->tb_bad[node_number] = bad; tlabel_handle->tb_free[node_number] = free; tlabel_handle->tb_bad_timestamp[node_number] = time; tlabel_handle->tb_last[node_number] = last; mutex_exit(&tlabel_handle->tb_mutex); return (DDI_FAILURE); } /* * hci1394_tlabel_free() * free the previously alloc()'d tlabel. Once a tlabel has been free'd, it * can be used again when alloc() is called. */ void hci1394_tlabel_free(hci1394_tlabel_handle_t tlabel_handle, hci1394_tlabel_info_t *tlabel_info) { uint_t node_number; uint_t tlabel; ASSERT(tlabel_handle != NULL); ASSERT(tlabel_info != NULL); ASSERT(tlabel_info->tbi_tlabel <= TLABEL_MASK); /* figure out what node and tlabel we are using */ node_number = IEEE1394_NODE_NUM(tlabel_info->tbi_destination); tlabel = tlabel_info->tbi_tlabel; mutex_enter(&tlabel_handle->tb_mutex); /* * Put the tlabel back in the free list and NULL out the (void *) in the * lookup structure. You wouldn't expect to have to null out the lookup * structure, but we know first hand that bad HW will send invalid * tlabels which could really mess things up if you didn't :-) */ tlabel_handle->tb_lookup[node_number][tlabel] = NULL; tlabel_handle->tb_free[node_number] |= ((uint64_t)1 << tlabel); mutex_exit(&tlabel_handle->tb_mutex); } /* * hci1394_tlabel_register() * Register an opaque command with an alloc()'d tlabel. Each nodeID has it's * own tlabel list. */ void hci1394_tlabel_register(hci1394_tlabel_handle_t tlabel_handle, hci1394_tlabel_info_t *tlabel_info, void *cmd) { uint_t node_number; uint_t tlabel; ASSERT(tlabel_handle != NULL); ASSERT(tlabel_info != NULL); ASSERT(tlabel_info->tbi_tlabel <= TLABEL_MASK); /* figure out what node and tlabel we are using */ node_number = IEEE1394_NODE_NUM(tlabel_info->tbi_destination); tlabel = tlabel_info->tbi_tlabel; mutex_enter(&tlabel_handle->tb_mutex); /* enter the (void *) into the lookup table */ tlabel_handle->tb_lookup[node_number][tlabel] = cmd; mutex_exit(&tlabel_handle->tb_mutex); } /* * hci1394_tlabel_lookup() * returns (in cmd) the opaque command which was registered with the * specified tlabel from alloc(). If a tlabel was not registered, cmd ='s * NULL. */ void hci1394_tlabel_lookup(hci1394_tlabel_handle_t tlabel_handle, hci1394_tlabel_info_t *tlabel_info, void **cmd) { uint_t node_number; uint_t tlabel; ASSERT(tlabel_handle != NULL); ASSERT(tlabel_info != NULL); ASSERT(cmd != NULL); ASSERT(tlabel_info->tbi_tlabel <= TLABEL_MASK); /* figure out what node and tlabel we are using */ node_number = IEEE1394_NODE_NUM(tlabel_info->tbi_destination); tlabel = tlabel_info->tbi_tlabel; mutex_enter(&tlabel_handle->tb_mutex); /* * fetch the (void *) from the lookup table. The case where the pointer * equals NULL will be handled by the layer above. */ *cmd = tlabel_handle->tb_lookup[node_number][tlabel]; mutex_exit(&tlabel_handle->tb_mutex); } /* * hci1394_tlabel_bad() * Register the specified tlabel as bad. tlabel_lookup() will no longer * return a registered opaque command and this tlabel will not be returned * from alloc() until > reclaim_time has passed. See set_reclaim_time() for * more info. */ void hci1394_tlabel_bad(hci1394_tlabel_handle_t tlabel_handle, hci1394_tlabel_info_t *tlabel_info) { uint_t node_number; uint_t tlabel; ASSERT(tlabel_handle != NULL); ASSERT(tlabel_info != NULL); /* figure out what node and tlabel we are using */ node_number = IEEE1394_NODE_NUM(tlabel_info->tbi_destination); tlabel = tlabel_info->tbi_tlabel & TLABEL_MASK; mutex_enter(&tlabel_handle->tb_mutex); /* * Put the tlabel in the bad list and NULL out the (void *) in the * lookup structure. We may see this tlabel shortly if the device is * late in responding. We want to make sure to drop the message if we * do. Set the bad timestamp to the current time plus the reclaim time. * This is the "new" time when all of the bad tlabels for this node will * be free'd. */ tlabel_handle->tb_bad_timestamp[node_number] = gethrtime() + tlabel_handle->tb_reclaim_time; tlabel_handle->tb_bad[node_number] |= ((uint64_t)1 << tlabel); tlabel_handle->tb_lookup[node_number][tlabel] = NULL; mutex_exit(&tlabel_handle->tb_mutex); } /* * hci1394_tlabel_reset() * resets the tlabel tracking structures to an initial state where no * tlabels are outstanding and all tlabels are registered as good. This * routine should be called every bus reset. */ void hci1394_tlabel_reset(hci1394_tlabel_handle_t tlabel_handle) { int index; int index2; ASSERT(tlabel_handle != NULL); mutex_enter(&tlabel_handle->tb_mutex); /* Bus reset optimization. handle broadcast writes separately */ if (tlabel_handle->tb_bcast_sent == B_TRUE) { tlabel_handle->tb_free[IEEE1394_BROADCAST_NODEID] = (uint64_t)0xFFFFFFFFFFFFFFFF; tlabel_handle->tb_bad[IEEE1394_BROADCAST_NODEID] = (uint64_t)0; tlabel_handle->tb_bad_timestamp[IEEE1394_BROADCAST_NODEID] = (hrtime_t)0; tlabel_handle->tb_last[IEEE1394_BROADCAST_NODEID] = 0; for (index2 = 0; index2 < TLABEL_RANGE; index2++) { tlabel_handle->tb_lookup[IEEE1394_BROADCAST_NODEID ][index2] = NULL; } } /* * Mark all tlabels as free. No bad tlabels. Start the first tlabel * alloc at 0. Cleanout the lookup table. An optimization to only do * this up to the max node we have seen on the bus has been added. */ for (index = 0; index <= tlabel_handle->tb_max_node; index++) { tlabel_handle->tb_free[index] = (uint64_t)0xFFFFFFFFFFFFFFFF; tlabel_handle->tb_bad[index] = (uint64_t)0; tlabel_handle->tb_bad_timestamp[index] = (hrtime_t)0; tlabel_handle->tb_last[index] = 0; for (index2 = 0; index2 < TLABEL_RANGE; index2++) { tlabel_handle->tb_lookup[index][index2] = NULL; } } tlabel_handle->tb_max_node = 0; tlabel_handle->tb_bcast_sent = B_FALSE; mutex_exit(&tlabel_handle->tb_mutex); } /* * hci1394_tlabel_set_reclaim_time() * This function should be called if a change to the reclaim_time is * required after the initial call to init(). It is not necessary to call * this function if the reclaim time never changes. * * Currently, bad tlabels are reclaimed in tlabel_alloc(). * It looks like the following for a given node: * * if bad tlabels exist * if ((current time + reclaim time) >= last bad tlabel time) * free all bad tlabels. */ void hci1394_tlabel_set_reclaim_time(hci1394_tlabel_handle_t tlabel_handle, hrtime_t reclaim_time_nS) { ASSERT(tlabel_handle != NULL); /* * We do not need to lock the tlabel structure in this because we are * doing a single write to reclaim_time. If this changes in the future, * we may need to add calls to lock() and unlock(). */ tlabel_handle->tb_reclaim_time = reclaim_time_nS; }
