/*ARGSUSED*/
static int
tcli_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
int instance = ddi_get_instance(devi);
struct dstate *dstatep;
int rval;
if (cmd != DDI_ATTACH)
return (DDI_SUCCESS);
if (ddi_soft_state_zalloc(dstates, instance) != DDI_SUCCESS) {
cmn_err(CE_CONT, "%s%d: can't allocate state\n",
ddi_get_name(devi), instance);
return (DDI_FAILURE);
}
dstatep = ddi_get_soft_state(dstates, instance);
dstatep->dip = devi;
rval = ddi_create_minor_node(devi, "client", S_IFCHR,
(INST_TO_MINOR(instance)), DDI_PSEUDO, NULL);
if (rval == DDI_FAILURE) {
ddi_remove_minor_node(devi, NULL);
ddi_soft_state_free(dstates, instance);
cmn_err(CE_WARN, "%s%d: can't create minor nodes",
ddi_get_name(devi), instance);
return (DDI_FAILURE);
}
ddi_report_dev(devi);
return (DDI_SUCCESS);
}
static int
gen_create_display(dev_info_t *devi)
{
int instance = ddi_get_instance(devi);
char minor_name[15];
(void) sprintf(minor_name, "cgtwenty%d", instance);
return (ddi_create_minor_node(devi, minor_name, S_IFCHR,
INST_TO_MINOR(instance), DDI_NT_DISPLAY, NULL));
}
static int
gen_create_net(dev_info_t *devi)
{
int instance = ddi_get_instance(devi);
char minorname[32];
if (gen_create_properties(devi) != DDI_SUCCESS)
return (DDI_FAILURE);
(void) snprintf(minorname, sizeof (minorname), "gen_drv%d", instance);
return (ddi_create_minor_node(devi, minorname, S_IFCHR,
INST_TO_MINOR(instance), DDI_NT_NET, 0));
}
static int
gen_create_serial(dev_info_t *devi)
{
struct driver_serial_minor_data *dmdp;
int instance = ddi_get_instance(devi);
for (dmdp = serial_minor_data; dmdp->name != NULL; dmdp++) {
if (ddi_create_minor_node(devi, dmdp->name, dmdp->type,
(INST_TO_MINOR(instance)) | dmdp->minor,
dmdp->node_type, NULL) != DDI_SUCCESS) {
return (DDI_FAILURE);
}
}
return (DDI_SUCCESS);
}
static int
gen_create_mn_disk_fd(dev_info_t *devi)
{
struct driver_minor_data *dmdp;
int instance = ddi_get_instance(devi);
for (dmdp = disk_minor_data; dmdp->name != NULL; dmdp++) {
if (ddi_create_minor_node(devi, dmdp->name, dmdp->type,
(INST_TO_MINOR(instance)) | dmdp->minor,
DDI_NT_BLOCK_CHAN, NULL) != DDI_SUCCESS) {
return (DDI_FAILURE);
}
}
return (DDI_SUCCESS);
}
static int
gen_create_mn_disk_wwn(dev_info_t *devi)
{
struct driver_minor_data *dmdp;
int instance = ddi_get_instance(devi);
char *address = ddi_get_name_addr(devi);
int target, lun;
if (address[0] >= '0' && address[0] <= '9' &&
strchr(address, ',')) {
target = atod(address);
address = strchr(address, ',');
lun = atod(++address);
} else { /* this hack is for rm_stale_link() testing */
target = 10;
lun = 5;
}
if (ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP,
"target", (caddr_t)&target, sizeof (int))
!= DDI_PROP_SUCCESS) {
return (DDI_FAILURE);
}
if (ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP,
"lun", (caddr_t)&lun, sizeof (int))
!= DDI_PROP_SUCCESS) {
return (DDI_FAILURE);
}
for (dmdp = disk_minor_data; dmdp->name != NULL; dmdp++) {
if (ddi_create_minor_node(devi, dmdp->name, dmdp->type,
(INST_TO_MINOR(instance)) | dmdp->minor,
DDI_NT_BLOCK_WWN, NULL) != DDI_SUCCESS) {
return (DDI_FAILURE);
}
}
return (DDI_SUCCESS);
}
static int
pca9556_attach(dev_info_t *dip)
{
pca9556_unit_t *pcap;
int instance = ddi_get_instance(dip);
char name[MAXNAMELEN];
char *device_name;
minor_t minor;
int i, num_ports;
if (ddi_soft_state_zalloc(pca9556_soft_statep, instance) != 0) {
cmn_err(CE_WARN, "%s%d failed to zalloc softstate",
ddi_get_name(dip), instance);
return (DDI_FAILURE);
}
pcap = ddi_get_soft_state(pca9556_soft_statep, instance);
if (pcap == NULL)
return (DDI_FAILURE);
mutex_init(&pcap->pca9556_mutex, NULL, MUTEX_DRIVER, NULL);
cv_init(&pcap->pca9556_cv, NULL, CV_DRIVER, NULL);
(void) snprintf(pcap->pca9556_name, sizeof (pcap->pca9556_name),
"%s_%d", ddi_driver_name(dip), instance);
device_name = ddi_get_name(dip);
if (strcmp(device_name, "i2c-pca9555") == 0) {
num_ports = PCA9555_NUM_PORTS;
pcap->pca9555_device = B_TRUE;
} else {
num_ports = PCA9556_NUM_PORTS;
pcap->pca9555_device = B_FALSE;
minor = INST_TO_MINOR(instance);
}
for (i = 0; i < num_ports; i++) {
if (!(pcap->pca9555_device)) {
(void) snprintf(pcap->pca9556_name,
sizeof (pcap->pca9556_name), "%s_%d",
ddi_driver_name(dip), instance);
(void) snprintf(name, sizeof (name), "%s",
pcap->pca9556_name);
} else {
(void) sprintf(name, "port_%d", i);
minor = INST_TO_MINOR(instance) |
PORT_TO_MINOR(I2C_PORT(i));
}
if (ddi_create_minor_node(dip, name, S_IFCHR, minor,
PCA9556_NODE_TYPE, NULL) == DDI_FAILURE) {
cmn_err(CE_WARN, "%s: failed to create node for %s",
pcap->pca9556_name, name);
pca9556_detach(dip);
return (DDI_FAILURE);
}
}
pcap->pca9556_flags |= PCA9556_MINORFLAG;
/*
* Add a zero-length attribute to tell the world we support
* kernel ioctls (for layered drivers)
*/
(void) ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP,
DDI_KERNEL_IOCTL, NULL, 0);
/*
* preallocate a single buffer for all reads and writes
*/
if (i2c_transfer_alloc(pcap->pca9556_hdl, &pcap->pca9556_transfer,
2, 2, I2C_SLEEP) != I2C_SUCCESS) {
cmn_err(CE_WARN, "%s i2c_transfer_alloc failed",
pcap->pca9556_name);
pca9556_detach(dip);
return (DDI_FAILURE);
}
pcap->pca9556_flags |= PCA9556_TBUFFLAG;
pcap->pca9556_transfer->i2c_version = I2C_XFER_REV;
if (i2c_client_register(dip, &pcap->pca9556_hdl) != I2C_SUCCESS) {
ddi_remove_minor_node(dip, NULL);
cmn_err(CE_WARN, "%s i2c_client_register failed",
pcap->pca9556_name);
pca9556_detach(dip);
return (DDI_FAILURE);
}
pcap->pca9556_flags |= PCA9556_REGFLAG;
/*
* Store the dip for future dip.
*/
pcap->pca9556_dip = dip;
return (DDI_SUCCESS);
}
static int
gen_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
int instance = ddi_get_instance(devi);
struct dstate *dstatep;
int rval;
int n_devs;
int n_minorcomps;
int isclone;
ddi_eventcookie_t dev_offline_cookie, dev_reset_cookie;
ddi_eventcookie_t bus_reset_cookie, bus_quiesce_cookie;
ddi_eventcookie_t bus_unquiesce_cookie, bus_test_post_cookie;
int i_init = 0;
int level_tmp;
int i;
char *pm_comp[] = {
"NAME=leaf0",
"0=D0",
"1=D1",
"2=D2",
"3=D3",
"NAME=leaf1",
"0=off",
"1=blank",
"2=on"};
char *pm_hw_state = {"needs-suspend-resume"};
switch (cmd) {
case DDI_ATTACH:
if (ddi_soft_state_zalloc(dstates, instance) !=
DDI_SUCCESS) {
cmn_err(CE_CONT, "%s%d: can't allocate state\n",
ddi_get_name(devi), instance);
return (DDI_FAILURE);
}
dstatep = ddi_get_soft_state(dstates, instance);
dstatep->dip = devi;
mutex_init(&dstatep->lock, NULL, MUTEX_DRIVER, NULL);
n_devs = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0,
"ndevs", 1);
isclone = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0,
"isclone", 0);
n_minorcomps = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0,
"ncomps", 1);
GEN_DEBUG((CE_CONT,
"%s%d attaching: n_devs=%d n_minorcomps=%d isclone=%d",
ddi_get_name(devi), ddi_get_instance(devi),
n_devs, n_minorcomps, isclone));
if (isclone) {
if (ddi_create_minor_node(devi, "gen", S_IFCHR,
INST_TO_MINOR(instance), mnodetypes[0],
isclone) != DDI_SUCCESS) {
ddi_remove_minor_node(devi, NULL);
ddi_soft_state_free(dstates, instance);
cmn_err(CE_WARN, "%s%d: can't create minor "
"node", ddi_get_name(devi), instance);
return (DDI_FAILURE);
}
rval = DDI_SUCCESS;
} else {
rval = gen_create_minor_nodes(devi, dstatep);
if (rval != DDI_SUCCESS) {
ddi_prop_remove_all(devi);
ddi_remove_minor_node(devi, NULL);
ddi_soft_state_free(dstates, instance);
cmn_err(CE_WARN, "%s%d: can't create minor "
"nodes", ddi_get_name(devi), instance);
return (DDI_FAILURE);
}
}
if (ddi_get_eventcookie(devi, "pshot_dev_offline",
&dev_offline_cookie) == DDI_SUCCESS) {
(void) ddi_add_event_handler(devi, dev_offline_cookie,
gen_event_cb, NULL, &(dstatep->gen_cb_ids[0]));
}
if (ddi_get_eventcookie(devi, "pshot_dev_reset",
&dev_reset_cookie) == DDI_SUCCESS) {
(void) ddi_add_event_handler(devi, dev_reset_cookie,
gen_event_cb, NULL, &(dstatep->gen_cb_ids[1]));
}
if (ddi_get_eventcookie(devi, "pshot_bus_reset",
&bus_reset_cookie) == DDI_SUCCESS) {
(void) ddi_add_event_handler(devi, bus_reset_cookie,
gen_event_cb, NULL, &(dstatep->gen_cb_ids[2]));
}
if (ddi_get_eventcookie(devi, "pshot_bus_quiesce",
&bus_quiesce_cookie) == DDI_SUCCESS) {
(void) ddi_add_event_handler(devi, bus_quiesce_cookie,
gen_event_cb, NULL, &(dstatep->gen_cb_ids[3]));
}
if (ddi_get_eventcookie(devi, "pshot_bus_unquiesce",
&bus_unquiesce_cookie) == DDI_SUCCESS) {
(void) ddi_add_event_handler(devi,
bus_unquiesce_cookie, gen_event_cb,
NULL, &(dstatep->gen_cb_ids[4]));
}
if (ddi_get_eventcookie(devi, "pshot_bus_test_post",
&bus_test_post_cookie) == DDI_SUCCESS) {
(void) ddi_add_event_handler(devi,
bus_test_post_cookie, gen_event_cb,
NULL, &(dstatep->gen_cb_ids[5]));
}
/*
* initialize the devices' pm state
*/
mutex_enter(&dstatep->lock);
dstatep->flag &= ~OPEN_FLAG;
dstatep->flag &= ~PWR_HAS_CHANGED_ON_RESUME_FLAG;
dstatep->flag &= ~FAIL_SUSPEND_FLAG;
dstatep->flag &= ~PUP_WITH_PWR_HAS_CHANGED_FLAG;
dstatep->flag |= LOWER_POWER_FLAG;
dstatep->flag &= ~NO_INVOL_FLAG;
dstatep->flag |= PM_SUPPORTED_FLAG;
dstatep->busy[0] = 0;
dstatep->busy[1] = 0;
dstatep->level[0] = -1;
dstatep->level[1] = -1;
mutex_exit(&dstatep->lock);
/*
* stash the nodename
*/
dstatep->nodename = ddi_node_name(devi);
/*
* Check if the no-involuntary-power-cycles property
* was created. Set NO_INVOL_FLAG if so.
*/
if (ddi_prop_exists(DDI_DEV_T_ANY, dstatep->dip,
(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
"no-involuntary-power-cycles") == 1) {
GEN_DEBUG((CE_CONT,
"%s%d: DDI_ATTACH:\n\tno-involuntary-power-cycles"
" property was created",
ddi_node_name(devi), ddi_get_instance(devi)));
mutex_enter(&dstatep->lock);
dstatep->flag |= NO_INVOL_FLAG;
mutex_exit(&dstatep->lock);
}
/*
* Check if the dependency-property property
* was created.
*/
if (ddi_prop_exists(DDI_DEV_T_ANY, dstatep->dip,
(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
"dependency-property") == 1) {
GEN_DEBUG((CE_CONT,
"%s%d: DDI_ATTACH:\n\tdependency-property"
" property was created",
ddi_node_name(devi), ddi_get_instance(devi)));
}
/*
* create the pm-components property. two comps:
* 4 levels on comp0, 3 on comp 1.
* - skip for a "tape" device, clear PM_SUPPORTED_FLAG
*/
if (strcmp(ddi_node_name(devi), "tape") != 0) {
if (ddi_prop_update_string_array(DDI_DEV_T_NONE, devi,
"pm-components", pm_comp, 9) != DDI_PROP_SUCCESS) {
cmn_err(CE_WARN, "%s%d: %s\n",
ddi_node_name(devi),
ddi_get_instance(devi),
"unable to create \"pm-components\" "
" property.");
return (DDI_FAILURE);
}
} else {
mutex_enter(&dstatep->lock);
dstatep->flag &= ~PM_SUPPORTED_FLAG;
mutex_exit(&dstatep->lock);
}
/*
* Check if the pm-components property was created
*/
if (dstatep->flag & PM_SUPPORTED_FLAG) {
if (ddi_prop_exists(DDI_DEV_T_ANY, dstatep->dip,
(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
"pm-components") != 1) {
cmn_err(CE_WARN, "%s%d: DDI_ATTACH:\n\t%s",
ddi_node_name(devi),
ddi_get_instance(devi),
"\"pm-components\" property does"
" not exist");
return (DDI_FAILURE);
} else {
GEN_DEBUG((CE_CONT, "%s%d: DDI_ATTACH:"
" created pm-components property",
ddi_node_name(devi),
ddi_get_instance(devi)));
}
}
/*
* create the pm-hardware-state property.
* needed to get DDI_SUSPEND and DDI_RESUME calls
*/
if (ddi_prop_update_string(DDI_DEV_T_NONE, devi,
"pm-hardware-state", pm_hw_state) != DDI_PROP_SUCCESS) {
cmn_err(CE_WARN, "%s%d: DDI_ATTACH:\n\t%s\n",
ddi_node_name(devi), ddi_get_instance(devi),
"unable to create \"pm-hardware-state\" "
" property.");
return (DDI_FAILURE);
}
/*
* set power levels to max via pm_raise_power(),
*/
mutex_enter(&dstatep->lock);
i_init = (dstatep->flag & PM_SUPPORTED_FLAG) ? 0 : COMPONENTS;
mutex_exit(&dstatep->lock);
for (i = i_init; i < COMPONENTS; i++) {
GEN_DEBUG((CE_CONT,
"%s%d: DDI_ATTACH: pm_raise_power comp %d "
"to level %d", ddi_node_name(devi),
ddi_get_instance(devi), i, maxpwr[i]));
if (pm_raise_power(dstatep->dip, i, maxpwr[i]) !=
DDI_SUCCESS) {
cmn_err(CE_WARN,
"%s%d: DDI_ATTACH: pm_raise_power failed\n",
ddi_node_name(devi),
ddi_get_instance(devi));
dstatep->level[i] = -1;
return (DDI_FAILURE);
}
}
if (rval == DDI_SUCCESS) {
ddi_report_dev(devi);
}
return (rval);
case DDI_RESUME:
GEN_DEBUG((CE_CONT, "%s%d: DDI_RESUME", ddi_node_name(devi),
ddi_get_instance(devi)));
dstatep = ddi_get_soft_state(dstates, ddi_get_instance(devi));
if (dstatep == NULL) {
return (DDI_FAILURE);
}
/*
* Call pm_power_has_changed() if flag
* PWR_HAS_CHANGED_ON_RESUME_FLAG is set,
* then clear the flag
*/
mutex_enter(&dstatep->lock);
i_init = (dstatep->flag & PM_SUPPORTED_FLAG) ? 0 : COMPONENTS;
mutex_exit(&dstatep->lock);
if (dstatep->flag & PWR_HAS_CHANGED_ON_RESUME_FLAG) {
for (i = i_init; i < COMPONENTS; i++) {
GEN_DEBUG((CE_CONT,
"%s%d: DDI_RESUME: pm_power_has_changed "
"comp %d to level %d", ddi_node_name(devi),
ddi_get_instance(devi), i, maxpwr[i]));
mutex_enter(&dstatep->lock);
level_tmp = dstatep->level[i];
dstatep->level[i] = maxpwr[i];
if (pm_power_has_changed(dstatep->dip, i,
maxpwr[i]) != DDI_SUCCESS) {
cmn_err(CE_WARN,
"%s%d: DDI_RESUME:\n\t"
" pm_power_has_changed"
" failed: comp %d to level %d\n",
ddi_node_name(devi),
ddi_get_instance(devi),
i, maxpwr[i]);
dstatep->level[i] = level_tmp;
}
mutex_exit(&dstatep->lock);
}
} else {
/*
* Call pm_raise_power() instead
*/
for (i = i_init; i < COMPONENTS; i++) {
GEN_DEBUG((CE_CONT,
"%s%d: DDI_RESUME: pm_raise_power"
" comp %d to level %d",
ddi_node_name(devi), ddi_get_instance(devi),
i, maxpwr[i]));
if (pm_raise_power(dstatep->dip, i, maxpwr[i])
!= DDI_SUCCESS) {
cmn_err(CE_WARN,
"%s%d: DDI_RESUME:"
"\n\tpm_raise_power"
"failed: comp %d to level %d\n",
ddi_node_name(devi),
ddi_get_instance(devi),
i, maxpwr[i]);
}
}
}
return (DDI_SUCCESS);
default:
GEN_DEBUG((CE_WARN, "attach: default"));
return (DDI_FAILURE);
}
}
static int
gen_create_minor_nodes(dev_info_t *devi, struct dstate *dstatep)
{
int rval = DDI_SUCCESS;
char *node_name;
node_name = ddi_node_name(devi);
if (strcmp(node_name, "disk_chan") == 0) {
rval = gen_create_mn_disk_chan(devi);
} else if (strcmp(node_name, "disk_wwn") == 0) {
rval = gen_create_mn_disk_wwn(devi);
} else if (strcmp(node_name, "disk_cdrom") == 0) {
rval = gen_create_mn_disk_cdrom(devi);
} else if (strcmp(node_name, "disk_fd") == 0) {
rval = gen_create_mn_disk_fd(devi);
} else if (strcmp(node_name, "cgtwenty") == 0) {
rval = gen_create_display(devi);
} else if (strcmp(node_name, "genzs") == 0) {
rval = gen_create_serial(devi);
} else if (strcmp(node_name, "net") == 0) {
rval = gen_create_net(devi);
} else {
int instance = ddi_get_instance(devi);
char *node_type;
/*
* Solaris may directly hang the node_type off the minor node
* (without making a copy). Since we free the node_type
* property below we need to make a private copy to pass
* to ddi_create_minor_node to avoid devinfo snapshot panics.
* We store a pointer to our copy in dstate and free it in
* gen_detach after the minor nodes have been deleted by
* ddi_remove_minor_node.
*/
if (ddi_prop_lookup_string(DDI_DEV_T_ANY, devi,
DDI_PROP_DONTPASS, "node-type", &node_type) != 0) {
cmn_err(CE_WARN, "couldn't get node-type\n");
return (DDI_FAILURE);
}
if (node_type) {
dstatep->node_type = kmem_alloc(
strlen(node_type) + 1, KM_SLEEP);
(void) strcpy(dstatep->node_type, node_type);
}
ddi_prop_free(node_type);
/* the minor name is the same as the node name */
if (ddi_create_minor_node(devi, node_name, S_IFCHR,
(INST_TO_MINOR(instance)), dstatep->node_type, NULL) !=
DDI_SUCCESS) {
if (dstatep->node_type) {
kmem_free(dstatep->node_type,
strlen(dstatep->node_type) + 1);
dstatep->node_type = NULL;
}
return (DDI_FAILURE);
}
return (DDI_SUCCESS);
}
if (rval != DDI_SUCCESS) {
ddi_prop_remove_all(devi);
ddi_remove_minor_node(devi, NULL);
}
return (rval);
}
