static int sensor_accel_dev_probe(struct device *dev)
{
struct sensor_accel_info *info;
gb_debug("%s:\n",__func__);
if (!dev) {
return -EINVAL;
}
info = zalloc(sizeof(*info));
if (!info) {
return -ENOMEM;
}
info->dev = dev;
device_set_private(dev, info);
atomic_init(&txn, 0);
#ifdef CONFIG_PM
if (pm_register(&pm_callback) != OK)
{
dbg("Failed register to power management!\n");
}
#endif
return 0;
}
/**@brief Function for the Peer Manager initialization.
*/
static void peer_manager_init(void)
{
ble_gap_sec_params_t sec_param;
ret_code_t err_code;
err_code = pm_init();
APP_ERROR_CHECK(err_code);
memset(&sec_param, 0, sizeof(ble_gap_sec_params_t));
// Security parameters to be used for all security procedures.
sec_param.bond = SEC_PARAM_BOND;
sec_param.mitm = SEC_PARAM_MITM;
sec_param.lesc = SEC_PARAM_LESC;
sec_param.keypress = SEC_PARAM_KEYPRESS;
sec_param.io_caps = SEC_PARAM_IO_CAPABILITIES;
sec_param.oob = SEC_PARAM_OOB;
sec_param.min_key_size = SEC_PARAM_MIN_KEY_SIZE;
sec_param.max_key_size = SEC_PARAM_MAX_KEY_SIZE;
sec_param.kdist_own.enc = 1;
sec_param.kdist_own.id = 1;
sec_param.kdist_peer.enc = 1;
sec_param.kdist_peer.id = 1;
err_code = pm_sec_params_set(&sec_param);
APP_ERROR_CHECK(err_code);
err_code = pm_register(pm_evt_handler);
APP_ERROR_CHECK(err_code);
}
void stm32f0_led_pminitialize(void)
{
/* Register to receive power management callbacks */
int ret = pm_register(&g_ledscb);
DEBUGASSERT(ret == OK);
UNUSED(ret);
}
void stm32_ledpminitialize(void)
{
/* Register to receive power management callbacks */
int ret = pm_register(&g_ledscb);
if (ret != OK)
{
board_led_on(LED_ASSERTION);
}
}
/**@brief Function for the Peer Manager initialization.
*
* @param[in] erase_bonds Indicates whether bonding information should be cleared from
* persistent storage during initialization of the Peer Manager.
*/
static void peer_manager_init(bool erase_bonds)
{
ble_gap_sec_params_t sec_params;
ret_code_t err_code;
err_code = pm_init();
APP_ERROR_CHECK(err_code);
if (erase_bonds)
{
(void) pm_peers_delete();
}
memset(&sec_params, 0, sizeof(ble_gap_sec_params_t));
// Security parameters to be used for all security procedures.
sec_params.bond = SEC_PARAMS_BOND;
sec_params.mitm = SEC_PARAMS_MITM;
sec_params.lesc = SEC_PARAMS_LESC;
sec_params.keypress = SEC_PARAMS_KEYPRESS;
sec_params.io_caps = SEC_PARAMS_IO_CAPABILITIES;
sec_params.oob = SEC_PARAMS_OOB;
sec_params.min_key_size = SEC_PARAMS_MIN_KEY_SIZE;
sec_params.max_key_size = SEC_PARAMS_MAX_KEY_SIZE;
sec_params.kdist_own.enc = 1;
sec_params.kdist_own.id = 1;
sec_params.kdist_peer.enc = 1;
sec_params.kdist_peer.id = 1;
err_code = pm_sec_params_set(&sec_params);
APP_ERROR_CHECK(err_code);
err_code = pm_register(pm_evt_handler);
APP_ERROR_CHECK(err_code);
err_code = fds_register(fds_evt_handler);
APP_ERROR_CHECK(err_code);
ecc_init();
#if LESC_DEBUG_MODE
memcpy(m_lesc_sk.sk, m_debug_lesc_sk.sk, BLE_GAP_LESC_P256_SK_LEN);
err_code = ecc_p256_public_key_compute((uint8_t *) m_lesc_sk.sk, m_lesc_pk.pk);
APP_ERROR_CHECK(err_code);
#else
err_code = ecc_p256_keypair_gen(m_lesc_sk.sk, m_lesc_pk.pk);
APP_ERROR_CHECK(err_code);
#endif
/* Set the public key */
err_code = pm_lesc_public_key_set(&m_lesc_pk);
APP_ERROR_CHECK(err_code);
}
static int omap_mmc_slot_init( void )
{
int retval;
long flags;
/* Set up timers */
g_omap_mmc_data.sd_detect_timer.function = omap_mmc_fix_sd_detect;
g_omap_mmc_data.sd_detect_timer.data = (unsigned long) &g_omap_mmc_data;
init_timer(&g_omap_mmc_data.sd_detect_timer);
/* Basic service interrupt */
local_irq_save(flags);
retval = request_irq( INT_MMC, omap_mmc_int,
SA_INTERRUPT, "omap_mmc_int", &g_omap_mmc_data );
if ( retval ) {
printk(KERN_CRIT "MMC/SD: unable to grab MMC IRQ\n");
return retval;
}
disable_irq( INT_MMC );
/* Card Detect interrupt */
retval = request_irq( INT_FPGA_CD, omap_mmc_sd_detect_int,
SA_INTERRUPT, "omap_mmc_fpga_cd", &g_omap_mmc_data );
if ( retval ) {
printk(KERN_CRIT "MMC/SD: unable to grab FPGA_CD_IRQ\n");
free_irq(INT_MMC, &g_omap_mmc_data);
}
disable_irq( INT_FPGA_CD );
/* Allocate DMA buffers (max BLOCK LENGTH = 2048 (11 bit)) */
g_omap_mmc_data.buf_dma_virt = consistent_alloc(GFP_KERNEL | GFP_DMA | GFP_ATOMIC,
2048, &(g_omap_mmc_data.buf_dma_phys));
#ifdef CONFIG_PM
pm_register(PM_UNKNOWN_DEV, PM_SYS_UNKNOWN, omap_mmc_pm_callback);
#endif
omap_mmc_slot_up();
enable_irq ( INT_FPGA_CD ); /* Enable IRQ to detect card*/
local_irq_restore(flags);
return retval;
}
static int test_init_module(void)
{
int rc;
printk("starting module\n");
ltp_pm_dev = pm_register(PM_UNKNOWN_DEV, 0, ltp_pm_callback);
rc = register_blkdev(INCLUDEMAJOR, DEVICE_NAME);
printk("BLK INC - result =%d major %d\n", rc, INCLUDEMAJOR);
if (rc < 0) {
printk("Failed to register device.\n");
return rc;
}
gd_ptr = kmalloc(sizeof(struct gendisk *), GFP_KERNEL);
if (!gd_ptr) {
printk(KERN_ALERT "ERROR getting memory !!!\n");
return 0;
}
printk("major = %d\n", Major);
gd_ptr = alloc_disk(1);
printk(KERN_ALERT "gd_ptr after alloc = %p \n", gd_ptr);
gd_ptr->major = INCLUDEMAJOR;
gd_ptr->first_minor = 0;
gd_ptr->fops = &bdops;
// gd_ptr->minor_shift= MINOR_SHIFT_BITS;
gd_ptr->driverfs_dev = NULL;
gd_ptr->capacity = MAX_NUM_DISKS;
// gd_ptr->disk_de = NULL;
gd_ptr->flags = genhd_flags;
sprintf(gd_ptr->disk_name, DEVICE_NAME);
add_disk(gd_ptr);
printk("major = %d\n", Major);
test_acpi();
test_vga();
test_lockd();
test_sunrpc_auth();
test_nfsfh();
test_sunrpc_cache();
test_sunrpc_svc();
test_sunrpc_timer();
printk("finished module\n");
return 0;
}
static int vibrator_open(struct inode *inode, struct file *file)
{
if(!count)
{
count ++;
//ssp_pcap_init();
#ifdef CONFIG_PM
pm_dev = pm_register(PM_SYS_DEV, 0, vibrator_pm_callback);
#endif
AUDPRINTk1("open vibrator \n");
return 0;
}
else
return -EBUSY;
}
int init_module(void)
{
int result;
printk(KERN_ALERT "ltpdev_init_module \n");
ltp_pm_dev = pm_register(PM_UNKNOWN_DEV, 0, ltp_pm_callback);
result = register_blkdev(ltp_fs_major, LTP_FS_DEV_NAME);
printk(KERN_ALERT "LTP FS: register_blkdev result=%d major %d\n",result, ltp_fs_major);
if (result < 0) {
printk(KERN_ALERT "LTP FS: can't get major %d\n",ltp_fs_major);
return result;
}
gd_ptr = kmalloc(sizeof(struct gendisk *), GFP_KERNEL);
if (!gd_ptr) {
printk(KERN_ALERT "ERROR getting memory !!!\n");
return 0;
}
gd_ptr = alloc_disk(1);
printk(KERN_ALERT "gd_ptr after alloc = %p \n",gd_ptr);
gd_ptr->major = ltp_fs_major;
gd_ptr->first_minor = 0;
gd_ptr->fops = &blkops;
gd_ptr->driverfs_dev = NULL;
gd_ptr->capacity = MAX_NUM_DISKS;
gd_ptr->flags = genhd_flags;
sprintf(gd_ptr->disk_name, LTP_FS_DEV_NAME);
add_disk(gd_ptr);
return 0;
}
/* perfctr driver should call this instead of pm_register() */
struct pm_dev *apic_pm_register(pm_dev_t type,
unsigned long id,
pm_callback callback)
{
struct pm_dev *dev;
if (!apic_pm_state.active)
return pm_register(type, id, callback);
if (apic_pm_state.perfctr_pmdev)
return NULL; /* we're busy */
dev = kmalloc(sizeof(struct pm_dev), GFP_KERNEL);
if (dev) {
memset(dev, 0, sizeof(*dev));
dev->type = type;
dev->id = id;
dev->callback = callback;
apic_pm_state.perfctr_pmdev = dev;
}
return dev;
}
/**@brief Function for the Peer Manager initialization.
*
* @param[in] erase_bonds Indicates whether bonding information should be cleared from
* persistent storage during initialization of the Peer Manager.
*/
static void peer_manager_init(bool erase_bonds)
{
ble_gap_sec_params_t sec_param;
ret_code_t err_code;
err_code = pm_init();
APP_ERROR_CHECK(err_code);
if (erase_bonds)
{
pm_peer_delete_all();
}
memset(&sec_param, 0, sizeof(ble_gap_sec_params_t));
// Security parameters to be used for all security procedures.
sec_param.bond = SEC_PARAM_BOND;
sec_param.mitm = SEC_PARAM_MITM;
sec_param.io_caps = SEC_PARAM_IO_CAPABILITIES;
sec_param.oob = SEC_PARAM_OOB;
sec_param.min_key_size = SEC_PARAM_MIN_KEY_SIZE;
sec_param.max_key_size = SEC_PARAM_MAX_KEY_SIZE;
sec_param.kdist_periph.enc = 1;
sec_param.kdist_periph.id = 1;
sec_param.kdist_central.enc = 1;
sec_param.kdist_central.id = 1;
err_code = pm_sec_params_set(&sec_param);
APP_ERROR_CHECK(err_code);
err_code = pm_register(pm_evt_handler);
APP_ERROR_CHECK(err_code);
err_code = fds_register(fds_evt_handler);
APP_ERROR_CHECK(err_code);
}
int omap_audio_attach(struct inode *inode, struct file *file,
audio_state_t *state)
{
audio_stream_t *os = state->output_stream;
audio_stream_t *is = state->input_stream;
int err, need_tx_dma;
DPRINTK("audio_open\n");
down(&state->sem);
/* access control */
err = -ENODEV;
if ((file->f_mode & FMODE_WRITE) && !os)
goto out;
if ((file->f_mode & FMODE_READ) && !is)
goto out;
err = -EBUSY;
if ((file->f_mode & FMODE_WRITE) && state->wr_ref)
goto out;
if ((file->f_mode & FMODE_READ) && state->rd_ref)
goto out;
err = -EINVAL;
if ((file->f_mode & FMODE_READ) && state->need_tx_for_rx && !os)
goto out;
/* request DMA channels */
need_tx_dma = ((file->f_mode & FMODE_WRITE) ||
((file->f_mode & FMODE_READ) && state->need_tx_for_rx));
if (state->wr_ref || (state->rd_ref && state->need_tx_for_rx))
need_tx_dma = 0;
if (need_tx_dma) {
err = DMA_REQUEST(os, audio_dma_callback);
if (err)
goto out;
}
if (file->f_mode & FMODE_READ) {
err = DMA_REQUEST(is, audio_dma_callback);
if (err) {
if (need_tx_dma)
DMA_FREE(os);
goto out;
}
}
/* now complete initialisation */
if (!AUDIO_ACTIVE(state)) {
if (state->hw_init)
state->hw_init(state->data);
#ifdef CONFIG_PM
state->pm_dev = pm_register(PM_SYS_DEV, 0, audio_pm_callback);
if (state->pm_dev)
state->pm_dev->data = state;
#endif
}
if ((file->f_mode & FMODE_WRITE)) {
state->wr_ref = 1;
audio_reset(os);
os->fragsize = AUDIO_FRAGSIZE_DEFAULT;
os->nbfrags = AUDIO_NBFRAGS_DEFAULT;
os->mapped = 0;
init_waitqueue_head(&os->wq);
}
if (file->f_mode & FMODE_READ) {
state->rd_ref = 1;
audio_reset(is);
is->fragsize = AUDIO_FRAGSIZE_DEFAULT;
is->nbfrags = AUDIO_NBFRAGS_DEFAULT;
is->mapped = 0;
init_waitqueue_head(&is->wq);
}
file->private_data = state;
file->f_op->release = audio_release;
file->f_op->write = audio_write;
file->f_op->read = audio_read;
file->f_op->mmap = audio_mmap;
file->f_op->poll = audio_poll;
file->f_op->ioctl = audio_ioctl;
file->f_op->llseek = audio_llseek;
err = 0;
out:
up(&state->sem);
return err;
}
ble_error_t
btle_initializeSecurity(bool enableBonding,
bool requireMITM,
SecurityManager::SecurityIOCapabilities_t iocaps,
const SecurityManager::Passkey_t passkey)
{
/* guard against multiple initializations */
if (initialized) {
return BLE_ERROR_NONE;
}
ret_code_t rc;
if (passkey) {
ble_opt_t opts;
opts.gap_opt.passkey.p_passkey = const_cast<uint8_t *>(passkey);
if ((rc = sd_ble_opt_set(BLE_GAP_OPT_PASSKEY, &opts)) != NRF_SUCCESS) {
switch (rc) {
case BLE_ERROR_INVALID_CONN_HANDLE:
case NRF_ERROR_INVALID_ADDR:
case NRF_ERROR_INVALID_PARAM:
default:
return BLE_ERROR_INVALID_PARAM;
case NRF_ERROR_INVALID_STATE:
return BLE_ERROR_INVALID_STATE;
case NRF_ERROR_BUSY:
return BLE_STACK_BUSY;
}
}
}
// update default security parameters with function call parameters
securityParameters.bond = enableBonding;
securityParameters.mitm = requireMITM;
securityParameters.io_caps = iocaps;
if (enableBonding) {
securityParameters.kdist_own.enc = 1;
securityParameters.kdist_own.id = 1;
} else {
securityParameters.kdist_own.enc = 0;
securityParameters.kdist_own.id = 0;
}
rc = pm_sec_params_set(&securityParameters);
if (rc == NRF_SUCCESS) {
rc = pm_register(pm_handler);
}
switch (rc) {
case NRF_SUCCESS:
initialized = true;
return BLE_ERROR_NONE;
case NRF_ERROR_INVALID_STATE:
return BLE_ERROR_INVALID_STATE;
case NRF_ERROR_INVALID_PARAM:
return BLE_ERROR_INVALID_PARAM;
default:
return BLE_ERROR_UNSPECIFIED;
}
initialized = true;
return BLE_ERROR_NONE;
}
/*
* Function nsc_ircc_open (iobase, irq)
*
* Open driver instance
*
*/
static int nsc_ircc_open(int i, chipio_t *info)
{
struct net_device *dev;
struct nsc_ircc_cb *self;
struct pm_dev *pmdev;
void *ret;
int err;
IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
MESSAGE("%s, Found chip at base=0x%03x\n", driver_name,
info->cfg_base);
if ((nsc_ircc_setup(info)) == -1)
return -1;
MESSAGE("%s, driver loaded (Dag Brattli)\n", driver_name);
/* Allocate new instance of the driver */
self = kmalloc(sizeof(struct nsc_ircc_cb), GFP_KERNEL);
if (self == NULL) {
ERROR("%s(), can't allocate memory for "
"control block!\n", __FUNCTION__);
return -ENOMEM;
}
memset(self, 0, sizeof(struct nsc_ircc_cb));
spin_lock_init(&self->lock);
/* Need to store self somewhere */
dev_self[i] = self;
self->index = i;
/* Initialize IO */
self->io.cfg_base = info->cfg_base;
self->io.fir_base = info->fir_base;
self->io.irq = info->irq;
self->io.fir_ext = CHIP_IO_EXTENT;
self->io.dma = info->dma;
self->io.fifo_size = 32;
/* Reserve the ioports that we need */
ret = request_region(self->io.fir_base, self->io.fir_ext, driver_name);
if (!ret) {
WARNING("%s(), can't get iobase of 0x%03x\n",
__FUNCTION__, self->io.fir_base);
dev_self[i] = NULL;
kfree(self);
return -ENODEV;
}
/* Initialize QoS for this device */
irda_init_max_qos_capabilies(&self->qos);
/* The only value we must override it the baudrate */
self->qos.baud_rate.bits = IR_9600|IR_19200|IR_38400|IR_57600|
IR_115200|IR_576000|IR_1152000 |(IR_4000000 << 8);
self->qos.min_turn_time.bits = qos_mtt_bits;
irda_qos_bits_to_value(&self->qos);
self->flags = IFF_FIR|IFF_MIR|IFF_SIR|IFF_DMA|IFF_PIO|IFF_DONGLE;
/* Max DMA buffer size needed = (data_size + 6) * (window_size) + 6; */
self->rx_buff.truesize = 14384;
self->tx_buff.truesize = 14384;
/* Allocate memory if needed */
self->rx_buff.head = (__u8 *) kmalloc(self->rx_buff.truesize,
GFP_KERNEL|GFP_DMA);
if (self->rx_buff.head == NULL) {
kfree(self);
return -ENOMEM;
}
memset(self->rx_buff.head, 0, self->rx_buff.truesize);
self->tx_buff.head = (__u8 *) kmalloc(self->tx_buff.truesize,
GFP_KERNEL|GFP_DMA);
if (self->tx_buff.head == NULL) {
kfree(self->rx_buff.head);
kfree(self);
return -ENOMEM;
}
memset(self->tx_buff.head, 0, self->tx_buff.truesize);
self->rx_buff.in_frame = FALSE;
self->rx_buff.state = OUTSIDE_FRAME;
self->tx_buff.data = self->tx_buff.head;
self->rx_buff.data = self->rx_buff.head;
/* Reset Tx queue info */
self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0;
self->tx_fifo.tail = self->tx_buff.head;
if (!(dev = dev_alloc("irda%d", &err))) {
ERROR("%s(), dev_alloc() failed!\n", __FUNCTION__);
return -ENOMEM;
}
dev->priv = (void *) self;
self->netdev = dev;
/* Override the network functions we need to use */
dev->init = nsc_ircc_net_init;
dev->hard_start_xmit = nsc_ircc_hard_xmit_sir;
dev->open = nsc_ircc_net_open;
dev->stop = nsc_ircc_net_close;
dev->do_ioctl = nsc_ircc_net_ioctl;
dev->get_stats = nsc_ircc_net_get_stats;
rtnl_lock();
err = register_netdevice(dev);
rtnl_unlock();
if (err) {
ERROR("%s(), register_netdev() failed!\n", __FUNCTION__);
return -1;
}
MESSAGE("IrDA: Registered device %s\n", dev->name);
/* Check if user has supplied the dongle id or not */
if (!dongle_id) {
dongle_id = nsc_ircc_read_dongle_id(self->io.fir_base);
MESSAGE("%s, Found dongle: %s\n", driver_name,
dongle_types[dongle_id]);
} else {
MESSAGE("%s, Using dongle: %s\n", driver_name,
dongle_types[dongle_id]);
}
self->io.dongle_id = dongle_id;
nsc_ircc_init_dongle_interface(self->io.fir_base, dongle_id);
pmdev = pm_register(PM_SYS_DEV, PM_SYS_IRDA, nsc_ircc_pmproc);
if (pmdev)
pmdev->data = self;
return 0;
}
static int pxa250_irda_net_init(struct net_device *dev)
{
struct pxa250_irda *si = dev->priv;
unsigned int baudrate_mask;
int err = -ENOMEM;
si = kmalloc(sizeof(struct pxa250_irda), GFP_KERNEL);
if (!si)
goto out;
memset(si, 0, sizeof(*si));
/*
* Initialise the HP-SIR buffers
*/
err = pxa250_irda_init_iobuf(&si->rx_buff, 14384);
if (err)
goto out;
err = pxa250_irda_init_iobuf(&si->tx_buff, 4000);
if (err)
goto out_free_rx;
si->fir_irq = IRQ_ICP;
dev->priv = si;
dev->hard_start_xmit = pxa250_irda_hard_xmit;
dev->open = pxa250_irda_start;
dev->stop = pxa250_irda_stop;
dev->do_ioctl = pxa250_irda_ioctl;
dev->get_stats = pxa250_irda_stats;
irda_device_setup(dev);
irda_init_max_qos_capabilies(&si->qos);
/*
* We support original IRDA up to 115k2. (we don't currently
* support 4Mbps). Min Turn Time set to 1ms or greater.
*/
baudrate_mask = IR_9600|IR_19200|IR_38400|IR_57600|IR_115200;
baudrate_mask |= IR_4000000 << 8;
si->qos.baud_rate.bits &= baudrate_mask;
si->qos.min_turn_time.bits = 7;
irda_qos_bits_to_value(&si->qos);
#ifdef CONFIG_PM
/*
* Power-Management is optional.
*/
si->pmdev = pm_register(PM_SYS_DEV, PM_SYS_IRDA, pxa250_irda_pmproc);
if (si->pmdev)
si->pmdev->data = dev;
#endif
return 0;
kfree(si->tx_buff.head);
out_free_rx:
kfree(si->rx_buff.head);
out:
kfree(si);
return err;
}
/**
* monitor_modinit - commission bus interface driver
*
*/
static int __init monitor_modinit(void)
{
printk(KERN_INFO "usbdm: %s\n", __usbd_module_info);
// Initialize data structures _before_ installing interrupt handlers
monitor.status = MONITOR_UNKNOWN;
monitor.monitor_bh.routine = monitor_bh;
monitor.monitor_bh.data = NULL;
// XXX monitor.monitor_bh.sync = 0;
monitor.hotplug_bh.routine = hotplug_bh;
monitor.hotplug_bh.data = NULL;
// XXX monitor.hotplug_bh.sync = 0;
/*
* Architecture specific - request IRQ
*/
if (!monitor_request_irq()) {
monitor.have_irq++;
}
else {
printk(KERN_DEBUG"usbdm: request irq failed\n");
}
#ifdef CONFIG_PM
/*
* Architecture specific - register with power management
*/
monitor.pm_info = NULL;
if (!(monitor.pm_info = pm_register(PM_USB_DEV, PM_SYS_UNKNOWN, monitor_pm_event))) {
printk(KERN_ERR "%s: couldn't register for power management\n", __FUNCTION__);
if (monitor.have_irq) {
free_irq(IRQ_GPIO12, &monitor);
}
return 1;
}
monitor.pm_info->state = 0;
#endif
#ifdef CONFIG_USBD_PROCFS
{
struct proc_dir_entry *p;
// create proc filesystem entries
if ((p = create_proc_entry("usb-monitor", 0, 0)) == NULL) {
if (monitor.have_irq) {
monitor_free_irq();
monitor.have_irq = 0;
}
#ifdef CONFIG_PM
if (monitor.pm_info) {
pm_unregister(monitor.pm_info);
monitor.pm_info = NULL;
}
#endif
return -ENOMEM;
}
p->proc_fops = &usbd_monitor_proc_operations_functions;
}
#endif
// Find out if the cable is connected
// and load USBD modules if we are.
monitor_event();
printk(KERN_INFO "monitor_modinit: finished\n");
return 0;
}
static int __init s3c2410_ts_init(void)
{
int ret;
tsEvent = tsEvent_dummy;
ret = register_chrdev(0, DEVICE_NAME, &s3c2410_fops);
if (ret < 0) {
printk(DEVICE_NAME " can't get major number\n");
return ret;
}
tsMajor = ret;
/* set gpio to XP, YM, YP and YM */
#if 0
set_GPIO_mode(GPIO106_nYPON_MD);
set_GPIO_mode(GPIO105_YMON_MD);
set_GPIO_mode(GPIO104_nXPON_MD);
set_GPIO_mode(GPIO103_XMON_MD);
GPUP(GPIO106_nYPON) |= GPIO_bit(GPIO106_nYPON);
GPUP(GPIO105_YMON) &= GPIO_bit(GPIO105_YMON);
GPUP(GPIO104_nXPON) |= GPIO_bit(GPIO104_nXPON);
GPUP(GPIO103_XMON) &= GPIO_bit(GPIO103_XMON);
#else
set_gpio_ctrl(GPIO_YPON);
set_gpio_ctrl(GPIO_YMON);
set_gpio_ctrl(GPIO_XPON);
set_gpio_ctrl(GPIO_XMON);
#endif
/* Enable touch interrupt */
ret = request_irq(IRQ_ADC_DONE, s3c2410_isr_adc, SA_INTERRUPT,
DEVICE_NAME, s3c2410_isr_adc);
if (ret) goto adc_failed;
ret = request_irq(IRQ_TC, s3c2410_isr_tc, SA_INTERRUPT,
DEVICE_NAME, s3c2410_isr_tc);
if (ret) goto tc_failed;
/* Wait for touch screen interrupts */
wait_down_int();
#ifdef CONFIG_DEVFS_FS
devfs_ts_dir = devfs_mk_dir(NULL, "touchscreen", NULL);
devfs_tsraw = devfs_register(devfs_ts_dir, "0raw", DEVFS_FL_DEFAULT,
tsMajor, TSRAW_MINOR, S_IFCHR | S_IRUSR | S_IWUSR,
&s3c2410_fops, NULL);
#endif
#ifdef CONFIG_PM
#if 0
tsdev.pm_dev = pm_register(PM_GP_DEV, PM_USER_INPUT,
s3c2410_ts_pm_callback);
#endif
tsdev.pm_dev = pm_register(PM_DEBUG_DEV, PM_USER_INPUT,
s3c2410_ts_pm_callback);
#endif
printk(DEVICE_NAME " initialized\n");
return 0;
tc_failed:
free_irq(IRQ_ADC_DONE, s3c2410_isr_adc);
adc_failed:
return ret;
}
/* bi_modinit - commission bus interface driver
*/
static int __init bi_modinit (void)
{
extern const char __usbd_module_info[];
struct usb_bus_instance *bus;
struct usb_device_instance *device;
struct bi_data *data;
printk (KERN_INFO "%s (dbg=\"%s\")\n", __usbd_module_info, dbg ? dbg : "");
// process debug options
if (0 != scan_debug_options ("usbd-bi", dbg_table, dbg)) {
return -EINVAL;
}
// check if we can see the UDC
if (bi_udc_init ()) {
return -EINVAL;
}
// allocate a bi private data structure
if ((data = kmalloc (sizeof (struct bi_data), GFP_KERNEL)) == NULL) {
bi_udc_exit ();
return -EINVAL;
}
memset (data, 0, sizeof (struct bi_data));
// register this bus interface driver and create the device driver instance
if ((bus = usbd_register_bus (&bi_driver)) == NULL) {
kfree (data);
bi_udc_exit ();
return -EINVAL;
}
bus->privdata = data;
// see if we can scrounge up something to set a sort of unique device address
if (!udc_serial_init (bus)) {
dbg_init (1, "serial: %s %04x\n", bus->serial_number_str, bus->serial_number);
}
if ((device = usbd_register_device (NULL, bus, 8)) == NULL) {
usbd_deregister_bus (bus);
kfree (data);
bi_udc_exit ();
return -EINVAL;
}
#if defined(CONFIG_PM) && !defined(CONFIG_USBD_MONITOR) && !defined(CONFIG_USBD_MONITOR_MODULE)
// register with power management
pm_dev = pm_register (PM_USB_DEV, PM_SYS_UNKNOWN, bi_pm_event);
pm_dev->data = device;
#endif
#ifdef CONFIG_DPM /* MVL-CEE */
bi_udc_ldm_driver_register();
bi_udc_ldm_device_register();
#endif
bus->device = device;
device_array[0] = device;
// initialize the device
{
struct usb_endpoint_instance *endpoint = device->bus->endpoint_array + 0;
// setup endpoint zero
endpoint->endpoint_address = 0;
endpoint->tx_attributes = 0;
endpoint->tx_transferSize = 255;
endpoint->tx_packetSize = udc_ep0_packetsize ();
endpoint->rcv_attributes = 0;
endpoint->rcv_transferSize = 0x8;
endpoint->rcv_packetSize = udc_ep0_packetsize ();
udc_setup_ep (device, 0, endpoint);
}
// hopefully device enumeration will finish this process
printk(KERN_INFO"bi_modinit: call udc_startup_events\n");
udc_startup_events (device);
#if defined(CONFIG_PM) && !defined(CONFIG_USBD_MONITOR) && !defined(CONFIG_USBD_MONITOR_MODULE)
dbg_pm (0, "pm_dev->callback#%p", pm_dev->callback);
if (!udc_connected ()) {
/* Fake a call from the PM system to suspend the UDC until it
is needed (cable connect, etc) */
(void) bi_pm_event (pm_dev, PM_SUSPEND, NULL);
/* There appears to be no constant for this, but inspection
of arch/arm/mach-l7200/apm.c:send_event() shows that the
suspended state is 3 (i.e. pm_send_all(PM_SUSPEND, (void *)3))
corresponding to ACPI_D3. */
pm_dev->state = 3;
}
#endif
if (dbgflg_usbdbi_tick > 0) {
// start ticker
ticker_kickoff ();
}
#ifdef CONFIG_USBD_PROCFS
{
struct proc_dir_entry *p;
// create proc filesystem entries
if ((p = create_proc_entry ("usbd", 0, 0)) == NULL) {
return -ENOMEM;
}
p->proc_fops = &usbd_proc_operations_functions;
}
#endif
dbgLEAVE (dbgflg_usbdbi_init, 1);
return 0;
}
static void __init apic_pm_init2(void)
{
if (apic_pm_state.active)
pm_register(PM_SYS_DEV, 0, apic_pm_callback);
}
static int __init ucb1x00_init(void)
{
struct mcp *mcp;
unsigned int id;
int ret = -ENODEV;
mcp = mcp_get();
if (!mcp)
goto no_mcp;
mcp_enable(mcp);
id = mcp_reg_read(mcp, UCB_ID);
if (id != UCB_ID_1200 && id != UCB_ID_1300) {
printk(KERN_WARNING "UCB1x00 ID not found: %04x\n", id);
goto out;
}
my_ucb = kmalloc(sizeof(struct ucb1x00), GFP_KERNEL);
ret = -ENOMEM;
if (!my_ucb)
goto out;
if (machine_is_shannon()) {
/* reset the codec */
GPDR |= SHANNON_GPIO_CODEC_RESET;
GPCR = SHANNON_GPIO_CODEC_RESET;
GPSR = SHANNON_GPIO_CODEC_RESET;
}
memset(my_ucb, 0, sizeof(struct ucb1x00));
spin_lock_init(&my_ucb->lock);
spin_lock_init(&my_ucb->io_lock);
sema_init(&my_ucb->adc_sem, 1);
my_ucb->id = id;
my_ucb->mcp = mcp;
ret = ucb1x00_configure(my_ucb);
if (ret)
goto out;
ret = request_irq(my_ucb->irq, ucb1x00_irq, 0, "UCB1x00", my_ucb);
if (ret) {
printk(KERN_ERR "ucb1x00: unable to grab irq%d: %d\n",
my_ucb->irq, ret);
kfree(my_ucb);
my_ucb = NULL;
goto out;
}
#ifdef CONFIG_PM
my_ucb->pmdev = pm_register(PM_SYS_DEV, PM_SYS_UNKNOWN, ucb1x00_pm);
if (my_ucb->pmdev == NULL)
printk("ucb1x00: unable to register in PM.\n");
else
my_ucb->pmdev->data = my_ucb;
#endif
out:
mcp_disable(mcp);
no_mcp:
return ret;
}
/**@brief Function for handling Peer Manager events.
*
* @param[in] p_evt Peer Manager event.
*/
static void pm_evt_handler(pm_evt_t const * p_evt)
{
ret_code_t err_code;
switch (p_evt->evt_id)
{
case PM_EVT_BONDED_PEER_CONNECTED:
{
NRF_LOG_DEBUG("Connected to previously bonded device\r\n");
m_peer_id = p_evt->peer_id;
err_code = pm_peer_rank_highest(p_evt->peer_id);
if (err_code != NRF_ERROR_BUSY)
{
APP_ERROR_CHECK(err_code);
}
}break;//PM_EVT_BONDED_PEER_CONNECTED
case PM_EVT_CONN_SEC_START:
break;//PM_EVT_CONN_SEC_START
case PM_EVT_CONN_SEC_SUCCEEDED:
{
NRF_LOG_DEBUG("Link secured. Role: %d. conn_handle: %d, Procedure: %d\r\n",
ble_conn_state_role(p_evt->conn_handle),
p_evt->conn_handle,
p_evt->params.conn_sec_succeeded.procedure);
err_code = pm_peer_rank_highest(p_evt->peer_id);
if (err_code != NRF_ERROR_BUSY)
{
APP_ERROR_CHECK(err_code);
}
if (p_evt->params.conn_sec_succeeded.procedure == PM_LINK_SECURED_PROCEDURE_BONDING)
{
NRF_LOG_DEBUG("New Bond, add the peer to the whitelist if possible\r\n");
NRF_LOG_DEBUG("\tm_whitelist_peer_cnt %d, MAX_PEERS_WLIST %d\r\n",
m_whitelist_peer_cnt + 1,
BLE_GAP_WHITELIST_ADDR_MAX_COUNT);
if (m_whitelist_peer_cnt < BLE_GAP_WHITELIST_ADDR_MAX_COUNT)
{
//bonded to a new peer, add it to the whitelist.
m_whitelist_peers[m_whitelist_peer_cnt++] = m_peer_id;
m_is_wl_changed = true;
}
}
}break;//PM_EVT_CONN_SEC_SUCCEEDED
case PM_EVT_CONN_SEC_FAILED:
{
/** In some cases, when securing fails, it can be restarted directly. Sometimes it can
* be restarted, but only after changing some Security Parameters. Sometimes, it cannot
* be restarted until the link is disconnected and reconnected. Sometimes it is
* impossible, to secure the link, or the peer device does not support it. How to
* handle this error is highly application dependent. */
switch (p_evt->params.conn_sec_failed.error)
{
case PM_CONN_SEC_ERROR_PIN_OR_KEY_MISSING:
// Rebond if one party has lost its keys.
err_code = pm_conn_secure(p_evt->conn_handle, true);
if (err_code != NRF_ERROR_INVALID_STATE)
{
APP_ERROR_CHECK(err_code);
}
break;
default:
break;
}
}break;//PM_EVT_CONN_SEC_FAILED
case PM_EVT_CONN_SEC_CONFIG_REQ:
{
// Reject pairing request from an already bonded peer.
pm_conn_sec_config_t conn_sec_config = {.allow_repairing = false};
pm_conn_sec_config_reply(p_evt->conn_handle, &conn_sec_config);
}break;//PM_EVT_CONN_SEC_CONFIG_REQ
case PM_EVT_STORAGE_FULL:
// Run garbage collection on the flash.
err_code = fds_gc();
if (err_code == FDS_ERR_BUSY || err_code == FDS_ERR_NO_SPACE_IN_QUEUES)
{
// Retry.
}
else
{
APP_ERROR_CHECK(err_code);
}
break;//PM_EVT_STORAGE_FULL
case PM_EVT_ERROR_UNEXPECTED:
// A likely fatal error occurred. Assert.
APP_ERROR_CHECK(p_evt->params.error_unexpected.error);
break;//PM_EVT_ERROR_UNEXPECTED
case PM_EVT_PEER_DATA_UPDATE_SUCCEEDED:
break;//PM_EVT_PEER_DATA_UPDATE_SUCCEEDED
case PM_EVT_PEER_DATA_UPDATE_FAILED:
APP_ERROR_CHECK(p_evt->params.peer_data_update_failed.error);
break;//PM_EVT_PEER_DATA_UPDATE_FAILED
case PM_EVT_PEER_DELETE_SUCCEEDED:
break;//PM_EVT_PEER_DELETE_SUCCEEDED
case PM_EVT_PEER_DELETE_FAILED:
APP_ERROR_CHECK(p_evt->params.peer_delete_failed.error);
break;//PM_EVT_PEER_DELETE_FAILED
case PM_EVT_PEERS_DELETE_SUCCEEDED:
break;//PM_EVT_PEERS_DELETE_SUCCEEDED
case PM_EVT_PEERS_DELETE_FAILED:
APP_ERROR_CHECK(p_evt->params.peers_delete_failed_evt.error);
break;//PM_EVT_PEERS_DELETE_FAILED
case PM_EVT_LOCAL_DB_CACHE_APPLIED:
break;//PM_EVT_LOCAL_DB_CACHE_APPLIED
case PM_EVT_LOCAL_DB_CACHE_APPLY_FAILED:
// The local database has likely changed, send service changed indications.
pm_local_database_has_changed();
break;//PM_EVT_LOCAL_DB_CACHE_APPLY_FAILED
case PM_EVT_SERVICE_CHANGED_IND_SENT:
break;//PM_EVT_SERVICE_CHANGED_IND_SENT
case PM_EVT_SERVICE_CHANGED_IND_CONFIRMED:
break;//PM_EVT_SERVICE_CHANGED_IND_CONFIRMED
default:
// No implementation needed.
break;
}
}
/**@brief Function for the Peer Manager initialization.
*
* @param[in] erase_bonds Indicates whether bonding information should be cleared from
* persistent storage during initialization of the Peer Manager.
*/
static void peer_manager_init(bool erase_bonds)
{
ble_gap_sec_params_t sec_param;
ret_code_t err_code;
err_code = pm_init();
APP_ERROR_CHECK(err_code);
if (erase_bonds)
{
err_code = pm_peers_delete();
APP_ERROR_CHECK(err_code);
}
memset(&sec_param, 0, sizeof(ble_gap_sec_params_t));
// Security parameters to be used for all security procedures.
sec_param.bond = SEC_PARAM_BOND;
sec_param.mitm = SEC_PARAM_MITM;
sec_param.lesc = SEC_PARAM_LESC;
sec_param.keypress = SEC_PARAM_KEYPRESS;
sec_param.io_caps = SEC_PARAM_IO_CAPABILITIES;
sec_param.oob = SEC_PARAM_OOB;
sec_param.min_key_size = SEC_PARAM_MIN_KEY_SIZE;
sec_param.max_key_size = SEC_PARAM_MAX_KEY_SIZE;
sec_param.kdist_own.enc = 1;
sec_param.kdist_own.id = 1;
sec_param.kdist_peer.enc = 1;
sec_param.kdist_peer.id = 1;
err_code = pm_sec_params_set(&sec_param);
APP_ERROR_CHECK(err_code);
err_code = pm_register(pm_evt_handler);
APP_ERROR_CHECK(err_code);
}
int sa1100_audio_attach(struct inode *inode, struct file *file,
audio_state_t *state)
{
int err, need_tx_dma;
DPRINTK("audio_open\n");
down(&state->sem);
/* access control */
err = -ENODEV;
if ((file->f_mode & FMODE_WRITE) && !state->output_stream)
goto out;
if ((file->f_mode & FMODE_READ) && !state->input_stream)
goto out;
err = -EBUSY;
if ((file->f_mode & FMODE_WRITE) && state->wr_ref)
goto out;
if ((file->f_mode & FMODE_READ) && state->rd_ref)
goto out;
err = -EINVAL;
if ((file->f_mode & FMODE_READ) && state->need_tx_for_rx && !state->output_stream)
goto out;
/* request DMA channels */
if (state->skip_dma_init)
goto skip_dma;
need_tx_dma = ((file->f_mode & FMODE_WRITE) ||
((file->f_mode & FMODE_READ) && state->need_tx_for_rx));
if (state->wr_ref || (state->rd_ref && state->need_tx_for_rx))
need_tx_dma = 0;
if (need_tx_dma) {
err = sa1100_request_dma(&state->output_stream->dma_ch,
state->output_id,
state->output_dma);
if (err)
goto out;
}
if (file->f_mode & FMODE_READ) {
err = sa1100_request_dma(&state->input_stream->dma_ch,
state->input_id,
state->input_dma);
if (err) {
if (need_tx_dma)
sa1100_free_dma(state->output_stream->dma_ch);
goto out;
}
}
skip_dma:
/* now complete initialisation */
if (!AUDIO_ACTIVE(state)) {
if (state->hw_init)
state->hw_init(state->data);
#ifdef CONFIG_PM
state->pm_dev = pm_register(PM_SYS_DEV, 0, audio_pm_callback);
if (state->pm_dev)
state->pm_dev->data = state;
#endif
}
if ((file->f_mode & FMODE_WRITE)) {
state->wr_ref = 1;
audio_clear_buf(state->output_stream);
state->output_stream->fragsize = AUDIO_FRAGSIZE_DEFAULT;
state->output_stream->nbfrags = AUDIO_NBFRAGS_DEFAULT;
state->output_stream->mapped = 0;
sa1100_dma_set_callback(state->output_stream->dma_ch,
audio_dmaout_done_callback);
init_waitqueue_head(&state->output_stream->wq);
}
if (file->f_mode & FMODE_READ) {
state->rd_ref = 1;
audio_clear_buf(state->input_stream);
state->input_stream->fragsize = AUDIO_FRAGSIZE_DEFAULT;
state->input_stream->nbfrags = AUDIO_NBFRAGS_DEFAULT;
state->input_stream->mapped = 0;
sa1100_dma_set_callback(state->input_stream->dma_ch,
audio_dmain_done_callback);
init_waitqueue_head(&state->input_stream->wq);
}
file->private_data = state;
file->f_op->release = audio_release;
file->f_op->write = audio_write;
file->f_op->read = audio_read;
file->f_op->mmap = audio_mmap;
file->f_op->poll = audio_poll;
file->f_op->ioctl = audio_ioctl;
file->f_op->llseek = audio_llseek;
err = 0;
out:
up(&state->sem);
return err;
}
static int sa1100_irda_net_init(struct net_device *dev)
{
struct sa1100_irda *si = dev->priv;
unsigned int baudrate_mask;
int err = -ENOMEM;
si = kmalloc(sizeof(struct sa1100_irda), GFP_KERNEL);
if (!si)
goto out;
memset(si, 0, sizeof(*si));
/*
* Initialise the HP-SIR buffers
*/
err = sa1100_irda_init_iobuf(&si->rx_buff, 14384);
if (err)
goto out;
err = sa1100_irda_init_iobuf(&si->tx_buff, 4000);
if (err)
goto out_free_rx;
dev->priv = si;
dev->hard_start_xmit = sa1100_irda_hard_xmit;
dev->open = sa1100_irda_start;
dev->stop = sa1100_irda_stop;
dev->do_ioctl = sa1100_irda_ioctl;
dev->get_stats = sa1100_irda_stats;
irda_device_setup(dev);
irda_init_max_qos_capabilies(&si->qos);
/*
* We support original IRDA up to 115k2. (we don't currently
* support 4Mbps). Min Turn Time set to 1ms or greater.
*/
baudrate_mask = IR_9600|IR_19200|IR_38400|IR_57600|IR_115200;
baudrate_mask |= IR_4000000 << 8;
si->qos.baud_rate.bits &= baudrate_mask;
si->qos.min_turn_time.bits = 7;
irda_qos_bits_to_value(&si->qos);
si->utcr4 = UTCR4_HPSIR;
if (tx_lpm)
si->utcr4 |= UTCR4_Z1_6us;
/*
* Initially enable HP-SIR modulation, and ensure that the port
* is disabled.
*/
Ser2UTCR3 = 0;
Ser2UTCR4 = si->utcr4;
Ser2HSCR0 = HSCR0_UART;
#ifdef CONFIG_PM
/*
* Power-Management is optional.
*/
si->pmdev = pm_register(PM_SYS_DEV, PM_SYS_IRDA, sa1100_irda_pmproc);
if (si->pmdev)
si->pmdev->data = dev;
#endif
return 0;
kfree(si->tx_buff.head);
out_free_rx:
kfree(si->rx_buff.head);
out:
kfree(si);
return err;
}
static int __init
nm256_install(struct pci_dev *pcidev, enum nm256rev rev, char *verstr)
{
struct nm256_info *card;
struct pm_dev *pmdev;
int x;
card = kmalloc (sizeof (struct nm256_info), GFP_KERNEL);
if (card == NULL) {
printk (KERN_ERR "NM256: out of memory!\n");
return 0;
}
card->magsig = NM_MAGIC_SIG;
card->playing = 0;
card->recording = 0;
card->rev = rev;
/* Init the memory port info. */
for (x = 0; x < 2; x++) {
card->port[x].physaddr = RSRCADDRESS (pcidev, x);
card->port[x].ptr = NULL;
card->port[x].start_offset = 0;
card->port[x].end_offset = 0;
}
/* Port 2 is easy. */
card->port[1].start_offset = 0;
card->port[1].end_offset = NM_PORT2_SIZE;
/* Yuck. But we have to map in port 2 so we can check how much RAM the
card has. */
if (nm256_remap_ports (card)) {
kfree (card);
return 0;
}
/*
* The NM256 has two memory ports. The first port is nothing
* more than a chunk of video RAM, which is used as the I/O ring
* buffer. The second port has the actual juicy stuff (like the
* mixer and the playback engine control registers).
*/
if (card->rev == REV_NM256AV) {
/* Ok, try to see if this is a non-AC97 version of the hardware. */
int pval = nm256_readPort16 (card, 2, NM_MIXER_PRESENCE);
if ((pval & NM_PRESENCE_MASK) != NM_PRESENCE_VALUE) {
if (! force_load) {
printk (KERN_ERR "NM256: This doesn't look to me like the AC97-compatible version.\n");
printk (KERN_ERR " You can force the driver to load by passing in the module\n");
printk (KERN_ERR " parameter:\n");
printk (KERN_ERR " force_ac97 = 1\n");
printk (KERN_ERR "\n");
printk (KERN_ERR " More likely, you should be using the appropriate SB-16 or\n");
printk (KERN_ERR " CS4232 driver instead. (If your BIOS has settings for\n");
printk (KERN_ERR " IRQ and/or DMA for the sound card, this is *not* the correct\n");
printk (KERN_ERR " driver to use.)\n");
nm256_release_ports (card);
kfree (card);
return 0;
}
else {
printk (KERN_INFO "NM256: Forcing driver load as per user request.\n");
}
}
else {
/* printk (KERN_INFO "NM256: Congratulations. You're not running Eunice.\n")*/;
}
card->port[0].end_offset = 2560 * 1024;
card->introutine = nm256_interrupt;
card->mixer_status_offset = NM_MIXER_STATUS_OFFSET;
card->mixer_status_mask = NM_MIXER_READY_MASK;
}
else {
/* Not sure if there is any relevant detect for the ZX or not. */
if (nm256_readPort8 (card, 2, 0xa0b) != 0)
card->port[0].end_offset = 6144 * 1024;
else
card->port[0].end_offset = 4096 * 1024;
card->introutine = nm256_interrupt_zx;
card->mixer_status_offset = NM2_MIXER_STATUS_OFFSET;
card->mixer_status_mask = NM2_MIXER_READY_MASK;
}
if (buffertop >= 98304 && buffertop < card->port[0].end_offset)
card->port[0].end_offset = buffertop;
else
nm256_peek_for_sig (card);
card->port[0].start_offset = card->port[0].end_offset - 98304;
printk (KERN_INFO "NM256: Mapping port 1 from 0x%x - 0x%x\n",
card->port[0].start_offset, card->port[0].end_offset);
if (nm256_remap_ports (card)) {
kfree (card);
return 0;
}
/* See if we can get the interrupt. */
card->irq = pcidev->irq;
card->has_irq = 0;
if (nm256_grabInterrupt (card) != 0) {
nm256_release_ports (card);
kfree (card);
return 0;
}
nm256_releaseInterrupt (card);
/*
* Init the board.
*/
card->playbackBufferSize = 16384;
card->recordBufferSize = 16384;
card->coeffBuf = card->port[0].end_offset - NM_MAX_COEFFICIENT;
card->abuf2 = card->coeffBuf - card->recordBufferSize;
card->abuf1 = card->abuf2 - card->playbackBufferSize;
card->allCoeffBuf = card->abuf2 - (NM_TOTAL_COEFF_COUNT * 4);
/* Fixed setting. */
card->mixer = NM_MIXER_OFFSET;
card->mixer_values_init = 0;
card->is_open_play = 0;
card->is_open_record = 0;
card->coeffsCurrent = 0;
card->opencnt[0] = 0; card->opencnt[1] = 0;
/* Reasonable default settings, but largely unnecessary. */
for (x = 0; x < 2; x++) {
card->sinfo[x].bits = 8;
card->sinfo[x].stereo = 0;
card->sinfo[x].samplerate = 8000;
}
nm256_initHw (card);
for (x = 0; x < 2; x++) {
if ((card->dev[x] =
sound_install_audiodrv(AUDIO_DRIVER_VERSION,
"NM256", &nm256_audio_driver,
sizeof(struct audio_driver),
DMA_NODMA, AFMT_U8 | AFMT_S16_LE,
NULL, -1, -1)) >= 0) {
/* 1K minimum buffer size. */
audio_devs[card->dev[x]]->min_fragment = 10;
/* Maximum of 8K buffer size. */
audio_devs[card->dev[x]]->max_fragment = 13;
}
else {
printk(KERN_ERR "NM256: Too many PCM devices available\n");
nm256_release_ports (card);
kfree (card);
return 0;
}
}
/* Insert the card in the list. */
card->next_card = nmcard_list;
nmcard_list = card;
printk(KERN_INFO "Initialized NeoMagic %s audio in PCI native mode\n",
verstr);
/*
* And our mixer. (We should allow support for other mixers, maybe.)
*/
nm256_install_mixer (card);
pmdev = pm_register(PM_PCI_DEV, PM_PCI_ID(pcidev), handle_pm_event);
if (pmdev)
pmdev->data = card;
return 1;
}
/* rs_init inits the driver */
static int __init
rs68328_init(void)
{
int flags, i;
struct m68k_serial *info;
/* Setup base handler, and timer table. */
init_bh(SERIAL_BH, do_serial_bh);
show_serial_version();
/* Initialize the tty_driver structure */
/* SPARC: Not all of this is exactly right for us. */
memset(&serial_driver, 0, sizeof(struct tty_driver));
serial_driver.magic = TTY_DRIVER_MAGIC;
serial_driver.name = "ttyS";
serial_driver.major = TTY_MAJOR;
serial_driver.minor_start = 64;
serial_driver.num = NR_PORTS;
serial_driver.type = TTY_DRIVER_TYPE_SERIAL;
serial_driver.subtype = SERIAL_TYPE_NORMAL;
serial_driver.init_termios = tty_std_termios;
serial_driver.init_termios.c_cflag =
m68328_console_cbaud | CS8 | CREAD | HUPCL | CLOCAL;
serial_driver.flags = TTY_DRIVER_REAL_RAW;
serial_driver.refcount = &serial_refcount;
serial_driver.table = serial_table;
serial_driver.termios = serial_termios;
serial_driver.termios_locked = serial_termios_locked;
serial_driver.open = rs_open;
serial_driver.close = rs_close;
serial_driver.write = rs_write;
serial_driver.flush_chars = rs_flush_chars;
serial_driver.write_room = rs_write_room;
serial_driver.chars_in_buffer = rs_chars_in_buffer;
serial_driver.flush_buffer = rs_flush_buffer;
serial_driver.ioctl = rs_ioctl;
serial_driver.throttle = rs_throttle;
serial_driver.unthrottle = rs_unthrottle;
serial_driver.set_termios = rs_set_termios;
serial_driver.stop = rs_stop;
serial_driver.start = rs_start;
serial_driver.hangup = rs_hangup;
serial_driver.set_ldisc = rs_set_ldisc;
/*
* The callout device is just like normal device except for
* major number and the subtype code.
*/
callout_driver = serial_driver;
callout_driver.name = "cua";
callout_driver.major = TTYAUX_MAJOR;
callout_driver.subtype = SERIAL_TYPE_CALLOUT;
if (tty_register_driver(&serial_driver))
panic("Couldn't register serial driver\n");
if (tty_register_driver(&callout_driver))
panic("Couldn't register callout driver\n");
save_flags(flags);
cli();
for(i=0; i<NR_PORTS; i++) {
info = &m68k_soft[i];
info->magic = SERIAL_MAGIC;
info->port = &uart_addr[i];
info->tty = 0;
info->irq = uart_irqs[i];
info->custom_divisor = 16;
info->close_delay = 50;
info->closing_wait = 3000;
info->x_char = 0;
info->event = 0;
info->count = 0;
info->blocked_open = 0;
info->tqueue.routine = do_softint;
info->tqueue.data = info;
info->tqueue_hangup.routine = do_serial_hangup;
info->tqueue_hangup.data = info;
info->callout_termios =callout_driver.init_termios;
info->normal_termios = serial_driver.init_termios;
init_waitqueue_head(&info->open_wait);
init_waitqueue_head(&info->close_wait);
info->line = i;
info->is_cons = 1; /* Means shortcuts work */
printk("%s%d at 0x%08x (irq = %d)", serial_driver.name, info->line,
info->port, info->irq);
printk(" is a builtin MC68328 UART\n");
IRQ_ports[info->irq] = info; /* waste of space */
#ifdef CONFIG_M68VZ328
if (i > 0)
PJSEL &= 0xCF; /* PSW enable second port output */
#endif
if (request_irq(uart_irqs[i],
rs_interrupt,
IRQ_FLG_STD,
"M68328_UART", NULL))
panic("Unable to attach 68328 serial interrupt\n");
#ifdef CONFIG_PM
serial_pm[i] = pm_register(PM_SYS_DEV, PM_SYS_COM, serial_pm_callback);
if (serial_pm[i])
serial_pm[i]->data = info;
#endif
}
restore_flags(flags);
return 0;
}
//static
wlan_private *
wlan_add_card(void *card)
{
//struct net_device *dev = NULL;
wlan_private *priv = NULL;
//struct eth_drv_sc *dev;
ENTER();
/* probe the card */
if (sbi_probe_card(card) < 0) {
diag_printf("NO card found!\n");
return NULL;
}
#if 0
/* Allocate an Ethernet device and register it */
if (!(dev = alloc_etherdev(sizeof(wlan_private)))) {
diag_printf("Init ethernet device failed!\n");
return NULL;
}
#endif
priv = (wlan_private *)((cyg_uint32)&w99702_priv_data0 | NON_CACHE_FLAG);
/* allocate buffer for wlan_adapter */
MALLOC(priv->adapter, wlan_adapter *, sizeof(wlan_adapter), 0, M_NOWAIT);
if(!priv->adapter)
{
diag_printf("Allocate buffer for wlan_adapter failed!\n");
goto err_kmalloc;
}
priv->adapter = (wlan_adapter *)((unsigned int)priv->adapter | NON_CACHE_FLAG);
/* init wlan_adapter */
memset(priv->adapter, 0, sizeof(wlan_adapter));
priv->wlan_dev.netdev = &w99702_netdev;
priv->wlan_dev.card = card;
// wlanpriv = priv;
// SET_MODULE_OWNER(dev);
#if 0
/* Setup the OS Interface to our functions */
dev->open = wlan_open;
dev->hard_start_xmit = wlan_hard_start_xmit;
dev->stop = wlan_close;
dev->do_ioctl = wlan_do_ioctl;
dev->set_mac_address = wlan_set_mac_address;
#define WLAN_WATCHDOG_TIMEOUT (2 * HZ)
dev->tx_timeout = wlan_tx_timeout;
dev->get_stats = wlan_get_stats;
dev->watchdog_timeo = WLAN_WATCHDOG_TIMEOUT;
#ifdef WIRELESS_EXT
dev->get_wireless_stats = wlan_get_wireless_stats;
dev->wireless_handlers = (struct iw_handler_def *) &wlan_handler_def;
#endif
#define NETIF_F_DYNALLOC 16
dev->features |= NETIF_F_DYNALLOC;
dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
dev->set_multicast_list = wlan_set_multicast_list;
#endif//clyu
#ifdef MFG_CMD_SUPPORT
/* Required for the mfg command */
//init_waitqueue_head(&priv->adapter->mfg_cmd_q);
cyg_cond_init(&priv->adapter->mfg_cond_q, &priv->adapter->mfg_mutex);
#endif
//init_waitqueue_head(&priv->adapter->ds_awake_q);
cyg_cond_init(&priv->adapter->ds_cond_q, &priv->adapter->ds_mutex);
#ifdef ENABLE_PM
if (!(wlan_pm_dev = pm_register(PM_UNKNOWN_DEV, 0, wlan_pm_callback)))
diag_printf("Failed to register PM callback\n");
#endif
INIT_LIST_HEAD(&priv->adapter->CmdFreeQ);
INIT_LIST_HEAD(&priv->adapter->CmdPendingQ);
diag_printf("Starting kthread...\n");
priv->MainThread.priv = priv;
cyg_thread_create(WIRELESS_THREAD_PRIORITY, // Priority
wlan_service_main_thread, // entry
(cyg_addrword_t)&w99702_sc, // entry parameter
"pxa270m card support", // Name
&thread_stack[0], // Stack
sizeof(thread_stack), // Size
&thread_handle, // Handle
&thread_data // Thread data structure
);
priv->MainThread.task = thread_handle;
cyg_thread_resume(thread_handle); // Start it
// ConfigureThreadPriority();
#ifdef REASSOCIATION
priv->ReassocThread.priv = priv;
/*
wlan_create_thread(wlan_reassociation_thread,
&priv->ReassocThread, "wlan_reassoc_service");*/
cyg_thread_create(WIRELESS_THREAD_PRIORITY, // Priority
wlan_reassociation_thread, // entry
(cyg_addrword_t)&w99702_sc, // entry parameter
"wlan_reassoc_service", // Name
&reassoc_stack[0], // Stack
sizeof(reassoc_stack), // Size
&reassoc_handle, // Handle
&reassoc_data // Thread data structure
);
priv->ReassocThread.task = reassoc_handle;
cyg_thread_resume(reassoc_handle); // Start it
#endif /* REASSOCIATION */
/*
* Register the device. Fillup the private data structure with
* relevant information from the card and request for the required
* IRQ.
*/
if (sbi_register_dev(priv) < 0) {
diag_printf("Failed to register wlan device!\n");
goto err_registerdev;
}
#if 0
diag_printf("%s: Marvell Wlan 802.11 Adapter "
"revision 0x%02X at IRQ %i\n", dev->name,
priv->adapter->chip_rev, dev->irq);
#endif
//wlan_proc_entry(priv, dev);
#ifdef PROC_DEBUG
wlan_debug_entry(priv, dev);
#endif
#if 0
/* Get the CIS Table */
sbi_get_cis_info(priv);
#endif
/* init FW and HW */
if (wlan_init_fw(priv)) {
diag_printf("Firmware Init Failed\n");
goto err_init_fw;
}
#if 0
if (register_netdev(dev)) {
printk(KERN_ERR "Cannot register network device!\n");
goto err_init_fw;
}
#endif
LEAVE();
return priv;
err_init_fw:
sbi_unregister_dev(priv);
err_registerdev:
/* Stop the thread servicing the interrupts */
//wake_up_interruptible(&priv->MainThread.waitQ);
cyg_flag_setbits( &priv->MainThread.waitQ_flag_q, 1 );
wlan_terminate_thread(&priv->MainThread);
#ifdef REASSOCIATION
//wake_up_interruptible(&priv->ReassocThread.waitQ);
cyg_flag_setbits( &priv->ReassocThread.waitQ_flag_q, 1 );
wlan_terminate_thread(&priv->ReassocThread);
#endif /* REASSOCIATION */
err_kmalloc:
// unregister_netdev(dev);
FREE(priv->adapter, 0);
//wlanpriv = NULL;
LEAVE();
return NULL;
}
/* bi_modinit - commission bus interface driver
*/
int __init bi_modinit(void)
{
struct usb_bus_instance * bus;
struct usb_device_instance * device;
//extern const char __usbd_module_info[];
//printk(KERN_INFO "%s (dbg=\"%s\")\n", __usbd_module_info, dbg?dbg:"");
if (0 != scan_debug_options("usb-bus",dbg_table,dbg)) {
printk("Failed to scan dbg in bi_modinit\n");
}
if (bi_udc_init()) {
return(-EINVAL);
}
// register this bus interface driver and create the device driver instance
if ((bus = usbd_register_bus(&bi_driver))==NULL) {
bi_udc_exit();
return -EINVAL;
}
// see if we can scrounge up something to set a sort of unique device
// address
if (!udc_serial_init(bus)) {
dbg_init(1,"serial: %s %04x", bus->serial_number_str,
bus->serial_number);
}
if ((device = usbd_register_device(NULL, bus, 8))==NULL) {
usbd_deregister_bus(bus);
bi_udc_exit();
return -EINVAL;
}
#ifdef CONFIG_PM
// register with power management
pm_dev = pm_register(PM_USB_DEV, PM_SYS_UNKNOWN, bi_pm_event);
pm_dev->data = device;
#endif
bus->device = device;
device_array[0] = device;
// initialize the device
{
struct usb_endpoint_instance *endpoint = device->bus->endpoint_array + 0;
// setup endpoint zero
endpoint->endpoint_address = 0;
endpoint->tx_attributes = 0;
endpoint->tx_transferSize = 255;
endpoint->tx_packetSize = udc_ep0_packetsize();
endpoint->rcv_attributes = 0;
endpoint->rcv_transferSize = 0x8;
endpoint->rcv_packetSize = udc_ep0_packetsize();
udc_setup_ep(device, 0, endpoint);
}
// hopefully device enumeration will finish this process
udc_startup_events(device);
#ifdef CONFIG_PM
dbg_pm(0,"pm_dev->callback#%p",pm_dev->callback);
if (!udc_connected()) {
/* Fake a call from the PM system to suspend the UDC until it
is needed (cable connect, etc) */
(void) bi_pm_event(pm_dev,PM_SUSPEND,NULL);
/* There appears to be no constant for this, but inspection
of arch/arm/mach-l7200/apm.c:send_event() shows that the
suspended state is 3 (i.e. pm_send_all(PM_SUSPEND, (void *)3))
corresponding to ACPI_D3. */
pm_dev->state = 3;
}
#endif
if (dbgflg_usbdbi_tick > 0) {
// start ticker
ticker_kickoff();
}
dbgLEAVE(dbgflg_usbdbi_init,1);
return 0;
}
