/*
* 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 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* PCMCIA Card Services
* The PCMCIA Card Services is a loadable module which
* presents the Card Services interface to client device
* drivers.
*
* Card Services uses Socket Services-like calls into the
* PCMCIA nexus driver to manipulate socket and adapter
* resources.
*
* Note that a bunch of comments are not indented correctly with the
* code that they are commenting on. This is because cstyle is
* is inflexible concerning 4-column indenting.
*/
#if defined(DEBUG)
#define CS_DEBUG
#endif
#include <sys/types.h>
#include <sys/systm.h>
#include <sys/user.h>
#include <sys/buf.h>
#include <sys/file.h>
#include <sys/uio.h>
#include <sys/conf.h>
#include <sys/stat.h>
#include <sys/autoconf.h>
#include <sys/vtoc.h>
#include <sys/dkio.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/debug.h>
#include <sys/varargs.h>
#include <sys/var.h>
#include <sys/proc.h>
#include <sys/thread.h>
#include <sys/utsname.h>
#include <sys/vtrace.h>
#include <sys/kstat.h>
#include <sys/kmem.h>
#include <sys/modctl.h>
#include <sys/kobj.h>
#include <sys/callb.h>
#include <sys/time.h>
#include <sys/pctypes.h>
#include <pcmcia/sys/cs_types.h>
#include <sys/pcmcia.h>
#include <sys/sservice.h>
#include <pcmcia/sys/cis.h>
#include <pcmcia/sys/cis_handlers.h>
#include <pcmcia/sys/cs.h>
#include <pcmcia/sys/cs_priv.h>
#include <pcmcia/sys/cs_stubs.h>
/*
* The cs_strings header file is where all of the major strings that
* Card Services uses are located.
*/
#include <pcmcia/sys/cs_strings.h>
/*
* Function declarations
*
* The main Card Services entry point
*/
int CardServices(int function, ...);
/*
* functions and globals used by Socket Services
*
* WAS: void *(*cis_parser)(int, ...) = NULL;
*/
void *(*cis_parser)(int, ...) = NULL;
csfunction_t *cs_socket_services = NULL;
/*
* event handling functions
*/
static event_t ss_to_cs_events(cs_socket_t *, event_t);
static event_t cs_cse2sbm(event_t);
static void cs_event_thread(uint32_t);
static int cs_card_insertion(cs_socket_t *, event_t);
static int cs_card_removal(cs_socket_t *);
static void cs_ss_thread(uint32_t);
void cs_ready_timeout(void *);
static int cs_card_for_client(client_t *);
static int cs_request_socket_mask(client_handle_t, request_socket_mask_t *);
static int cs_release_socket_mask(client_handle_t, release_socket_mask_t *);
static int cs_get_event_mask(client_handle_t, sockevent_t *);
static int cs_set_event_mask(client_handle_t, sockevent_t *);
static int cs_event2text(event2text_t *, int);
static int cs_read_event_status(cs_socket_t *, client_t *, event_t *,
get_ss_status_t *, int);
uint32_t cs_socket_event_softintr(caddr_t);
void cs_event_softintr_timeout(void *);
static int cs_get_status(client_handle_t, get_status_t *);
static uint32_t cs_sbm2cse(uint32_t);
static unsigned cs_merge_event_masks(cs_socket_t *, client_t *);
static int cs_set_socket_event_mask(cs_socket_t *, unsigned);
/*
* SS<->CS communication and internal socket and window handling functions
*/
static uint32_t cs_add_socket(uint32_t);
static uint32_t cs_drop_socket(uint32_t);
static cs_socket_t *cs_get_sp(uint32_t);
static cs_socket_t *cs_find_sp(uint32_t);
static cs_window_t *cs_get_wp(uint32_t);
static cs_window_t *cs_find_wp(uint32_t);
static int cs_add_windows(int, uint32_t);
static uint32_t cs_ss_init();
static void cs_set_acc_attributes(set_window_t *, uint32_t);
/*
* CIS handling functions
*/
cistpl_callout_t *cis_cistpl_std_callout;
static int cs_parse_tuple(client_handle_t, tuple_t *, cisparse_t *, cisdata_t);
static int cs_get_tuple_data(client_handle_t, tuple_t *);
static int cs_validate_cis(client_handle_t, cisinfo_t *);
static int cs_get_firstnext_tuple(client_handle_t, tuple_t *, uint32_t);
static int cs_create_cis(cs_socket_t *);
static int cs_destroy_cis(cs_socket_t *);
/*
* client handling functions
*/
unsigned cs_create_next_client_minor(unsigned, unsigned);
static client_t *cs_find_client(client_handle_t, int *);
static client_handle_t cs_create_client_handle(unsigned, client_t *);
static int cs_destroy_client_handle(client_handle_t);
static int cs_register_client(client_handle_t *, client_reg_t *);
static int cs_deregister_client(client_handle_t);
static int cs_deregister_mtd(client_handle_t);
static void cs_clear_superclient_lock(int);
static int cs_add_client_to_socket(unsigned, client_handle_t *,
client_reg_t *, int);
static int cs_get_client_info(client_handle_t, client_info_t *);
static int cs_get_firstnext_client(get_firstnext_client_t *, uint32_t);
/*
* window handling functions
*/
static int cs_request_window(client_handle_t, window_handle_t *, win_req_t *);
static int cs_release_window(window_handle_t);
static int cs_modify_window(window_handle_t, modify_win_t *);
static int cs_modify_mem_window(window_handle_t, modify_win_t *, win_req_t *,
int);
static int cs_map_mem_page(window_handle_t, map_mem_page_t *);
static int cs_find_mem_window(uint32_t, win_req_t *, uint32_t *);
static int cs_memwin_space_and_map_ok(inquire_window_t *, win_req_t *);
static int cs_valid_window_speed(inquire_window_t *, uint32_t);
static window_handle_t cs_create_window_handle(uint32_t);
static cs_window_t *cs_find_window(window_handle_t);
static int cs_find_io_win(uint32_t, iowin_char_t *, uint32_t *, uint32_t *);
/*
* IO, IRQ and configuration handling functions
*/
static int cs_request_io(client_handle_t, io_req_t *);
static int cs_release_io(client_handle_t, io_req_t *);
static int cs_allocate_io_win(uint32_t, uint32_t, uint32_t *);
static int cs_setup_io_win(uint32_t, uint32_t, baseaddru_t *,
uint32_t *, uint32_t, uint32_t);
static int cs_request_irq(client_handle_t, irq_req_t *);
static int cs_release_irq(client_handle_t, irq_req_t *);
static int cs_request_configuration(client_handle_t, config_req_t *);
static int cs_release_configuration(client_handle_t, release_config_t *);
static int cs_modify_configuration(client_handle_t, modify_config_t *);
static int cs_access_configuration_register(client_handle_t,
access_config_reg_t *);
/*
* RESET and general info functions
*/
static int cs_reset_function(client_handle_t, reset_function_t *);
static int cs_get_configuration_info(client_handle_t *,
get_configuration_info_t *);
static int cs_get_cardservices_info(client_handle_t,
get_cardservices_info_t *);
static int cs_get_physical_adapter_info(client_handle_t,
get_physical_adapter_info_t *);
/*
* general functions
*/
static uint32_t cs_get_socket(client_handle_t, uint32_t *, uint32_t *,
cs_socket_t **, client_t **);
static int cs_convert_speed(convert_speed_t *);
static int cs_convert_size(convert_size_t *);
static char *cs_error2text(int, int);
static int cs_map_log_socket(client_handle_t, map_log_socket_t *);
static int cs_convert_powerlevel(uint32_t, uint32_t, uint32_t, unsigned *);
static int cs_make_device_node(client_handle_t, make_device_node_t *);
static int cs_remove_device_node(client_handle_t, remove_device_node_t *);
static int cs_ddi_info(cs_ddi_info_t *);
static int cs_init_cis_window(cs_socket_t *, uint32_t *, acc_handle_t *,
uint32_t);
static int cs_sys_ctl(cs_sys_ctl_t *);
/*
* global variables
*/
static int cs_max_client_handles = CS_MAX_CLIENTS;
static client_t cs_socket_services_client; /* global SS client */
static client_types_t client_types[MAX_CLIENT_TYPES];
static cs_globals_t cs_globals;
int cs_reset_timeout_time = RESET_TIMEOUT_TIME;
int cs_rc1_delay = CS_RC1_DELAY;
int cs_rc2_delay = CS_RC2_DELAY;
int cs_rq_delay = CS_RQ_DELAY;
#ifdef CS_DEBUG
int cs_debug = 0;
#endif
/*
* cs_init - Initialize CS internal structures, databases, and state,
* and register with SS
*
* XXX - Need to make sure that if we fail at any point that we free
* any resources that we allocated, as well as kill any
* threads that may have been started.
*/
int
cs_init()
{
client_types_t *ct;
client_t *client;
/*
* Initialize the CS global structure
*/
bzero((caddr_t)&cs_globals, sizeof (cs_globals_t));
mutex_init(&cs_globals.global_lock, NULL, MUTEX_DRIVER, NULL);
mutex_init(&cs_globals.window_lock, NULL, MUTEX_DRIVER, NULL);
cs_globals.init_state = GLOBAL_INIT_STATE_MUTEX;
/*
* Set up the global Socket Services client, since we're going to
* need it once we register with SS.
*/
client = &cs_socket_services_client;
bzero((caddr_t)client, sizeof (client_t));
client->client_handle = CS_SS_CLIENT_HANDLE;
client->flags |= (INFO_SOCKET_SERVICES | CLIENT_CARD_INSERTED);
/*
* Setup the client type structure - this is used in the socket event
* thread to sequence the delivery of events to all clients on
* the socket.
*/
ct = &client_types[0];
ct->type = INFO_IO_CLIENT;
ct->order = CLIENT_EVENTS_LIFO;
ct->next = &client_types[1];
ct = ct->next;
ct->type = INFO_MTD_CLIENT;
ct->order = CLIENT_EVENTS_FIFO;
ct->next = &client_types[2];
ct = ct->next;
ct->type = INFO_MEM_CLIENT;
ct->order = CLIENT_EVENTS_FIFO;
ct->next = NULL;
return (CS_SUCCESS);
}
/*
* cs_deinit - Deinitialize CS
*
* This function cleans up any allocated resources, stops any running threads,
* destroys any mutexes and condition variables, and finally frees up the
* global socket and window structure arrays.
*/
int
cs_deinit()
{
cs_socket_t *sp;
int sn, have_clients = 0, have_sockets = 0;
cs_register_cardservices_t rcs;
#if defined(CS_DEBUG)
if (cs_debug > 1)
cmn_err(CE_CONT, "CS: cs_deinit\n");
#endif
/*
* Deregister with the Card Services kernel stubs module
*/
rcs.magic = CS_STUBS_MAGIC;
rcs.function = CS_ENTRY_DEREGISTER;
(void) csx_register_cardservices(&rcs);
/*
* Set the GLOBAL_INIT_STATE_NO_CLIENTS flag to prevent new clients
* from registering.
*/
mutex_enter(&cs_globals.global_lock);
cs_globals.init_state |= GLOBAL_INIT_STATE_NO_CLIENTS;
mutex_exit(&cs_globals.global_lock);
/*
* Go through each socket and make sure that there are no clients
* on any of the sockets. If there are, we can't deinit until
* all the clients for every socket are gone.
*/
for (sn = 0; sn < cs_globals.max_socket_num; sn++) {
if ((sp = cs_get_sp(sn)) != NULL) {
have_sockets++;
if (sp->client_list) {
cmn_err(CE_CONT, "cs_deinit: cannot unload module since "
"socket %d has registered clients\n", sn);
have_clients++;
}
}
}
/*
* We don't allow unload if there are any clients registered
* or if there are still sockets that are active.
*/
if ((have_clients > 0) || (have_sockets > 0))
return (BAD_FUNCTION);
#ifdef XXX
/*
* If one or more sockets have been added, we need to deallocate
* the resources associated with those sockets.
*/
/*
* First, tell Socket Services that we're leaving, so that we
* don't get any more event callbacks.
*/
SocketServices(CSUnregister);
/*
* Wait for the soft int timer to tell us it's done
*/
mutex_enter(&cs_globals.global_lock);
cs_globals.init_state |= GLOBAL_INIT_STATE_UNLOADING;
mutex_exit(&cs_globals.global_lock);
UNTIMEOUT(cs_globals.sotfint_tmo);
/*
* Remove the soft interrupt handler.
*/
mutex_enter(&cs_globals.global_lock);
if (cs_globals.init_state & GLOBAL_INIT_STATE_SOFTINTR) {
ddi_remove_softintr(cs_globals.softint_id);
cs_globals.init_state &= ~GLOBAL_INIT_STATE_SOFTINTR;
}
mutex_exit(&cs_globals.global_lock);
return (CS_SUCCESS);
/*
* Go through each socket and free any resource allocated to that
* socket, as well as any mutexs and condition variables.
*/
for (sn = 0; sn < cs_globals.max_socket_num; sn++) {
set_socket_t set_socket;
if ((sp = cs_get_sp(sn)) != NULL) {
/*
* untimeout possible pending ready/busy timer
*/
UNTIMEOUT(sp->rdybsy_tmo_id);
if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
mutex_enter(&sp->lock);
sp->flags = SOCKET_UNLOAD_MODULE;
if (sp->init_state & SOCKET_INIT_STATE_SOFTINTR)
sp->init_state &= ~SOCKET_INIT_STATE_SOFTINTR;
if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
mutex_exit(&sp->lock);
if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
mutex_enter(&sp->cis_lock);
(void) cs_destroy_cis(sp);
if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
mutex_exit(&sp->cis_lock);
/*
* Tell the event handler thread that we want it to exit, then
* wait around until it tells us that it has exited.
*/
if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
mutex_enter(&sp->client_lock);
if (sp->init_state & SOCKET_INIT_STATE_THREAD) {
sp->thread_state = SOCKET_THREAD_EXIT;
cv_broadcast(&sp->thread_cv);
cv_wait(&sp->caller_cv, &sp->client_lock);
}
if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
mutex_exit(&sp->client_lock);
/*
* Tell the SS work thread that we want it to exit, then
* wait around until it tells us that it has exited.
*/
if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
mutex_enter(&sp->ss_thread_lock);
if (sp->init_state & SOCKET_INIT_STATE_SS_THREAD) {
sp->ss_thread_state = SOCKET_THREAD_EXIT;
cv_broadcast(&sp->ss_thread_cv);
cv_wait(&sp->ss_caller_cv, &sp->ss_thread_lock);
}
if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
mutex_exit(&sp->ss_thread_lock);
/*
* Free the mutexii and condition variables that we used.
*/
if (sp->init_state & SOCKET_INIT_STATE_MUTEX) {
mutex_destroy(&sp->lock);
mutex_destroy(&sp->client_lock);
mutex_destroy(&sp->cis_lock);
mutex_destroy(&sp->ss_thread_lock);
}
if (sp->init_state & SOCKET_INIT_STATE_CV) {
cv_destroy(&sp->thread_cv);
cv_destroy(&sp->caller_cv);
cv_destroy(&sp->reset_cv);
cv_destroy(&sp->ss_thread_cv);
cv_destroy(&sp->ss_caller_cv);
}
#ifdef USE_IOMMAP_WINDOW
/*
* Free the memory-mapped IO structure if we allocated one.
*/
if (sp->io_mmap_window)
kmem_free(sp->io_mmap_window, sizeof (io_mmap_window_t));
#endif /* USE_IOMMAP_WINDOW */
/*
* Return the socket to memory-only mode and turn off the
* socket power.
*/
sp->event_mask = 0;
set_socket.socket = sp->socket_num;
set_socket.SCIntMask = 0;
set_socket.IREQRouting = 0;
set_socket.IFType = IF_MEMORY;
set_socket.CtlInd = 0; /* turn off controls and indicators */
set_socket.State = (unsigned)~0; /* clear latched state bits */
(void) cs_convert_powerlevel(sp->socket_num, 0, VCC,
&set_socket.VccLevel);
(void) cs_convert_powerlevel(sp->socket_num, 0, VPP1,
&set_socket.Vpp1Level);
(void) cs_convert_powerlevel(sp->socket_num, 0, VPP2,
&set_socket.Vpp2Level);
/*
* If we fail this call, there's not much we can do, so
* just continue with the resource deallocation.
*/
if ((ret =
SocketServices(SS_SetSocket, &set_socket)) != SUCCESS) {
cmn_err(CE_CONT,
"cs_deinit: socket %d SS_SetSocket failure %d\n",
sp->socket_num, ret);
}
} /* cs_get_sp */
} /* for (sn) */
#endif /* XXX */
/*
* Destroy the global mutexii.
*/
mutex_destroy(&cs_globals.global_lock);
mutex_destroy(&cs_globals.window_lock);
#ifdef XXX
/*
* Free the global "super-client" structure
*/
if (cs_globals.sclient_list)
kmem_free(cs_globals.sclient_list,
(cs_globals.num_sockets * sizeof (struct sclient_list_t)));
cs_globals.sclient_list = NULL;
#endif /* XXX */
return (CS_SUCCESS);
}
/*
* ==== drip, drip, drip - the Card Services waterfall :-) ====
*/
/*
* CardServices - general Card Services entry point for CS clients
* and Socket Services; the address of this
* function is handed to SS via the CSRegister
* SS call
*/
int
CardServices(int function, ...)
{
va_list arglist;
int retcode = CS_UNSUPPORTED_FUNCTION;
cs_socket_t *socp;
uint32_t *offp;
acc_handle_t *hp;
client_handle_t ch;
client_handle_t *chp;
window_handle_t wh;
window_handle_t *whp;
tuple_t *tuple;
cisparse_t *cisparse;
#ifdef CS_DEBUG
if (cs_debug > 127) {
cmn_err(CE_CONT, "CardServices: called for function %s (0x%x)\n",
cs_error2text(function, CSFUN2TEXT_FUNCTION),
function);
}
#endif
va_start(arglist, function);
/*
* Here's the Card Services waterfall
*/
switch (function) {
/*
* We got here as a result of the CIS module calling us
* in response to cs_ss_init() calling the CIS module
* at CIS_PARSER(CISP_CIS_SETUP, ...)
*/
case CISRegister: {
cisregister_t *cisr;
cisr = va_arg(arglist, cisregister_t *);
if (cisr->cis_magic != PCCS_MAGIC ||
cisr->cis_version != PCCS_VERSION) {
cmn_err(CE_WARN,
"CS: CISRegister (%lx, %lx, %lx, %lx) *ERROR*",
(long)cisr->cis_magic,
(long)cisr->cis_version,
(long)cisr->cis_parser,
(long)cisr->cistpl_std_callout);
retcode = CS_BAD_ARGS;
} else {
/*
* Replace the CIS Parser entry point if
* necessary.
*/
if (cisr->cis_parser != NULL)
cis_parser = cisr->cis_parser;
cis_cistpl_std_callout = cisr->cistpl_std_callout;
retcode = CS_SUCCESS;
}
}
break;
case CISUnregister: /* XXX - should we do some more checking */
/* XXX - need to protect this by a mutex */
cis_parser = NULL;
cis_cistpl_std_callout = NULL;
retcode = CS_SUCCESS;
break;
case InitCISWindow:
socp = va_arg(arglist, cs_socket_t *);
offp = va_arg(arglist, uint32_t *);
hp = va_arg(arglist, acc_handle_t *);
retcode = cs_init_cis_window(socp, offp, hp,
va_arg(arglist, uint32_t));
break;
case RegisterClient:
chp = va_arg(arglist, client_handle_t *),
retcode = cs_register_client(chp,
va_arg(arglist, client_reg_t *));
break;
case DeregisterClient:
retcode = cs_deregister_client(
va_arg(arglist, client_handle_t));
break;
case GetStatus:
ch = va_arg(arglist, client_handle_t);
retcode = cs_get_status(ch,
va_arg(arglist, get_status_t *));
break;
case ResetFunction:
ch = va_arg(arglist, client_handle_t);
retcode = cs_reset_function(ch,
va_arg(arglist, reset_function_t *));
break;
case SetEventMask:
ch = va_arg(arglist, client_handle_t);
retcode = cs_set_event_mask(ch,
va_arg(arglist, sockevent_t *));
break;
case GetEventMask:
ch = va_arg(arglist, client_handle_t);
retcode = cs_get_event_mask(ch,
va_arg(arglist, sockevent_t *));
break;
case RequestIO:
ch = va_arg(arglist, client_handle_t);
retcode = cs_request_io(ch,
va_arg(arglist, io_req_t *));
break;
case ReleaseIO:
ch = va_arg(arglist, client_handle_t);
retcode = cs_release_io(ch,
va_arg(arglist, io_req_t *));
break;
case RequestIRQ:
ch = va_arg(arglist, client_handle_t);
retcode = cs_request_irq(ch,
va_arg(arglist, irq_req_t *));
break;
case ReleaseIRQ:
ch = va_arg(arglist, client_handle_t);
retcode = cs_release_irq(ch,
va_arg(arglist, irq_req_t *));
break;
case RequestWindow:
ch = va_arg(arglist, client_handle_t);
whp = va_arg(arglist, window_handle_t *);
retcode = cs_request_window(ch, whp,
va_arg(arglist, win_req_t *));
break;
case ReleaseWindow:
retcode = cs_release_window(
va_arg(arglist, window_handle_t));
break;
case ModifyWindow:
wh = va_arg(arglist, window_handle_t);
retcode = cs_modify_window(wh,
va_arg(arglist, modify_win_t *));
break;
case MapMemPage:
wh = va_arg(arglist, window_handle_t);
retcode = cs_map_mem_page(wh,
va_arg(arglist, map_mem_page_t *));
break;
case RequestSocketMask:
ch = va_arg(arglist, client_handle_t);
retcode = cs_request_socket_mask(ch,
va_arg(arglist, request_socket_mask_t *));
break;
case ReleaseSocketMask:
ch = va_arg(arglist, client_handle_t);
retcode = cs_release_socket_mask(ch,
va_arg(arglist, release_socket_mask_t *));
break;
case RequestConfiguration:
ch = va_arg(arglist, client_handle_t);
retcode = cs_request_configuration(ch,
va_arg(arglist, config_req_t *));
break;
case GetPhysicalAdapterInfo:
ch = va_arg(arglist, client_handle_t);
retcode = cs_get_physical_adapter_info(ch,
va_arg(arglist, get_physical_adapter_info_t *));
break;
case GetCardServicesInfo:
ch = va_arg(arglist, client_handle_t);
retcode = cs_get_cardservices_info(ch,
va_arg(arglist, get_cardservices_info_t *));
break;
case GetConfigurationInfo:
chp = va_arg(arglist, client_handle_t *);
retcode = cs_get_configuration_info(chp,
va_arg(arglist, get_configuration_info_t *));
break;
case ModifyConfiguration:
ch = va_arg(arglist, client_handle_t);
retcode = cs_modify_configuration(ch,
va_arg(arglist, modify_config_t *));
break;
case AccessConfigurationRegister:
ch = va_arg(arglist, client_handle_t);
retcode = cs_access_configuration_register(ch,
va_arg(arglist, access_config_reg_t *));
break;
case ReleaseConfiguration:
ch = va_arg(arglist, client_handle_t);
retcode = cs_release_configuration(ch,
va_arg(arglist, release_config_t *));
break;
case OpenMemory:
cmn_err(CE_CONT, "CS: OpenMemory\n");
break;
case ReadMemory:
cmn_err(CE_CONT, "CS: ReadMemory\n");
break;
case WriteMemory:
cmn_err(CE_CONT, "CS: WriteMemory\n");
break;
case CopyMemory:
cmn_err(CE_CONT, "CS: CopyMemory\n");
break;
case RegisterEraseQueue:
cmn_err(CE_CONT, "CS: RegisterEraseQueue\n");
break;
case CheckEraseQueue:
cmn_err(CE_CONT, "CS: CheckEraseQueue\n");
break;
case DeregisterEraseQueue:
cmn_err(CE_CONT, "CS: DeregisterEraseQueue\n");
break;
case CloseMemory:
cmn_err(CE_CONT, "CS: CloseMemory\n");
break;
case GetFirstRegion:
cmn_err(CE_CONT, "CS: GetFirstRegion\n");
break;
case GetNextRegion:
cmn_err(CE_CONT, "CS: GetNextRegion\n");
break;
case GetFirstPartition:
cmn_err(CE_CONT, "CS: GetFirstPartition\n");
break;
case GetNextPartition:
cmn_err(CE_CONT, "CS: GetNextPartition\n");
break;
case ReturnSSEntry:
cmn_err(CE_CONT, "CS: ReturnSSEntry\n");
break;
case MapLogSocket:
ch = va_arg(arglist, client_handle_t);
retcode = cs_map_log_socket(ch,
va_arg(arglist, map_log_socket_t *));
break;
case MapPhySocket:
cmn_err(CE_CONT, "CS: MapPhySocket\n");
break;
case MapLogWindow:
cmn_err(CE_CONT, "CS: MapLogWindow\n");
break;
case MapPhyWindow:
cmn_err(CE_CONT, "CS: MapPhyWindow\n");
break;
case RegisterMTD:
cmn_err(CE_CONT, "CS: RegisterMTD\n");
break;
case RegisterTimer:
cmn_err(CE_CONT, "CS: RegisterTimer\n");
break;
case SetRegion:
cmn_err(CE_CONT, "CS: SetRegion\n");
break;
case RequestExclusive:
cmn_err(CE_CONT, "CS: RequestExclusive\n");
break;
case ReleaseExclusive:
cmn_err(CE_CONT, "CS: ReleaseExclusive\n");
break;
case GetFirstClient:
retcode = cs_get_firstnext_client(
va_arg(arglist, get_firstnext_client_t *),
CS_GET_FIRST_FLAG);
break;
case GetNextClient:
retcode = cs_get_firstnext_client(
va_arg(arglist, get_firstnext_client_t *),
CS_GET_NEXT_FLAG);
break;
case GetClientInfo:
ch = va_arg(arglist, client_handle_t);
retcode = cs_get_client_info(ch,
va_arg(arglist, client_info_t *));
break;
case AddSocketServices:
cmn_err(CE_CONT, "CS: AddSocketServices\n");
break;
case ReplaceSocketServices:
cmn_err(CE_CONT, "CS: ReplaceSocketServices\n");
break;
case VendorSpecific:
cmn_err(CE_CONT, "CS: VendorSpecific\n");
break;
case AdjustResourceInfo:
cmn_err(CE_CONT, "CS: AdjustResourceInfo\n");
break;
case ValidateCIS:
ch = va_arg(arglist, client_handle_t);
retcode = cs_validate_cis(ch,
va_arg(arglist, cisinfo_t *));
break;
case GetFirstTuple:
ch = va_arg(arglist, client_handle_t);
retcode = cs_get_firstnext_tuple(ch,
va_arg(arglist, tuple_t *),
CS_GET_FIRST_FLAG);
break;
case GetNextTuple:
ch = va_arg(arglist, client_handle_t);
retcode = cs_get_firstnext_tuple(ch,
va_arg(arglist, tuple_t *),
CS_GET_NEXT_FLAG);
break;
case GetTupleData:
ch = va_arg(arglist, client_handle_t);
retcode = cs_get_tuple_data(ch,
va_arg(arglist, tuple_t *));
break;
case ParseTuple:
ch = va_arg(arglist, client_handle_t);
tuple = va_arg(arglist, tuple_t *);
cisparse = va_arg(arglist, cisparse_t *);
retcode = cs_parse_tuple(ch, tuple, cisparse,
va_arg(arglist, uint_t));
break;
case MakeDeviceNode:
ch = va_arg(arglist, client_handle_t);
retcode = cs_make_device_node(ch,
va_arg(arglist, make_device_node_t *));
break;
case RemoveDeviceNode:
ch = va_arg(arglist, client_handle_t);
retcode = cs_remove_device_node(ch,
va_arg(arglist, remove_device_node_t *));
break;
case ConvertSpeed:
retcode = cs_convert_speed(
va_arg(arglist, convert_speed_t *));
break;
case ConvertSize:
retcode = cs_convert_size(
va_arg(arglist, convert_size_t *));
break;
case Event2Text:
retcode = cs_event2text(
va_arg(arglist, event2text_t *), 1);
break;
case Error2Text: {
error2text_t *cft;
cft = va_arg(arglist, error2text_t *);
(void) strcpy(cft->text,
cs_error2text(cft->item, CSFUN2TEXT_RETURN));
retcode = CS_SUCCESS;
}
break;
case CS_DDI_Info:
retcode = cs_ddi_info(va_arg(arglist, cs_ddi_info_t *));
break;
case CS_Sys_Ctl:
retcode = cs_sys_ctl(va_arg(arglist, cs_sys_ctl_t *));
break;
default:
cmn_err(CE_CONT, "CS: {unknown function %d}\n", function);
break;
} /* switch(function) */
va_end(arglist);
#ifdef CS_DEBUG
if (cs_debug > 127) {
cmn_err(CE_CONT, "CardServices: returning %s (0x%x)\n",
cs_error2text(retcode, CSFUN2TEXT_RETURN),
retcode);
}
#endif
return (retcode);
}
/*
* ==== tuple and CIS handling section ====
*/
/*
* cs_parse_tuple - This function supports the CS ParseTuple function call.
*
* returns: CS_SUCCESS - if tuple parsed sucessfully
* CS_NO_CARD - if no card in socket
* CS_BAD_ARGS - if passed CIS list pointer is NULL
* CS_UNKNOWN_TUPLE - if unknown tuple passed to CIS parser
* CS_BAD_CIS - if generic parser error
* CS_NO_CIS - if no CIS for card/function
*
* See notes for the cs_get_firstnext_tuple function.
*/
static int
cs_parse_tuple(client_handle_t client_handle, tuple_t *tuple,
cisparse_t *cisparse, cisdata_t cisdata)
{
cs_socket_t *sp;
client_t *client;
uint32_t fn;
int ret;
if ((ret = cs_get_socket(client_handle, &tuple->Socket,
&fn, &sp, &client)) != CS_SUCCESS)
return (ret);
/*
* If there's no card in the socket or the card in the socket is not
* for this client, then return an error.
*/
if (!(client->flags & CLIENT_CARD_INSERTED))
return (CS_NO_CARD);
/*
* Sanity check to be sure that we've got a non-NULL CIS list
* pointer.
*/
if (!(tuple->CISOffset))
return (CS_BAD_ARGS);
mutex_enter(&sp->cis_lock);
/*
* Check to see if there is a valid CIS for this function.
* There is an implicit assumption here that if this
* is a multi-function CIS and the specified function
* number is not CS_GLOBAL_CIS that in order for there
* to be a valid function-specific CIS, there also must
* be a valid global CIS. This means that we don't need
* to know whether this tuple came from the global CIS
* or from the function-specific CIS.
*/
if ((sp->cis_flags & CW_VALID_CIS) &&
(sp->cis[fn].flags & CW_VALID_CIS)) {
ret = (int)(uintptr_t)CIS_PARSER(CISP_CIS_PARSE_TUPLE,
cis_cistpl_std_callout,
tuple->CISOffset,
(tuple->Attributes & TUPLE_RETURN_NAME)?
HANDTPL_RETURN_NAME:
HANDTPL_PARSE_LTUPLE,
cisparse, cisdata);
mutex_exit(&sp->cis_lock);
if (ret == CISTPLF_UNKNOWN)
return (CS_UNKNOWN_TUPLE);
if (ret != CISTPLF_NOERROR)
return (CS_BAD_CIS);
ret = CS_SUCCESS;
} else {
mutex_exit(&sp->cis_lock);
ret = CS_NO_CIS;
} /* if (CW_VALID_CIS) */
return (ret);
}
/*
* cs_get_firstnext_tuple - returns the first/next tuple of the specified type
* this is to support the GetFirstTuple and
* GetNextTuple function call
*
* flags - one of:
* CS_GET_FIRST_FLAG causes function to support GetFirstTuple
* CS_GET_NEXT_FLAG causes function to support GetNextTuple
*
* tuple_t->Attributes flags:
* TUPLE_RETURN_LINK - XXX Not implemented, see notes below.
* TUPLE_RETURN_IGNORED_TUPLES - return tuples with
* CISTPLF_IGNORE_TUPLE set in the
* cistpl_t->flags member.
*
* Notes for regular PC card driver callers:
*
* On a single-function card, the caller will get back all the tuples in
* the CIS.
*
* On a multi-function card, the caller will get the tuples from the
* global CIS followed by the tuples in the function-specific CIS. The
* caller will not get any tuples from a function-specific CIS that
* does not belong to the caller's function.
*
* Notes for Socket Services, the "super-client" or CSI driver callers:
*
* On a single-function card, the operation is the same as for regular
* PC card driver callers with the addition that if the function number
* is set to CS_GLOBAL_CIS this function will return CS_NO_CIS.
*
* On a multi-function card, the operation is the same as for regular
* PC card driver callers with the addition that if the function number
* is set to CS_GLOBAL_CIS the caller will only get tuples from the
* global CIS. If a particular function nubmer does not exist, this
* function will return CS_NO_CIS for that function.
*
* General notes:
*
* On both a single-function card and a multi-function card, if the tuple
* comes from the global CIS chain, the CISTPLF_GLOBAL_CIS flag will be
* set in the tuple_t->flags member.
*
* On a multi-function card, if the tuple comes from the function-specific
* CIS chain, the CISTPLF_MF_CIS flag will be set in the tuple_t->flags
* member.
*
* For other flags that are set in the tuple_t->flags member, see the
* comments for the cis_list_lcreate function in the cis.c file.
*
* The CIS parser may not include all the tuples that are in the CIS in
* the private CIS list that it creates and maintains. See the CIS
* parser documentation for a list of tuples that the parser does not
* include in the list.
*
* If a tuple has the CISTPLF_IGNORE_TUPLE flag set and the flags
* parameter CIS_GET_LTUPLE_IGNORE is not set, that tuple will not
* be returned to the caller. Instead, the next tuple that matches
* the calling criteria will be returned (or NULL if no other tuples
* match the calling criteria). If CIS_GET_LTUPLE_IGNORE is set in
* the flags paramter, tuples in the CIS list that match the calling
* criteria will be returned.
*
* XXX The PC Card 95 Standard says that if the TUPLE_RETURN_LINK flag in
* the tuple_t->Attributes member is not set, then we don't return
* any of the link tuples. This function ignores this flag and always
* returns link tuples.
*
* Return codes:
* CS_SUCCESS - if tuple sucessfully found and returned
* CS_NO_CARD - if no card inserted
* CS_NO_CIS - if no CIS for the specified card/function
* CS_NO_MORE_ITEMS - if tuple not found or no more tuples
* to return
*
* See notes for cs_get_socket for a description of valid client, socket
* and function number combinations.
*/
static int
cs_get_firstnext_tuple(client_handle_t client_handle,
tuple_t *tuple, uint32_t flags)
{
cs_socket_t *sp;
client_t *client;
uint32_t fn;
int ret;
if ((ret = cs_get_socket(client_handle, &tuple->Socket, &fn,
&sp, &client)) != CS_SUCCESS)
return (ret);
/*
* If there's no card in the socket or the card in the socket is not
* for this client, then return an error.
*/
if (!(client->flags & CLIENT_CARD_INSERTED))
return (CS_NO_CARD);
mutex_enter(&sp->cis_lock);
/*
* If there's no CIS on this card or no CIS for the specified
* function, then we can't do much.
*/
if ((!(sp->cis_flags & CW_VALID_CIS)) ||
(!(sp->cis[fn].flags & CW_VALID_CIS))) {
mutex_exit(&sp->cis_lock);
return (CS_NO_CIS);
}
/*
* This will set the CIS_GET_LTUPLE_IGNORE flag if the
* TUPLE_RETURN_IGNORED_TUPLES flag is set. The
* assumption here is that the CIS_GET_LTUPLE_IGNORE
* flag and the TUPLE_RETURN_IGNORED_TUPLES flag
* shares the same bit position. If this ever changes,
* we'll ahve to re-work this section of code.
*/
if (tuple->Attributes & TUPLE_RETURN_IGNORED_TUPLES)
flags |= CIS_GET_LTUPLE_IGNORE;
/*
* Are we GetFirstTuple or GetNextTuple?
*/
if ((flags & CIS_GET_LTUPLE_OPMASK) & CS_GET_FIRST_FLAG) {
/*
* Initialize the tuple structure; we need this information when
* we have to process a GetNextTuple or ParseTuple call.
* If this card has a multi-function CIS, then we always start out
* delivering tuples from the global CIS chain. If this card does
* not have a multi-function CIS, then the function 0 CIS chain
* will contain the complete CIS list.
* If this is a multi-function card, then use the GET_FIRST_LTUPLE
* macro to return the first tuple in the CIS list - we do this
* since we don't want to return tuples with CISTPLF_IGNORE_TUPLE
* set unless CIS_GET_LTUPLE_IGNORE is set in the flags parameter.
* Note that we don't have to cross over into the fucntion-specific
* CIS chain if GET_FIRST_LTUPLE returns NULL, since a MF CIS will
* always have at least a CISTPL_LONGLINK_MFC tuple in the global
* CIS chain - the test for NULL is just a sanity check.
*/
if (sp->cis_flags & CW_MULTI_FUNCTION_CIS) {
if ((tuple->CISOffset =
GET_FIRST_LTUPLE(sp->cis[CS_GLOBAL_CIS].cis,
flags)) == NULL) {
mutex_exit(&sp->cis_lock);
return (CS_NO_MORE_ITEMS);
} /* GET_FIRST_LTUPLE */
} else {
tuple->CISOffset = sp->cis[0].cis;
} /* CW_MULTI_FUNCTION_CIS */
} else {
cistpl_t *tp;
/*
* Check to be sure that we have a non-NULL tuple list pointer.
* This is necessary in the case where the caller calls us
* with get next tuple requests but we don't have any more
* tuples to give back.
*/
if (tuple->CISOffset == NULL) {
mutex_exit(&sp->cis_lock);
return (CS_NO_MORE_ITEMS);
}
/*
* Point to the next tuple in the list. If we're searching for
* a particular tuple, FIND_LTUPLE_FWD will find it.
*
* If there are no more tuples in the chain that we're looking
* at, then if we're looking at the global portion of a
* multi-function CIS, switch to the function-specific list
* and start looking there.
*/
if ((tp = GET_NEXT_TUPLE(tuple->CISOffset, flags)) == NULL) {
if (sp->cis_flags & CW_MULTI_FUNCTION_CIS) {
if ((tuple->CISOffset->flags & CISTPLF_GLOBAL_CIS) &&
(fn != CS_GLOBAL_CIS)) {
tp = GET_FIRST_LTUPLE(sp->cis[fn].cis, flags);
} /* CISTPLF_GLOBAL_CIS */
} /* CW_MULTI_FUNCTION_CIS */
} /* GET_NEXT_TUPLE */
/*
* If there are no more tuples in the chain, then return.
*/
if ((tuple->CISOffset = tp) == NULL) {
mutex_exit(&sp->cis_lock);
return (CS_NO_MORE_ITEMS);
}
} /* CS_GET_FIRST_FLAG */
/*
* Check if we want to get the first of a particular type of tuple
* or just the first tuple in the chain.
* If there are no more tuples of the type we're searching for in
* the chain that we're looking at, then if we're looking at
* the global portion of a multi-function CIS, switch to the
* function-specific list and start looking there.
*/
if (tuple->DesiredTuple != RETURN_FIRST_TUPLE) {
cistpl_t *tp;
if ((tp = FIND_LTUPLE_FWD(tuple->CISOffset,
tuple->DesiredTuple, flags)) == NULL) {
if (sp->cis_flags & CW_MULTI_FUNCTION_CIS) {
if ((tuple->CISOffset->flags & CISTPLF_GLOBAL_CIS) &&
(fn != CS_GLOBAL_CIS)) {
tp = FIND_FIRST_LTUPLE(sp->cis[fn].cis,
tuple->DesiredTuple, flags);
} /* CISTPLF_GLOBAL_CIS */
} /* CW_MULTI_FUNCTION_CIS */
} /* FIND_LTUPLE_FWD */
/*
* If there are no more tuples in the chain, then return.
*/
if ((tuple->CISOffset = tp) == NULL) {
mutex_exit(&sp->cis_lock);
return (CS_NO_MORE_ITEMS);
}
} /* !RETURN_FIRST_TUPLE */
/*
* We've got a tuple, now fill out the rest of the tuple_t
* structure. Callers can use the flags member to
* determine whether or not the tuple data was copied
* to the linked list or if it's still on the card.
*/
tuple->Flags = tuple->CISOffset->flags;
tuple->TupleCode = tuple->CISOffset->type;
tuple->TupleLink = tuple->CISOffset->len;
tuple->TupleDataLen = tuple->CISOffset->len;
mutex_exit(&sp->cis_lock);
return (CS_SUCCESS);
}
/*
* cs_get_tuple_data - get the data portion of a tuple; this is to
* support the GetTupleData function call.
*
* Note that if the data body of a tuple was not read from the CIS,
* then this function will return CS_NO_MORE_ITEMS.
*
* For flags that are set in the tuple_t->flags member, see the
* comments for the cis_list_lcreate function in the cis.c file.
* These flags are copied into the tuple_t->flags member by the
* cs_get_firstnext_tuple function call.
*
* See notes for the cs_get_firstnext_tuple function.
*/
static int
cs_get_tuple_data(client_handle_t client_handle, tuple_t *tuple)
{
cs_socket_t *sp;
client_t *client;
int ret, nbytes;
uint32_t fn, flags;
cisdata_t *tsd, *tdd;
uint32_t newoffset;
acc_handle_t cis_handle;
if ((ret = cs_get_socket(client_handle, &tuple->Socket, &fn,
&sp, &client)) != CS_SUCCESS)
return (ret);
/*
* If there's no card in the socket or the card in the socket is not
* for this client, then return an error.
*/
if (!(client->flags & CLIENT_CARD_INSERTED))
return (CS_NO_CARD);
mutex_enter(&sp->cis_lock);
if ((sp->cis_flags & CW_VALID_CIS) &&
(sp->cis[fn].flags & CW_VALID_CIS)) {
/*
* Check to be sure that we have a non-NULL pointer to
* a CIS list.
*/
if (!(tuple->CISOffset)) {
mutex_exit(&sp->cis_lock);
return (CS_NO_MORE_ITEMS);
}
/*
* Since the tuple data buffer that the caller calls us with
* is preallocated in the tuple_t structure, we ignore any
* TupleDataMax value that the caller has setup and use the
* actual size of the tuple data buffer in the structure.
*/
tuple->TupleDataMax = sizeof (tuple->TupleData);
/*
* Make sure the requested offset is not past the end of the
* tuple data body nor past the end of the user-supplied
* buffer.
*/
if ((int)tuple->TupleOffset >= min((int)tuple->TupleLink,
(int)tuple->TupleDataMax)) {
mutex_exit(&sp->cis_lock);
return (CS_NO_MORE_ITEMS);
}
tuple->TupleDataLen = tuple->TupleLink;
if ((nbytes = min((int)tuple->TupleDataMax -
(int)tuple->TupleOffset,
(int)tuple->TupleDataLen -
(int)tuple->TupleOffset)) < 1) {
mutex_exit(&sp->cis_lock);
return (CS_BAD_ARGS);
}
/*
* The tuple data destination is always the tuple_t->TupleData
* buffer in the tuple_t structure no matter where we read the
* tuple data from.
*/
tdd = tuple->TupleData;
bzero((caddr_t)tdd, sizeof (tuple->TupleData));
/*
* Do we have a copy of the tuple data? If not, we have to
* get a pointer to the CIS and read the tuple data from the
* card itself.
*/
switch (tuple->CISOffset->flags & CISTPLF_SPACE_MASK) {
case CISTPLF_LM_SPACE:
tsd = (tuple->CISOffset->data +
(unsigned)tuple->TupleOffset);
while (nbytes--)
*tdd++ = *tsd++;
break;
case CISTPLF_AM_SPACE:
case CISTPLF_CM_SPACE:
newoffset = tuple->CISOffset->offset;
/*
* Setup the proper space flags as well as setup the
* address offset to point to the start of the tuple
* data area; we need to do the latter since the
* cis_store_cis_addr function in cis.c sets up the
* tuple->CISOffset->offset offset to point to the
* start of the tuple.
*/
if (tuple->CISOffset->flags & CISTPLF_AM_SPACE) {
flags = CISTPLF_AM_SPACE;
newoffset += ((tuple->TupleOffset * 2) + 4);
} else {
flags = CISTPLF_CM_SPACE;
newoffset += (tuple->TupleOffset + 2);
}
if (cs_init_cis_window(sp, &newoffset, &cis_handle,
flags) != CS_SUCCESS) {
mutex_exit(&sp->cis_lock);
cmn_err(CE_CONT, "cs_get_tuple_data: socket %d "
"can't init CIS window\n",
sp->socket_num);
return (CS_GENERAL_FAILURE);
} /* cs_init_cis_window */
while (nbytes--) {
*tdd++ = csx_Get8(cis_handle, newoffset++);
if (tuple->CISOffset->flags & CISTPLF_AM_SPACE)
newoffset++;
} /* while */
break;
default:
mutex_exit(&sp->cis_lock);
return (CS_GENERAL_FAILURE);
} /* switch */
ret = CS_SUCCESS;
} else {
ret = CS_NO_CIS;
} /* if (CW_VALID_CIS) */
mutex_exit(&sp->cis_lock);
return (ret);
}
/*
* cs_validate_cis - validates the CIS on a card in the given socket; this
* is to support the ValidateCIS function call.
*
* Notes for regular PC card driver callers:
*
* Regular PC card drivers calling ValidateCIS will get the meaning of
* the structure members as specified in the standard.
*
* Notes for Socket Services, the "super-client" or CSI driver callers:
*
* with: Function Number = CS_GLOBAL_CIS
*
* For a single-function card, CS_NO_CIS will be returned and the
* cisinfo_t->Chains and cisinfo_t->Tuples members will be set to 0.
*
* For a multi-function card, cisinfo_t->Chains will contain a count of
* the number of CIS chains in the global portion of the CIS, and
* cisinfo_t->Tuples will contain a count of the number of tuples in
* the global portion of the CIS.
*
* with: 0 <= Function Number < CIS_MAX_FUNCTIONS
*
* For a single-function card, if the function number is equal to 0 and
* has a CIS, cisinfo_t->Chains will contain a count of the number of
* CIS chains in the CIS, and cisinfo_t->Tuples will contain a count of
* the number of tuples in the CIS. If the card does not have a CIS, or
* if the function number is not equal to 0, CS_NO_CIS will be returned
* and the cisinfo_t->Chains and cisinfo_t->Tuples members will be set
* to 0.
*
* For a multi-function card, cisinfo_t->Chains will contain a count of
* the number of CIS chains in the global and function-specific
* portions of the CIS, and cisinfo_t->Tuples will contain a count of
* the number of tuples in the global and function-specific portions of
* the CIS. If the function does not exist or has no CIS, CS_NO_CIS
* will be returned and the cisinfo_t->Chains and cisinfo_t->Tuples
* members will be set to 0.
*
* General notes:
*
* If the card does not have a CIS, or if the function does not exist
* or has no CIS, CS_NO_CIS will be returned and the cisinfo_t->Chains
* and cisinfo_t->Tuples members will be set to 0.
*
* Most of the work of validating the CIS has already been done by the
* CIS parser module, so we don't have to do much here except for
* looking at the various flags and tuple/chain counts that were already
* setup by the CIS parser.
*
* See notes for the cs_get_firstnext_tuple function.
*/
static int
cs_validate_cis(client_handle_t client_handle, cisinfo_t *cisinfo)
{
cs_socket_t *sp;
client_t *client;
uint32_t fn;
int ret;
if ((ret = cs_get_socket(client_handle, &cisinfo->Socket, &fn,
&sp, &client)) != CS_SUCCESS)
return (ret);
/*
* If there's no card in the socket or the card in the socket is not
* for this client, then return an error.
*/
if (!(client->flags & CLIENT_CARD_INSERTED))
return (CS_NO_CARD);
mutex_enter(&sp->cis_lock);
if ((sp->cis_flags & CW_VALID_CIS) &&
(sp->cis[fn].flags & CW_VALID_CIS)) {
cisinfo->Chains = sp->cis[fn].nchains;
cisinfo->Tuples = sp->cis[fn].ntuples;
if ((fn != CS_GLOBAL_CIS) &&
(sp->cis[CS_GLOBAL_CIS].flags & CW_VALID_CIS)) {
cisinfo->Chains += sp->cis[CS_GLOBAL_CIS].nchains;
cisinfo->Tuples += sp->cis[CS_GLOBAL_CIS].ntuples;
} /* !CS_GLOBAL_CIS */
ret = CS_SUCCESS;
} else {
cisinfo->Chains = 0;
cisinfo->Tuples = 0;
ret = CS_NO_CIS;
}
mutex_exit(&sp->cis_lock);
return (ret);
}
/*
* cs_init_cis_window - initializes the CIS window for the passed socket
*
* calling: *sp - pointer to the per-socket structure
* *offset - offset from start of AM or CM space
* *hp - pointer to acc_handle_t to store modified
* window access handle in
* flags - one of:
* CISTPLF_AM_SPACE - set window to AM space
* CISTPLF_CM_SPACE - set window to CM space
*
* returns: CS_SUCCESS if CIS window was set up
* *offset - contains adjusted offset to use to access
* requested space
* CS_BAD_WINDOW if CIS window could not be setup
* CS_GENERAL_FAILURE if socket has a CIS window number
* but the window flags are wrong
*
* Note: This function will check to be sure that there is a valid
* CIS window allocated to this socket.
* If there is an error in setting up the window hardware, the
* CIS window information for this socket is cleared.
* This function is also used by routines that need to get
* a pointer to the base of AM space to access the card's
* configuration registers.
* The passed offset is the un-window-size-aligned offset.
*/
int
cs_init_cis_window(cs_socket_t *sp, uint32_t *offset,
acc_handle_t *hp, uint32_t flags)
{
set_window_t sw;
get_window_t gw;
inquire_window_t iw;
set_page_t set_page;
cs_window_t *cw;
/*
* Check to be sure that we have a valid CIS window
*/
if (!SOCKET_HAS_CIS_WINDOW(sp)) {
cmn_err(CE_CONT,
"cs_init_cis_window: socket %d has no CIS window\n",
sp->socket_num);
return (CS_BAD_WINDOW);
}
/*
* Check to be sure that this window is allocated for CIS use
*/
if ((cw = cs_get_wp(sp->cis_win_num)) == NULL)
return (CS_BAD_WINDOW);
if (!(cw->state & CW_CIS)) {
cmn_err(CE_CONT,
"cs_init_cis_window: socket %d invalid CIS window state 0x%x\n",
sp->socket_num, cw->state);
return (CS_BAD_WINDOW);
}
/*
* Get the characteristics of this window - we use this to
* determine whether we need to re-map the window or
* just move the window offset on the card.
*/
iw.window = sp->cis_win_num;
SocketServices(SS_InquireWindow, &iw);
/*
* We've got a window, now set up the hardware. If we've got
* a variable sized window, then all we need to do is to
* get a valid mapping to the base of the window using
* the current window size; if we've got a fixed-size
* window, then we need to get a mapping to the window
* starting at offset zero of the window.
*/
if (iw.mem_win_char.MemWndCaps & WC_SIZE) {
sw.WindowSize = sp->cis_win_size;
set_page.offset = ((*offset / sp->cis_win_size) *
sp->cis_win_size);
} else {
set_page.offset = ((*offset / iw.mem_win_char.MinSize) *
iw.mem_win_char.MinSize);
sw.WindowSize = (((*offset & ~(PAGESIZE - 1)) &
(set_page.offset - 1)) + PAGESIZE);
}
/*
* Return a normalized base offset; this takes care of the case
* where the required offset is greater than the window size.
* BugID 1236404
* code was:
* *offset = *offset & (set_page.offset - 1);
*/
*offset = *offset - set_page.offset;
#ifdef CS_DEBUG
if (cs_debug > 1)
cmn_err(CE_CONT, "cs_init_cis_window: WindowSize 0x%x "
"offset 0x%x\n",
(int)sw.WindowSize,
(int)set_page.offset);
if (cs_debug > 1)
cmn_err(CE_CONT, "\t*offset = 0x%x space = %s\n",
(int)*offset,
(flags & CISTPLF_AM_SPACE)?
"CISTPLF_AM_SPACE":"CISTPLF_CM_SPACE");
#endif
sw.window = sp->cis_win_num;
sw.socket = sp->socket_num;
sw.state = (WS_ENABLED | WS_EXACT_MAPIN);
sw.attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
sw.attr.devacc_attr_endian_flags = DDI_NEVERSWAP_ACC;
sw.attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;
/*
* The PCMCIA SS spec specifies this be expressed in
* a device speed format per 5.2.7.1.3 but
* our implementation of SS_SetWindow uses
* actual nanoseconds.
*/
sw.speed = CIS_DEFAULT_SPEED;
sw.base = 0;
/*
* Set up the window - if this fails, then just set the
* CIS window number back to it's initialized value so
* that we'll fail when we break out of the loop.
*/
if (SocketServices(SS_SetWindow, &sw) != SUCCESS) {
sp->cis_win_num = PCMCIA_MAX_WINDOWS;
cw->state = 0; /* XXX do we really want to do this? */
return (CS_BAD_WINDOW);
} else {
set_page.window = sp->cis_win_num;
set_page.page = 0;
set_page.state = PS_ENABLED;
if (flags & CISTPLF_AM_SPACE)
set_page.state |= PS_ATTRIBUTE;
if (SocketServices(SS_SetPage, &set_page) != SUCCESS) {
sp->cis_win_num = PCMCIA_MAX_WINDOWS;
cw->state = 0; /* XXX do we really want to do this? */
return (CS_BAD_WINDOW);
} /* if (SS_SetPage) */
} /* if (SS_SetWindow) */
/*
* Get the window information for the CIS window for this socket.
*/
gw.window = sp->cis_win_num;
gw.socket = sp->socket_num; /* XXX - SS_GetWindow should set this */
if (SocketServices(SS_GetWindow, &gw) != SUCCESS)
return (CS_BAD_WINDOW);
*hp = (acc_handle_t)gw.handle;
return (CS_SUCCESS);
}
/*
* ==== client registration/deregistration section ====
*/
/*
* cs_register_client - This supports the RegisterClient call.
*
* Upon successful registration, the client_handle_t * handle argument will
* contain the new client handle and we return CS_SUCCESS.
*/
static int
cs_register_client(client_handle_t *ch, client_reg_t *cr)
{
uint32_t sn;
int super_client = 0;
sclient_reg_t *scr = cr->priv;
struct sclient_list_t *scli;
/*
* See if we're not supposed to register any new clients.
*/
if (cs_globals.init_state & GLOBAL_INIT_STATE_NO_CLIENTS)
return (CS_OUT_OF_RESOURCE);
/*
* Do a version check - if the client expects a later version of
* Card Services than what we are, return CS_BAD_VERSION.
* XXX - How do we specify just a PARTICULAR version of CS??
*/
if (CS_VERSION < cr->Version)
return (CS_BAD_VERSION);
/*
* Check to be sure that the client has given us a valid set of
* client type flags. We also use this opportunity to see
* if the registering client is Socket Services or is a
* "super-client" or a CSI client.
*
* Note that SS can not set any flag in the Attributes field other
* than the INFO_SOCKET_SERVICES flag.
*
* Valid combinations of cr->Attributes and cr->EventMask flags:
*
* for Socket Services:
* cr->Attributes:
* set:
* INFO_SOCKET_SERVICES
* clear:
* {all other flags}
* cr->EventMask:
* don't care:
* {all flags}
*
* for regular clients:
* cr->Attributes:
* only one of:
* INFO_IO_CLIENT
* INFO_MTD_CLIENT
* INFO_MEM_CLIENT
* don't care:
* INFO_CARD_SHARE
* INFO_CARD_EXCL
* cr->EventMask:
* clear:
* CS_EVENT_ALL_CLIENTS
* don't care:
* {all other flags}
*
* for CSI clients:
* cr->Attributes:
* set:
* INFO_IO_CLIENT
* INFO_CSI_CLIENT
* clear:
* INFO_MTD_CLIENT
* INFO_MEM_CLIENT
* don't care:
* INFO_CARD_SHARE
* INFO_CARD_EXCL
* cr->EventMask:
* don't care:
* {all flags}
*
* for "super-clients":
* cr->Attributes:
* set:
* INFO_IO_CLIENT
* INFO_MTD_CLIENT
* INFO_SOCKET_SERVICES
* INFO_CARD_SHARE
* clear:
* INFO_MEM_CLIENT
* INFO_CARD_EXCL
* cr->EventMask:
* don't care:
* {all flags}
*/
switch (cr->Attributes & INFO_CLIENT_TYPE_MASK) {
/*
* Check first to see if this is Socket Services registering; if
* so, we don't do anything but return the client handle that is
* in the global SS client.
*/
case INFO_SOCKET_SERVICES:
*ch = cs_socket_services_client.client_handle;
return (CS_SUCCESS);
/* NOTREACHED */
/* CSI clients */
case (INFO_CSI_CLIENT | INFO_IO_CLIENT):
break;
/* regular clients */
case INFO_IO_CLIENT:
case INFO_MTD_CLIENT:
case INFO_MEM_CLIENT:
if (cr->EventMask & CS_EVENT_ALL_CLIENTS)
return (CS_BAD_ATTRIBUTE);
break;
/* "super-client" clients */
case (INFO_IO_CLIENT | INFO_MTD_CLIENT | INFO_SOCKET_SERVICES):
if ((!(cr->Attributes & INFO_CARD_SHARE)) ||
(cr->Attributes & INFO_CARD_EXCL))
return (CS_BAD_ATTRIBUTE);
/*
* We only allow one "super-client" per system.
*/
mutex_enter(&cs_globals.global_lock);
if (cs_globals.flags & GLOBAL_SUPER_CLIENT_REGISTERED) {
mutex_exit(&cs_globals.global_lock);
return (CS_NO_MORE_ITEMS);
}
cs_globals.flags |= GLOBAL_SUPER_CLIENT_REGISTERED;
mutex_exit(&cs_globals.global_lock);
super_client = CLIENT_SUPER_CLIENT;
break;
default:
return (CS_BAD_ATTRIBUTE);
} /* switch (cr->Attributes) */
/*
* Now, actually create the client node on the socket; this will
* also return the new client handle if there were no errors
* creating the client node.
* The DIP2SOCKET_NUM macro will return the socket and function
* number using the encoding specified in the cs_priv.h file.
*/
if (super_client != CLIENT_SUPER_CLIENT) {
if (cr->Attributes & INFO_CSI_CLIENT)
sn = (uint32_t)(uintptr_t)cr->priv;
else
sn = DIP2SOCKET_NUM(cr->dip);
return (cs_add_client_to_socket(sn, ch, cr, super_client));
} /* CLIENT_SUPER_CLIENT */
/*
* This registering client is a "super-client", so we create one
* client node for each socket in the system. We use the
* client_reg_t.priv structure member to point to a struct
* that the "super-client" client knows about. The client
* handle pointer is not used in this case.
* We return CS_SUCCESS if at least one client node could be
* created. The client must check the error codes in the
* error code array to determine which clients could not
* be created on which sockets.
* We return CS_BAD_HANDLE if no client nodes could be created.
*/
scr->num_clients = 0;
scr->max_socket_num = cs_globals.max_socket_num;
scr->num_sockets = cs_globals.num_sockets;
scr->num_windows = cs_globals.num_windows;
*(scr->sclient_list) = cs_globals.sclient_list;
for (sn = 0; sn < scr->num_sockets; sn++) {
scli = scr->sclient_list[sn];
if ((scli->error = cs_add_client_to_socket(sn, &scli->client_handle,
cr, super_client)) == CS_SUCCESS) {
scr->num_clients++;
}
}
/*
* If we couldn't create any client nodes at all, then
* return an error.
*/
if (!scr->num_clients) {
/*
* XXX - The global superclient lock now gets
* cleared in cs_deregister_client
*/
/* cs_clear_superclient_lock(super_client); */
return (CS_BAD_HANDLE);
}
return (CS_SUCCESS);
}
/*
* cs_add_client_to_socket - this function creates the client node on the
* requested socket.
*
* Note that if we return an error, there is no state that can be cleaned
* up. The only way that we can return an error with allocated resources
* would be if one of the client handle functions had an internal error.
* Since we wouldn't get a valid client handle in this case anyway, there
* would be no way to find out what was allocated and what wasn't.
*/
static int
cs_add_client_to_socket(unsigned sn, client_handle_t *ch,
client_reg_t *cr, int super_client)
{
cs_socket_t *sp;
client_t *client, *cclp;
int error, cie = 1;
int client_lock_acquired;
if (cr->event_handler == NULL)
return (CS_BAD_ARGS);
if ((sp = cs_get_sp(sn)) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Run through all of the registered clients and compare the passed
* dip to the dip of each client to make sure that this client
* is not trying to register more than once. If they are, then
* display a message and return an error.
* XXX - we should really check all the sockets in case the client
* manipulates the instance number in the dip.
* XXX - if we check each socket, we ned to also check for the
* "super-client" since it will use the same dip for all
* of it's client nodes.
*/
mutex_enter(&sp->lock);
client = sp->client_list;
while (client) {
if (!(cr->Attributes & INFO_CSI_CLIENT) &&
(client->dip == cr->dip)) {
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
cmn_err(CE_CONT, "cs_add_client_to_socket: socket %d "
"function 0x%x\n"
"\tclient already registered with "
"handle 0x%x\n",
(int)CS_GET_SOCKET_NUMBER(sn),
(int)CS_GET_FUNCTION_NUMBER(sn),
(int)client->client_handle);
return (CS_BAD_HANDLE);
}
client = client->next;
} /* while (client) */
mutex_exit(&sp->lock);
/*
* Create a unique client handle then make sure that we can find it.
* This has the side effect of getting us a pointer to the
* client structure as well.
* Create a client list entry - cs_create_client_handle will use this
* as the new client node.
* We do it here so that we can grab the sp->lock mutex for the
* duration of our manipulation of the client list.
* If this function fails, then it will not have added the newly
* allocated client node to the client list on this socket,
* so we have to free the node that we allocated.
*/
cclp = (client_t *)kmem_zalloc(sizeof (client_t), KM_SLEEP);
mutex_enter(&sp->lock);
if (!(*ch = cs_create_client_handle(sn, cclp))) {
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
kmem_free(cclp, sizeof (client_t));
return (CS_OUT_OF_RESOURCE);
}
/*
* Make sure that this is a valid client handle. We should never
* fail this since we just got a valid client handle.
* If this fails, then we have an internal error so don't bother
* trying to clean up the allocated client handle since the
* whole system is probably hosed anyway and will shortly
* esplode.
* It doesn't make sense to call cs_deregister_client at this point
* to clean up this broken client since the deregistration
* code will also call cs_find_client and most likely fail.
*/
if (!(client = cs_find_client(*ch, &error))) {
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
cmn_err(CE_CONT, "cs_add_client_to_socket: socket %d function 0x%x "
"invalid client handle created handle 0x%x\n",
(int)CS_GET_SOCKET_NUMBER(sn),
(int)CS_GET_FUNCTION_NUMBER(sn),
(int)*ch);
return (error);
}
/*
* Save the DDI information.
*/
client->dip = cr->dip;
cr->driver_name[MODMAXNAMELEN - 1] = NULL;
client->driver_name = (char *)kmem_zalloc(strlen(cr->driver_name) + 1,
KM_SLEEP);
(void) strcpy(client->driver_name, cr->driver_name);
client->instance = ddi_get_instance(cr->dip);
/*
* Copy over the interesting items that the client gave us.
*/
client->flags = (cr->Attributes & INFO_CLIENT_TYPE_MASK);
client->event_callback_handler = cr->event_handler;
bcopy((caddr_t)&cr->event_callback_args,
(caddr_t)&client->event_callback_args,
sizeof (event_callback_args_t));
/*
* Set the client handle since the client needs a client handle
* when they call us for their event handler.
*/
client->event_callback_args.client_handle = *ch;
/*
* Initialize the IO window numbers; if an IO window number is equal
* to PCMCIA_MAX_WINDOWS it means that IO range is not in use.
*/
client->io_alloc.Window1 = PCMCIA_MAX_WINDOWS;
client->io_alloc.Window2 = PCMCIA_MAX_WINDOWS;
/*
* Give the client the iblock and idevice cookies to use in
* the client's event handler high priority mutex.
*/
cr->iblk_cookie = sp->iblk;
cr->idev_cookie = sp->idev;
/*
* Set up the global event mask information; we copy this directly
* from the client; since we are the only source of events,
* any bogus bits that the client puts in here won't matter
* because we'll never look at them.
*/
client->global_mask = cr->EventMask;
/*
* If this client registered as a CSI client, set the appropriate
* flag in the client's flags area.
*/
if (cr->Attributes & INFO_CSI_CLIENT)
client->flags |= CLIENT_CSI_CLIENT;
/*
* If this client registered as a "super-client" set the appropriate
* flag in the client's flags area.
*/
if (super_client == CLIENT_SUPER_CLIENT)
client->flags |= CLIENT_SUPER_CLIENT;
/*
* Save other misc information that this client gave us - it is
* used in the GetClientInfo function.
*/
client->flags |= (cr->Attributes & INFO_CARD_FLAGS_MASK);
/*
* Determine if we should give artificial card insertion events and
* a registration complete event. Since we don't differentiate
* between sharable and exclusive use cards when giving clients
* event notification, we modify the definition of the share/excl
* flags as follows:
*
* If either INFO_CARD_SHARE or INFO_CARD_EXCL is set,
* the client will receive artificial card insertion
* events (if the client's card is currently in the
* socket) and a registration complete event.
*
* If neither of the INFO_CARD_SHARE or INFO_CARD_EXCL is
* set, the client will not receive an artificial card
* insertion event nor a registration complete event
* due to the client's call to register client.
*
* The client's event mask is not affected by the setting
* of these two bits.
*/
if (cr->Attributes & (INFO_CARD_SHARE | INFO_CARD_EXCL))
client->pending_events = CS_EVENT_REGISTRATION_COMPLETE;
/*
* Check to see if the card for this client is currently in
* the socket. If it is, then set CLIENT_CARD_INSERTED
* since clients that are calling GetStatus at attach
* time will typically check to see if their card is
* currently installed.
* If this is the CSI client, we also need to check to see
* if there is any card inserted in the socket, since
* the cs_card_for_client function will always return
* TRUE for a CSI client.
* XXX What about super-clients?
*/
if (client->flags & CLIENT_CSI_CLIENT) {
get_ss_status_t get_ss_status;
get_ss_status.socket = sp->socket_num;
if (SocketServices(SS_GetStatus, &get_ss_status) != SUCCESS) {
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_SOCKET);
} /* SS_GetStatus */
if (!(cs_sbm2cse(get_ss_status.CardState) &
CS_EVENT_CARD_INSERTION))
cie = 0;
} /* CLIENT_CSI_CLIENT */
if (cs_card_for_client(client) && (cie != 0)) {
client->pending_events |= CS_EVENT_CARD_INSERTION;
client->flags |= CLIENT_CARD_INSERTED;
} /* cs_card_for_client */
sp->num_clients++;
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
}
/*
* cs_deregister_client - This supports the DeregisterClient call.
*/
static int
cs_deregister_client(client_handle_t client_handle)
{
cs_socket_t *sp;
client_t *client;
int error, super_client = 0;
int client_lock_acquired;
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't do anything except for return success.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_SUCCESS);
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
}
/*
* Make sure that any resources allocated by this client are
* not still allocated, and that if this is an MTD that
* no MTD operations are still in progress.
*/
if (client->flags & (CLIENT_IO_ALLOCATED |
CLIENT_IRQ_ALLOCATED |
CLIENT_WIN_ALLOCATED |
REQ_CONFIGURATION_DONE |
REQ_SOCKET_MASK_DONE |
REQ_IO_DONE |
REQ_IRQ_DONE)) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BUSY);
}
if (client->flags & CLIENT_MTD_IN_PROGRESS) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_IN_USE);
}
/*
* Any previously allocated resources are not allocated anymore, and
* no MTD operations are in progress, so if this is an MTD client
* then do any MTD-specific client deregistration, and then
* nuke this client.
* We expect cs_deregister_mtd to never fail.
*/
if (client->flags & INFO_MTD_CLIENT)
(void) cs_deregister_mtd(client_handle);
if (client->flags & CLIENT_SUPER_CLIENT)
super_client = CLIENT_SUPER_CLIENT;
kmem_free(client->driver_name, strlen(client->driver_name) + 1);
error = cs_destroy_client_handle(client_handle);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
/*
* If this was the "super-client" deregistering, then this
* will clear the global "super-client" lock.
* XXX - move this outside the per-socket code.
*/
cs_clear_superclient_lock(super_client);
return (error);
}
/*
* cs_create_next_client_minor - returns the next available client minor
* number or 0 if none available
*
* Note that cs_find_client will always return a valid pointer to the
* global Socket Services client which has a client minor number
* of 0; this means that this function can never return a 0 as the
* next valid available client minor number.
*/
unsigned
cs_create_next_client_minor(unsigned socket_num, unsigned next_minor)
{
unsigned max_client_handles = cs_max_client_handles;
do {
next_minor &= CS_MAX_CLIENTS_MASK;
if (!cs_find_client(MAKE_CLIENT_HANDLE(
CS_GET_SOCKET_NUMBER(socket_num),
CS_GET_FUNCTION_NUMBER(socket_num),
next_minor), NULL)) {
return (next_minor);
}
next_minor++;
} while (max_client_handles--);
return (0);
}
/*
* cs_find_client - finds the client pointer associated with the client handle
* or NULL if client not found
*
* returns: (client_t *)NULL - if client not found or an error occured
* If the error argument is not NULL,
* it is set to:
* CS_BAD_SOCKET - socket number in client_handle_t is
* invalid
* CS_BAD_HANDLE - client not found
* If no error, the error argument is not modified.
* (client_t *) - pointer to client_t structure
*
* Note that each socket always has a pseudo client with a client minor number
* of 0; this client minor number is used for Socket Services access to
* Card Services functions. The client pointer returned for client minor
* number 0 is the global Socket Services client pointer.
*/
static client_t *
cs_find_client(client_handle_t client_handle, int *error)
{
cs_socket_t *sp;
client_t *clp;
/*
* If we are being asked to see if a client with a minor number
* of 0 exists, always return a pointer to the global Socket
* Services client, since this client always exists, and is
* only for use by Socket Services. There is no socket
* associated with this special client handle.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (&cs_socket_services_client);
/*
* Check to be sure that the socket number is in range
*/
if (!(CHECK_SOCKET_NUM(GET_CLIENT_SOCKET(client_handle),
cs_globals.max_socket_num))) {
if (error)
*error = CS_BAD_SOCKET;
return (NULL);
}
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL) {
if (error)
*error = CS_BAD_SOCKET;
return (NULL);
}
clp = sp->client_list;
while (clp) {
if (clp->client_handle == client_handle)
return (clp);
clp = clp->next;
}
if (error)
*error = CS_BAD_HANDLE;
return (NULL);
}
/*
* cs_destroy_client_handle - destroys client handle and client structure of
* passed client handle
*
* returns: CS_SUCCESS - if client handle sucessfully destroyed
* CS_BAD_HANDLE - if client handle is invalid or if trying
* to destroy global SS client
* {other errors} - other errors from cs_find_client()
*/
static int
cs_destroy_client_handle(client_handle_t client_handle)
{
client_t *clp;
cs_socket_t *sp;
int error = CS_BAD_HANDLE;
/*
* See if we were passed a valid client handle or if we're being asked
* to destroy the Socket Services client
*/
if ((!(clp = cs_find_client(client_handle, &error))) ||
(CLIENT_HANDLE_IS_SS(client_handle)))
return (error);
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
/*
* Recycle this client's minor number. This will most likely
* be the next client minor number we use, but it is also
* a hint to cs_create_client_handle, and that function
* may actually create a new client handle using a minor
* number different that this number.
*/
mutex_enter(&sp->lock);
sp->next_cl_minor = GET_CLIENT_MINOR(client_handle);
/*
* See if we're the first or not in the client list; if we're
* not first, then just adjust the client behind us to
* point to the client ahead of us; this could be NULL
* if we're the last client in the list.
*/
if (clp->prev) {
clp->prev->next = clp->next;
} else {
/*
* We are first, so adjust the client list head pointer
* in the socket to point to the client structure that
* follows us; this could turn out to be NULL if we're
* the only client on this socket.
*/
sp->client_list = clp->next;
}
/*
* If we're not the last client in the list, point the next
* client to the client behind us; this could turn out
* to be NULL if we're the first client on this socket.
*/
if (clp->next)
clp->next->prev = clp->prev;
sp->num_clients--;
mutex_exit(&sp->lock);
/*
* Free this client's memory.
*/
kmem_free(clp, sizeof (client_t));
return (CS_SUCCESS);
}
/*
* cs_create_client_handle - create a new client handle for the passed
* socket and function number
*
* returns: 0 - if can't create client for some reason
* client_handle_t - new client handle
*/
static client_handle_t
cs_create_client_handle(unsigned socket_num, client_t *cclp)
{
client_t *clp;
cs_socket_t *sp;
unsigned next_minor;
client_handle_t client_handle;
if ((sp = cs_get_sp(socket_num)) == NULL)
return (0);
/*
* Get the next available minor number that we can use. We use the
* next_cl_minor number as a hint to cs_create_next_client_minor
* and in most cases this will be the minor number we get back.
* If for some reason we can't get a minor number, return an error.
* The only way we could get an error would be if there are
* already the maximum number of clients for this socket. Since
* the maximum number of clients per socket is pretty large,
* this error is unlikely to occur.
*/
if (!(next_minor =
cs_create_next_client_minor(socket_num, sp->next_cl_minor)))
return (0);
/*
* Got a new client minor number, now create a new client handle.
*/
client_handle = MAKE_CLIENT_HANDLE(CS_GET_SOCKET_NUMBER(socket_num),
CS_GET_FUNCTION_NUMBER(socket_num),
next_minor);
/*
* If this client handle exists, then we have an internal
* error; this should never happen, BTW. This is really
* a double-check on the cs_create_next_client_minor
* function, which also calls cs_find_client.
*/
if (cs_find_client(client_handle, NULL)) {
cmn_err(CE_CONT,
"cs_create_client_handle: duplicate client handle 0x%x\n",
(int)client_handle);
return (0);
}
/*
* If we don't have any clients on this socket yet, create
* a new client and hang it on the socket client list.
*/
if (!sp->client_list) {
sp->client_list = cclp;
clp = sp->client_list;
} else {
/*
* There are other clients on this socket, so look for
* the last client and add our new client after it.
*/
clp = sp->client_list;
while (clp->next) {
clp = clp->next;
}
clp->next = cclp;
clp->next->prev = clp;
clp = clp->next;
} /* if (!sp->client_list) */
/*
* Assign the new client handle to this new client structure.
*/
clp->client_handle = client_handle;
/*
* Create the next available client minor number for this socket
* and save it away.
*/
sp->next_cl_minor =
cs_create_next_client_minor(socket_num, sp->next_cl_minor);
return (client_handle);
}
/*
* cs_clear_superclient_lock - clears the global "super-client" lock
*
* Note: this function uses the cs_globals.global_lock so observe proper
* nexting of locks!!
*/
static void
cs_clear_superclient_lock(int super_client)
{
/*
* If this was a "super-client" registering then we need
* to clear the GLOBAL_SUPER_CLIENT_REGISTERED flag
* so that other "super-clients" can register.
*/
if (super_client == CLIENT_SUPER_CLIENT) {
mutex_enter(&cs_globals.global_lock);
cs_globals.flags &= ~GLOBAL_SUPER_CLIENT_REGISTERED;
mutex_exit(&cs_globals.global_lock);
}
}
/*
* ==== event handling section ====
*/
/*
* cs_event - CS event hi-priority callback handler
*
* This function gets called by SS and is passed the event type in
* the "event" argument, and the socket number in the "sn"
* argument. The "sn" argument is a valid logical socket
* number for all events except the PCE_SS_READY event.
*
* The PCE_SS_INIT_STATE, PCE_ADD_SOCKET and PCE_DROP_SOCKET events
* are never called at high priority. These events return
* the following return codes:
*
* CS_SUCCESS - operation sucessful
* CS_BAD_SOCKET - unable to complete operation
* CS_UNSUPPORTED_FUNCTION - bad subfunction of
* PCE_SS_INIT_STATE
*
* The caller MUST look at these return codes!
*
* This function is called at high-priority interrupt time for standard
* Card Services events, and the only standard Card Services
* event that it handles directly is the CS_EVENT_CARD_REMOVAL
* event, which gets shuttled right into the client's event
* handler. All other events are just queued up and the socket
* event thread is woken up via the soft interrupt handler.
* Note that CS_EVENT_CARD_INSERTION events are not set in the clients'
* event field, since the CS card insertion/card ready processing
* code is responsible for setting this event in a client's
* event field.
*
*/
/*ARGSUSED*/
uint32_t
cs_event(event_t event, uint32_t sn, uint32_t arg)
{
client_t *client;
cs_socket_t *sp;
client_types_t *ct;
uint32_t ret = CS_SUCCESS;
/*
* Handle special SS<->CS events
*/
switch (event) {
case PCE_SS_INIT_STATE:
mutex_enter(&cs_globals.global_lock);
switch (sn) {
case PCE_SS_STATE_INIT:
if ((ret = cs_ss_init()) == CS_SUCCESS)
cs_globals.init_state |= GLOBAL_INIT_STATE_SS_READY;
break;
case PCE_SS_STATE_DEINIT:
cs_globals.init_state &= ~GLOBAL_INIT_STATE_SS_READY;
break;
default:
ret = CS_UNSUPPORTED_FUNCTION;
cmn_err(CE_CONT, "cs_event: PCE_SS_INIT_STATE invalid "
"directive: 0x%x\n", sn);
break;
} /* switch (sn) */
mutex_exit(&cs_globals.global_lock);
return (ret);
case PCE_ADD_SOCKET:
return (cs_add_socket(sn));
case PCE_DROP_SOCKET:
return (cs_drop_socket(sn));
} /* switch (event) */
if ((sp = cs_get_sp(sn)) == NULL)
return (CS_BAD_SOCKET);
/*
* Check to see if CS wants to unload - we do this since it's possible
* to disable certain sockets. Do NOT acquire any locks yet.
*/
if (sp->flags & SOCKET_UNLOAD_MODULE) {
if (event == PCE_CARD_INSERT)
cmn_err(CE_CONT, "PCMCIA: socket %d disabled - please "
"remove card\n", sn);
return (CS_SUCCESS);
}
mutex_enter(&sp->lock);
#ifdef CS_DEBUG
if (cs_debug > 1) {
event2text_t event2text;
event2text.event = event;
(void) cs_event2text(&event2text, 0);
cmn_err(CE_CONT, "cs_event: event=%s (x%x), socket=0x%x\n",
event2text.text, (int)event, (int)sn);
}
#endif
/*
* Convert SS events to CS events; handle the PRR if necessary.
*/
sp->events |= ss_to_cs_events(sp, event);
/*
* We want to maintain the required event dispatching order as
* specified in the PCMCIA spec, so we cycle through all
* clients on this socket to make sure that they are
* notified in the correct order of any high-priority
* events.
*/
ct = &client_types[0];
while (ct) {
/*
* Point to the head of the client list for this socket, and go
* through each client to set up the client events as well as
* call the client's event handler directly if we have a high
* priority event that we need to tell the client about.
*/
client = sp->client_list;
if (ct->order & CLIENT_EVENTS_LIFO) {
client_t *clp = NULL;
while (client) {
clp = client;
client = client->next;
}
client = clp;
}
while (client) {
client->events |= ((sp->events & ~CS_EVENT_CARD_INSERTION) &
(client->event_mask | client->global_mask));
if (client->flags & ct->type) {
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_event: socket %d client [%s] "
"events 0x%x flags 0x%x\n",
sn, client->driver_name,
(int)client->events,
(int)client->flags);
}
#endif
/*
* Handle the suspend and card removal events
* specially here so that the client can receive
* these events at high-priority.
*/
if (client->events & CS_EVENT_PM_SUSPEND) {
if (client->flags & CLIENT_CARD_INSERTED) {
CLIENT_EVENT_CALLBACK(client, CS_EVENT_PM_SUSPEND,
CS_EVENT_PRI_HIGH);
} /* if (CLIENT_CARD_INSERTED) */
client->events &= ~CS_EVENT_PM_SUSPEND;
} /* if (CS_EVENT_PM_SUSPEND) */
if (client->events & CS_EVENT_CARD_REMOVAL) {
if (client->flags & CLIENT_CARD_INSERTED) {
client->flags &= ~(CLIENT_CARD_INSERTED |
CLIENT_SENT_INSERTION);
CLIENT_EVENT_CALLBACK(client,
CS_EVENT_CARD_REMOVAL,
CS_EVENT_PRI_HIGH);
/*
* Check to see if the client wants low priority
* removal events as well.
*/
if ((client->event_mask | client->global_mask) &
CS_EVENT_CARD_REMOVAL_LOWP) {
client->events |= CS_EVENT_CARD_REMOVAL_LOWP;
}
} /* if (CLIENT_CARD_INSERTED) */
client->events &= ~CS_EVENT_CARD_REMOVAL;
} /* if (CS_EVENT_CARD_REMOVAL) */
} /* if (ct->type) */
if (ct->order & CLIENT_EVENTS_LIFO) {
client = client->prev;
} else {
client = client->next;
}
} /* while (client) */
ct = ct->next;
} /* while (ct) */
/*
* Set the SOCKET_NEEDS_THREAD flag so that the soft interrupt
* handler will wakeup this socket's event thread.
*/
if (sp->events)
sp->flags |= SOCKET_NEEDS_THREAD;
/*
* Fire off a soft interrupt that will cause the socket thread
* to be woken up and any remaining events to be sent to
* the clients on this socket.
*/
if ((sp->init_state & SOCKET_INIT_STATE_SOFTINTR) &&
!(cs_globals.init_state & GLOBAL_INIT_STATE_UNLOADING))
ddi_trigger_softintr(sp->softint_id);
mutex_exit(&sp->lock);
return (CS_SUCCESS);
}
/*
* cs_card_insertion - handle card insertion and card ready events
*
* We read the CIS, if present, and store it away, then tell SS that
* we have read the CIS and it's ready to be parsed. Since card
* insertion and card ready events are pretty closely intertwined,
* we handle both here. For card ready events that are not the
* result of a card insertion event, we expect that the caller has
* already done the appropriate processing and that we will not be
* called unless we received a card ready event right after a card
* insertion event, i.e. that the SOCKET_WAIT_FOR_READY flag in
* sp->thread_state was set or if we get a CARD_READY event right
* after a CARD_INSERTION event.
*
* calling: sp - pointer to socket structure
* event - event to handle, one of:
* CS_EVENT_CARD_INSERTION
* CS_EVENT_CARD_READY
* CS_EVENT_SS_UPDATED
*/
static int
cs_card_insertion(cs_socket_t *sp, event_t event)
{
int ret;
/*
* Since we're only called while waiting for the card insertion
* and card ready sequence to occur, we may have a pending
* card ready timer that hasn't gone off yet if we got a
* real card ready event.
*/
UNTIMEOUT(sp->rdybsy_tmo_id);
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_card_insertion: event=0x%x, socket=0x%x\n",
(int)event, sp->socket_num);
}
#endif
/*
* Handle card insertion processing
*/
if (event & CS_EVENT_CARD_INSERTION) {
set_socket_t set_socket;
get_ss_status_t gs;
/*
* Check to be sure that we have a valid CIS window
*/
if (!SOCKET_HAS_CIS_WINDOW(sp)) {
cmn_err(CE_CONT,
"cs_card_insertion: socket %d has no "
"CIS window\n",
sp->socket_num);
return (CS_GENERAL_FAILURE);
}
/*
* Apply power to the socket, enable card detect and card ready
* events, then reset the socket.
*/
mutex_enter(&sp->lock);
sp->event_mask = (CS_EVENT_CARD_REMOVAL |
CS_EVENT_CARD_READY);
mutex_exit(&sp->lock);
set_socket.socket = sp->socket_num;
set_socket.SCIntMask = (SBM_CD | SBM_RDYBSY);
set_socket.IREQRouting = 0;
set_socket.IFType = IF_MEMORY;
set_socket.CtlInd = 0; /* turn off controls and indicators */
set_socket.State = (unsigned)~0; /* clear latched state bits */
(void) cs_convert_powerlevel(sp->socket_num, 50, VCC,
&set_socket.VccLevel);
(void) cs_convert_powerlevel(sp->socket_num, 50, VPP1,
&set_socket.Vpp1Level);
(void) cs_convert_powerlevel(sp->socket_num, 50, VPP2,
&set_socket.Vpp2Level);
if ((ret = SocketServices(SS_SetSocket, &set_socket)) != SUCCESS) {
cmn_err(CE_CONT,
"cs_card_insertion: socket %d SS_SetSocket failure %d\n",
sp->socket_num, ret);
return (ret);
}
/*
* Clear the ready and ready_timeout events since they are now
* bogus since we're about to reset the socket.
* XXX - should these be cleared right after the RESET??
*/
mutex_enter(&sp->lock);
sp->events &= ~(CS_EVENT_CARD_READY | CS_EVENT_READY_TIMEOUT);
mutex_exit(&sp->lock);
SocketServices(SS_ResetSocket, sp->socket_num,
RESET_MODE_CARD_ONLY);
/*
* We are required by the PCMCIA spec to wait some number of
* milliseconds after reset before we access the card, so
* we set up a timer here that will wake us up and allow us
* to continue with our card initialization.
*/
mutex_enter(&sp->lock);
sp->thread_state |= SOCKET_RESET_TIMER;
(void) timeout(cs_ready_timeout, sp,
drv_usectohz(cs_reset_timeout_time * 1000));
cv_wait(&sp->reset_cv, &sp->lock);
sp->thread_state &= ~SOCKET_RESET_TIMER;
mutex_exit(&sp->lock);
#ifdef CS_DEBUG
if (cs_debug > 2) {
cmn_err(CE_CONT, "cs_card_insertion: socket %d out of RESET "
"for %d mS sp->events 0x%x\n",
sp->socket_num, cs_reset_timeout_time, (int)sp->events);
}
#endif
/*
* If we have a pending CS_EVENT_CARD_REMOVAL event it
* means that we likely got CD line bounce on the
* insertion, so terminate this processing.
*/
if (sp->events & CS_EVENT_CARD_REMOVAL) {
#ifdef CS_DEBUG
if (cs_debug > 0) {
cmn_err(CE_CONT, "cs_card_insertion: socket %d "
"CS_EVENT_CARD_REMOVAL event "
"terminating insertion "
"processing\n",
sp->socket_num);
}
#endif
return (CS_SUCCESS);
} /* if (CS_EVENT_CARD_REMOVAL) */
/*
* If we got a card ready event after the reset, then don't
* bother setting up a card ready timer, since we'll blast
* right on through to the card ready processing.
* Get the current card status to see if it's ready; if it
* is, we probably won't get a card ready event.
*/
gs.socket = sp->socket_num;
gs.CardState = 0;
if ((ret = SocketServices(SS_GetStatus, &gs)) != SUCCESS) {
cmn_err(CE_CONT,
"cs_card_insertion: socket %d SS_GetStatus failure %d\n",
sp->socket_num, ret);
return (ret);
}
mutex_enter(&sp->lock);
if ((sp->events & CS_EVENT_CARD_READY) ||
(gs.CardState & SBM_RDYBSY)) {
event = CS_EVENT_CARD_READY;
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_card_insertion: socket %d card "
"READY\n", sp->socket_num);
}
#endif
} else {
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_card_insertion: socket %d setting "
"READY timer\n", sp->socket_num);
}
#endif
sp->rdybsy_tmo_id = timeout(cs_ready_timeout, sp,
READY_TIMEOUT_TIME);
sp->thread_state |= SOCKET_WAIT_FOR_READY;
} /* if (CS_EVENT_CARD_READY) */
mutex_exit(&sp->lock);
} /* if (CS_EVENT_CARD_INSERTION) */
/*
* Handle card ready processing. This is only card ready processing
* for card ready events in conjunction with a card insertion.
*/
if (event == CS_EVENT_CARD_READY) {
get_socket_t get_socket;
set_socket_t set_socket;
/*
* The only events that we want to see now are card removal
* events.
*/
mutex_enter(&sp->lock);
sp->event_mask = CS_EVENT_CARD_REMOVAL;
mutex_exit(&sp->lock);
get_socket.socket = sp->socket_num;
if (SocketServices(SS_GetSocket, &get_socket) != SUCCESS) {
cmn_err(CE_CONT,
"cs_card_insertion: socket %d SS_GetSocket failed\n",
sp->socket_num);
return (CS_BAD_SOCKET);
}
set_socket.socket = sp->socket_num;
set_socket.SCIntMask = SBM_CD;
set_socket.VccLevel = get_socket.VccLevel;
set_socket.Vpp1Level = get_socket.Vpp1Level;
set_socket.Vpp2Level = get_socket.Vpp2Level;
set_socket.IREQRouting = get_socket.IRQRouting;
set_socket.IFType = get_socket.IFType;
set_socket.CtlInd = get_socket.CtlInd;
/* XXX (is ~0 correct here?) to reset latched values */
set_socket.State = (unsigned)~0;
if (SocketServices(SS_SetSocket, &set_socket) != SUCCESS) {
cmn_err(CE_CONT,
"cs_card_insertion: socket %d SS_SetSocket failed\n",
sp->socket_num);
return (CS_BAD_SOCKET);
}
/*
* Grab the cis_lock mutex to protect the CIS-to-be and
* the CIS window, then fire off the CIS parser to
* create a local copy of the card's CIS.
*/
mutex_enter(&sp->cis_lock);
if ((ret = cs_create_cis(sp)) != CS_SUCCESS) {
mutex_exit(&sp->cis_lock);
return (ret);
}
mutex_exit(&sp->cis_lock);
/*
* If we have a pending CS_EVENT_CARD_REMOVAL event it
* means that we likely got CD line bounce on the
* insertion, so destroy the CIS and terminate this
* processing. We'll get called back to handle the
* insertion again later.
*/
if (sp->events & CS_EVENT_CARD_REMOVAL) {
mutex_enter(&sp->cis_lock);
(void) cs_destroy_cis(sp);
mutex_exit(&sp->cis_lock);
} else {
/*
* Schedule the call to the Socket Services work thread.
*/
mutex_enter(&sp->ss_thread_lock);
sp->ss_thread_state |= SOCKET_THREAD_CSCISInit;
cv_broadcast(&sp->ss_thread_cv);
mutex_exit(&sp->ss_thread_lock);
} /* if (CS_EVENT_CARD_REMOVAL) */
} /* if (CS_EVENT_CARD_READY) */
/*
* Socket Services has parsed the CIS and has done any other
* work to get the client driver loaded and attached if
* necessary, so setup the per-client state.
*/
if (event == CS_EVENT_SS_UPDATED) {
client_t *client;
/*
* Now that we and SS are done handling the card insertion
* semantics, go through each client on this socket and set
* the CS_EVENT_CARD_INSERTION event in each client's event
* field. We do this here instead of in cs_event so that
* when a client gets a CS_EVENT_CARD_INSERTION event, the
* card insertion and ready processing has already been done
* and SocketServices has had a chance to create a dip for
* the card in this socket.
*/
mutex_enter(&sp->lock);
client = sp->client_list;
while (client) {
client->events |= (CS_EVENT_CARD_INSERTION &
(client->event_mask | client->global_mask));
client = client->next;
} /* while (client) */
mutex_exit(&sp->lock);
} /* if (CS_EVENT_SS_UPDATED) */
return (CS_SUCCESS);
}
/*
* cs_card_removal - handle card removal events
*
* Destroy the CIS.
*
* calling: sp - pointer to socket structure
*
*/
static int
cs_card_removal(cs_socket_t *sp)
{
set_socket_t set_socket;
int ret;
#ifdef CS_DEBUG
if (cs_debug > 0) {
cmn_err(CE_CONT, "cs_card_removal: socket %d\n", sp->socket_num);
}
#endif
/*
* Remove any pending card ready timer
*/
UNTIMEOUT(sp->rdybsy_tmo_id);
/*
* Clear various flags so that everyone else knows that there's
* nothing on this socket anymore. Note that we clear the
* SOCKET_CARD_INSERTED and SOCKET_IS_IO flags in the
* ss_to_cs_events event mapping function.
*/
mutex_enter(&sp->lock);
sp->thread_state &= ~(SOCKET_WAIT_FOR_READY | SOCKET_RESET_TIMER);
/*
* Turn off socket power and set the socket back to memory mode.
* Disable all socket events except for CARD_INSERTION events.
*/
sp->event_mask = CS_EVENT_CARD_INSERTION;
mutex_exit(&sp->lock);
set_socket.socket = sp->socket_num;
set_socket.SCIntMask = SBM_CD;
set_socket.IREQRouting = 0;
set_socket.IFType = IF_MEMORY;
set_socket.CtlInd = 0; /* turn off controls and indicators */
set_socket.State = (unsigned)~0; /* clear latched state bits */
(void) cs_convert_powerlevel(sp->socket_num, 0, VCC,
&set_socket.VccLevel);
(void) cs_convert_powerlevel(sp->socket_num, 0, VPP1,
&set_socket.Vpp1Level);
(void) cs_convert_powerlevel(sp->socket_num, 0, VPP2,
&set_socket.Vpp2Level);
if ((ret = SocketServices(SS_SetSocket, &set_socket)) != SUCCESS) {
cmn_err(CE_CONT,
"cs_card_removal: socket %d SS_SetSocket failure %d\n",
sp->socket_num, ret);
return (ret);
}
#ifdef CS_DEBUG
if (cs_debug > 2) {
cmn_err(CE_CONT, "cs_card_removal: socket %d "
"calling cs_destroy_cis\n",
sp->socket_num);
}
#endif
/*
* Destroy the CIS and tell Socket Services that we're done
* handling the card removal event.
*/
mutex_enter(&sp->cis_lock);
(void) cs_destroy_cis(sp);
mutex_exit(&sp->cis_lock);
#ifdef CS_DEBUG
if (cs_debug > 2) {
cmn_err(CE_CONT, "cs_card_removal: calling CSCardRemoved\n");
}
#endif
SocketServices(CSCardRemoved, sp->socket_num);
return (CS_SUCCESS);
}
/*
* ss_to_cs_events - convert Socket Services events to Card Services event
* masks; this function will not read the PRR if the
* socket is in IO mode; this happens in cs_event_thread
*
* This function returns a bit mask of events.
*
* Note that we do some simple hysterious on card insertion and card removal
* events to prevent spurious insertion and removal events from being
* propogated down the chain.
*/
static event_t
ss_to_cs_events(cs_socket_t *sp, event_t event)
{
event_t revent = 0;
switch (event) {
case PCE_CARD_STATUS_CHANGE:
revent |= CS_EVENT_STATUS_CHANGE;
break;
case PCE_CARD_REMOVAL:
if (sp->flags & SOCKET_CARD_INSERTED) {
sp->flags &= ~(SOCKET_CARD_INSERTED | SOCKET_IS_IO);
revent |= CS_EVENT_CARD_REMOVAL;
/*
* If we're processing a removal event, it makes
* no sense to keep any insertion or ready events,
* so nuke them here. This will not clear any
* insertion events in the per-client event field.
*/
sp->events &= ~(CS_EVENT_CARD_INSERTION |
CS_EVENT_CARD_READY |
CS_EVENT_READY_TIMEOUT);
/*
* We also don't need to wait for READY anymore since
* it probably won't show up, or if it does, it will
* be a bogus READY event as the card is sliding out
* of the socket. Since we never do a cv_wait on the
* card ready timer, it's OK for that timer to either
* never go off (via an UNTIMEOUT in cs_card_removal)
* or to go off but not do a cv_broadcast (since the
* SOCKET_WAIT_FOR_READY flag is cleared here).
*/
sp->thread_state &= ~SOCKET_WAIT_FOR_READY;
}
break;
case PCE_CARD_INSERT:
if (!(sp->flags & SOCKET_CARD_INSERTED)) {
sp->flags |= SOCKET_CARD_INSERTED;
revent |= CS_EVENT_CARD_INSERTION;
}
break;
case PCE_CARD_READY:
if (sp->flags & SOCKET_CARD_INSERTED)
revent |= CS_EVENT_CARD_READY;
break;
case PCE_CARD_BATTERY_WARN:
if (sp->flags & SOCKET_CARD_INSERTED)
revent |= CS_EVENT_BATTERY_LOW;
break;
case PCE_CARD_BATTERY_DEAD:
if (sp->flags & SOCKET_CARD_INSERTED)
revent |= CS_EVENT_BATTERY_DEAD;
break;
case PCE_CARD_WRITE_PROTECT:
if (sp->flags & SOCKET_CARD_INSERTED)
revent |= CS_EVENT_WRITE_PROTECT;
break;
case PCE_PM_RESUME:
revent |= CS_EVENT_PM_RESUME;
break;
case PCE_PM_SUSPEND:
revent |= CS_EVENT_PM_SUSPEND;
break;
default:
cmn_err(CE_CONT, "ss_to_cs_events: unknown event 0x%x\n",
(int)event);
break;
} /* switch(event) */
return (revent);
}
/*
* cs_ready_timeout - general purpose READY/BUSY and RESET timer
*
* Note that we really only expect one of the two events to be asserted when
* we are called. XXX - Perhaps this might be a problem later on??
*
* There is also the problem of cv_broadcast dropping the interrupt
* priority, even though we have our high-priority mutex held. If
* we hold our high-priority mutex (sp->lock) over a cv_broadcast, and
* we get a high-priority interrupt during this time, the system will
* deadlock or panic. Thanks to Andy Banta for finding this out in
* the SPC/S (stc.c) driver.
*
* This callback routine can not grab the sp->client_lock mutex or deadlock
* will result.
*/
void
cs_ready_timeout(void *arg)
{
cs_socket_t *sp = arg;
kcondvar_t *cvp = NULL;
mutex_enter(&sp->lock);
if (sp->thread_state & SOCKET_RESET_TIMER) {
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_ready_timeout: SOCKET_RESET_TIMER socket %d\n",
sp->socket_num);
}
#endif
cvp = &sp->reset_cv;
}
if (sp->thread_state & SOCKET_WAIT_FOR_READY) {
sp->events |= CS_EVENT_READY_TIMEOUT;
cvp = &sp->thread_cv;
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_ready_timeout: SOCKET_WAIT_FOR_READY "
"socket %d\n", sp->socket_num);
}
#endif
}
mutex_exit(&sp->lock);
if (cvp)
cv_broadcast(cvp);
}
/*
* cs_event_softintr_timeout - wrapper function to call cs_socket_event_softintr
*/
/* ARGSUSED */
void
cs_event_softintr_timeout(void *arg)
{
/*
* If we're trying to unload this module, then don't do
* anything but exit.
* We acquire the cs_globals.global_lock mutex here so that
* we can correctly synchronize with cs_deinit when it
* is telling us to shut down. XXX - is this bogus??
*/
mutex_enter(&cs_globals.global_lock);
if (!(cs_globals.init_state & GLOBAL_INIT_STATE_UNLOADING)) {
mutex_exit(&cs_globals.global_lock);
(void) cs_socket_event_softintr(NULL);
cs_globals.sotfint_tmo = timeout(cs_event_softintr_timeout,
NULL, SOFTINT_TIMEOUT_TIME);
} else {
mutex_exit(&cs_globals.global_lock);
}
}
/*
* cs_socket_event_softintr - This function just does a cv_broadcast on behalf
* of the high-priority interrupt handler.
*
* Note: There is no calling argument.
*/
/*ARGSUSED*/
uint32_t
cs_socket_event_softintr(caddr_t notused)
{
cs_socket_t *sp;
uint32_t sn;
int ret = DDI_INTR_UNCLAIMED;
/*
* If the module is on it's way out, then don't bother
* to do anything else except return.
*/
mutex_enter(&cs_globals.global_lock);
if ((cs_globals.init_state & GLOBAL_INIT_STATE_UNLOADING) ||
(cs_globals.init_state & GLOBAL_IN_SOFTINTR)) {
mutex_exit(&cs_globals.global_lock);
/*
* Note that we return DDI_INTR_UNCLAIMED here
* since we don't want to be constantly
* called back.
*/
return (ret);
} else {
cs_globals.init_state |= GLOBAL_IN_SOFTINTR;
mutex_exit(&cs_globals.global_lock);
}
/*
* Go through each socket and dispatch the appropriate events.
* We have to funnel everything through this one routine because
* we can't do a cv_broadcast from a high level interrupt handler
* and we also can't have more than one soft interrupt handler
* on a single dip and using the same handler address.
*/
for (sn = 0; sn < cs_globals.max_socket_num; sn++) {
if ((sp = cs_get_sp(sn)) != NULL) {
if (sp->init_state & SOCKET_INIT_STATE_READY) {
/*
* If we're being asked to unload CS, then don't bother
* waking up the socket event thread handler.
*/
if (!(sp->flags & SOCKET_UNLOAD_MODULE) &&
(sp->flags & SOCKET_NEEDS_THREAD)) {
ret = DDI_INTR_CLAIMED;
mutex_enter(&sp->client_lock);
cv_broadcast(&sp->thread_cv);
mutex_exit(&sp->client_lock);
} /* if (SOCKET_NEEDS_THREAD) */
} /* if (SOCKET_INIT_STATE_READY) */
} /* cs_get_sp */
} /* for (sn) */
mutex_enter(&cs_globals.global_lock);
cs_globals.init_state &= ~GLOBAL_IN_SOFTINTR;
mutex_exit(&cs_globals.global_lock);
return (ret);
}
/*
* cs_event_thread - This is the per-socket event thread.
*/
static void
cs_event_thread(uint32_t sn)
{
cs_socket_t *sp;
client_t *client;
client_types_t *ct;
if ((sp = cs_get_sp(sn)) == NULL)
return;
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_event_thread: socket %d thread started\n",
sp->socket_num);
}
#endif
CALLB_CPR_INIT(&sp->cprinfo_cs, &sp->client_lock,
callb_generic_cpr, "cs_event_thread");
mutex_enter(&sp->client_lock);
for (;;) {
CALLB_CPR_SAFE_BEGIN(&sp->cprinfo_cs);
cv_wait(&sp->thread_cv, &sp->client_lock);
CALLB_CPR_SAFE_END(&sp->cprinfo_cs, &sp->client_lock);
mutex_enter(&sp->lock);
sp->flags &= ~SOCKET_NEEDS_THREAD;
mutex_exit(&sp->lock);
/*
* Check to see if there are any special thread operations that
* we are being asked to perform.
*/
if (sp->thread_state & SOCKET_THREAD_EXIT) {
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_event_thread: socket %d "
"SOCKET_THREAD_EXIT\n",
sp->socket_num);
}
#endif
CALLB_CPR_EXIT(&sp->cprinfo_cs);
cv_broadcast(&sp->caller_cv); /* wakes up cs_deinit */
mutex_exit(&sp->client_lock);
return;
} /* if (SOCKET_THREAD_EXIT) */
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_event_thread: socket %d sp->events 0x%x\n",
sp->socket_num,
(int)sp->events);
}
#endif
/*
* Handle CS_EVENT_CARD_INSERTION events
*/
if (sp->events & CS_EVENT_CARD_INSERTION) {
mutex_enter(&sp->lock);
sp->events &= ~CS_EVENT_CARD_INSERTION;
mutex_exit(&sp->lock);
/*
* If we have a pending CS_EVENT_CARD_REMOVAL event it
* means that we likely got CD line bounce on the
* insertion, so terminate this processing.
*/
if ((sp->events & CS_EVENT_CARD_REMOVAL) == 0) {
(void) cs_card_insertion(sp, CS_EVENT_CARD_INSERTION);
}
#ifdef CS_DEBUG
else if (cs_debug > 0) {
cmn_err(CE_CONT, "cs_event_thread: socket %d "
"CS_EVENT_CARD_REMOVAL event "
"terminating "
"CS_EVENT_CARD_INSERTION "
"processing\n", sp->socket_num);
}
#endif
} /* if (CS_EVENT_CARD_INSERTION) */
/*
* Handle CS_EVENT_CARD_READY and CS_EVENT_READY_TIMEOUT events
*/
if (sp->events & (CS_EVENT_CARD_READY | CS_EVENT_READY_TIMEOUT)) {
mutex_enter(&sp->lock);
sp->events &= ~(CS_EVENT_CARD_READY | CS_EVENT_READY_TIMEOUT);
mutex_exit(&sp->lock);
if (sp->thread_state & SOCKET_WAIT_FOR_READY) {
mutex_enter(&sp->lock);
sp->thread_state &= ~SOCKET_WAIT_FOR_READY;
mutex_exit(&sp->lock);
(void) cs_card_insertion(sp, CS_EVENT_CARD_READY);
} /* if (SOCKET_WAIT_FOR_READY) */
} /* if (CS_EVENT_CARD_READY) */
/*
* Handle CS_EVENT_SS_UPDATED events
*/
if (sp->events & CS_EVENT_SS_UPDATED) {
mutex_enter(&sp->lock);
sp->events &= ~CS_EVENT_SS_UPDATED;
mutex_exit(&sp->lock);
(void) cs_card_insertion(sp, CS_EVENT_SS_UPDATED);
} /* if (CS_EVENT_SS_UPDATED) */
/*
* Handle CS_EVENT_STATUS_CHANGE events
*/
if (sp->events & CS_EVENT_STATUS_CHANGE) {
event_t revent;
mutex_enter(&sp->cis_lock);
mutex_enter(&sp->lock);
sp->events &= ~CS_EVENT_STATUS_CHANGE;
/*
* Go through each client and add any events that we saw to
* the client's event list if the client has that event
* enabled in their event mask.
* Remove any events that may be pending for this client if
* the client's event mask says that the client doesn't
* want to see those events anymore. This handles the
* case where the client had an event enabled in it's
* event mask when the event came in but between that
* time and the time we're called here the client
* disabled that event.
*/
client = sp->client_list;
while (client) {
/*
* Read the PRR (if it exists) and check for any events.
* The PRR will only be read if the socket is in IO
* mode, if there is a card in the socket, and if there
* is a PRR.
* We don't have to clear revent before we call the
* cs_read_event_status function since it will
* clear it before adding any current events.
*/
if (client->flags & CLIENT_CARD_INSERTED) {
(void) cs_read_event_status(sp, client,
&revent, NULL, 0);
client->events = ((client->events | revent) &
(client->event_mask |
client->global_mask));
} /* CLIENT_CARD_INSERTED */
client = client->next;
} /* while (client) */
mutex_exit(&sp->lock);
mutex_exit(&sp->cis_lock);
} /* if (CS_EVENT_STATUS_CHANGE) */
/*
* We want to maintain the required event dispatching order as
* specified in the PCMCIA spec, so we cycle through all
* clients on this socket to make sure that they are
* notified in the correct order.
*/
ct = &client_types[0];
while (ct) {
/*
* Point to the head of the client list for this socket, and go
* through each client to set up the client events as well
* as call the client's event handler directly if we have
* a high priority event that we need to tell the client
* about.
*/
client = sp->client_list;
if (ct->order & CLIENT_EVENTS_LIFO) {
client_t *clp = NULL;
while (client) {
clp = client;
client = client->next;
}
client = clp;
}
while (client) {
if (client->flags & ct->type) {
uint32_t bit = 0;
event_t event;
while (client->events) {
switch (event = CS_BIT_GET(client->events, bit)) {
/*
* Clients always receive registration complete
* events, even if there is no card of
* their type currently in the socket.
*/
case CS_EVENT_REGISTRATION_COMPLETE:
CLIENT_EVENT_CALLBACK(client, event,
CS_EVENT_PRI_LOW);
break;
/*
* The client only gets a card insertion event
* if there is currently a card in the
* socket that the client can control.
* The nexus determines this. We also
* prevent the client from receiving
* multiple CS_EVENT_CARD_INSERTION
* events without receiving intervening
* CS_EVENT_CARD_REMOVAL events.
*/
case CS_EVENT_CARD_INSERTION:
if (cs_card_for_client(client)) {
int send_insertion;
mutex_enter(&sp->lock);
send_insertion = client->flags;
client->flags |=
(CLIENT_CARD_INSERTED |
CLIENT_SENT_INSERTION);
mutex_exit(&sp->lock);
if (!(send_insertion &
CLIENT_SENT_INSERTION)) {
CLIENT_EVENT_CALLBACK(client,
event, CS_EVENT_PRI_LOW);
} /* if (!CLIENT_SENT_INSERTION) */
}
break;
/*
* The CS_EVENT_CARD_REMOVAL_LOWP is a low
* priority CS_EVENT_CARD_REMOVAL event.
*/
case CS_EVENT_CARD_REMOVAL_LOWP:
mutex_enter(&sp->lock);
client->flags &= ~CLIENT_SENT_INSERTION;
mutex_exit(&sp->lock);
CLIENT_EVENT_CALLBACK(client,
CS_EVENT_CARD_REMOVAL,
CS_EVENT_PRI_LOW);
break;
/*
* The hardware card removal events are handed
* to the client in cs_event at high
* priority interrupt time; this card
* removal event is a software-generated
* event.
*/
case CS_EVENT_CARD_REMOVAL:
if (client->flags & CLIENT_CARD_INSERTED) {
mutex_enter(&sp->lock);
client->flags &=
~(CLIENT_CARD_INSERTED |
CLIENT_SENT_INSERTION);
mutex_exit(&sp->lock);
CLIENT_EVENT_CALLBACK(client, event,
CS_EVENT_PRI_LOW);
}
break;
/*
* Write protect events require the info field
* of the client's event callback args to
* be zero if the card is not write
* protected and one if it is.
*/
case CS_EVENT_WRITE_PROTECT:
if (client->flags & CLIENT_CARD_INSERTED) {
get_ss_status_t gs;
mutex_enter(&sp->cis_lock);
mutex_enter(&sp->lock);
(void) cs_read_event_status(sp, client,
NULL,
&gs, 0);
if (gs.CardState & SBM_WP) {
client->event_callback_args.info =
(void *)
CS_EVENT_WRITE_PROTECT_WPON;
} else {
client->event_callback_args.info =
(void *)
CS_EVENT_WRITE_PROTECT_WPOFF;
}
mutex_exit(&sp->lock);
mutex_exit(&sp->cis_lock);
CLIENT_EVENT_CALLBACK(client, event,
CS_EVENT_PRI_LOW);
} /* CLIENT_CARD_INSERTED */
break;
case CS_EVENT_CLIENT_INFO:
CLIENT_EVENT_CALLBACK(client, event,
CS_EVENT_PRI_LOW);
break;
case 0:
break;
default:
if (client->flags & CLIENT_CARD_INSERTED) {
CLIENT_EVENT_CALLBACK(client, event,
CS_EVENT_PRI_LOW);
}
break;
} /* switch */
mutex_enter(&sp->lock);
CS_BIT_CLEAR(client->events, bit);
mutex_exit(&sp->lock);
bit++;
} /* while (client->events) */
} /* if (ct->type) */
if (ct->order & CLIENT_EVENTS_LIFO) {
client = client->prev;
} else {
client = client->next;
}
} /* while (client) */
ct = ct->next;
} /* while (ct) */
/*
* Handle CS_EVENT_CARD_REMOVAL events
*/
if (sp->events & CS_EVENT_CARD_REMOVAL) {
mutex_enter(&sp->lock);
sp->events &= ~CS_EVENT_CARD_REMOVAL;
mutex_exit(&sp->lock);
(void) cs_card_removal(sp);
} /* if (CS_EVENT_CARD_REMOVAL) */
/*
* If someone is waiting for us to complete, signal them now.
*/
if (sp->thread_state & SOCKET_WAIT_SYNC) {
mutex_enter(&sp->lock);
sp->thread_state &= ~SOCKET_WAIT_SYNC;
mutex_exit(&sp->lock);
cv_broadcast(&sp->caller_cv);
} /* SOCKET_WAIT_SYNC */
} /* for (;;) */
}
/*
* cs_card_for_client - checks to see if a card that the client can control
* is currently inserted in the socket. Socket Services
* has to tell us if this is the case.
*/
static int
cs_card_for_client(client_t *client)
{
/*
* If the client has set the CS_EVENT_ALL_CLIENTS it means that they
* want to get all events for all clients, irrespective of
* whether or not there is a card in the socket. Such clients
* have to be very careful if they touch the card hardware in
* any way to prevent causing problems for other clients on the
* same socket. This flag will typically only be set by the
* "super-client" or CSI types of clients that wish to get
* information on other clients or cards in the system.
* Note that the CS_EVENT_ALL_CLIENTS must be set in either the
* client's global event mask or client event mask.
* The client must also have registered as a "super-client" or as a
* CSI client for this socket.
*/
if ((client->flags & (CLIENT_SUPER_CLIENT | CLIENT_CSI_CLIENT)) &&
((client->global_mask | client->event_mask) &
CS_EVENT_ALL_CLIENTS))
return (1);
/*
* Look for the PCM_DEV_ACTIVE property on this client's dip; if
* it's found, it means that this client can control the card
* that is currently in the socket. This is a boolean
* property managed by Socket Services.
*/
if (ddi_getprop(DDI_DEV_T_ANY, client->dip, (DDI_PROP_CANSLEEP |
DDI_PROP_NOTPROM),
PCM_DEV_ACTIVE, NULL)) {
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_card_for_client: client handle 0x%x "
"driver [%s] says %s found\n",
(int)client->client_handle,
client->driver_name,
PCM_DEV_ACTIVE);
}
#endif
return (1);
}
return (0);
}
/*
* cs_ss_thread - This is the Socket Services work thread. We fire off
* any calls to Socket Services here that we want
* to run on a thread that is seperate from the
* per-socket event thread.
*/
static void
cs_ss_thread(uint32_t sn)
{
cs_socket_t *sp;
if ((sp = cs_get_sp(sn)) == NULL)
return;
/*
* Tell CPR that we've started a new thread.
*/
CALLB_CPR_INIT(&sp->cprinfo_ss, &sp->ss_thread_lock,
callb_generic_cpr, "cs_ss_thread");
mutex_enter(&sp->ss_thread_lock);
for (;;) {
CALLB_CPR_SAFE_BEGIN(&sp->cprinfo_ss);
cv_wait(&sp->ss_thread_cv, &sp->ss_thread_lock);
CALLB_CPR_SAFE_END(&sp->cprinfo_ss, &sp->ss_thread_lock);
/*
* Check to see if there are any special thread operations
* that we are being asked to perform.
*/
if (sp->ss_thread_state & SOCKET_THREAD_EXIT) {
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_ss_thread: socket %d "
"SOCKET_THREAD_EXIT\n",
sp->socket_num);
}
#endif
CALLB_CPR_EXIT(&sp->cprinfo_ss);
cv_broadcast(&sp->ss_caller_cv); /* wake up cs_deinit */
mutex_exit(&sp->ss_thread_lock);
return;
} /* if (SOCKET_THREAD_EXIT) */
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_ss_thread: socket %d "
"ss_thread_state = 0x%x\n",
(int)sp->socket_num,
(int)sp->ss_thread_state);
}
#endif
/*
* Call SocketServices(CSCISInit) to have SS parse the
* CIS and load/attach any client drivers necessary.
*/
if (sp->ss_thread_state & SOCKET_THREAD_CSCISInit) {
sp->ss_thread_state &= ~SOCKET_THREAD_CSCISInit;
if (!(sp->flags & SOCKET_CARD_INSERTED)) {
cmn_err(CE_CONT, "cs_ss_thread %d "
"card NOT inserted\n",
sp->socket_num);
}
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_ss_thread: socket %d calling "
"CSCISInit\n", sp->socket_num);
}
#endif
/*
* Tell SS that we have a complete CIS and that it can now
* be parsed.
* Note that in some cases the client driver may block in
* their attach routine, causing this call to block until
* the client completes their attach.
*/
SocketServices(CSCISInit, sp->socket_num);
/*
* Set the CS_EVENT_SS_UPDATED event for this socket so that the
* event thread can continue any card insertion processing
* that it has to do.
*/
mutex_enter(&sp->lock);
sp->events |= CS_EVENT_SS_UPDATED;
mutex_exit(&sp->lock);
/*
* Wake up this socket's event thread so that clients can
* continue any card insertion or attach processing
* that they need to do.
*/
cv_broadcast(&sp->thread_cv);
} /* if ST_CSCISInit */
} /* for (;;) */
}
/*
* cs_request_socket_mask - set the client's event mask as well as causes
* any events pending from RegisterClient to
* be scheduled to be sent to the client
*/
static int
cs_request_socket_mask(client_handle_t client_handle,
request_socket_mask_t *se)
{
cs_socket_t *sp;
client_t *client;
int error;
int client_lock_acquired;
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't do anything except for return success.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_SUCCESS);
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
}
mutex_enter(&sp->lock);
/*
* If this client has already done a RequestSocketMask without
* a corresponding ReleaseSocketMask, then return an error.
*/
if (client->flags & REQ_SOCKET_MASK_DONE) {
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_IN_USE);
}
/*
* Set up the event mask information; we copy this directly from
* the client; since we are the only source of events, any
* bogus bits that the client puts in here won't matter
* because we'll never look at them.
*/
client->event_mask = se->EventMask;
/*
* If RegisterClient left us some events to process, set these
* events up here.
*/
if (client->pending_events) {
client->events |= client->pending_events;
client->pending_events = 0;
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_request_socket_mask: client_handle = 0x%x "
"driver_name = [%s] events = 0x%x\n",
(int)client->client_handle,
client->driver_name,
(int)client->events);
}
#endif
}
client->flags |= REQ_SOCKET_MASK_DONE;
/*
* Merge all the clients' event masks and set the socket
* to generate the appropriate events.
*/
(void) cs_set_socket_event_mask(sp, cs_merge_event_masks(sp, client));
mutex_exit(&sp->lock);
/*
* Wakeup the event thread if there are any client events to process.
*/
if (client->events) {
cv_broadcast(&sp->thread_cv);
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_request_socket_mask: did cv_broadcast for "
"client_handle = 0x%x "
"driver_name = [%s] events = 0x%x\n",
(int)client->client_handle,
client->driver_name,
(int)client->events);
}
#endif
}
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
}
/*
* cs_release_socket_mask - clear the client's event mask
*
* Once this function returns, the client is guaranteed
* not to get any more event callbacks.
*/
/*ARGSUSED*/
static int
cs_release_socket_mask(client_handle_t client_handle,
release_socket_mask_t *rsm)
{
cs_socket_t *sp;
client_t *client;
int error;
int client_lock_acquired;
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't do anything except for return success.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_SUCCESS);
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
}
mutex_enter(&sp->lock);
/*
* If this client has already done a RequestSocketMask without
* a corresponding ReleaseSocketMask, then return an error.
*/
if (!(client->flags & REQ_SOCKET_MASK_DONE)) {
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_SOCKET);
}
/*
* Clear both the client event mask and the global event mask.
* We clear both since the semantics of this function are
* that once it returns, the client will not be called at
* it's event handler for any events until RequestSocketMask
* is called again.
*/
client->event_mask = 0;
client->global_mask = 0;
client->flags &= ~REQ_SOCKET_MASK_DONE;
/*
* Merge all the clients' event masks and set the socket
* to generate the appropriate events.
*/
(void) cs_set_socket_event_mask(sp, cs_merge_event_masks(sp, client));
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
}
/*
* cs_get_event_mask - return the event mask for this client
*/
static int
cs_get_event_mask(client_handle_t client_handle, sockevent_t *se)
{
cs_socket_t *sp;
client_t *client;
int error;
int client_lock_acquired;
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't do anything except for return success.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_SUCCESS);
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
}
mutex_enter(&sp->lock);
#ifdef XXX
/*
* If there's no card in the socket or the card in the socket is not
* for this client, then return an error.
* XXX - how can a client get their event masks if their card
* goes away?
*/
if (!(client->flags & CLIENT_CARD_INSERTED)) {
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_NO_CARD);
}
#endif
/*
* We are only allowed to get the client event mask if a
* RequestSocketMask has been called previously. We
* are allowed to get the global event mask at any
* time.
* The global event mask is initially set by the client
* in the call to RegisterClient. The client event
* mask is set by the client in calls to SetEventMask
* and RequestSocketMask and gotten in calls to
* GetEventMask.
*/
if (se->Attributes & CONF_EVENT_MASK_CLIENT) {
if (!(client->flags & REQ_SOCKET_MASK_DONE)) {
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_SOCKET);
}
se->EventMask = client->event_mask;
} else {
se->EventMask = client->global_mask;
}
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
}
/*
* cs_set_event_mask - set the event mask for this client
*/
static int
cs_set_event_mask(client_handle_t client_handle, sockevent_t *se)
{
cs_socket_t *sp;
client_t *client;
int error;
int client_lock_acquired;
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't do anything except for return success.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_SUCCESS);
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
}
mutex_enter(&sp->lock);
#ifdef XXX
/*
* If there's no card in the socket or the card in the socket is not
* for this client, then return an error.
*/
if (!(client->flags & CLIENT_CARD_INSERTED)) {
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_NO_CARD);
}
#endif
/*
* We are only allowed to set the client event mask if a
* RequestSocketMask has been called previously. We
* are allowed to set the global event mask at any
* time.
* The global event mask is initially set by the client
* in the call to RegisterClient. The client event
* mask is set by the client in calls to SetEventMask
* and RequestSocketMask and gotten in calls to
* GetEventMask.
*/
if (se->Attributes & CONF_EVENT_MASK_CLIENT) {
if (!(client->flags & REQ_SOCKET_MASK_DONE)) {
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_SOCKET);
}
client->event_mask = se->EventMask;
} else {
client->global_mask = se->EventMask;
}
/*
* Merge all the clients' event masks and set the socket
* to generate the appropriate events.
*/
(void) cs_set_socket_event_mask(sp, cs_merge_event_masks(sp, client));
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
}
/*
* cs_read_event_status - handles PRR events and returns card status
*
* calling: *sp - socket struct point
* *client - client to check events on
* *revent - pointer to event mask to update; if NULL, will
* not be updated, if non-NULL, will be updated
* with CS-format events; it is NOT necessary
* to clear this value before calling this
* function
* *gs - pointer to a get_ss_status_t used for the SS GetStatus
* call; it is not necessary to initialize any
* members in this structure; set to NULL if
* not used
* flags - if CS_RES_IGNORE_NO_CARD is set, the check for a
* card present will not be done
*
* returns: CS_SUCCESS
* CS_NO_CARD - if no card is in the socket and the flags arg
* is not set to CS_RES_IGNORE_NO_CARD
* CS_BAD_SOCKET - if the SS_GetStatus function returned an
* error
*
* Note that if the client that configured this socket has told us that
* the READY pin in the PRR isn't valid and the socket is in IO
* mode, we always return that the card is READY.
*
* Note that if gs is not NULL, the current card state will be returned
* in the gs->CardState member; this will always reflect the
* current card state and the state will come from both the
* SS_GetStatus call and the PRR, whichever is appropriate for
* the mode that the socket is currently in.
*/
static int
cs_read_event_status(cs_socket_t *sp, client_t *client, event_t *revent,
get_ss_status_t *gs, int flags)
{
cfg_regs_t prrd = 0;
/*
* SOCKET_IS_IO will only be set if a RequestConfiguration
* has been done by at least one client on this socket.
* If there isn't a card in the socket or the caller wants to ignore
* whether the card is in the socket or not, get the current
* card status.
*/
if ((sp->flags & SOCKET_CARD_INSERTED) ||
(flags & CS_RES_IGNORE_NO_CARD)) {
if (sp->flags & SOCKET_IS_IO) {
if (client->present & CONFIG_PINREPL_REG_PRESENT) {
acc_handle_t cis_handle;
uint32_t newoffset = client->config_regs_offset;
/*
* Get a handle to the CIS window
*/
if (cs_init_cis_window(sp, &newoffset, &cis_handle,
CISTPLF_AM_SPACE) != CS_SUCCESS) {
cmn_err(CE_CONT, "cs_read_event_status: socket %d "
"can't init CIS window\n",
sp->socket_num);
return (CS_GENERAL_FAILURE);
} /* cs_init_cis_window */
prrd = csx_Get8(cis_handle, client->config_regs.prr_p);
prrd &= client->pin;
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_read_event_status: "
"prrd 0x%x client->pin 0x%x\n",
(int)prrd,
client->pin);
cmn_err(CE_CONT, "PRR(1) = [%s%s%s%s%s%s%s%s]\n",
((prrd & PRR_WP_STATUS)?
"PRR_WP_STATUS ":""),
((prrd & PRR_READY_STATUS)?
"PRR_READY_STATUS ":""),
((prrd & PRR_BVD2_STATUS)?
"PRR_BVD2_STATUS ":""),
((prrd & PRR_BVD1_STATUS)?
"PRR_BVD1_STATUS ":""),
((prrd & PRR_WP_EVENT)?
"PRR_WP_EVENT ":""),
((prrd & PRR_READY_EVENT)?
"PRR_READY_EVENT ":""),
((prrd & PRR_BVD2_EVENT)?
"PRR_BVD2_EVENT ":""),
((prrd & PRR_BVD1_EVENT)?
"PRR_BVD1_EVENT ":""));
}
#endif
/*
* The caller wants the event changes sent back and
* the PRR event change bits cleared.
*/
if (revent) {
get_socket_t get_socket;
set_socket_t set_socket;
/*
* Bug ID: 1193636 - Card Services sends bogus
* events on CS_EVENT_STATUS_CHANGE events
* Clear this before we OR-in any values.
*/
*revent = 0;
PRR_EVENT(prrd, PRR_WP_EVENT, PRR_WP_STATUS,
CS_EVENT_WRITE_PROTECT, *revent);
PRR_EVENT(prrd, PRR_READY_EVENT, PRR_READY_STATUS,
CS_EVENT_CARD_READY, *revent);
PRR_EVENT(prrd, PRR_BVD2_EVENT, PRR_BVD2_STATUS,
CS_EVENT_BATTERY_LOW, *revent);
PRR_EVENT(prrd, PRR_BVD1_EVENT, PRR_BVD1_STATUS,
CS_EVENT_BATTERY_DEAD, *revent);
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "PRR() = [%s%s%s%s%s%s%s%s]\n",
((prrd & PRR_WP_STATUS)?
"PRR_WP_STATUS ":""),
((prrd & PRR_READY_STATUS)?
"PRR_READY_STATUS ":""),
((prrd & PRR_BVD2_STATUS)?
"PRR_BVD2_STATUS ":""),
((prrd & PRR_BVD1_STATUS)?
"PRR_BVD1_STATUS ":""),
((prrd & PRR_WP_EVENT)?
"PRR_WP_EVENT ":""),
((prrd & PRR_READY_EVENT)?
"PRR_READY_EVENT ":""),
((prrd & PRR_BVD2_EVENT)?
"PRR_BVD2_EVENT ":""),
((prrd & PRR_BVD1_EVENT)?
"PRR_BVD1_EVENT ":""));
}
#endif
if (prrd)
csx_Put8(cis_handle, client->config_regs.prr_p,
prrd);
/*
* We now have to reenable the status change interrupts
* if there are any valid bits in the PRR. Since
* the BVD1 signal becomes the STATUS_CHANGE
* signal when the socket is in IO mode, we just
* have to set the SBM_BVD1 enable bit in the
* event mask.
*/
if (client->pin) {
get_socket.socket = sp->socket_num;
SocketServices(SS_GetSocket, &get_socket);
set_socket.socket = sp->socket_num;
set_socket.SCIntMask =
get_socket.SCIntMask | SBM_BVD1;
set_socket.VccLevel = get_socket.VccLevel;
set_socket.Vpp1Level = get_socket.Vpp1Level;
set_socket.Vpp2Level = get_socket.Vpp2Level;
set_socket.IREQRouting = get_socket.IRQRouting;
set_socket.IFType = get_socket.IFType;
set_socket.CtlInd = get_socket.CtlInd;
set_socket.State = get_socket.state;
SocketServices(SS_SetSocket, &set_socket);
} /* if (client->pin) */
} /* if (revent) */
} /* if (CONFIG_PINREPL_REG_PRESENT) */
} /* if (SOCKET_IS_IO) */
/*
* The caller wants the current card state; we just read
* it and return a copy of it but do not clear any of
* the event changed bits (if we're reading the PRR).
*/
if (gs) {
gs->socket = sp->socket_num;
gs->CardState = 0;
if (SocketServices(SS_GetStatus, gs) != SUCCESS)
return (CS_BAD_SOCKET);
if (sp->flags & SOCKET_IS_IO) {
/*
* If the socket is in IO mode, then clear the
* gs->CardState bits that are now in the PRR
*/
gs->CardState &= ~(SBM_WP | SBM_BVD1 |
SBM_BVD2 | SBM_RDYBSY);
/*
* Convert PRR status to SS_GetStatus status
*/
if (prrd & PRR_WP_STATUS)
gs->CardState |= SBM_WP;
if (prrd & PRR_BVD2_STATUS)
gs->CardState |= SBM_BVD2;
if (prrd & PRR_BVD1_STATUS)
gs->CardState |= SBM_BVD1;
/*
* If the client has indicated that there is no
* PRR or that the READY bit in the PRR isn't
* valid, then we simulate the READY bit by
* always returning READY.
*/
if (!(client->present & CONFIG_PINREPL_REG_PRESENT) ||
((client->present & CONFIG_PINREPL_REG_PRESENT) &&
!((client->pin &
(PRR_READY_STATUS | PRR_READY_EVENT)) ==
(PRR_READY_STATUS | PRR_READY_EVENT))) ||
(prrd & PRR_READY_STATUS))
gs->CardState |= SBM_RDYBSY;
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_read_event_status: prrd 0x%x "
"client->pin 0x%x "
"gs->CardState 0x%x\n",
prrd, client->pin, gs->CardState);
}
#endif
} /* if (SOCKET_IS_IO) */
} /* if (gs) */
return (CS_SUCCESS);
} /* if (SOCKET_CARD_INSERTED) */
return (CS_NO_CARD);
}
/*
* cs_get_status - gets live card status and latched card status changes
* supports the GetStatus CS call
*
* returns: CS_SUCCESS
* CS_BAD_HANDLE if the passed client handle is invalid
*
* Note: This function resets the latched status values maintained
* by Socket Services
*/
static int
cs_get_status(client_handle_t client_handle, get_status_t *gs)
{
cs_socket_t *sp;
client_t *client;
get_ss_status_t get_ss_status;
get_socket_t get_socket;
set_socket_t set_socket;
int error;
int client_lock_acquired;
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't do anything except for return success.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_SUCCESS);
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
}
/*
* Get the current card status as well as the latched card
* state. Set the CS_RES_IGNORE_NO_CARD so that even
* if there is no card in the socket we'll still get
* a valid status.
* Note that it is not necessary to initialize any values
* in the get_ss_status structure.
*/
mutex_enter(&sp->cis_lock);
if ((error = cs_read_event_status(sp, client, NULL, &get_ss_status,
CS_RES_IGNORE_NO_CARD)) != CS_SUCCESS) {
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
}
mutex_exit(&sp->cis_lock);
gs->raw_CardState = cs_sbm2cse(get_ss_status.CardState);
/*
* Assign the "live" card state to the "real" card state. If there's
* no card in the socket or the card in the socket is not
* for this client, then we lie and tell the caller that the
* card is not inserted.
*/
gs->CardState = gs->raw_CardState;
if (!(client->flags & CLIENT_CARD_INSERTED))
gs->CardState &= ~CS_EVENT_CARD_INSERTION;
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
get_socket.socket = sp->socket_num;
if (SocketServices(SS_GetSocket, &get_socket) != SUCCESS)
return (CS_BAD_SOCKET);
gs->SocketState = cs_sbm2cse(get_socket.state);
set_socket.socket = sp->socket_num;
set_socket.SCIntMask = get_socket.SCIntMask;
set_socket.VccLevel = get_socket.VccLevel;
set_socket.Vpp1Level = get_socket.Vpp1Level;
set_socket.Vpp2Level = get_socket.Vpp2Level;
set_socket.IREQRouting = get_socket.IRQRouting;
set_socket.IFType = get_socket.IFType;
set_socket.CtlInd = get_socket.CtlInd;
/* XXX (is ~0 correct here?) reset latched values */
set_socket.State = (unsigned)~0;
if (SocketServices(SS_SetSocket, &set_socket) != SUCCESS)
return (CS_BAD_SOCKET);
return (CS_SUCCESS);
}
/*
* cs_cse2sbm - converts a CS event mask to an SS (SBM_XXX) event mask
*/
static event_t
cs_cse2sbm(event_t event_mask)
{
event_t sbm_event = 0;
/*
* XXX - we need to handle PM_CHANGE and RESET here as well
*/
if (event_mask & CS_EVENT_WRITE_PROTECT)
sbm_event |= SBM_WP;
if (event_mask & CS_EVENT_BATTERY_DEAD)
sbm_event |= SBM_BVD1;
if (event_mask & CS_EVENT_BATTERY_LOW)
sbm_event |= SBM_BVD2;
if (event_mask & CS_EVENT_CARD_READY)
sbm_event |= SBM_RDYBSY;
if (event_mask & CS_EVENT_CARD_LOCK)
sbm_event |= SBM_LOCKED;
if (event_mask & CS_EVENT_EJECTION_REQUEST)
sbm_event |= SBM_EJECT;
if (event_mask & CS_EVENT_INSERTION_REQUEST)
sbm_event |= SBM_INSERT;
if (event_mask & (CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL))
sbm_event |= SBM_CD;
return (sbm_event);
}
/*
* cs_sbm2cse - converts SBM_xxx state to CS event bits
*
* This function should never set any of the following bits:
*
* CS_EVENT_MTD_REQUEST
* CS_EVENT_CLIENT_INFO
* CS_EVENT_TIMER_EXPIRED
* CS_EVENT_CARD_REMOVAL
* CS_EVENT_CARD_REMOVAL_LOWP
* CS_EVENT_ALL_CLIENTS
* CS_EVENT_READY_TIMEOUT
*
* These bits are defined in the CS_STATUS_XXX series and are
* used by GetStatus.
*/
static uint32_t
cs_sbm2cse(uint32_t state)
{
uint32_t rstate = 0;
/*
* XXX - we need to handle PM_CHANGE and RESET here as well
*/
if (state & SBM_WP)
rstate |= CS_EVENT_WRITE_PROTECT;
if (state & SBM_BVD1)
rstate |= CS_EVENT_BATTERY_DEAD;
if (state & SBM_BVD2)
rstate |= CS_EVENT_BATTERY_LOW;
if (state & SBM_RDYBSY)
rstate |= CS_EVENT_CARD_READY;
if (state & SBM_LOCKED)
rstate |= CS_EVENT_CARD_LOCK;
if (state & SBM_EJECT)
rstate |= CS_EVENT_EJECTION_REQUEST;
if (state & SBM_INSERT)
rstate |= CS_EVENT_INSERTION_REQUEST;
if (state & SBM_CD)
rstate |= CS_EVENT_CARD_INSERTION;
return (rstate);
}
/*
* cs_merge_event_masks - merge the CS global socket event mask with the
* passed client's event masks
*/
static unsigned
cs_merge_event_masks(cs_socket_t *sp, client_t *client)
{
unsigned SCIntMask;
uint32_t event_mask;
/*
* We always want to see card detect and status change events.
*/
SCIntMask = SBM_CD;
event_mask = client->event_mask | client->global_mask |
sp->event_mask;
if (!(sp->flags & SOCKET_IS_IO)) {
SCIntMask |= cs_cse2sbm(event_mask);
} else {
/*
* If the socket is in IO mode and there is a PRR present,
* then we may need to enable PCE_CARD_STATUS_CHANGE
* events.
*/
if (client->present & CONFIG_PINREPL_REG_PRESENT) {
SCIntMask |= (cs_cse2sbm(event_mask) &
~(SBM_WP | SBM_BVD1 | SBM_BVD2 | SBM_RDYBSY));
if ((client->pin & (PRR_WP_STATUS | PRR_WP_EVENT)) ==
(PRR_WP_STATUS | PRR_WP_EVENT))
if (event_mask & CS_EVENT_WRITE_PROTECT)
SCIntMask |= SBM_BVD1;
if ((client->pin & (PRR_READY_STATUS | PRR_READY_EVENT)) ==
(PRR_READY_STATUS | PRR_READY_EVENT))
if (event_mask & CS_EVENT_CARD_READY)
SCIntMask |= SBM_BVD1;
if ((client->pin & (PRR_BVD2_STATUS | PRR_BVD2_EVENT)) ==
(PRR_BVD2_STATUS | PRR_BVD2_EVENT))
if (event_mask & CS_EVENT_BATTERY_LOW)
SCIntMask |= SBM_BVD1;
if ((client->pin & (PRR_BVD1_STATUS | PRR_BVD1_EVENT)) ==
(PRR_BVD1_STATUS | PRR_BVD1_EVENT))
if (event_mask & CS_EVENT_BATTERY_DEAD)
SCIntMask |= SBM_BVD1;
} /* if (CONFIG_PINREPL_REG_PRESENT) */
} /* if (!SOCKET_IS_IO) */
return (SCIntMask);
}
/*
* cs_set_socket_event_mask - set the event mask for the socket
*/
static int
cs_set_socket_event_mask(cs_socket_t *sp, unsigned event_mask)
{
get_socket_t get_socket;
set_socket_t set_socket;
get_socket.socket = sp->socket_num;
if (SocketServices(SS_GetSocket, &get_socket) != SUCCESS)
return (CS_BAD_SOCKET);
set_socket.socket = sp->socket_num;
set_socket.SCIntMask = event_mask;
set_socket.VccLevel = get_socket.VccLevel;
set_socket.Vpp1Level = get_socket.Vpp1Level;
set_socket.Vpp2Level = get_socket.Vpp2Level;
set_socket.IREQRouting = get_socket.IRQRouting;
set_socket.IFType = get_socket.IFType;
set_socket.CtlInd = get_socket.CtlInd;
/* XXX (is ~0 correct here?) reset latched values */
set_socket.State = (unsigned)~0;
if (SocketServices(SS_SetSocket, &set_socket) != SUCCESS)
return (CS_BAD_SOCKET);
return (CS_SUCCESS);
}
/*
* ==== MTD handling section ====
*/
static int
cs_deregister_mtd(client_handle_t client_handle)
{
cmn_err(CE_CONT, "cs_deregister_mtd: client_handle 0x%x\n",
(int)client_handle);
return (CS_SUCCESS);
}
/*
* ==== memory window handling section ====
*/
/*
* cs_request_window - searches through window list for the socket to find a
* memory window that matches the requested criteria;
* this is RequestWindow
*
* calling: cs_request_window(client_handle_t, *window_handle_t, win_req_t *)
*
* On sucessful return, the window_handle_t * pointed to will
* contain a valid window handle for this window.
*
* returns: CS_SUCCESS - if window found
* CS_OUT_OF_RESOURCE - if no windows match requirements
* CS_BAD_HANDLE - client handle is invalid
* CS_BAD_SIZE - if requested size can not be met
* CS_BAD_WINDOW - if an internal error occured
* CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
* CS_NO_CARD - if no card is in socket
* CS_BAD_ATTRIBUTE - if any of the unsupported Attrbute
* flags are set
*/
static int
cs_request_window(client_handle_t client_handle,
window_handle_t *wh,
win_req_t *rw)
{
cs_socket_t *sp;
cs_window_t *cw;
client_t *client;
modify_win_t mw;
inquire_window_t iw;
uint32_t aw;
int error;
int client_lock_acquired;
uint32_t socket_num;
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't support SS using this call.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_UNSUPPORTED_FUNCTION);
/*
* Make sure that none of the unsupported flags are set.
*/
if (rw->Attributes & (/* Compatability */
WIN_PAGED |
WIN_SHARED |
WIN_FIRST_SHARED |
WIN_BINDING_SPECIFIC |
/* CS internal */
WIN_DATA_WIDTH_VALID |
/* IO window flags */
WIN_MEMORY_TYPE_IO |
/* CardBus flags */
WIN_DATA_WIDTH_32 |
WIN_PREFETCH_CACHE_MASK |
WIN_BAR_MASK))
return (CS_BAD_ATTRIBUTE);
mutex_enter(&cs_globals.window_lock);
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (error);
}
mutex_enter(&sp->lock);
/*
* If there's no card in the socket or the card in the socket is not
* for this client, then return an error.
*/
if (!(client->flags & CLIENT_CARD_INSERTED)) {
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_NO_CARD);
}
mutex_exit(&sp->lock);
socket_num = CS_MAKE_SOCKET_NUMBER(GET_CLIENT_SOCKET(client_handle),
GET_CLIENT_FUNCTION(client_handle));
/*
* See if we can find a window that matches the caller's criteria.
* If we can't, then thre's not much more that we can do except
* for return an error.
*/
if ((error = cs_find_mem_window(sp->socket_num, rw, &aw)) !=
CS_SUCCESS) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (error);
}
/*
* We got a window, now synthesize a new window handle for this
* client and get a pointer to the global window structs
* and assign this window to this client.
* We don't have to check for errors from cs_create_window_handle
* since that function always returns a valid window handle
* if it is given a valid window number.
*/
*wh = cs_create_window_handle(aw);
if ((cw = cs_get_wp(aw)) == NULL) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_BAD_WINDOW);
}
cw->window_handle = *wh;
cw->client_handle = client_handle;
cw->socket_num = sp->socket_num;
cw->state |= (CW_ALLOCATED | CW_MEM);
mw.Attributes = (
rw->Attributes |
WIN_DATA_WIDTH_VALID |
WIN_ACCESS_SPEED_VALID);
mw.AccessSpeed = rw->win_params.AccessSpeed;
if ((error = cs_modify_mem_window(*wh, &mw, rw, socket_num)) !=
CS_SUCCESS) {
cw->state = 0;
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (error);
}
/*
* Get any required card offset and pass it back to the client.
* This is not defined in the current PCMCIA spec. It is
* an aid to clients that want to use it to generate an
* optimum card offset.
*/
iw.window = GET_WINDOW_NUMBER(*wh);
SocketServices(SS_InquireWindow, &iw);
if (iw.mem_win_char.MemWndCaps & WC_CALIGN)
rw->ReqOffset = rw->Size;
else
rw->ReqOffset = iw.mem_win_char.ReqOffset;
/*
* Increment the client's memory window count; this is how we know
* when a client has any allocated memory windows.
*/
client->memwin_count++;
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_SUCCESS);
}
/*
* cs_release_window - deallocates the window associated with the passed
* window handle; this is ReleaseWindow
*
* returns: CS_SUCCESS if window handle is valid and window was
* sucessfully deallocated
* CS_BAD_HANDLE if window handle is invalid or if window
* handle is valid but window is not allocated
*/
static int
cs_release_window(window_handle_t wh)
{
cs_socket_t *sp;
cs_window_t *cw;
client_t *client;
int error;
int client_lock_acquired;
mutex_enter(&cs_globals.window_lock);
if (!(cw = cs_find_window(wh))) {
mutex_exit(&cs_globals.window_lock);
return (CS_BAD_HANDLE);
}
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't support SS using this call.
*/
if (CLIENT_HANDLE_IS_SS(cw->client_handle)) {
mutex_exit(&cs_globals.window_lock);
return (CS_UNSUPPORTED_FUNCTION);
}
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(cw->client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(cw->client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (error);
}
/*
* Mark this window as not in use anymore.
*/
cw->state &= ~CW_WIN_IN_USE;
/*
* Decrement the client's memory window count; this is how we know
* when a client has any allocated memory windows.
*/
if (!(--(client->memwin_count)))
client->flags &= ~CLIENT_WIN_ALLOCATED;
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_SUCCESS);
}
/*
* cs_modify_window - modifies a window's characteristics; this is ModifyWindow
*/
static int
cs_modify_window(window_handle_t wh, modify_win_t *mw)
{
cs_socket_t *sp;
cs_window_t *cw;
client_t *client;
int error;
int client_lock_acquired;
mutex_enter(&cs_globals.window_lock);
/*
* Do some sanity checking - make sure that we can find a pointer
* to the window structure, and if we can, get the client that
* has allocated that window.
*/
if (!(cw = cs_find_window(wh))) {
mutex_exit(&cs_globals.window_lock);
return (CS_BAD_HANDLE);
}
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(cw->client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
if (!(client = cs_find_client(cw->client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (error);
}
mutex_enter(&sp->lock);
/*
* If there's no card in the socket or the card in the socket is not
* for this client, then return an error.
*/
if (!(client->flags & CLIENT_CARD_INSERTED)) {
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_NO_CARD);
}
mutex_exit(&sp->lock);
mw->Attributes &= (
WIN_MEMORY_TYPE_MASK |
WIN_ENABLE |
WIN_ACCESS_SPEED_VALID |
WIN_ACC_ENDIAN_MASK |
WIN_ACC_ORDER_MASK);
mw->Attributes &= ~WIN_DATA_WIDTH_VALID;
if ((error = cs_modify_mem_window(wh, mw, NULL, NULL)) != CS_SUCCESS) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (error);
}
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_SUCCESS);
}
/*
* cs_modify_mem_window - modifies a window's characteristics; used internally
* by Card Services
*
* If *wr is NULL, it means that we're being called by ModifyWindow
* If *wr is non-NULL, it means that we are being called by RequestWindow
* and so we can't use SS_GetWindow.
*/
static int
cs_modify_mem_window(window_handle_t wh, modify_win_t *mw,
win_req_t *wr, int sn)
{
get_window_t gw;
set_window_t sw;
set_page_t set_page;
get_page_t get_page;
/*
* If the win_req_t struct pointer is NULL, it means that
* we're being called by ModifyWindow, so get the
* current window characteristics.
*/
if (!wr) {
gw.window = GET_WINDOW_NUMBER(wh);
if (SocketServices(SS_GetWindow, &gw) != SUCCESS)
return (CS_BAD_WINDOW);
sw.state = gw.state;
sw.socket = gw.socket;
sw.WindowSize = gw.size;
} else {
sw.state = 0;
sw.socket = sn;
sw.WindowSize = wr->Size;
}
/*
* If we're being called by RequestWindow, we must always have
* WIN_ACCESS_SPEED_VALID set since get_window_t is not
* defined.
*/
if (mw->Attributes & WIN_ACCESS_SPEED_VALID) {
convert_speed_t convert_speed;
convert_speed.Attributes = CONVERT_DEVSPEED_TO_NS;
convert_speed.devspeed = mw->AccessSpeed;
if (cs_convert_speed(&convert_speed) != CS_SUCCESS)
return (CS_BAD_SPEED);
sw.speed = convert_speed.nS;
} else {
sw.speed = gw.speed;
}
if (!wr) {
get_page.window = GET_WINDOW_NUMBER(wh);
get_page.page = 0;
if (SocketServices(SS_GetPage, &get_page) != SUCCESS)
return (CS_BAD_WINDOW);
set_page.state = get_page.state;
set_page.offset = get_page.offset;
} else {
set_page.state = 0;
set_page.offset = 0;
}
if (mw->Attributes & WIN_ENABLE) {
sw.state |= WS_ENABLED;
set_page.state |= PS_ENABLED;
} else {
sw.state &= ~WS_ENABLED;
set_page.state &= ~PS_ENABLED;
}
if (mw->Attributes & WIN_DATA_WIDTH_VALID) {
if (mw->Attributes & WIN_DATA_WIDTH_16)
sw.state |= WS_16BIT;
else
sw.state &= ~WS_16BIT;
}
sw.window = GET_WINDOW_NUMBER(wh);
sw.base = 0;
cs_set_acc_attributes(&sw, mw->Attributes);
if (SocketServices(SS_SetWindow, &sw) != SUCCESS)
return (CS_BAD_WINDOW);
if (mw->Attributes & WIN_MEMORY_TYPE_AM)
set_page.state |= PS_ATTRIBUTE;
else
set_page.state &= ~PS_ATTRIBUTE;
set_page.window = GET_WINDOW_NUMBER(wh);
set_page.page = 0;
if (SocketServices(SS_SetPage, &set_page) != SUCCESS)
return (CS_BAD_OFFSET);
/*
* Return the current base address of this window
*/
if (wr) {
gw.window = GET_WINDOW_NUMBER(wh);
if (SocketServices(SS_GetWindow, &gw) != SUCCESS)
return (CS_BAD_WINDOW);
wr->Base.handle = (acc_handle_t)gw.handle;
}
return (CS_SUCCESS);
}
/*
* cs_map_mem_page - sets the card offset of the mapped window
*/
static int
cs_map_mem_page(window_handle_t wh, map_mem_page_t *mmp)
{
cs_socket_t *sp;
cs_window_t *cw;
client_t *client;
inquire_window_t iw;
get_window_t gw;
set_page_t set_page;
get_page_t get_page;
int error;
uint32_t size;
int client_lock_acquired;
/*
* We don't support paged windows, so never allow a page number
* of other than 0
*/
if (mmp->Page)
return (CS_BAD_PAGE);
mutex_enter(&cs_globals.window_lock);
/*
* Do some sanity checking - make sure that we can find a pointer
* to the window structure, and if we can, get the client that
* has allocated that window.
*/
if (!(cw = cs_find_window(wh))) {
mutex_exit(&cs_globals.window_lock);
return (CS_BAD_HANDLE);
}
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(cw->client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
if (!(client = cs_find_client(cw->client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (error);
}
mutex_enter(&sp->lock);
/*
* If there's no card in the socket or the card in the socket is not
* for this client, then return an error.
*/
if (!(client->flags & CLIENT_CARD_INSERTED)) {
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_NO_CARD);
}
mutex_exit(&sp->lock);
gw.window = GET_WINDOW_NUMBER(wh);
SocketServices(SS_GetWindow, &gw);
iw.window = GET_WINDOW_NUMBER(wh);
SocketServices(SS_InquireWindow, &iw);
if (iw.mem_win_char.MemWndCaps & WC_CALIGN)
size = gw.size;
else
size = iw.mem_win_char.ReqOffset;
if (((mmp->CardOffset/size)*size) != mmp->CardOffset) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_BAD_OFFSET);
}
get_page.window = GET_WINDOW_NUMBER(wh);
get_page.page = 0;
SocketServices(SS_GetPage, &get_page);
set_page.window = GET_WINDOW_NUMBER(wh);
set_page.page = 0;
set_page.state = get_page.state;
set_page.offset = mmp->CardOffset;
if (SocketServices(SS_SetPage, &set_page) != SUCCESS) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_BAD_OFFSET);
}
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_SUCCESS);
}
/*
* cs_find_window - finds the window associated with the passed window
* handle; if the window handle is invalid or no
* windows match the passed window handle, NULL
* is returned. Note that the window must be
* allocated for this function to return a valid
* window pointer.
*
* returns: cs_window_t * pointer to the found window
* NULL if window handle invalid or window not allocated
*/
cs_window_t *
cs_find_window(window_handle_t wh)
{
cs_window_t *cw;
if ((GET_WINDOW_NUMBER(wh) > cs_globals.num_windows) ||
(GET_WINDOW_MAGIC(wh) != WINDOW_HANDLE_MAGIC))
return ((cs_window_t *)NULL);
if ((cw = cs_get_wp(GET_WINDOW_NUMBER(wh))) == NULL)
return (NULL);
if ((cw->state & CW_ALLOCATED) && (cw->state & CW_MEM))
return (cw);
return ((cs_window_t *)NULL);
}
/*
* cs_create_window_handle - creates a unique window handle based on the
* passed window number.
*/
static window_handle_t
cs_create_window_handle(uint32_t aw)
{
return (WINDOW_HANDLE_MAGIC | (aw & WINDOW_HANDLE_MASK));
}
/*
* cs_find_mem_window - tries to find a memory window matching the caller's
* criteria
*
* We return the first window that matches the requested criteria.
*
* returns: CS_SUCCESS - if memory window found
* CS_OUT_OF_RESOURCE - if no windows match requirements
* CS_BAD_SIZE - if requested size can not be met
* CS_BAD_WINDOW - if an internal error occured
*/
/* BEGIN CSTYLED */
static int
cs_find_mem_window(uint32_t sn, win_req_t *rw, uint32_t *assigned_window)
{
uint32_t wn;
int error = CS_OUT_OF_RESOURCE;
uint32_t window_num = PCMCIA_MAX_WINDOWS;
uint32_t min_size = UINT_MAX;
inquire_window_t inquire_window, *iw;
uint32_t MinSize, MaxSize, ReqGran, MemWndCaps, WndCaps;
uint32_t tws;
iw = &inquire_window;
for (wn = 0; wn < cs_globals.num_windows; wn++) {
cs_window_t *cw;
/*
* If we can't get a pointer to this window, we should contine
* with scanning the next window, since this window might have
* been dropped.
*/
if ((cw = cs_get_wp(wn)) != NULL) {
iw->window = wn;
if (SocketServices(SS_InquireWindow, iw) != SUCCESS)
return (CS_BAD_WINDOW);
MinSize = iw->mem_win_char.MinSize;
MaxSize = iw->mem_win_char.MaxSize;
ReqGran = iw->mem_win_char.ReqGran;
MemWndCaps = iw->mem_win_char.MemWndCaps;
WndCaps = iw->WndCaps;
if (WINDOW_FOR_SOCKET(iw->Sockets, sn) &&
WINDOW_AVAILABLE_FOR_MEM(cw) &&
WndCaps & (WC_COMMON|WC_ATTRIBUTE)) {
if ((error = cs_valid_window_speed(iw, rw->win_params.AccessSpeed)) ==
CS_SUCCESS) {
error = CS_OUT_OF_RESOURCE;
if (cs_memwin_space_and_map_ok(iw, rw)) {
error = CS_BAD_SIZE;
if (!rw->Size) {
min_size = min(min_size, MinSize);
window_num = wn;
goto found_window;
} else {
if (!(MemWndCaps & WC_SIZE)) {
if (rw->Size == MinSize) {
min_size = MinSize;
window_num = wn;
goto found_window;
}
} else { /* WC_SIZE */
if (!ReqGran) {
error = CS_BAD_WINDOW;
} else {
if ((rw->Size >= MinSize) &&
(rw->Size <= MaxSize)) {
if (MemWndCaps & WC_POW2) {
unsigned rg = ReqGran;
for (tws = MinSize; tws <= MaxSize;
rg = (rg<<1)) {
if (rw->Size == tws) {
min_size = tws;
window_num = wn;
goto found_window;
}
tws += rg;
} /* for (tws) */
} else {
for (tws = MinSize; tws <= MaxSize;
tws += ReqGran) {
if (rw->Size == tws) {
min_size = tws;
window_num = wn;
goto found_window;
}
} /* for (tws) */
} /* if (!WC_POW2) */
} /* if (Size >= MinSize) */
} /* if (!ReqGran) */
} /* if (WC_SIZE) */
} /* if (rw->Size) */
} /* if (cs_space_and_map_ok) */
} /* if (cs_valid_window_speed) */
} /* if (WINDOW_FOR_SOCKET) */
} /* if (cs_get_wp) */
} /* for (wn) */
/*
* If we got here and the window_num wasn't set by any window
* matches in the above code, it means that we didn't
* find a window matching the caller's criteria.
* If the error is CS_BAD_TYPE, it means that the last reason
* that we couldn't match a window was because the caller's
* requested speed was out of range of the last window that
* we checked. We convert this error code to CS_OUT_OF_RESOURCE
* to conform to the RequestWindow section of the PCMCIA
* Card Services spec.
*/
if (window_num == PCMCIA_MAX_WINDOWS) {
if (error == CS_BAD_TYPE)
error = CS_OUT_OF_RESOURCE;
return (error);
}
found_window:
rw->Size = min_size;
*assigned_window = window_num;
iw->window = window_num;
SocketServices(SS_InquireWindow, iw);
MemWndCaps = iw->mem_win_char.MemWndCaps;
if (MemWndCaps & WC_CALIGN)
rw->Attributes |= WIN_OFFSET_SIZE;
else
rw->Attributes &= ~WIN_OFFSET_SIZE;
return (CS_SUCCESS);
}
/* END CSTYLED */
/*
* cs_memwin_space_and_map_ok - checks to see if the passed window mapping
* capabilities and window speeds are in the
* range of the passed window.
*
* returns: 0 - if the capabilities are out of range
* 1 - if the capabilities are in range
*/
static int
cs_memwin_space_and_map_ok(inquire_window_t *iw, win_req_t *rw)
{
#ifdef CS_DEBUG
if (cs_debug > 240)
printf("-> s&m_ok: Attributes 0x%x AccessSpeed 0x%x "
"WndCaps 0x%x MemWndCaps 0x%x\n",
(int)rw->Attributes,
(int)rw->win_params.AccessSpeed,
iw->WndCaps,
iw->mem_win_char.MemWndCaps);
#endif
if (rw->win_params.AccessSpeed & WIN_USE_WAIT) {
if (!(iw->WndCaps & WC_WAIT))
return (0);
}
if (rw->Attributes & WIN_DATA_WIDTH_16) {
if (!(iw->mem_win_char.MemWndCaps & WC_16BIT))
return (0);
} else {
if (!(iw->mem_win_char.MemWndCaps & WC_8BIT))
return (0);
}
if (rw->Attributes & WIN_MEMORY_TYPE_AM) {
if (!(iw->WndCaps & WC_ATTRIBUTE))
return (0);
}
if (rw->Attributes & WIN_MEMORY_TYPE_CM) {
if (!(iw->WndCaps & WC_COMMON))
return (0);
}
return (1);
}
/*
* cs_valid_window_speed - checks to see if requested window speed
* is in range of passed window
*
* The inquire_window_t struct gives us speeds in nS, and we
* get speeds in the AccessSpeed variable as a devspeed code.
*
* returns: CS_BAD_SPEED - if AccessSpeed is invalid devspeed code
* CS_BAD_TYPE - if AccessSpeed is not in range of valid
* speed for this window
* CS_SUCCESS - if window speed is in range
*/
static int
cs_valid_window_speed(inquire_window_t *iw, uint32_t AccessSpeed)
{
convert_speed_t convert_speed, *cs;
cs = &convert_speed;
cs->Attributes = CONVERT_DEVSPEED_TO_NS;
cs->devspeed = AccessSpeed;
if (cs_convert_speed(cs) != CS_SUCCESS)
return (CS_BAD_SPEED);
if ((cs->nS < iw->mem_win_char.Fastest) ||
(cs->nS > iw->mem_win_char.Slowest))
return (CS_BAD_TYPE);
return (CS_SUCCESS);
}
/*
* ==== IO window handling section ====
*/
/*
* cs_request_io - provides IO resources for clients; this is RequestIO
*
* calling: cs_request_io(client_handle_t, io_req_t *)
*
* returns: CS_SUCCESS - if IO resources available for client
* CS_OUT_OF_RESOURCE - if no windows match requirements
* CS_BAD_HANDLE - client handle is invalid
* CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
* CS_NO_CARD - if no card is in socket
* CS_BAD_ATTRIBUTE - if any of the unsupported Attribute
* flags are set
* CS_BAD_BASE - if either or both base port addresses
* are invalid or out of range
* CS_CONFIGURATION_LOCKED - a RequestConfiguration has
* already been done
* CS_IN_USE - IO ports already in use or function has
* already been called
* CS_BAD_WINDOW - if failure while trying to set window
* characteristics
*/
static int
cs_request_io(client_handle_t client_handle, io_req_t *ior)
{
cs_socket_t *sp;
client_t *client;
int error;
int client_lock_acquired;
uint32_t socket_num;
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't support SS using this call.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_UNSUPPORTED_FUNCTION);
/*
* If the client has only requested one IO range, then make sure
* that the Attributes2 filed is clear.
*/
if (!ior->NumPorts2)
ior->Attributes2 = 0;
/*
* Make sure that none of the unsupported or reserved flags are set.
*/
if ((ior->Attributes1 | ior->Attributes2) & (IO_SHARED |
IO_FIRST_SHARED |
IO_FORCE_ALIAS_ACCESS |
IO_DEALLOCATE_WINDOW |
IO_DISABLE_WINDOW))
return (CS_BAD_ATTRIBUTE);
/*
* Make sure that we have a port count for the first region.
*/
if (!ior->NumPorts1)
return (CS_BAD_BASE);
/*
* If we're being asked for multiple IO ranges, then both base port
* members must be non-zero.
*/
if ((ior->NumPorts2) && !(ior->BasePort1.base && ior->BasePort2.base))
return (CS_BAD_BASE);
mutex_enter(&cs_globals.window_lock);
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (error);
}
/*
* If RequestConfiguration has already been done, we don't allow
* this call.
*/
if (client->flags & REQ_CONFIGURATION_DONE) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_CONFIGURATION_LOCKED);
}
/*
* If RequestIO has already been done, we don't allow this call.
*/
if (client->flags & REQ_IO_DONE) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_IN_USE);
}
mutex_enter(&sp->lock);
/*
* If there's no card in the socket or the card in the socket is not
* for this client, then return an error.
*/
if (!(client->flags & CLIENT_CARD_INSERTED)) {
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_NO_CARD);
}
mutex_exit(&sp->lock);
/*
* If we're only being asked for one IO range, then set BasePort2 to
* zero, since we use it later on.
*/
if (!ior->NumPorts2)
ior->BasePort2.base = 0;
/*
* See if we can allow Card Services to select the base address
* value for this card; if the client has specified a non-zero
* base IO address but the card doesn't decode enough IO
* address lines to uniquely use that address, then we have
* the flexibility to choose an alternative base address.
* Note that if the client specifies that the card decodes zero
* IO address lines, then we have to use the NumPortsX
* values to figure out how many address lines the card
* actually decodes, and we have to round the NumPortsX
* values up to the closest power of two.
*/
if (ior->IOAddrLines) {
ior->BasePort1.base = IOADDR_FROBNITZ(ior->BasePort1.base,
ior->IOAddrLines);
ior->BasePort2.base = IOADDR_FROBNITZ(ior->BasePort2.base,
ior->IOAddrLines);
} else {
ior->BasePort1.base = ior->BasePort1.base &
((IONUMPORTS_FROBNITZ(ior->NumPorts1) +
IONUMPORTS_FROBNITZ(ior->NumPorts2)) - 1);
ior->BasePort2.base = ior->BasePort2.base &
((IONUMPORTS_FROBNITZ(ior->NumPorts1) +
IONUMPORTS_FROBNITZ(ior->NumPorts2)) - 1);
}
socket_num = CS_MAKE_SOCKET_NUMBER(GET_CLIENT_SOCKET(client_handle),
GET_CLIENT_FUNCTION(client_handle));
#ifdef USE_IOMMAP_WINDOW
/*
* Here is where the code diverges, depending on the type of IO windows
* that this socket supports. If this socket supportes memory
* mapped IO windows, as determined by cs_init allocating an
* io_mmap_window_t structure on the socket structure, then we
* use one IO window for all the clients on this socket. We can
* do this safely since a memory mapped IO window implies that
* only this socket shares the complete IO space of the card.
* See the next major block of code for a description of what we do
* if a socket doesn't support memory mapped IO windows.
*/
if (sp->io_mmap_window) {
cs_window_t *cw;
io_mmap_window_t *imw = sp->io_mmap_window;
uint32_t offset;
/*
* If we haven't allocated an IO window yet, do it now.
* Try to allocate the IO window that cs_init found for us;
* if that fails, then call cs_find_io_win to find a window.
*/
if (!imw->count) {
set_window_t set_window;
if (!WINDOW_AVAILABLE_FOR_IO(imw->number)) {
iowin_char_t iowin_char;
iowin_char.IOWndCaps = (WC_IO_RANGE_PER_WINDOW |
WC_8BIT |
WC_16BIT);
if ((error = cs_find_io_win(sp->socket_num, &iowin_char,
&imw->number, &imw->size)) != CS_SUCCESS) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
} /* cs_find_io_win */
} /* if (!WINDOW_AVAILABLE_FOR_IO) */
set_window.socket = socket_num;
set_window.window = imw->number;
set_window.speed = IO_WIN_SPEED;
set_window.base.base = 0;
set_window.WindowSize = imw->size;
set_window.state = (WS_ENABLED | WS_16BIT |
WS_EXACT_MAPIN | WS_IO);
/* XXX - what to d here? XXX */
cs_set_acc_attributes(&set_window, Attributes);
if (SocketServices(SS_SetWindow, &set_window) != SUCCESS) {
(void) cs_setup_io_win(socket_num, imw->number,
NULL, NULL, NULL,
(IO_DEALLOCATE_WINDOW |
IO_DISABLE_WINDOW));
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_BAD_WINDOW);
}
imw->handle = set_window.base.handle;
imw->size = set_window.WindowSize;
/*
* Check the caller's port requirements to be sure that they
* fit within our found IO window.
*/
if ((ior->BasePort1.base + ior->NumPorts1 +
ior->BasePort2.base + ior->NumPorts2) > imw->size) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_BAD_BASE);
}
if ((cw = cs_get_wp(imw->number)) == NULL) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_BAD_WINDOW)
}
cw->state |= (CW_ALLOCATED | CW_IO);
} /* if (!imw->count) */
imw->count++;
/*
* All common access handles for this type of adapter are
* duped. We never give the original back to the caller.
*/
/* XXX need to set endianess and data ordering flags */
csx_DupHandle(imw->handle, &ior->BasePort1.handle, 0);
csx_GetHandleOffset(ior->BasePort1.handle, &offset);
csx_SetHandleOffset(ior->BasePort1.handle,
ior->BasePort1.base + offset);
if (ior->NumPorts2) {
/* XXX need to set endianess and data ordering flags */
csx_DupHandle(imw->handle, &ior->BasePort2.handle, 0);
csx_GetHandleOffset(ior->BasePort2.handle, &offset);
csx_SetHandleOffset(ior->BasePort2.handle,
ior->BasePort1.base + offset);
}
/*
* We don't really use these two values if we've got a memory
* mapped IO window since the assigned window number is stored
* in imw->number.
*/
client->io_alloc.Window1 = imw->number;
client->io_alloc.Window2 = PCMCIA_MAX_WINDOWS;
/*
* This socket supports only IO port IO windows.
*/
} else {
#else /* USE_IOMMAP_WINDOW */
{
#endif /* USE_IOMMAP_WINDOW */
baseaddru_t baseaddru;
baseaddru.base = ior->BasePort1.base;
if ((error = cs_allocate_io_win(sp->socket_num, ior->Attributes1,
&client->io_alloc.Window1)) != CS_SUCCESS) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (error);
} /* if (cs_allocate_io_win(1)) */
/*
* Setup the window hardware; if this fails, then we need to
* deallocate the previously allocated window.
*/
if ((error = cs_setup_io_win(socket_num,
client->io_alloc.Window1,
&baseaddru,
&ior->NumPorts1,
ior->IOAddrLines,
ior->Attributes1)) !=
CS_SUCCESS) {
(void) cs_setup_io_win(socket_num, client->io_alloc.Window1,
NULL, NULL, NULL,
(
IO_DEALLOCATE_WINDOW |
IO_DISABLE_WINDOW));
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (error);
} /* if (cs_setup_io_win(1)) */
ior->BasePort1.handle = (acc_handle_t)baseaddru.handle;
ior->BasePort1.base = baseaddru.base;
/*
* See if the client wants two IO ranges.
*/
if (ior->NumPorts2) {
baseaddru_t baseaddru;
baseaddru.base = ior->BasePort2.base;
/*
* If we fail to allocate this window, then we must deallocate
* the previous IO window that is already allocated.
*/
if ((error = cs_allocate_io_win(sp->socket_num,
ior->Attributes2,
&client->io_alloc.Window2)) !=
CS_SUCCESS) {
(void) cs_setup_io_win(socket_num,
client->io_alloc.Window2,
NULL, NULL, NULL,
(
IO_DEALLOCATE_WINDOW |
IO_DISABLE_WINDOW));
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (error);
} /* if (cs_allocate_io_win(2)) */
/*
* Setup the window hardware; if this fails, then we need to
* deallocate the previously allocated window.
*/
if ((error = cs_setup_io_win(socket_num,
client->io_alloc.Window2,
&baseaddru,
&ior->NumPorts2,
ior->IOAddrLines,
ior->Attributes2)) !=
CS_SUCCESS) {
(void) cs_setup_io_win(socket_num,
client->io_alloc.Window1,
NULL, NULL, NULL,
(
IO_DEALLOCATE_WINDOW |
IO_DISABLE_WINDOW));
(void) cs_setup_io_win(socket_num,
client->io_alloc.Window2,
NULL, NULL, NULL,
(
IO_DEALLOCATE_WINDOW |
IO_DISABLE_WINDOW));
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (error);
} /* if (cs_setup_io_win(2)) */
ior->BasePort2.handle = (acc_handle_t)baseaddru.handle;
ior->BasePort2.base = baseaddru.base;
} else {
client->io_alloc.Window2 = PCMCIA_MAX_WINDOWS;
} /* if (ior->NumPorts2) */
} /* if (sp->io_mmap_window) */
/*
* Save a copy of the client's port information so that we
* can use it in the RequestConfiguration call. We set
* the IO window number(s) allocated in the respective
* section of code, above.
*/
client->io_alloc.BasePort1.base = ior->BasePort1.base;
client->io_alloc.BasePort1.handle = ior->BasePort1.handle;
client->io_alloc.NumPorts1 = ior->NumPorts1;
client->io_alloc.Attributes1 = ior->Attributes1;
client->io_alloc.BasePort2.base = ior->BasePort2.base;
client->io_alloc.BasePort2.handle = ior->BasePort2.handle;
client->io_alloc.NumPorts2 = ior->NumPorts2;
client->io_alloc.Attributes2 = ior->Attributes2;
client->io_alloc.IOAddrLines = ior->IOAddrLines;
/*
* Mark this client as having done a successful RequestIO call.
*/
client->flags |= (REQ_IO_DONE | CLIENT_IO_ALLOCATED);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_SUCCESS);
}
/*
* cs_release_io - releases IO resources allocated by RequestIO; this is
* ReleaseIO
*
* calling: cs_release_io(client_handle_t, io_req_t *)
*
* returns: CS_SUCCESS - if IO resources sucessfully deallocated
* CS_BAD_HANDLE - client handle is invalid
* CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
* CS_CONFIGURATION_LOCKED - a RequestConfiguration has been
* done without a ReleaseConfiguration
* CS_IN_USE - no RequestIO has been done
*/
static int
cs_release_io(client_handle_t client_handle, io_req_t *ior)
{
cs_socket_t *sp;
client_t *client;
int error;
int client_lock_acquired;
uint32_t socket_num;
#ifdef lint
ior = NULL;
#endif
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't support SS using this call.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_UNSUPPORTED_FUNCTION);
mutex_enter(&cs_globals.window_lock);
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (error);
}
/*
* If RequestConfiguration has already been done, we don't allow
* this call.
*/
if (client->flags & REQ_CONFIGURATION_DONE) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_CONFIGURATION_LOCKED);
}
/*
* If RequestIO has not been done, we don't allow this call.
*/
if (!(client->flags & REQ_IO_DONE)) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_IN_USE);
}
socket_num = CS_MAKE_SOCKET_NUMBER(GET_CLIENT_SOCKET(client_handle),
GET_CLIENT_FUNCTION(client_handle));
#ifdef XXX
/*
* Check the passed IO allocation with the stored allocation; if
* they don't match, then return an error.
*/
if ((client->io_alloc.BasePort1 != ior->BasePort1) ||
(client->io_alloc.NumPorts1 != ior->NumPorts1) ||
(client->io_alloc.Attributes1 != ior->Attributes1) ||
(client->io_alloc.BasePort2 != ior->BasePort2) ||
(client->io_alloc.NumPorts2 != ior->NumPorts2) ||
(client->io_alloc.Attributes2 != ior->Attributes2) ||
(client->io_alloc.IOAddrLines != ior->IOAddrLines)) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_BAD_ARGS);
}
#endif
#ifdef USE_IOMMAP_WINDOW
/*
* The code diverges here depending on if this socket supports
* memory mapped IO windows or not. See comments in the
* cs_request_io function for a description of what's
* going on here.
*/
if (sp->io_mmap_window) {
io_mmap_window_t *imw = sp->io_mmap_window;
/*
* We should never see this; if we do, it's an internal
* consistency error.
*/
if (!imw->count) {
cmn_err(CE_CONT, "cs_release_io: socket %d !imw->count\n",
sp->socket_num);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_GENERAL_FAILURE);
}
/*
* All common access handles for this type of adapter are
* duped. We never give the original back to the caller,
* so it's OK to unconditionally free the handle here.
*/
csx_FreeHandle(&ior->BasePort1.handle);
/*
* If the IO window referance count is zero, then deallocate
* and disable this window.
*/
if (!--(imw->count)) {
(void) cs_setup_io_win(socket_num, imw->number, NULL,
NULL, NULL,
(
IO_DEALLOCATE_WINDOW |
IO_DISABLE_WINDOW));
} /* if (imw->count) */
} else {
#endif /* USE_IOMMAP_WINDOW */
(void) cs_setup_io_win(socket_num, client->io_alloc.Window1,
NULL, NULL, NULL,
(
IO_DEALLOCATE_WINDOW |
IO_DISABLE_WINDOW));
if (client->io_alloc.Window2 != PCMCIA_MAX_WINDOWS)
(void) cs_setup_io_win(socket_num, client->io_alloc.Window2,
NULL, NULL, NULL,
(
IO_DEALLOCATE_WINDOW |
IO_DISABLE_WINDOW));
#ifdef USE_IOMMAP_WINDOW
} /* if (sp->io_mmap_window) */
#endif /* USE_IOMMAP_WINDOW */
/*
* Mark the client as not having any IO resources allocated.
*/
client->flags &= ~(REQ_IO_DONE | CLIENT_IO_ALLOCATED);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
mutex_exit(&cs_globals.window_lock);
return (CS_SUCCESS);
}
/*
* cs_find_io_win - finds an IO window that matches the parameters specified
* in the flags argument
*
* calling: sn - socket number to look for IO window on
* *iwc - other window characteristics to match
* *assigned_window - pointer to where we return the assigned
* window number if we found a window or
* undefined otherwise
* *size - if non-NULL, the found window size will be stored here
*
* returns: CS_SUCCESS - if IO window found
* CS_OUT_OF_RESOURCE - if no windows match requirements
*/
static int
cs_find_io_win(uint32_t sn, iowin_char_t *iwc, uint32_t *assigned_window,
uint32_t *size)
{
inquire_window_t inquire_window, *iw;
unsigned wn;
iw = &inquire_window;
for (wn = 0; wn < cs_globals.num_windows; wn++) {
iowin_char_t *iowc;
cs_window_t *cw;
if ((cw = cs_get_wp(wn)) != NULL) {
iw->window = wn;
SocketServices(SS_InquireWindow, iw);
iowc = &iw->iowin_char;
if (WINDOW_FOR_SOCKET(iw->Sockets, sn) &&
WINDOW_AVAILABLE_FOR_IO(cw) &&
(iw->WndCaps & WC_IO) &&
((iowc->IOWndCaps & iwc->IOWndCaps) == iwc->IOWndCaps)) {
*assigned_window = wn;
if (size)
*size = iw->iowin_char.ReqGran;
return (CS_SUCCESS);
} /* if (WINDOW_FOR_SOCKET) */
} /* cs_get_wp */
} /* for (wn) */
return (CS_OUT_OF_RESOURCE);
}
/*
* cs_allocate_io_win - finds and allocates an IO window
*
* calling: sn - socket number to look for window on
* Attributes - window attributes in io_req_t.Attributes format
* *assigned_window - pointer to return assigned window number
*
* returns: CS_SUCCESS - IO window found and allocated
* CS_OUT_OF_RESOURCE - if cs_find_io_win couldn't find a
* window that matches the passed criteria
*
* Note: This fucntion will find and allocate an IO window. The caller is
* responsible for deallocating the window.
*/
static int
cs_allocate_io_win(uint32_t sn, uint32_t Attributes, uint32_t *assigned_window)
{
iowin_char_t iowin_char;
cs_window_t *cw;
iowin_char.IOWndCaps =
((Attributes & IO_DATA_PATH_WIDTH_16)?WC_16BIT:WC_8BIT);
if (cs_find_io_win(sn, &iowin_char, assigned_window, NULL) ==
CS_SUCCESS) {
if ((cw = cs_get_wp(*assigned_window)) == NULL)
return (CS_OUT_OF_RESOURCE);
cw->state = (cw->state & CW_WINDOW_VALID) | (CW_ALLOCATED | CW_IO);
return (CS_SUCCESS);
}
return (CS_OUT_OF_RESOURCE);
}
/*
* cs_setup_io_win - setup and destroy an IO window
*
* calling: sn - socket number
* wn - window number
* XXX Base - pointer to XXX
* *NumPorts - pointer to number of allocated ports to return
* IOAddrLines - number of IO address lines decoded by this card
* Attributes - either io_req_t attributes, or a combination of
* the following flags:
* IO_DEALLOCATE_WINDOW - deallocate the window
* IO_DISABLE_WINDOW - disable the window
* When either of these two flags are set, *Base
* and NumPorts should be NULL.
*
* returns: CS_SUCCESS - if no failure
* CS_BAD_WINDOW - if error while trying to configure window
*
* Note: We use the IOAddrLines value to determine what base address to pass
* to Socket Services.
*/
static int
cs_setup_io_win(uint32_t sn, uint32_t wn, baseaddru_t *Base, uint32_t *NumPorts,
uint32_t IOAddrLines, uint32_t Attributes)
{
set_window_t set_window;
if (Attributes & (IO_DEALLOCATE_WINDOW | IO_DISABLE_WINDOW)) {
if (Attributes & IO_DEALLOCATE_WINDOW) {
cs_window_t *cw;
if ((cw = cs_get_wp(wn)) == NULL)
return (CS_BAD_WINDOW);
cw->state &= CW_WINDOW_VALID;
} /* IO_DEALLOCATE_WINDOW */
if (Attributes & IO_DISABLE_WINDOW) {
get_window_t get_window;
get_window.window = wn;
SocketServices(SS_GetWindow, &get_window);
set_window.socket = get_window.socket;
set_window.window = get_window.window;
set_window.speed = get_window.speed;
set_window.base = 0;
set_window.WindowSize = get_window.size;
set_window.state = get_window.state & ~WS_ENABLED;
cs_set_acc_attributes(&set_window, Attributes);
SocketServices(SS_SetWindow, &set_window);
} /* IO_DISABLE_WINDOW */
return (CS_SUCCESS);
} /* if (IO_DEALLOCATE_WINDOW | IO_DISABLE_WINDOW) */
/*
* See if we can allow Socket Services to select the base address
* value for this card; if the client has specified a non-zero
* base IO address but the card doesn't decode enough IO
* address lines to uniquely use that address, then we have
* the flexibility to choose an alternative base address.
* XXX - Is this really correct in all cases?
*/
if (!IOAddrLines)
Base->base = 0;
else
Base->base = IOADDR_FROBNITZ(Base->base, IOAddrLines);
set_window.socket = sn;
set_window.window = wn;
set_window.speed = IO_WIN_SPEED;
set_window.base = Base->base;
set_window.WindowSize = *NumPorts;
set_window.state = (WS_ENABLED | WS_IO |
((Attributes & IO_DATA_PATH_WIDTH_16)?WS_16BIT:0));
cs_set_acc_attributes(&set_window, Attributes);
if (SocketServices(SS_SetWindow, &set_window) != SUCCESS)
return (CS_BAD_WINDOW);
Base->base = set_window.base;
Base->handle = set_window.handle;
*NumPorts = set_window.WindowSize;
return (CS_SUCCESS);
}
/*
* ==== IRQ handling functions ====
*/
/*
* cs_request_irq - add's client's IRQ handler; supports RequestIRQ
*
* calling: irq_req_t.Attributes - must have the IRQ_TYPE_EXCLUSIVE
* flag set, and all other flags clear, or
* CS_BAD_ATTRIBUTE will be returned
*
* returns: CS_SUCCESS - if IRQ resources available for client
* CS_BAD_IRQ - if IRQ can not be allocated
* CS_BAD_HANDLE - client handle is invalid
* CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
* CS_NO_CARD - if no card is in socket
* CS_BAD_ATTRIBUTE - if any of the unsupported Attribute
* flags are set
* CS_CONFIGURATION_LOCKED - a RequestConfiguration has
* already been done
* CS_IN_USE - IRQ ports already in use or function has
* already been called
*
* Note: We only allow level-mode interrupts.
*/
static int
cs_request_irq(client_handle_t client_handle, irq_req_t *irqr)
{
cs_socket_t *sp;
client_t *client;
set_irq_handler_t set_irq_handler;
int error;
int client_lock_acquired;
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't support SS using this call.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_UNSUPPORTED_FUNCTION);
/*
* Make sure that none of the unsupported or reserved flags are set.
*/
if ((irqr->Attributes & (IRQ_TYPE_TIME | IRQ_TYPE_DYNAMIC_SHARING |
IRQ_FIRST_SHARED | IRQ_PULSE_ALLOCATED |
IRQ_FORCED_PULSE)) ||
!(irqr->Attributes & IRQ_TYPE_EXCLUSIVE))
return (CS_BAD_ATTRIBUTE);
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
}
/*
* If RequestConfiguration has already been done, we don't allow
* this call.
*/
if (client->flags & REQ_CONFIGURATION_DONE) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_CONFIGURATION_LOCKED);
}
/*
* If RequestIRQ has already been done, we don't allow this call.
*/
if (client->flags & REQ_IRQ_DONE) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_IN_USE);
}
/*
* If there's no card in the socket or the card in the socket is not
* for this client, then return an error.
*/
if (!(client->flags & CLIENT_CARD_INSERTED)) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_NO_CARD);
}
/*
* Set up the parameters and ask Socket Services to give us an IRQ
* for this client. We don't really do much, since the IRQ
* resources are managed by SS and the kernel. We also don't
* care which IRQ level we are given.
*/
set_irq_handler.socket =
CS_MAKE_SOCKET_NUMBER(GET_CLIENT_SOCKET(client_handle),
GET_CLIENT_FUNCTION(client_handle));
set_irq_handler.irq = IRQ_ANY;
set_irq_handler.handler_id = client_handle;
set_irq_handler.handler = (f_t *)irqr->irq_handler;
set_irq_handler.arg1 = irqr->irq_handler_arg;
set_irq_handler.arg2 = NULL;
if ((error = SocketServices(SS_SetIRQHandler,
&set_irq_handler)) != SUCCESS) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_IRQ);
}
irqr->iblk_cookie = set_irq_handler.iblk_cookie;
irqr->idev_cookie = set_irq_handler.idev_cookie;
/*
* Save the allocated IRQ information for this client.
*/
client->irq_alloc.Attributes = irqr->Attributes;
client->irq_alloc.irq = set_irq_handler.irq;
client->irq_alloc.handler_id = set_irq_handler.handler_id;
client->irq_alloc.irq_handler = (f_t *)set_irq_handler.handler;
client->irq_alloc.irq_handler_arg1 = set_irq_handler.arg1;
client->irq_alloc.irq_handler_arg2 = set_irq_handler.arg2;
#ifdef CS_DEBUG
if (cs_debug > 0)
cmn_err(CE_CONT, "cs_request_irq: socket %d irqr->Attributes 0x%x "
"set_irq_handler.irq 0x%x\n",
sp->socket_num,
(int)irqr->Attributes,
set_irq_handler.irq);
#endif
/*
* Mark this client as having done a successful RequestIRQ call.
*/
client->flags |= (REQ_IRQ_DONE | CLIENT_IRQ_ALLOCATED);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
}
/*
* cs_release_irq - releases IRQ resources allocated by RequestIRQ; this is
* ReleaseIRQ
*
* calling: cs_release_irq(client_handle_t, irq_req_t *)
*
* returns: CS_SUCCESS - if IRQ resources sucessfully deallocated
* CS_BAD_IRQ - if IRQ can not be deallocated
* CS_BAD_HANDLE - client handle is invalid
* CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
* CS_CONFIGURATION_LOCKED - a RequestConfiguration has been
* done without a ReleaseConfiguration
* CS_IN_USE - no RequestIRQ has been done
*/
static int
cs_release_irq(client_handle_t client_handle, irq_req_t *irqr)
{
cs_socket_t *sp;
client_t *client;
clear_irq_handler_t clear_irq_handler;
int error;
int client_lock_acquired;
#ifdef lint
irqr = NULL;
#endif
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't support SS using this call.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_UNSUPPORTED_FUNCTION);
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
}
/*
* If RequestConfiguration has already been done, we don't allow
* this call.
*/
if (client->flags & REQ_CONFIGURATION_DONE) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_CONFIGURATION_LOCKED);
}
/*
* If RequestIRQ has not been done, we don't allow this call.
*/
if (!(client->flags & REQ_IRQ_DONE)) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_IN_USE);
}
/*
* Tell Socket Services that we want to deregister this client's
* IRQ handler.
*/
clear_irq_handler.socket =
CS_MAKE_SOCKET_NUMBER(GET_CLIENT_SOCKET(client_handle),
GET_CLIENT_FUNCTION(client_handle));
clear_irq_handler.handler_id = client->irq_alloc.handler_id;
clear_irq_handler.handler = (f_t *)client->irq_alloc.irq_handler;
/*
* At this point, we should never fail this SS call; if we do, it
* means that there is an internal consistancy error in either
* Card Services or Socket Services.
*/
if ((error = SocketServices(SS_ClearIRQHandler, &clear_irq_handler)) !=
SUCCESS) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_IRQ);
}
/*
* Mark the client as not having any IRQ resources allocated.
*/
client->flags &= ~(REQ_IRQ_DONE | CLIENT_IRQ_ALLOCATED);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
}
/*
* ==== configuration handling functions ====
*/
/*
* cs_request_configuration - sets up socket and card configuration on behalf
* of the client; this is RequestConfiguration
*
* returns: CS_SUCCESS - if configuration sucessfully set
* CS_BAD_SOCKET - if Socket Services returns an error
* CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
* CS_BAD_ATTRIBUTE - if any unsupported or reserved flags
* are set
* CS_BAD_TYPE - if the socket doesn't support a mem and IO
* interface (SOCKET_INTERFACE_MEMORY_AND_IO set)
* CS_CONFIGURATION_LOCKED - a RequestConfiguration has
* already been done
* CS_BAD_VCC - if Vcc value is not supported by socket
* CS_BAD_VPP1 - if Vpp1 value is not supported by socket
* CS_BAD_VPP2 - if Vpp2 value is not supported by socket
*
* Bug ID: 1193637 - Card Services RequestConfiguration does not conform
* to PCMCIA standard
* We allow clients to do a RequestConfiguration even if they haven't
* done a RequestIO or RequestIRQ.
*/
static int
cs_request_configuration(client_handle_t client_handle, config_req_t *cr)
{
cs_socket_t *sp;
client_t *client;
volatile config_regs_t *crt;
set_socket_t set_socket;
get_socket_t get_socket;
acc_handle_t cis_handle;
int error;
uint32_t newoffset;
int client_lock_acquired;
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't support SS using this call.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_UNSUPPORTED_FUNCTION);
#ifdef XXX
/*
* If the client specifies Vcc = 0 and any non-zero value for
* either of the Vpp members, that's an illegal condition.
*/
if (!(cr->Vcc) && (cr->Vpp1 || cr->Vpp2))
return (CS_BAD_VCC);
#endif
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
/*
* If the client is asking for a memory and IO interface on this
* socket, then check the socket capabilities to be sure that
* this socket supports this configuration.
*/
if (cr->IntType & SOCKET_INTERFACE_MEMORY_AND_IO) {
inquire_socket_t inquire_socket;
inquire_socket.socket = sp->socket_num;
if (SocketServices(SS_InquireSocket, &inquire_socket) != SUCCESS)
return (CS_BAD_SOCKET);
if (!(inquire_socket.SocketCaps & IF_IO))
return (CS_BAD_TYPE);
} /* if (SOCKET_INTERFACE_MEMORY_AND_IO) */
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
}
/*
* If RequestConfiguration has already been done, we don't allow
* this call.
*/
if (client->flags & REQ_CONFIGURATION_DONE) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_CONFIGURATION_LOCKED);
}
/*
* If there's no card in the socket or the card in the socket is not
* for this client, then return an error.
*/
if (!(client->flags & CLIENT_CARD_INSERTED)) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_NO_CARD);
}
/*
* At this point, most of the client's calling parameters have been
* validated, so we can go ahead and configure the socket and
* the card.
*/
mutex_enter(&sp->cis_lock);
/*
* Configure the socket with the interface type and voltages requested
* by the client.
*/
get_socket.socket = sp->socket_num;
if (SocketServices(SS_GetSocket, &get_socket) != SUCCESS) {
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_SOCKET);
}
#ifdef CS_DEBUG
if (cs_debug > 0)
cmn_err(CE_CONT, "cs_request_configuration: socket %d "
"client->irq_alloc.irq 0x%x "
"get_socket.IRQRouting 0x%x\n",
sp->socket_num,
(int)client->irq_alloc.irq,
get_socket.IRQRouting);
#endif
bzero(&set_socket, sizeof (set_socket));
set_socket.socket = sp->socket_num;
set_socket.IREQRouting = client->irq_alloc.irq & ~IRQ_ENABLE;
set_socket.CtlInd = get_socket.CtlInd;
set_socket.State = 0; /* don't reset latched values */
if (cs_convert_powerlevel(sp->socket_num, cr->Vcc, VCC,
&set_socket.VccLevel) != CS_SUCCESS) {
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_VCC);
}
if (cs_convert_powerlevel(sp->socket_num, cr->Vpp1, VPP1,
&set_socket.Vpp1Level) != CS_SUCCESS) {
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_VPP);
}
if (cs_convert_powerlevel(sp->socket_num, cr->Vpp2, VPP2,
&set_socket.Vpp2Level) != CS_SUCCESS) {
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_VPP);
}
if (!(cr->IntType & SOCKET_INTERFACE_MEMORY_AND_IO))
set_socket.IFType = IF_MEMORY;
else {
set_socket.IFType = IF_IO;
/*
* The Cirrus Logic PD6710/672X/others? adapters will write
* protect the CIS if the socket is in MEMORY mode and the
* WP/IOCS16 pin is true. When this happens, the CIS registers
* will fail to be written. Go ahead and set the socket,
* even though the event mask isn't complete yet, so we can
* configure the adapter. Afterwards, set the socket again
* to make sure the event mask is correct.
*/
if (SocketServices(SS_SetSocket, &set_socket) != SUCCESS) {
sp->flags &= ~SOCKET_IS_IO;
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_SOCKET);
}
}
if (cs_rc2_delay)
drv_usecwait(cs_rc2_delay * 1000);
/*
* Get a pointer to a window that contains the configuration
* registers.
*/
mutex_enter(&sp->lock);
client->config_regs_offset = cr->ConfigBase;
newoffset = client->config_regs_offset;
mutex_exit(&sp->lock);
if (cs_init_cis_window(sp, &newoffset, &cis_handle,
CISTPLF_AM_SPACE) != CS_SUCCESS) {
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
cmn_err(CE_CONT, "cs_request_configuration: socket %d can't init "
"CIS window\n", sp->socket_num);
return (CS_GENERAL_FAILURE);
}
/*
* Setup the config register pointers.
* Note that these pointers are not the complete virtual address;
* the complete address is constructed each time the registers
* are accessed.
*/
mutex_enter(&sp->lock);
crt = &client->config_regs;
client->present = cr->Present;
bzero((char *)crt, sizeof (config_regs_t));
/* Configuration Option Register */
if (client->present & CONFIG_OPTION_REG_PRESENT)
crt->cor_p = (newoffset + CONFIG_OPTION_REG_OFFSET);
/* Configuration and Status Register */
if (client->present & CONFIG_STATUS_REG_PRESENT)
crt->ccsr_p = (newoffset + CONFIG_STATUS_REG_OFFSET);
/* Pin Replacement Register */
if (client->present & CONFIG_PINREPL_REG_PRESENT)
crt->prr_p = (newoffset + CONFIG_PINREPL_REG_OFFSET);
/* Socket and Copy Register */
if (client->present & CONFIG_COPY_REG_PRESENT)
crt->scr_p = (newoffset + CONFIG_COPY_REG_OFFSET);
/* Extended Status Register */
if (client->present & CONFIG_EXSTAT_REG_PRESENT)
crt->exstat_p = (newoffset + CONFIG_EXSTAT_REG_OFFSET);
/* IO Base 0 Register */
if (client->present & CONFIG_IOBASE0_REG_PRESENT)
crt->iobase0_p = (newoffset + CONFIG_IOBASE0_REG_OFFSET);
/* IO Base 1 Register */
if (client->present & CONFIG_IOBASE1_REG_PRESENT)
crt->iobase1_p = (newoffset + CONFIG_IOBASE1_REG_OFFSET);
/* IO Base 2 Register */
if (client->present & CONFIG_IOBASE2_REG_PRESENT)
crt->iobase2_p = (newoffset + CONFIG_IOBASE2_REG_OFFSET);
/* IO Base 3 Register */
if (client->present & CONFIG_IOBASE3_REG_PRESENT)
crt->iobase3_p = (newoffset + CONFIG_IOBASE3_REG_OFFSET);
/* IO Limit Register */
if (client->present & CONFIG_IOLIMIT_REG_PRESENT)
crt->iolimit_p = (newoffset + CONFIG_IOLIMIT_REG_OFFSET);
/*
* Setup the bits in the PRR mask that are valid; this is easy, just
* copy the Pin value that the client gave us. Note that for
* this to work, the client must set both of the XXX_STATUS
* and the XXX_EVENT bits in the Pin member.
*/
client->pin = cr->Pin;
#ifdef CS_DEBUG
if (cs_debug > 128)
cmn_err(CE_CONT, "cs_request_configuration: client->pin 0x%x "
"client->config_regs_offset 0x%x newoffset 0x%x cor_p 0x%x "
"ccsr_p 0x%x prr_p 0x%x scr_p 0x%x\n",
client->pin, (int)client->config_regs_offset, newoffset,
(int)crt->cor_p, (int)crt->ccsr_p, (int)crt->prr_p,
(int)crt->scr_p);
#endif
/*
* If the socket isn't in IO mode, WP is asserted, and we're going to
* write any of the config registers, issue a warning.
*/
if ((client->present != 0) &&
(!(cr->IntType & SOCKET_INTERFACE_MEMORY_AND_IO)) &&
(get_socket.state & SBM_WP)) {
cmn_err(CE_NOTE, "!cs_request_configuration: attempting to "
"write CIS config regs with WP set\n");
}
/*
* Write any configuration registers that the client tells us are
* present to the card; save a copy of what we wrote so that we
* can return them if the client calls GetConfigurationInfo.
* The order in which we write the configuration registers is
* specified by the PCMCIA spec; we must write the socket/copy
* register first (if it exists), and then we can write the
* registers in any arbitrary order.
*/
/* Socket and Copy Register */
if (client->present & CONFIG_COPY_REG_PRESENT) {
crt->scr = cr->Copy;
csx_Put8(cis_handle, crt->scr_p, crt->scr);
}
/* Pin Replacement Register */
if (client->present & CONFIG_PINREPL_REG_PRESENT) {
crt->prr = cr->Pin;
csx_Put8(cis_handle, crt->prr_p, crt->prr);
}
/* Configuration and Status Register */
/* XXX should we set CCSR_SIG_CHG in the CCSR? XXX */
if (client->present & CONFIG_STATUS_REG_PRESENT) {
crt->ccsr = cr->Status;
csx_Put8(cis_handle, crt->ccsr_p, crt->ccsr);
}
/* Extended Status Register */
if (client->present & CONFIG_EXSTAT_REG_PRESENT) {
crt->exstat = cr->ExtendedStatus;
csx_Put8(cis_handle, crt->exstat_p, crt->exstat);
}
/*
* If any IO base and limit registers exist, and this client
* has done a RequestIO, setup the IO Base and IO Limit
* registers.
*/
if (client->flags & REQ_IO_DONE) {
if (client->present & CONFIG_IOBASE0_REG_PRESENT) {
uint32_t base = client->io_alloc.BasePort1.base;
uint32_t present = (client->present &
CONFIG_IOBASE_REG_MASK) >>
CONFIG_IOBASE_REG_SHIFT;
uint32_t reg = crt->iobase0_p;
do {
csx_Put8(cis_handle, reg, base & 0x0ff);
reg = reg + 2;
base = base >> 8;
present = present >> 1;
} while (present);
} /* CONFIG_IOBASE0_REG_PRESENT */
if (client->present & CONFIG_IOLIMIT_REG_PRESENT) {
uint32_t np = client->io_alloc.NumPorts1 +
client->io_alloc.NumPorts2;
uint32_t limit, do_bit = 0;
int lm;
limit = (IONUMPORTS_FROBNITZ(np) - 1);
for (lm = 7; lm >= 0; lm--) {
if (limit & (1 << lm))
do_bit = 1;
if (do_bit)
limit |= (1 << lm);
} /* for */
csx_Put8(cis_handle, crt->iolimit_p, limit);
} /* CONFIG_IOLIMIT_REG_PRESENT */
} /* REQ_IO_DONE */
/*
* Mark the socket as being in IO mode.
*/
if (cr->IntType & SOCKET_INTERFACE_MEMORY_AND_IO)
sp->flags |= SOCKET_IS_IO;
mutex_exit(&sp->lock);
/*
* Enable the interrupt if needed
*/
if (cr->Attributes & CONF_ENABLE_IRQ_STEERING)
set_socket.IREQRouting |= IRQ_ENABLE;
/*
* Now that we know if the PRR is present and if it is, which
* bits in the PRR are valid, we can construct the correct
* socket event mask.
*/
set_socket.SCIntMask = cs_merge_event_masks(sp, client);
/*
* Configuration Option Register - we handle this specially since
* we don't allow the client to manipulate the RESET or
* INTERRUPT bits (although a client can manipulate these
* bits via an AccessConfigurationRegister call - explain
* THAT logic to me).
* XXX - we force level-mode interrupts (COR_LEVEL_IRQ)
* XXX - we always enable the function on a multi-function card
*/
if (client->present & CONFIG_OPTION_REG_PRESENT) {
crt->cor = (cr->ConfigIndex & ~COR_SOFT_RESET) | COR_LEVEL_IRQ;
if (client->present & CONFIG_IOBASE0_REG_PRESENT)
crt->cor |= COR_ENABLE_BASE_LIMIT;
if (sp->cis_flags & CW_MULTI_FUNCTION_CIS) {
crt->cor |= COR_ENABLE_FUNCTION;
crt->cor &= ~COR_ENABLE_IREQ_ROUTING;
if (cr->Attributes & CONF_ENABLE_IRQ_STEERING)
crt->cor |= COR_ENABLE_IREQ_ROUTING;
} /* CW_MULTI_FUNCTION_CIS */
#ifdef CS_DEBUG
if (cs_debug > 0)
cmn_err(CE_CONT, "cs_request_configuration "
"cor=x%x ConfigIndex=x%x Attributes=x%x flags=x%x\n"
"present=x%x cis_handle=%p cor_p=x%x\n",
crt->cor, cr->ConfigIndex, cr->Attributes, sp->cis_flags,
client->present, cis_handle, crt->cor_p);
#endif
csx_Put8(cis_handle, crt->cor_p, crt->cor);
} /* CONFIG_OPTION_REG_PRESENT */
if (cs_rc1_delay)
drv_usecwait(cs_rc1_delay * 1000);
/*
* Set the socket to the parameters that the client requested.
*/
if (SocketServices(SS_SetSocket, &set_socket) != SUCCESS) {
if (client->present & CONFIG_OPTION_REG_PRESENT) {
crt->cor = 0; /* XXX is 0 the right thing here? */
csx_Put8(cis_handle, crt->cor_p, crt->cor);
}
sp->flags &= ~SOCKET_IS_IO;
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_SOCKET);
}
if (cs_rc2_delay)
drv_usecwait(cs_rc2_delay * 1000);
/*
* Mark this client as having done a successful RequestConfiguration
* call.
*/
client->flags |= REQ_CONFIGURATION_DONE;
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
}
/*
* cs_release_configuration - releases configuration previously set via the
* RequestConfiguration call; this is ReleaseConfiguration
*
* returns: CS_SUCCESS - if configuration sucessfully released
* CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
* CS_BAD_SOCKET - if Socket Services returns an error
* CS_BAD_HANDLE - a RequestConfiguration has not been done
*/
/*ARGSUSED*/
static int
cs_release_configuration(client_handle_t client_handle, release_config_t *rcfg)
{
cs_socket_t *sp;
client_t *client;
volatile config_regs_t *crt;
set_socket_t set_socket;
get_socket_t get_socket;
acc_handle_t cis_handle;
int error;
uint32_t newoffset;
int client_lock_acquired;
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't support SS using this call.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_UNSUPPORTED_FUNCTION);
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
}
/*
* If RequestConfiguration has not been done, we don't allow
* this call.
*/
if (!(client->flags & REQ_CONFIGURATION_DONE)) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_HANDLE);
}
#ifdef CS_DEBUG
if (cs_debug > 0)
cmn_err(CE_CONT, "cs_release_configuration: "
"flags=0x%x CW_MULTI_FUNCTION_CIS =0x%x \n",
sp->cis_flags, CW_MULTI_FUNCTION_CIS);
#endif
mutex_enter(&sp->cis_lock);
/*
* Set the card back to a memory-only interface byte writing a zero
* to the COR. Note that we don't update our soft copy of the
* COR state since the PCMCIA spec only requires us to maintain
* the last value that was written to that register during a
* call to RequestConfiguration.
*/
crt = &client->config_regs;
newoffset = client->config_regs_offset;
if (cs_init_cis_window(sp, &newoffset, &cis_handle,
CISTPLF_AM_SPACE) != CS_SUCCESS) {
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
cmn_err(CE_CONT, "cs_release_configuration: socket %d can't init "
"CIS window\n", sp->socket_num);
return (CS_GENERAL_FAILURE);
}
if (sp->cis_flags & CW_MULTI_FUNCTION_CIS) {
/*
* For the Multifunction cards do not reset the socket
* to a memory only interface but do clear the
* Configuration Option Register and mark this client
* as not having a configuration by clearing the
* REQ_CONFIGURATION_DONE flag.
*/
client->flags &= ~REQ_CONFIGURATION_DONE;
csx_Put8(cis_handle, crt->cor_p, 0);
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
}
/*
* Set the socket back to a memory-only interface; don't change
* any other parameter of the socket.
*/
get_socket.socket = sp->socket_num;
if (SocketServices(SS_GetSocket, &get_socket) != SUCCESS) {
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_SOCKET);
}
mutex_enter(&sp->lock);
sp->flags &= ~SOCKET_IS_IO;
set_socket.SCIntMask = cs_merge_event_masks(sp, client);
mutex_exit(&sp->lock);
set_socket.socket = sp->socket_num;
set_socket.IREQRouting = 0;
set_socket.CtlInd = get_socket.CtlInd;
set_socket.State = 0; /* don't reset latched values */
set_socket.VccLevel = get_socket.VccLevel;
set_socket.Vpp1Level = get_socket.Vpp1Level;
set_socket.Vpp2Level = get_socket.Vpp2Level;
set_socket.IFType = IF_MEMORY;
if (client->present & CONFIG_OPTION_REG_PRESENT)
csx_Put8(cis_handle, crt->cor_p, 0);
if (SocketServices(SS_SetSocket, &set_socket) != SUCCESS) {
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_SOCKET);
}
/*
* Mark this client as not having a configuration.
*/
client->flags &= ~REQ_CONFIGURATION_DONE;
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
}
/*
* cs_modify_configuration - modifies a configuration established by
* RequestConfiguration; this is ModifyConfiguration
*
* returns: CS_SUCCESS - if configuration sucessfully modified
* CS_BAD_SOCKET - if Socket Services returns an error
* CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
* CS_BAD_HANDLE - a RequestConfiguration has not been done
* CS_NO_CARD - if no card in socket
* CS_BAD_ATTRIBUTE - if any unsupported or reserved flags
* are set
* CS_BAD_VCC - if Vcc value is not supported by socket
* CS_BAD_VPP1 - if Vpp1 value is not supported by socket
* CS_BAD_VPP2 - if Vpp2 value is not supported by socket
*/
static int
cs_modify_configuration(client_handle_t client_handle, modify_config_t *mc)
{
cs_socket_t *sp;
client_t *client;
set_socket_t set_socket;
get_socket_t get_socket;
int error;
int client_lock_acquired;
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't support SS using this call.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_UNSUPPORTED_FUNCTION);
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
}
/*
* If RequestConfiguration has not been done, we don't allow
* this call.
*/
if (!(client->flags & REQ_CONFIGURATION_DONE)) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_HANDLE);
}
/*
* If there's no card in the socket or the card in the socket is not
* for this client, then return an error.
*/
if (!(client->flags & CLIENT_CARD_INSERTED)) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_NO_CARD);
}
/*
* Get the current socket parameters so that we can modify them.
*/
get_socket.socket = sp->socket_num;
if (SocketServices(SS_GetSocket, &get_socket) != SUCCESS) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_SOCKET);
}
#ifdef CS_DEBUG
if (cs_debug > 0)
cmn_err(CE_CONT, "cs_modify_configuration: socket %d "
"client->irq_alloc.irq 0x%x "
"get_socket.IRQRouting 0x%x\n",
sp->socket_num, (int)client->irq_alloc.irq,
get_socket.IRQRouting);
#endif
set_socket.socket = sp->socket_num;
set_socket.SCIntMask = get_socket.SCIntMask;
set_socket.CtlInd = get_socket.CtlInd;
set_socket.State = 0; /* don't reset latched values */
set_socket.IFType = get_socket.IFType;
set_socket.IREQRouting = get_socket.IRQRouting;
/*
* Modify the IRQ routing if the client wants it modified.
*/
if (mc->Attributes & CONF_IRQ_CHANGE_VALID) {
set_socket.IREQRouting &= ~IRQ_ENABLE;
if ((sp->cis_flags & CW_MULTI_FUNCTION_CIS) &&
(client->present & CONFIG_OPTION_REG_PRESENT)) {
config_regs_t *crt = &client->config_regs;
acc_handle_t cis_handle;
uint32_t newoffset = client->config_regs_offset;
/*
* Get a pointer to a window that contains the configuration
* registers.
*/
if (cs_init_cis_window(sp, &newoffset, &cis_handle,
CISTPLF_AM_SPACE) != CS_SUCCESS) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
cmn_err(CE_CONT,
"cs_modify_configuration: socket %d can't init "
"CIS window\n", sp->socket_num);
return (CS_GENERAL_FAILURE);
} /* cs_init_cis_window */
crt->cor &= ~COR_ENABLE_IREQ_ROUTING;
if (mc->Attributes & CONF_ENABLE_IRQ_STEERING)
crt->cor |= COR_ENABLE_IREQ_ROUTING;
#ifdef CS_DEBUG
if (cs_debug > 0)
cmn_err(CE_CONT, "cs_modify_configuration:"
" cor_p=0x%x cor=0x%x\n",
crt->cor_p, crt->cor);
#endif
csx_Put8(cis_handle, crt->cor_p, crt->cor);
} /* CW_MULTI_FUNCTION_CIS */
if (mc->Attributes & CONF_ENABLE_IRQ_STEERING)
set_socket.IREQRouting |= IRQ_ENABLE;
} /* CONF_IRQ_CHANGE_VALID */
/*
* Modify the voltage levels that the client specifies.
*/
set_socket.VccLevel = get_socket.VccLevel;
if (mc->Attributes & CONF_VPP1_CHANGE_VALID) {
if (cs_convert_powerlevel(sp->socket_num, mc->Vpp1, VPP1,
&set_socket.Vpp1Level) != CS_SUCCESS) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_VPP);
}
} else {
set_socket.Vpp1Level = get_socket.Vpp1Level;
}
if (mc->Attributes & CONF_VPP2_CHANGE_VALID) {
if (cs_convert_powerlevel(sp->socket_num, mc->Vpp2, VPP2,
&set_socket.Vpp2Level) != CS_SUCCESS) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_VPP);
}
} else {
set_socket.Vpp2Level = get_socket.Vpp2Level;
}
/*
* Setup the modified socket configuration.
*/
if (SocketServices(SS_SetSocket, &set_socket) != SUCCESS) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_SOCKET);
}
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
}
/*
* cs_access_configuration_register - provides a client access to the card's
* configuration registers; this is AccessConfigurationRegister
*
* returns: CS_SUCCESS - if register accessed successfully
* CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
* CS_BAD_ARGS - if arguments are out of range
* CS_NO_CARD - if no card in socket
* CS_BAD_BASE - if no config registers base address
* CS_UNSUPPORTED_MODE - if no RequestConfiguration has
* been done yet
*/
static int
cs_access_configuration_register(client_handle_t client_handle,
access_config_reg_t *acr)
{
cs_socket_t *sp;
client_t *client;
acc_handle_t cis_handle;
int error;
uint32_t newoffset;
int client_lock_acquired;
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't support SS using this call.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_UNSUPPORTED_FUNCTION);
/*
* Make sure that the specifed offset is in range.
*/
if (acr->Offset > ((CISTPL_CONFIG_MAX_CONFIG_REGS * 2) - 2))
return (CS_BAD_ARGS);
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
}
/*
* If there's no card in the socket or the card in the socket is not
* for this client, then return an error.
*/
if (!(client->flags & CLIENT_CARD_INSERTED)) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_NO_CARD);
}
/*
* If RequestConfiguration has not been done, we don't allow
* this call.
*/
if (!(client->flags & REQ_CONFIGURATION_DONE)) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_UNSUPPORTED_MODE);
}
mutex_enter(&sp->cis_lock);
/*
* Get a pointer to the CIS window
*/
newoffset = client->config_regs_offset + acr->Offset;
if (cs_init_cis_window(sp, &newoffset, &cis_handle,
CISTPLF_AM_SPACE) != CS_SUCCESS) {
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
cmn_err(CE_CONT, "cs_ACR: socket %d can't init CIS window\n",
sp->socket_num);
return (CS_GENERAL_FAILURE);
}
/*
* Create the address for the config register that the client
* wants to access.
*/
mutex_enter(&sp->lock);
#ifdef CS_DEBUG
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_ACR: config_regs_offset 0x%x "
"Offset 0x%x newoffset 0x%x\n",
(int)client->config_regs_offset,
(int)acr->Offset, newoffset);
}
#endif
/*
* Determine what the client wants us to do. The client is
* allowed to specify any valid offset, even if it would
* cause an unimplemented configuration register to be
* accessed.
*/
error = CS_SUCCESS;
switch (acr->Action) {
case CONFIG_REG_READ:
acr->Value = csx_Get8(cis_handle, newoffset);
break;
case CONFIG_REG_WRITE:
csx_Put8(cis_handle, newoffset, acr->Value);
break;
default:
error = CS_BAD_ARGS;
break;
} /* switch */
mutex_exit(&sp->lock);
mutex_exit(&sp->cis_lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
}
/*
* ==== RESET and general info functions ====
*/
/*
* cs_reset_function - RESET the requested function on the card; this
* is ResetFunction
*
* Note: We don't support this functionality yet, and the standard
* says it's OK to reutrn CS_IN_USE if we can't do this
* operation.
*/
/*ARGSUSED*/
static int
cs_reset_function(client_handle_t ch, reset_function_t *rf)
{
return (CS_IN_USE);
}
/*
* cs_get_configuration_info - return configuration info for the passed
* socket and function number to the caller;
* this is GetConfigurationInfo
*/
/*ARGSUSED*/
static int
cs_get_configuration_info(client_handle_t *chp, get_configuration_info_t *gci)
{
cs_socket_t *sp;
uint32_t fn;
client_t *client;
int client_lock_acquired;
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(CS_GET_SOCKET_NUMBER(gci->Socket))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
mutex_enter(&sp->lock);
fn = CS_GET_FUNCTION_NUMBER(gci->Socket);
client = sp->client_list;
while (client) {
if (GET_CLIENT_FUNCTION(client->client_handle) == fn) {
/*
* If there's no card in the socket or the card in the
* socket is not for this client, then return
* an error.
*/
if (!(client->flags & CLIENT_CARD_INSERTED)) {
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_NO_CARD);
}
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
} /* GET_CLIENT_FUNCTION == fn */
client = client->next;
} /* while (client) */
mutex_exit(&sp->lock);
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_SOCKET);
}
/*
* cs_get_cardservices_info - return info about Card Services to the
* caller; this is GetCardServicesInfo
*/
/*ARGSUSED*/
static int
cs_get_cardservices_info(client_handle_t ch, get_cardservices_info_t *gcsi)
{
gcsi->Signature[0] = 'C';
gcsi->Signature[1] = 'S';
gcsi->NumSockets = cs_globals.num_sockets;
gcsi->Revision = CS_INTERNAL_REVISION_LEVEL;
gcsi->CSLevel = CS_VERSION;
gcsi->FuncsPerSocket = CIS_MAX_FUNCTIONS;
(void) strncpy(gcsi->VendorString,
CS_GET_CARDSERVICES_INFO_VENDOR_STRING,
CS_GET_CARDSERVICES_INFO_MAX_VS_LEN);
return (CS_SUCCESS);
}
/*
* cs_get_physical_adapter_info - returns information about the requested
* physical adapter; this is
* GetPhysicalAdapterInfo
*
* calling: client_handle_t:
* NULL - use map_log_socket_t->LogSocket member
* to specify logical socket number
* !NULL - extract logical socket number from
* client_handle_t
*
* returns: CS_SUCCESS
* CS_BAD_SOCKET - if client_handle_t is NULL and invalid
* socket number is specified in
* map_log_socket_t->LogSocket
* CS_BAD_HANDLE - if client_handle_t is !NULL and invalid
* client handle is specified
*/
static int
cs_get_physical_adapter_info(client_handle_t ch,
get_physical_adapter_info_t *gpai)
{
cs_socket_t *sp;
int client_lock_acquired;
if (ch == NULL)
gpai->PhySocket = CS_GET_SOCKET_NUMBER(gpai->LogSocket);
else
gpai->PhySocket = GET_CLIENT_SOCKET(ch);
/*
* Determine if the passed socket number is valid or not.
*/
if ((sp = cs_get_sp(CS_GET_SOCKET_NUMBER(gpai->PhySocket))) == NULL)
return ((ch == NULL) ? CS_BAD_SOCKET : CS_BAD_HANDLE);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* If we were passed a client handle, determine if it's valid or not.
*/
if (ch != NULL) {
if (cs_find_client(ch, NULL) == NULL) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_HANDLE);
} /* cs_find_client */
} /* ch != NULL */
gpai->flags = sp->adapter.flags;
(void) strcpy(gpai->name, sp->adapter.name);
gpai->major = sp->adapter.major;
gpai->minor = sp->adapter.minor;
gpai->instance = sp->adapter.instance;
gpai->number = sp->adapter.number;
gpai->num_sockets = sp->adapter.num_sockets;
gpai->first_socket = sp->adapter.first_socket;
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
}
/*
* ==== general functions ====
*/
/*
* cs_map_log_socket - returns the physical socket number associated with
* either the passed client handle or the passed
* logical socket number; this is MapLogSocket
*
* calling: client_handle_t:
* NULL - use map_log_socket_t->LogSocket member
* to specify logical socket number
* !NULL - extract logical socket number from
* client_handle_t
*
* returns: CS_SUCCESS
* CS_BAD_SOCKET - if client_handle_t is NULL and invalid
* socket number is specified in
* map_log_socket_t->LogSocket
* CS_BAD_HANDLE - if client_handle_t is !NULL and invalid
* client handle is specified
*
* Note: We provide this function since the instance number of a client
* driver doesn't necessary correspond to the physical
* socket number
*/
static int
cs_map_log_socket(client_handle_t ch, map_log_socket_t *mls)
{
cs_socket_t *sp;
int client_lock_acquired;
if (ch == NULL)
mls->PhySocket = CS_GET_SOCKET_NUMBER(mls->LogSocket);
else
mls->PhySocket = GET_CLIENT_SOCKET(ch);
/*
* Determine if the passed socket number is valid or not.
*/
if ((sp = cs_get_sp(CS_GET_SOCKET_NUMBER(mls->PhySocket))) == NULL)
return ((ch == NULL) ? CS_BAD_SOCKET : CS_BAD_HANDLE);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* If we were passed a client handle, determine if it's valid or not.
*/
if (ch != NULL) {
if (cs_find_client(ch, NULL) == NULL) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_HANDLE);
} /* cs_find_client */
} /* ch != NULL */
mls->PhyAdapter = sp->adapter.number;
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
}
/*
* cs_convert_speed - convers nS to devspeed and devspeed to nS
*
* The actual function is is in the CIS parser module; this
* is only a wrapper.
*/
static int
cs_convert_speed(convert_speed_t *cs)
{
return ((int)(uintptr_t)CIS_PARSER(CISP_CIS_CONV_DEVSPEED, cs));
}
/*
* cs_convert_size - converts a devsize value to a size in bytes value
* or a size in bytes value to a devsize value
*
* The actual function is is in the CIS parser module; this
* is only a wrapper.
*/
static int
cs_convert_size(convert_size_t *cs)
{
return ((int)(uintptr_t)CIS_PARSER(CISP_CIS_CONV_DEVSIZE, cs));
}
/*
* cs_convert_powerlevel - converts a power level in tenths of a volt
* to a power table entry for the specified socket
*
* returns: CS_SUCCESS - if volts converted to a valid power level
* CS_BAD_ADAPTER - if SS_InquireAdapter fails
* CS_BAD_ARGS - if volts are not supported on this socket
* and adapter
*/
static int
cs_convert_powerlevel(uint32_t sn, uint32_t volts, uint32_t flags, unsigned *pl)
{
inquire_adapter_t inquire_adapter;
int i;
#ifdef lint
if (sn == 0)
panic("lint panic");
#endif
*pl = 0;
if (SocketServices(SS_InquireAdapter, &inquire_adapter) != SUCCESS)
return (CS_BAD_ADAPTER);
for (i = 0; (i < inquire_adapter.NumPower); i++) {
if ((inquire_adapter.power_entry[i].ValidSignals & flags) &&
(inquire_adapter.power_entry[i].PowerLevel == volts)) {
*pl = i;
return (CS_SUCCESS);
}
}
return (CS_BAD_ARGS);
}
/*
* cs_event2text - returns text string(s) associated with the event; this
* function supports the Event2Text CS call.
*
* calling: event2text_t * - pointer to event2text struct
* int event_source - specifies event type in event2text_t:
* 0 - SS event
* 1 - CS event
*
* returns: CS_SUCCESS
*/
static int
cs_event2text(event2text_t *e2t, int event_source)
{
event_t event;
char *sepchar = "|";
/*
* If event_source is 0, this is a SS event
*/
if (!event_source) {
for (event = 0; event < MAX_SS_EVENTS; event++) {
if (cs_ss_event_text[event].ss_event == e2t->event) {
(void) strcpy(e2t->text, cs_ss_event_text[event].text);
return (CS_SUCCESS);
}
}
(void) strcpy(e2t->text, cs_ss_event_text[MAX_CS_EVENTS].text);
return (CS_SUCCESS);
} else {
/*
* This is a CS event
*/
e2t->text[0] = '\0';
for (event = 0; event < MAX_CS_EVENTS; event++) {
if (cs_ss_event_text[event].cs_event & e2t->event) {
(void) strcat(e2t->text, cs_ss_event_text[event].text);
(void) strcat(e2t->text, sepchar);
} /* if (cs_ss_event_text) */
} /* for (event) */
if (e2t->text[0])
e2t->text[strlen(e2t->text)-1] = NULL;
} /* if (!event_source) */
return (CS_SUCCESS);
}
/*
* cs_error2text - returns a pointer to a text string containing the name
* of the passed Card Services function or return code
*
* This function supports the Error2Text CS call.
*/
static char *
cs_error2text(int function, int type)
{
cs_csfunc2text_strings_t *cfs;
int end_marker;
if (type == CSFUN2TEXT_FUNCTION) {
cfs = cs_csfunc2text_funcstrings;
end_marker = CSFuncListEnd;
} else {
cfs = cs_csfunc2text_returnstrings;
end_marker = CS_ERRORLIST_END;
}
while (cfs->item != end_marker) {
if (cfs->item == function)
return (cfs->text);
cfs++;
}
return (cfs->text);
}
/*
* cs_make_device_node - creates/removes device nodes on a client's behalf;
* this is MakeDeviceNode and RemoveDeviceNode
*
* returns: CS_SUCCESS - if all device nodes successfully created/removed
* CS_BAD_ATTRIBUTE - if NumDevNodes is not zero when Action
* is REMOVAL_ALL_DEVICES
* CS_BAD_ARGS - if an invalid Action code is specified
* CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
* CS_OUT_OF_RESOURCE - if can't create/remove device node
*/
static int
cs_make_device_node(client_handle_t client_handle, make_device_node_t *mdn)
{
cs_socket_t *sp;
client_t *client;
ss_make_device_node_t ss_make_device_node;
int error, i;
int client_lock_acquired;
/*
* Check to see if this is the Socket Services client handle; if it
* is, we don't support SS using this call.
*/
if (CLIENT_HANDLE_IS_SS(client_handle))
return (CS_UNSUPPORTED_FUNCTION);
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
/*
* Make sure that this is a valid client handle.
*/
if (!(client = cs_find_client(client_handle, &error))) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
}
#ifdef XXX
/*
* If there's no card in the socket or the card in the socket is not
* for this client, then return an error.
*/
if (!(client->flags & CLIENT_CARD_INSERTED)) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_NO_CARD);
}
#endif
/*
* Setup the client's dip, since we use it later on.
*/
ss_make_device_node.dip = client->dip;
/*
* Make sure that we're being given a valid Action. Set the default
* error code as well.
*/
error = CS_BAD_ARGS; /* for default case */
switch (mdn->Action) {
case CREATE_DEVICE_NODE:
case REMOVE_DEVICE_NODE:
break;
case REMOVAL_ALL_DEVICE_NODES:
if (mdn->NumDevNodes) {
error = CS_BAD_ATTRIBUTE;
} else {
ss_make_device_node.flags = SS_CSINITDEV_REMOVE_DEVICE;
ss_make_device_node.name = NULL;
SocketServices(CSInitDev, &ss_make_device_node);
error = CS_SUCCESS;
}
/* fall-through case */
default:
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (error);
/* NOTREACHED */
} /* switch */
/*
* Loop through the device node descriptions and create or destroy
* the device node.
*/
for (i = 0; i < mdn->NumDevNodes; i++) {
devnode_desc_t *devnode_desc = &mdn->devnode_desc[i];
ss_make_device_node.name = devnode_desc->name;
ss_make_device_node.spec_type = devnode_desc->spec_type;
ss_make_device_node.minor_num = devnode_desc->minor_num;
ss_make_device_node.node_type = devnode_desc->node_type;
/*
* Set the appropriate flag for the action that we want
* SS to perform. Note that if we ever OR-in the flag
* here, we need to be sure to clear the flags member
* since we sometimes OR-in other flags below.
*/
if (mdn->Action == CREATE_DEVICE_NODE) {
ss_make_device_node.flags = SS_CSINITDEV_CREATE_DEVICE;
} else {
ss_make_device_node.flags = SS_CSINITDEV_REMOVE_DEVICE;
}
/*
* If this is not the last device to process, then we need
* to tell SS that more device process requests are on
* their way after this one.
*/
if (i < (mdn->NumDevNodes - 1))
ss_make_device_node.flags |= SS_CSINITDEV_MORE_DEVICES;
if (SocketServices(CSInitDev, &ss_make_device_node) != SUCCESS) {
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_OUT_OF_RESOURCE);
} /* CSInitDev */
} /* for (mdn->NumDevNodes) */
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
}
/*
* cs_remove_device_node - removes device nodes
*
* (see cs_make_device_node for a description of the calling
* and return parameters)
*/
static int
cs_remove_device_node(client_handle_t client_handle, remove_device_node_t *rdn)
{
/*
* XXX - Note the assumption here that the make_device_node_t and
* remove_device_node_t structures are identical.
*/
return (cs_make_device_node(client_handle, (make_device_node_t *)rdn));
}
/*
* cs_ddi_info - this function is used by clients that need to support
* the xxx_getinfo function; this is CS_DDI_Info
*/
static int
cs_ddi_info(cs_ddi_info_t *cdi)
{
cs_socket_t *sp;
client_t *client;
int client_lock_acquired;
if (cdi->driver_name == NULL)
return (CS_BAD_ATTRIBUTE);
#ifdef CS_DEBUG
if (cs_debug > 0) {
cmn_err(CE_CONT, "cs_ddi_info: socket %d client [%s]\n",
(int)cdi->Socket, cdi->driver_name);
}
#endif
/*
* Check to see if the socket number is in range - the system
* framework may cause a client driver to call us with
* a socket number that used to be present but isn't
* anymore. This is not a bug, and it's OK to return
* an error if the socket number is out of range.
*/
if (!CHECK_SOCKET_NUM(cdi->Socket, cs_globals.max_socket_num)) {
#ifdef CS_DEBUG
if (cs_debug > 0) {
cmn_err(CE_CONT, "cs_ddi_info: socket %d client [%s] "
"SOCKET IS OUT OF RANGE\n",
(int)cdi->Socket,
cdi->driver_name);
}
#endif
return (CS_BAD_SOCKET);
} /* if (!CHECK_SOCKET_NUM) */
/*
* Get a pointer to this client's socket structure.
*/
if ((sp = cs_get_sp(cdi->Socket)) == NULL)
return (CS_BAD_SOCKET);
EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
client = sp->client_list;
while (client) {
#ifdef CS_DEBUG
if (cs_debug > 0) {
cmn_err(CE_CONT, "cs_ddi_info: socket %d checking client [%s] "
"handle 0x%x\n",
(int)cdi->Socket,
client->driver_name,
(int)client->client_handle);
}
#endif
if (client->driver_name != NULL) {
if (!(strcmp(client->driver_name, cdi->driver_name))) {
cdi->dip = client->dip;
cdi->instance = client->instance;
#ifdef CS_DEBUG
if (cs_debug > 0) {
cmn_err(CE_CONT, "cs_ddi_info: found client [%s] "
"instance %d handle 0x%x\n",
client->driver_name, client->instance,
(int)client->client_handle);
}
#endif
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_SUCCESS);
} /* strcmp */
} /* driver_name != NULL */
client = client->next;
} /* while (client) */
EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
return (CS_BAD_SOCKET);
}
/*
* cs_sys_ctl - Card Services system control; this is CS_Sys_Ctl
*/
static int
cs_sys_ctl(cs_sys_ctl_t *csc)
{
cs_socket_t *sp;
client_t *cp;
int sn, ret = CS_UNSUPPORTED_MODE;
switch (csc->Action) {
case CS_SYS_CTL_SEND_EVENT:
if (csc->Flags & CS_SYS_CTL_EVENT_SOCKET)
sn = CS_GET_SOCKET_NUMBER(csc->Socket);
else
sn = GET_CLIENT_SOCKET(csc->client_handle);
if ((sp = cs_get_sp(sn)) == NULL)
return (CS_BAD_SOCKET);
mutex_enter(&sp->client_lock);
mutex_enter(&sp->lock);
csc->Events &= CS_EVENT_CLIENT_EVENTS_MASK;
if (csc->Flags & CS_SYS_CTL_EVENT_SOCKET)
sp->events |= csc->Events;
if (csc->Flags & CS_SYS_CTL_EVENT_CLIENT) {
if ((cp = cs_find_client(csc->client_handle, &ret)) ==
NULL) {
mutex_exit(&sp->lock);
mutex_exit(&sp->client_lock);
return (ret);
} /* cs_find_client */
/*
* Setup the events that we want to send to the client.
*/
cp->events |= (csc->Events &
(cp->event_mask | cp->global_mask));
} /* CS_SYS_CTL_EVENT_CLIENT */
if (csc->Flags & CS_SYS_CTL_WAIT_SYNC) {
sp->thread_state |= SOCKET_WAIT_SYNC;
mutex_exit(&sp->lock);
cv_broadcast(&sp->thread_cv);
cv_wait(&sp->caller_cv, &sp->client_lock);
} else {
mutex_exit(&sp->lock);
cv_broadcast(&sp->thread_cv);
} /* CS_SYS_CTL_WAIT_SYNC */
mutex_exit(&sp->client_lock);
ret = CS_SUCCESS;
break;
default:
break;
} /* switch */
return (ret);
}
/*
* cs_get_sp - returns pointer to per-socket structure for passed
* socket number
*
* return: (cs_socket_t *) - pointer to socket structure
* NULL - invalid socket number passed in
*/
static cs_socket_t *
cs_get_sp(uint32_t sn)
{
cs_socket_t *sp = cs_globals.sp;
if (!(cs_globals.init_state & GLOBAL_INIT_STATE_SS_READY))
return (NULL);
if ((sp = cs_find_sp(sn)) == NULL)
return (NULL);
if (sp->flags & SOCKET_IS_VALID)
return (sp);
return (NULL);
}
/*
* cs_find_sp - searches socket list and returns pointer to passed socket
* number
*
* return: (cs_socket_t *) - pointer to socket structure if found
* NULL - socket not found
*/
static cs_socket_t *
cs_find_sp(uint32_t sn)
{
cs_socket_t *sp = cs_globals.sp;
while (sp) {
if (sp->socket_num == CS_GET_SOCKET_NUMBER(sn))
return (sp);
sp = sp->next;
} /* while */
return (NULL);
}
/*
* cs_add_socket - add a socket
*
* call: sn - socket number to add
*
* return: CS_SUCCESS - operation sucessful
* CS_BAD_SOCKET - unable to add socket
* CS_BAD_WINDOW - unable to get CIS window for socket
*
* We get called here once for each socket that the framework wants to
* add. When we are called, the framework guarentees that until we
* complete this routine, no other adapter instances will be allowed
* to attach and thus no other PCE_ADD_SOCKET events will occur.
* It is safe to call SS_InquireAdapter to get the number of
* windows that the framework currently knows about.
*/
static uint32_t
cs_add_socket(uint32_t sn)
{
cs_socket_t *sp;
sservice_t sservice;
get_cookies_and_dip_t *gcad;
win_req_t win_req;
convert_speed_t convert_speed;
set_socket_t set_socket;
cs_window_t *cw;
inquire_adapter_t inquire_adapter;
inquire_window_t inquire_window;
int ret, added_windows;
if (!(cs_globals.init_state & GLOBAL_INIT_STATE_SS_READY))
return (CS_BAD_SOCKET);
/*
* See if this socket has already been added - if it has, we
* fail this. If we can't find the socket, then allocate
* a new socket structure. If we do find the socket, then
* check to see if it's already added; if it is, then
* this is an error and return CS_BAD_SOCKET; if not,
* then traverse the socket structure list and add this
* next socket strcture to the end of the list.
* XXX What about locking this list while we update it? Is
* that necessary since we're using the SOCKET_IS_VALID
* flag and since we never delete a socket from the
* list once it's been added?
*/
if ((sp = cs_find_sp(sn)) == NULL) {
cs_socket_t *spp = cs_globals.sp;
sp = (cs_socket_t *)kmem_zalloc(sizeof (cs_socket_t), KM_SLEEP);
if (cs_globals.sp == NULL)
cs_globals.sp = sp;
else
while (spp) {
if (spp->next == NULL) {
spp->next = sp;
break;
} /* if */
spp = spp->next;
} /* while */
} else {
if (sp->flags & SOCKET_IS_VALID)
return (CS_BAD_SOCKET);
} /* cs_find_sp */
/*
* Setup the socket number
*/
sp->socket_num = sn;
/*
* Find out how many windows the framework knows about
* so far. If this number of windows is greater
* than our current window count, bump up our
* current window count.
* XXX Note that there is a BIG assumption here and that
* is that once the framework tells us that it has
* a window (as reflected in the NumWindows
* value) it can NEVER remove that window.
* When we really get the drop socket and drop
* window mechanism working correctly, we'll have
* to revisit this.
*/
SocketServices(SS_InquireAdapter, &inquire_adapter);
mutex_enter(&cs_globals.window_lock);
added_windows = inquire_adapter.NumWindows - cs_globals.num_windows;
if (added_windows > 0) {
if (cs_add_windows(added_windows,
cs_globals.num_windows) != CS_SUCCESS) {
mutex_exit(&cs_globals.window_lock);
return (CS_BAD_WINDOW);
} /* cs_add_windows */
cs_globals.num_windows = inquire_adapter.NumWindows;
} /* if (added_windows) */
/*
* Find a window that we can use for this socket's CIS window.
*/
sp->cis_win_num = PCMCIA_MAX_WINDOWS;
convert_speed.Attributes = CONVERT_NS_TO_DEVSPEED;
convert_speed.nS = CIS_DEFAULT_SPEED;
(void) cs_convert_speed(&convert_speed);
win_req.win_params.AccessSpeed = convert_speed.devspeed;
win_req.Attributes = (WIN_MEMORY_TYPE_AM | WIN_DATA_WIDTH_8);
win_req.Attributes = (WIN_MEMORY_TYPE_AM | WIN_MEMORY_TYPE_CM);
win_req.Base.base = 0;
win_req.Size = 0;
if ((ret = cs_find_mem_window(sp->socket_num, &win_req,
&sp->cis_win_num)) != CS_SUCCESS) {
mutex_exit(&cs_globals.window_lock);
sp->cis_win_num = PCMCIA_MAX_WINDOWS;
cmn_err(CE_CONT, "cs_add_socket: socket %d can't get CIS "
"window - error 0x%x\n",
sp->socket_num, ret);
return (CS_BAD_WINDOW);
} /* cs_find_mem_window */
if ((cw = cs_get_wp(sp->cis_win_num)) == NULL) {
mutex_exit(&cs_globals.window_lock);
return (CS_BAD_WINDOW);
}
inquire_window.window = sp->cis_win_num;
SocketServices(SS_InquireWindow, &inquire_window);
/*
* If the CIS window is a variable sized window, then use
* the size that cs_find_mem_window returned to us,
* since this will be the minimum size that we can
* set this window to. If the CIS window is a fixed
* sized window, then use the system pagesize as the
* CIS window size.
*/
if (inquire_window.mem_win_char.MemWndCaps & WC_SIZE) {
sp->cis_win_size = win_req.Size;
} else {
sp->cis_win_size = PAGESIZE;
}
cw->state |= (CW_CIS | CW_ALLOCATED);
cw->socket_num = sp->socket_num;
mutex_exit(&cs_globals.window_lock);
#if defined(CS_DEBUG)
if (cs_debug > 1) {
cmn_err(CE_CONT, "cs_add_socket: socket %d using CIS window %d "
"size 0x%x\n", (int)sp->socket_num,
(int)sp->cis_win_num,
(int)sp->cis_win_size);
}
#endif
/*
* Get the adapter information associated with this socket so
* that we can initialize the mutexes, condition variables,
* soft interrupt handler and per-socket adapter info.
*/
gcad = &sservice.get_cookies;
gcad->socket = sp->socket_num;
if (SocketServices(CSGetCookiesAndDip, &sservice) != SUCCESS) {
cmn_err(CE_CONT, "cs_add_socket: socket %d CSGetCookiesAndDip "
"failure\n", sp->socket_num);
return (CS_BAD_SOCKET);
} /* CSGetCookiesAndDip */
/*
* Save the iblock and idev cookies for RegisterClient
*/
sp->iblk = gcad->iblock;
sp->idev = gcad->idevice;
/*
* Setup the per-socket adapter info
*/
sp->adapter.flags = 0;
(void) strcpy(sp->adapter.name, gcad->adapter_info.name);
sp->adapter.major = gcad->adapter_info.major;
sp->adapter.minor = gcad->adapter_info.minor;
sp->adapter.instance = ddi_get_instance(gcad->dip);
sp->adapter.number = gcad->adapter_info.number;
sp->adapter.num_sockets = gcad->adapter_info.num_sockets;
sp->adapter.first_socket = gcad->adapter_info.first_socket;
/* Setup for cs_event and cs_event_thread */
mutex_init(&sp->lock, NULL, MUTEX_DRIVER, *(gcad->iblock));
mutex_init(&sp->client_lock, NULL, MUTEX_DRIVER, NULL);
mutex_init(&sp->cis_lock, NULL, MUTEX_DRIVER, NULL);
/* Setup for Socket Services work thread */
mutex_init(&sp->ss_thread_lock, NULL, MUTEX_DRIVER, NULL);
sp->init_state |= SOCKET_INIT_STATE_MUTEX;
/* Setup for cs_event_thread */
cv_init(&sp->thread_cv, NULL, CV_DRIVER, NULL);
cv_init(&sp->caller_cv, NULL, CV_DRIVER, NULL);
cv_init(&sp->reset_cv, NULL, CV_DRIVER, NULL);
/* Setup for Socket Services work thread */
cv_init(&sp->ss_thread_cv, NULL, CV_DRIVER, NULL);
cv_init(&sp->ss_caller_cv, NULL, CV_DRIVER, NULL);
sp->init_state |= SOCKET_INIT_STATE_CV;
/*
* If we haven't installed it yet, then install the soft interrupt
* handler and save away the softint id.
*/
if (!(cs_globals.init_state & GLOBAL_INIT_STATE_SOFTINTR)) {
if (ddi_add_softintr(gcad->dip, DDI_SOFTINT_HIGH,
&sp->softint_id,
NULL, NULL,
cs_socket_event_softintr,
(caddr_t)NULL) != DDI_SUCCESS) {
cmn_err(CE_CONT, "cs_add_socket: socket %d can't add "
"softintr\n", sp->socket_num);
return (CS_BAD_SOCKET);
} /* ddi_add_softintr */
mutex_enter(&cs_globals.global_lock);
cs_globals.softint_id = sp->softint_id;
cs_globals.init_state |= GLOBAL_INIT_STATE_SOFTINTR;
/* XXX this timer is hokey at best... */
cs_globals.sotfint_tmo = timeout(cs_event_softintr_timeout,
NULL, SOFTINT_TIMEOUT_TIME);
mutex_exit(&cs_globals.global_lock);
} else {
/*
* We've already added the soft interrupt handler, so just
* store away the softint id.
*/
sp->softint_id = cs_globals.softint_id;
} /* if (!GLOBAL_INIT_STATE_SOFTINTR) */
/*
* While this next flag doesn't really describe a per-socket
* resource, we still set it for each socket. When the soft
* interrupt handler finally gets removed in cs_deinit, this
* flag will get cleared.
*/
sp->init_state |= SOCKET_INIT_STATE_SOFTINTR;
/*
* Socket Services defaults all sockets to power off and
* clears all event masks. We want to receive at least
* card insertion events, so enable them. Turn off power
* to the socket as well. We will turn it on again when
* we get a card insertion event.
*/
sp->event_mask = CS_EVENT_CARD_INSERTION;
set_socket.socket = sp->socket_num;
set_socket.SCIntMask = SBM_CD;
set_socket.IREQRouting = 0;
set_socket.IFType = IF_MEMORY;
set_socket.CtlInd = 0; /* turn off controls and indicators */
set_socket.State = (unsigned)~0; /* clear latched state bits */
(void) cs_convert_powerlevel(sp->socket_num, 0, VCC,
&set_socket.VccLevel);
(void) cs_convert_powerlevel(sp->socket_num, 0, VPP1,
&set_socket.Vpp1Level);
(void) cs_convert_powerlevel(sp->socket_num, 0, VPP2,
&set_socket.Vpp2Level);
if ((ret = SocketServices(SS_SetSocket, &set_socket)) != SUCCESS) {
cmn_err(CE_CONT, "cs_add_socket: socket %d SS_SetSocket "
"failure %d\n", sp->socket_num, ret);
return (CS_BAD_SOCKET);
} /* SS_SetSocket */
/*
* The various socket-specific variables are now set up, so
* increment the global socket count and also mark the
* socket as available. We need to set this before we
* start any of the per-socket threads so that the threads
* can get a valid socket pointer when they start.
*/
mutex_enter(&cs_globals.global_lock);
cs_globals.num_sockets++;
cs_globals.max_socket_num =
max(cs_globals.max_socket_num, sp->socket_num + 1);
mutex_exit(&cs_globals.global_lock);
sp->flags = SOCKET_IS_VALID;
/*
* Create the per-socket event handler thread.
*/
sp->event_thread = CREATE_SOCKET_EVENT_THREAD(cs_event_thread,
(uintptr_t)sn);
mutex_enter(&sp->lock);
sp->init_state |= SOCKET_INIT_STATE_THREAD;
mutex_exit(&sp->lock);
/*
* Create the per-socket Socket Services work thread.
*/
sp->ss_thread = CREATE_SOCKET_EVENT_THREAD(cs_ss_thread,
(uintptr_t)sn);
mutex_enter(&sp->lock);
sp->init_state |= (SOCKET_INIT_STATE_SS_THREAD |
SOCKET_INIT_STATE_READY);
sp->event_mask = CS_EVENT_CARD_INSERTION;
mutex_exit(&sp->lock);
return (CS_SUCCESS);
}
/*
* cs_drop_socket - drop a socket
*
* call: sn - socket number to drop
*
* return: CS_SUCCESS - operation sucessful
* CS_BAD_SOCKET - unable to drop socket
*/
/*ARGSUSED*/
static uint32_t
cs_drop_socket(uint32_t sn)
{
#ifdef XXX
cs_socket_t *sp;
/*
* Tell the socket event thread to exit and then wait for it
* to do so.
*/
mutex_enter(&sp->client_lock);
sp->thread_state |= SOCKET_THREAD_EXIT;
cv_broadcast(&sp->thread_cv);
cv_wait(&sp->caller_cv, &sp->client_lock);
mutex_exit(&sp->client_lock);
/*
* Tell the socket SS thread to exit and then wait for it
* to do so.
*/
/*
* Mark the socket as dropped.
*/
sp->flags &= ~SOCKET_IS_VALID;
#endif /* XXX */
/* XXX for now don't allow dropping sockets XXX */
return (CS_BAD_SOCKET);
}
/*
* cs_get_socket - returns the socket and function numbers and a pointer
* to the socket structure
*
* calling: client_handle_t client_handle - client handle to extract
* socket number from
* uint32_t *socket - pointer to socket number to use if
* client_handle is for the SS client;
* this value will be filled in on
* return with the correct socket
* and function numbers if we
* return CS_SUCCESS
* uint32_t *function - pointer to return function number into
* if not NULL
* cs_socket_t **sp - pointer to a pointer where a pointer
* to the socket struct will be
* placed if this is non-NULL
* client_t **clp - pointer to a pointer where a pointer
* to the client struct will be
* placed if this is non-NULL
*
* The socket and function numbers are derived as follows:
*
* Client Type Socket Number Function Number
* PC card client From client_handle From client_handle
* Socket Services client From *socket From *socket
* CSI client From client_handle From *socket
*/
static uint32_t
cs_get_socket(client_handle_t client_handle, uint32_t *socket,
uint32_t *function, cs_socket_t **csp, client_t **clp)
{
cs_socket_t *sp;
client_t *client;
uint32_t sn, fn;
int ret;
sn = *socket;
/*
* If this is the Socket Services client, then return the
* socket and function numbers specified in the passed
* socket number parameter, otherwise extract the socket
* and function numbers from the client handle.
*/
if (CLIENT_HANDLE_IS_SS(client_handle)) {
fn = CS_GET_FUNCTION_NUMBER(sn);
sn = CS_GET_SOCKET_NUMBER(sn);
} else {
fn = GET_CLIENT_FUNCTION(client_handle);
sn = GET_CLIENT_SOCKET(client_handle);
}
/*
* Check to be sure that the socket number is in range
*/
if (!(CHECK_SOCKET_NUM(sn, cs_globals.max_socket_num)))
return (CS_BAD_SOCKET);
if ((sp = cs_get_sp(sn)) == NULL)
return (CS_BAD_SOCKET);
/*
* If we were given a pointer, then fill it in with a pointer
* to this socket.
*/
if (csp)
*csp = sp;
/*
* Search for the client; if it's not found, return an error.
*/
mutex_enter(&sp->lock);
if (!(client = cs_find_client(client_handle, &ret))) {
mutex_exit(&sp->lock);
return (ret);
}
/*
* If we're a CIS client, then extract the function number
* from the socket number.
*/
if (client->flags & CLIENT_CSI_CLIENT)
fn = CS_GET_FUNCTION_NUMBER(*socket);
mutex_exit(&sp->lock);
/*
* Return the found client pointer if the caller wants it.
*/
if (clp)
*clp = client;
/*
* Return a socket number that is made up of the socket number
* and the function number.
*/
*socket = CS_MAKE_SOCKET_NUMBER(sn, fn);
/*
* Return the function number if the caller wants it.
*/
if (function)
*function = fn;
return (CS_SUCCESS);
}
/*
* cs_get_wp - returns pointer to passed window number
*
* return: (cs_window_t *) - pointer to window structure
* NULL - if invalid window number passed in
*/
static cs_window_t *
cs_get_wp(uint32_t wn)
{
cs_window_t *cw;
if (!(cs_globals.init_state & GLOBAL_INIT_STATE_SS_READY))
return (NULL);
if ((cw = cs_find_wp(wn)) == NULL)
return (NULL);
if (cw->state & CW_WINDOW_VALID)
return (cw);
#ifdef CS_DEBUG
if (cs_debug > 0) {
cmn_err(CE_CONT, "cs_get_wp(): wn=%d cw=%p\n",
(int)wn, (void *)cw);
}
#endif
return (NULL);
}
/*
* cs_find_wp - searches window list and returns pointer to passed window
* number
*
* return: (cs_window_t *) - pointer to window structure
* NULL - window not found
*/
static cs_window_t *
cs_find_wp(uint32_t wn)
{
cs_window_t *cw = cs_globals.cw;
while (cw) {
if (cw->window_num == wn)
return (cw);
cw = cw->next;
} /* while */
#ifdef CS_DEBUG
if (cs_debug > 0) {
cmn_err(CE_CONT, "cs_find_wp(): wn=%d window_num=%d cw=%p\n",
(int)wn, (int)cw->window_num, (void *)cw);
}
#endif
return (NULL);
}
/*
* cs_add_windows - adds number of windows specified in "aw" to
* the global window list; start the window
* numbering at "bn"
*
* return: CS_SUCCESS - if windows added sucessfully
* CS_BAD_WINDOW - if unable to add windows
*
* Note: The window list must be protected by a lock by the caller.
*/
static int
cs_add_windows(int aw, uint32_t bn)
{
cs_window_t *cwp = cs_globals.cw;
cs_window_t *cw, *cwpp;
if (aw <= 0)
return (CS_BAD_WINDOW);
while (cwp) {
cwpp = cwp;
cwp = cwp->next;
}
while (aw--) {
cw = (cs_window_t *)kmem_zalloc(sizeof (cs_window_t), KM_SLEEP);
if (cs_globals.cw == NULL) {
cs_globals.cw = cw;
cwpp = cs_globals.cw;
} else {
cwpp->next = cw;
cwpp = cwpp->next;
}
cwpp->window_num = bn++;
cwpp->state = CW_WINDOW_VALID;
} /* while (aw) */
return (CS_SUCCESS);
}
/*
* cs_ss_init - initialize CS items that need to wait until we receive
* a PCE_SS_INIT_STATE/PCE_SS_STATE_INIT event
*
* return: CS_SUCESS - if sucessfully initialized
* (various) if error initializing
*
* At this point, we expect that Socket Services has setup the
* following global variables for us:
*
* cs_socket_services - Socket Services entry point
* cis_parser - CIS parser entry point
*/
static uint32_t
cs_ss_init()
{
cs_register_cardservices_t rcs;
csregister_t csr;
uint32_t ret;
/*
* Fill out the parameters for CISP_CIS_SETUP
*/
csr.cs_magic = PCCS_MAGIC;
csr.cs_version = PCCS_VERSION;
csr.cs_card_services = CardServices;
csr.cs_event = NULL;
/*
* Call into the CIS module and tell it what the private
* Card Services entry point is. The CIS module will
* call us back at CardServices(CISRegister, ...)
* with the address of various CIS-specific global
* data structures.
*/
CIS_PARSER(CISP_CIS_SETUP, &csr);
/*
* Register with the Card Services kernel stubs module
*/
rcs.magic = CS_STUBS_MAGIC;
rcs.function = CS_ENTRY_REGISTER;
rcs.cardservices = CardServices;
if ((ret = csx_register_cardservices(&rcs)) != CS_SUCCESS) {
cmn_err(CE_CONT, "cs_ss_init: can't register with "
"cs_stubs, retcode = 0x%x\n", ret);
return (ret);
} /* csx_register_cardservices */
return (CS_SUCCESS);
}
/*
* cs_create_cis - reads CIS on card in socket and creates CIS lists
*
* Most of the work is done in the CIS module in the CISP_CIS_LIST_CREATE
* function.
*
* This function returns:
*
* CS_SUCCESS - if the CIS lists were created sucessfully
* CS_BAD_WINDOW or CS_GENERAL_FAILURE - if CIS window could
* not be setup
* CS_BAD_CIS - if error creating CIS chains
* CS_BAD_OFFSET - if the CIS parser tried to read past the
* boundries of the allocated CIS window
*/
static int
cs_create_cis(cs_socket_t *sp)
{
uint32_t ret;
ret = (uint32_t)(uintptr_t)CIS_PARSER(CISP_CIS_LIST_CREATE,
cis_cistpl_std_callout, sp);
#ifdef CS_DEBUG
if (ret == CS_NO_CIS) {
if (cs_debug > 0)
cmn_err(CE_CONT, "cs_create_cis: socket %d has no CIS\n",
sp->socket_num);
} else if (ret != CS_SUCCESS) {
if (cs_debug > 0)
cmn_err(CE_CONT, "cs_create_cis: socket %d ERROR = 0x%x\n",
sp->socket_num, ret);
return (ret);
}
#else
if (ret != CS_NO_CIS)
if (ret != CS_SUCCESS)
return (ret);
#endif
/*
* If this card didn't have any CIS at all, there's not much
* else for us to do.
*/
if (!(sp->cis_flags & CW_VALID_CIS))
return (CS_SUCCESS);
/*
* If this is a single-function card, we need to move the CIS list
* that is currently on CS_GLOBAL_CIS to the function zero
* CIS list.
*/
if (!(sp->cis_flags & CW_MULTI_FUNCTION_CIS)) {
bcopy((caddr_t)&sp->cis[CS_GLOBAL_CIS],
(caddr_t)&sp->cis[0], sizeof (cis_info_t));
bzero((caddr_t)&sp->cis[CS_GLOBAL_CIS], sizeof (cis_info_t));
} /* !CW_MULTI_FUNCTION_CIS */
return (CS_SUCCESS);
}
/*
* cs_destroy_cis - destroys CIS list for socket
*/
static int
cs_destroy_cis(cs_socket_t *sp)
{
CIS_PARSER(CISP_CIS_LIST_DESTROY, sp);
return (CS_SUCCESS);
}
/*
* cs_get_client_info - This function is GetClientInfo.
*
* calling: client_handle_t - client handle to get client info on
* client_info_t * - pointer to a client_info_t structure
* to return client information in
*
* returns: CS_SUCCESS - if client info retreived from client
* CS_BAD_SOCKET, CS_BAD_HANDLE - if invalid client
* handle passed in
* CS_NO_MORE_ITEMS - if client does not handle the
* CS_EVENT_CLIENT_INFO event
* or if invalid client info
* retreived from client
*/
static int
cs_get_client_info(client_handle_t client_handle, client_info_t *ci)
{
cs_socket_t *sp;
client_t *client;
client_info_t *cinfo;
int ret = CS_SUCCESS;
if (CLIENT_HANDLE_IS_SS(client_handle)) {
ci->Attributes = (CS_CLIENT_INFO_SOCKET_SERVICES |
CS_CLIENT_INFO_VALID);
return (CS_SUCCESS);
} /* CLIENT_HANDLE_IS_SS */
if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
return (CS_BAD_SOCKET);
mutex_enter(&sp->client_lock);
mutex_enter(&sp->lock);
if ((client = cs_find_client(client_handle, &ret)) == NULL) {
mutex_exit(&sp->lock);
mutex_exit(&sp->client_lock);
return (ret);
} /* cs_find_client */
/*
* If this client is not handling CS_EVENT_CLIENT_INFO events,
* then don't bother to even wake up the event thread.
*/
if (!((client->event_mask | client->global_mask) &
CS_EVENT_CLIENT_INFO)) {
mutex_exit(&sp->lock);
mutex_exit(&sp->client_lock);
return (CS_NO_MORE_ITEMS);
} /* !CS_EVENT_CLIENT_INFO */
cinfo = &client->event_callback_args.client_info;
bzero((caddr_t)cinfo, sizeof (client_info_t));
cinfo->Attributes = (ci->Attributes & CS_CLIENT_INFO_SUBSVC_MASK);
client->events |= CS_EVENT_CLIENT_INFO;
sp->thread_state |= SOCKET_WAIT_SYNC;
mutex_exit(&sp->lock);
cv_broadcast(&sp->thread_cv);
cv_wait(&sp->caller_cv, &sp->client_lock);
if (cinfo->Attributes & CS_CLIENT_INFO_VALID) {
bcopy((caddr_t)cinfo, (caddr_t)ci, sizeof (client_info_t));
ci->Attributes &= (CS_CLIENT_INFO_FLAGS_MASK |
CS_CLIENT_INFO_SUBSVC_MASK);
ci->Attributes &= ~(CS_CLIENT_INFO_CLIENT_MASK |
INFO_CARD_FLAGS_MASK |
CS_CLIENT_INFO_CLIENT_ACTIVE);
ci->Attributes |= (client->flags & (CS_CLIENT_INFO_CLIENT_MASK |
INFO_CARD_FLAGS_MASK));
(void) strcpy(ci->DriverName, client->driver_name);
if (cs_card_for_client(client))
ci->Attributes |= CS_CLIENT_INFO_CLIENT_ACTIVE;
} else {
ret = CS_NO_MORE_ITEMS;
} /* CS_CLIENT_INFO_VALID */
mutex_exit(&sp->client_lock);
return (ret);
}
/*
* cs_get_firstnext_client - This function is GetFirstClient and
* GetNextClient
*
* calling: get_firstnext_client_t * - pointer to a get_firstnext_client_t
* structure to return client handle and
* attributes in
* flags - one of the following:
* CS_GET_FIRST_FLAG - get first client handle
* CS_GET_NEXT_FLAG - get next client handle
*
* returns: CS_SUCCESS - if client info retreived from client
* CS_BAD_SOCKET, CS_BAD_HANDLE - if invalid client
* handle passed in
* CS_NO_MORE_ITEMS - if client does not handle the
* CS_EVENT_CLIENT_INFO event
* or if invalid client info
* retreived from client
*/
static int
cs_get_firstnext_client(get_firstnext_client_t *fnc, uint32_t flags)
{
cs_socket_t *sp;
client_t *client;
uint32_t sn = 0;
int ret = CS_SUCCESS;
switch (flags) {
case CS_GET_FIRST_FLAG:
if (fnc->Attributes & CS_GET_FIRSTNEXT_CLIENT_ALL_CLIENTS) {
while (sn < cs_globals.max_socket_num) {
if ((sp = cs_get_sp(sn)) != NULL) {
mutex_enter(&sp->client_lock);
if ((client = sp->client_list) != NULL)
break;
mutex_exit(&sp->client_lock);
} /* if */
sn++;
} /* while */
if (sn == cs_globals.max_socket_num)
return (CS_NO_MORE_ITEMS);
} else if (fnc->Attributes &
CS_GET_FIRSTNEXT_CLIENT_SOCKET_ONLY) {
if ((sp = cs_get_sp(CS_GET_SOCKET_NUMBER(fnc->Socket))) ==
NULL)
return (CS_BAD_SOCKET);
mutex_enter(&sp->client_lock);
if ((client = sp->client_list) == NULL) {
mutex_exit(&sp->client_lock);
return (CS_NO_MORE_ITEMS);
}
} else {
return (CS_BAD_ATTRIBUTE);
}
fnc->client_handle = client->client_handle;
fnc->num_clients = sp->num_clients;
mutex_exit(&sp->client_lock);
break;
case CS_GET_NEXT_FLAG:
if (fnc->Attributes & CS_GET_FIRSTNEXT_CLIENT_ALL_CLIENTS) {
sn = GET_CLIENT_SOCKET(fnc->client_handle);
if ((sp = cs_get_sp(sn)) == NULL)
return (CS_BAD_SOCKET);
mutex_enter(&sp->client_lock);
if ((client = cs_find_client(fnc->client_handle,
&ret)) == NULL) {
mutex_exit(&sp->client_lock);
return (ret);
}
if ((client = client->next) == NULL) {
mutex_exit(&sp->client_lock);
sn++;
while (sn < cs_globals.max_socket_num) {
if ((sp = cs_get_sp(sn)) != NULL) {
mutex_enter(&sp->client_lock);
if ((client = sp->client_list) != NULL)
break;
mutex_exit(&sp->client_lock);
} /* if */
sn++;
} /* while */
if (sn == cs_globals.max_socket_num)
return (CS_NO_MORE_ITEMS);
} /* client = client->next */
} else if (fnc->Attributes &
CS_GET_FIRSTNEXT_CLIENT_SOCKET_ONLY) {
sp = cs_get_sp(GET_CLIENT_SOCKET(fnc->client_handle));
if (sp == NULL)
return (CS_BAD_SOCKET);
mutex_enter(&sp->client_lock);
if ((client = cs_find_client(fnc->client_handle,
&ret)) == NULL) {
mutex_exit(&sp->client_lock);
return (ret);
}
if ((client = client->next) == NULL) {
mutex_exit(&sp->client_lock);
return (CS_NO_MORE_ITEMS);
}
} else {
return (CS_BAD_ATTRIBUTE);
}
fnc->client_handle = client->client_handle;
fnc->num_clients = sp->num_clients;
mutex_exit(&sp->client_lock);
break;
default:
ret = CS_BAD_ATTRIBUTE;
break;
} /* switch */
return (ret);
}
/*
* cs_set_acc_attributes - converts Card Services endianness and
* data ordering values to values
* that Socket Services understands
*
* calling: *sw - pointer to a set_window_t to set attributes in
* Attributes - CS attributes
*/
static void
cs_set_acc_attributes(set_window_t *sw, uint32_t Attributes)
{
sw->attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
switch (Attributes & WIN_ACC_ENDIAN_MASK) {
case WIN_ACC_LITTLE_ENDIAN:
sw->attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC;
break;
case WIN_ACC_BIG_ENDIAN:
sw->attr.devacc_attr_endian_flags = DDI_STRUCTURE_BE_ACC;
break;
case WIN_ACC_NEVER_SWAP:
default:
sw->attr.devacc_attr_endian_flags = DDI_NEVERSWAP_ACC;
break;
} /* switch */
switch (Attributes & WIN_ACC_ORDER_MASK) {
case WIN_ACC_UNORDERED_OK:
sw->attr.devacc_attr_dataorder = DDI_UNORDERED_OK_ACC;
break;
case WIN_ACC_MERGING_OK:
sw->attr.devacc_attr_dataorder = DDI_MERGING_OK_ACC;
break;
case WIN_ACC_LOADCACHING_OK:
sw->attr.devacc_attr_dataorder = DDI_LOADCACHING_OK_ACC;
break;
case WIN_ACC_STORECACHING_OK:
sw->attr.devacc_attr_dataorder = DDI_STORECACHING_OK_ACC;
break;
case WIN_ACC_STRICT_ORDER:
default:
sw->attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;
break;
} /* switch */
}