int __init
blktap_ring_init(void)
{
dev_t dev = 0;
int err;
cdev_init(&blktap_ring_cdev, &blktap_ring_file_operations);
blktap_ring_cdev.owner = THIS_MODULE;
err = alloc_chrdev_region(&dev, 0, MAX_BLKTAP_DEVICE, "blktap2");
if (err < 0) {
BTERR("error registering ring devices: %d\n", err);
return err;
}
err = cdev_add(&blktap_ring_cdev, dev, MAX_BLKTAP_DEVICE);
if (err) {
BTERR("error adding ring device: %d\n", err);
unregister_chrdev_region(dev, MAX_BLKTAP_DEVICE);
return err;
}
blktap_ring_major = MAJOR(dev);
BTINFO("blktap ring major: %d\n", blktap_ring_major);
return 0;
}
static struct blktap *
blktap_control_allocate_tap(void)
{
int err, minor;
struct blktap *tap;
/*
* This is called only from the ioctl, which
* means we should always have interrupts enabled.
*/
BUG_ON(irqs_disabled());
spin_lock_irq(&blktap_control_lock);
for (minor = 0; minor < MAX_BLKTAP_DEVICE; minor++) {
tap = blktaps[minor];
if (!tap)
goto found;
if (!tap->dev_inuse) {
blktap_control_initialize_tap(tap);
goto found;
}
}
tap = NULL;
found:
spin_unlock_irq(&blktap_control_lock);
if (!tap) {
tap = blktap_control_create_tap();
if (!tap)
return NULL;
}
err = blktap_ring_create(tap);
if (err) {
BTERR("ring creation failed: %d\n", err);
clear_bit(BLKTAP_CONTROL, &tap->dev_inuse);
return NULL;
}
BTINFO("allocated tap %p\n", tap);
return tap;
}
static int ericsson(int fd, struct uart_t *u, struct termios *ti)
{
struct timespec tm = {0, 50000};
int err;
struct Ericsson_Set_UART_Speed cmd;
uint8_t buf[HCI_MAX_EVENT_SIZE];
struct Command_Complete_Status *ccs = (void*)buf;
switch (u->speed) {
case 57600:
cmd.speed = 0x03;
break;
case 115200:
cmd.speed = 0x02;
break;
case 230400:
cmd.speed = 0x01;
break;
case 460800:
cmd.speed = 0x00;
break;
case 921600:
cmd.speed = 0x20;
break;
default:
cmd.speed = 0x03;
u->speed = 57600;
break;
}
#if 0
err = hci_exec_cmd(fd, HCI_C_ERICSSON_SET_UART_SPEED, &cmd, sizeof(cmd),
COMMAND_COMPLETE_MASK, 0, ccs);
#else
ccs->Status = 0;
err = hci_exec_cmd1(fd, HCI_C_ERICSSON_SET_UART_SPEED, &cmd, sizeof(cmd),
COMMAND_COMPLETE_MASK, HCI_SKIP_STATUS);
nanosleep(&tm, NULL);
#endif
BTINFO("err: %d, status: %#x\n", err, ccs->Status);
if (err)
return err;
return ccs->Status;
}
/* Initialize UART device */
int init_uart(char *dev, struct uart_t *u)
{
struct termios ti;
int fd, err;
int to = 20, speed;
/* now device ready for initialization */
signal(SIGALRM, &sig_alarm);
alarm(to);
BTINFO("Initializing UART");
if (uart_rate)
speed = uart_speed(uart_rate > 0 ? uart_rate : u->init_speed);
else
speed = 0;
err = hci_setup_uart(dev, u->proto, speed, u->flags);
if (err)
return err;
/* Vendor specific initialization */
if (u->init) {
fd = _hci_open(dev);
if (fd < 0) {
BTERROR("unable to open: %s\n", dev);
return fd;
}
err = u->init(fd, u, &ti);
close(fd);
}
/* Set actual baudrate */
if (!err) {
err = hci_setup_uart(dev, u->proto, uart_speed(u->speed), u->flags);
if (err)
BTERROR("Can't setup uart");
}
alarm(0);
return err;
}
int sdpreg_unregister(struct btservice *svc)
{
int status;
sdpsvc_t *svcRec = svc->svcRec;
if (!svcRec)
return 0;
status = sdp_delete_service(srvHandle, svcRec);
switch (status) {
case 0:
BTINFO("service %s deleted", svc->name);
break;
case SDP_ERR_INVALID_ARG:
BTERROR("Error: You cannot delete service %s", svc->name);
break;
default:
BTERROR("Something went wrong. sdp_delete_service() returned: %d\n", status);
break;
}
sdp_free_svc(svcRec);
svc->svcRec = NULL;
return 0;
}
static int csr(int fd, struct uart_t *u, struct termios *ti)
{
struct timespec tm = {0, 10000000}; /* 10ms - be generous */
static int csr_seq = 0; /* Sequence number of command */
int divisor;
int err;
struct CSR_Get_Build_ID cmd1;
struct CSR_Get_Build_ID_Event cce;
struct CSR_Set_UART_Speed cmd2;
/* Try to read the build ID of the CSR chip */
cmd1.bcc.channel = 0xc2; /* first+last+channel=BCC */
cmd1.bcc.type = __htob16(0x0000); /* type = GET-REQ */
cmd1.bcc.len = __htob16(5 + 4); /* ??? */
cmd1.bcc.seq_num = __htob16(csr_seq); /* seq num */
csr_seq++;
cmd1.bcc.var_id = __htob16(0x2819); /* var_id = CSR_CMD_BUILD_ID */
cmd1.bcc.status = __htob16(0x0000); /* status = STATUS_OK */
/* CSR BCC payload */
memset(cmd1.data, 0, sizeof(cmd1.data));
/* Send command */
err = hci_exec_cmd1(fd, HCI_C_CSR_COMMAND, &cmd1, sizeof(cmd1),
ALL_EVENTS_MASK, HCI_SKIP_STATUS);
if (err)
return err;
do {
#if 0 // it's here in original code
/* Send command */
err = hci_exec_cmd(fd, &cmd1, ALL_EVENTS_MASK, HCI_SKIP_STATUS, NULL);
if (err)
return err;
#endif
err = hci_recv_event(fd, &cce, sizeof(cce), 20);
if (err < 0) {
return err;
}
} while (cce.hci.EventCode != 0xFF);
/* Display that to user */
BTINFO("CSR build ID 0x%02X-0x%02X\n", cce.data[12], cce.data[11]);
/* Now, create the command that will set the UART speed */
cmd2.bcc.channel = 0xc2;
cmd2.bcc.type = __htob16(0x0002); // SET-REQ
cmd2.bcc.len = __htob16(5 + 4);
cmd2.bcc.seq_num = __htob16(csr_seq);
csr_seq++;
cmd2.bcc.var_id = __htob16(0x6802); // CONFIG_UART
cmd2.bcc.status = __htob16(0x0000); // STATUS_OK
switch (u->speed) {
case 9600:
divisor = 0x0027;
break;
/* Various speeds ommited */
case 57600:
divisor = 0x00EC;
break;
case 115200:
divisor = 0x01D8;
break;
/* For Brainbox Pcmcia cards */
case 460800:
divisor = 0x075F;
break;
case 921600:
divisor = 0x0EBF;
break;
default:
/* Safe default */
divisor = 0x01D8;
u->speed = 115200;
break;
}
/* No parity, one stop bit -> divisor |= 0x0000; */
cmd2.speed = __htob16(divisor);
memset(cmd2.extra, 0, sizeof(cmd2.extra));
err = hci_exec_cmd1(fd, HCI_C_CSR_COMMAND, &cmd2, sizeof(cmd2),
ALL_EVENTS_MASK, HCI_SKIP_STATUS);
if (err)
return err;
#if 0 // no wait for response in original code
do {
err = hci_recv_event(fd, &cce, sizeof(cce), 20);
if (err < 0) {
return err;
}
} while (cce.hci.EventCode != 0xFF);
#endif
nanosleep(&tm, NULL);
return 0;
}
