开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多显示器编程 > 查看源码
voip-device.c
资源名称：voipblaster-0.2.0-src.tar.gz　[点击查看]
上传用户：weyjxb
上传日期：2020-05-18
资源大小：52k
文件大小：48k
源码类别：

多显示器编程

开发平台：

Unix_Linux

voip-device.c：源码内容
  1. /*
  2.  * voipblaster.c
  3.  * (C) Copyright 2001, 2002 by Thomas Davis (tdavis@beeble.homelinux.net)
  4.  * (C) Copyright 2001 by Michael Bosland <mike@ring.org>
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify it
  7.  * under the terms of the GNU General Public License as published by the
  8.  * Free Software Foundation; either version 2 of the License, or (at your
  9.  * option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful, but
  12.  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13.  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14.  * for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software Foundation,
  18.  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  */
  22. #include <linux/config.h>
  23. #include <linux/module.h>
  24. #include <linux/kernel.h>
  25. #include <linux/sched.h>
  26. #include <linux/signal.h>
  27. #include <linux/errno.h>
  29. #include <linux/proc_fs.h>
  30. #include <linux/fs.h>
  31. #include <linux/poll.h>
  32. #include <linux/init.h>
  33. #include <linux/slab.h>
  34. #include <linux/spinlock.h>
  35. #include <linux/smp_lock.h>
  37. #include <linux/usb.h>
  38. #include <asm/string.h>
  40. #include "telephony.h"
  41. #include "voip-ver.h"
  42. #include "voip-config.h"
  43. #include "ixjuser.h"
  44. #include "phonedev.h"
  45. #include "voipblaster.h"
  47. /* These lines are taken from the netbsd port.  */
  49. static u_char init_1[] =
  50. {
  51.     0x3b,0x00,0x40,0x8b // first 2 bytes is length, second 2 bytes is command?
  52. };
  54. static u_char init_2[] =
  55. {
  56.     0x00,0x01,0x00,0x00,0x18,0x02,0x8f,0x00,
  57.     0x10,0x00,0x28,0x40,0x03,0x1a,0x0d,0x0c,
  58.     0xfa,0x43,0xfd,0xea,0x93,0xfe,0x1a,0x41,
  59.     0x00,0x4a,0x93,0xfe,0x2a,0x40,0x00,0x1a,
  60.     0x93,0xfe,0x3a,0x0a,0x00,0x1f,0x3c,0x00,
  61.     0x8c,0x0d,0x03,0xa3,0x23,0xa2,0xdf,0x0d,
  62.     0x0c,0x3a,0x40,0x00,0x2a,0x93,0xfe,0x4a,
  63.     0x0a,0x00,0x0f
  64. };
  66. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,3,0)
  68. static struct usb_device_id voipblaster_ids[] = {
  69. { USB_DEVICE(0x1292,0x258) }, /* Vendor/Device */
  70. { },
  71. };
  73. MODULE_DEVICE_TABLE (usb, voipblaster_ids);
  75. #endif
  77. static struct usb_voipblaster *voipblaster_table[VOIP_MAX];
  79. /* lock to protect the voipblaster_table structure */
  80. static DECLARE_MUTEX (voipblaster_table_mutex);
  82. /* local function prototypes */
  83. static ssize_t voipblaster_read(struct file *file, char *buffer, size_t count, loff_t *ppos);
  84. static ssize_t voipblaster_write(struct file *file, const char *buffer, size_t count, loff_t *ppos);
  85. static int voipblaster_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
  86. static int voipblaster_release(struct inode *inode, struct file *file);
  87. static unsigned int voipblaster_poll(struct file *file, poll_table * wait);
  88. static int voipblaster_fasync(int fd, struct file *file, int mode);
  90. /* external functions */
  91. extern void voipblaster_register_device(struct usb_voipblaster *);
  92. extern void voipblaster_proc_init(void);
  93. extern void voipblaster_proc_destroy(void);
  94. extern int voipblaster_get_status_proc(char *);
  95. extern int voipblaster_read_proc(char *page, char **start, off_t off,
  96.  int count, int *eof, void *data);
  98. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,3,0)
  99. static void *voipblaster_probe(struct usb_device *dev, unsigned int ifnum, const struct usb_device_id *id);
  100. #else
  101. static void *voipblaster_probe(struct usb_device *dev, unsigned int ifnum);
  102. #endif
  104. static void voipblaster_disconnect(struct usb_device *dev, void *ptr);
  106. struct file_operations voipblaster_fops =
  107. {
  108. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,3,0)
  109.         owner:          THIS_MODULE,
  110. #endif
  111.         read:           voipblaster_read,
  112.         write:          voipblaster_write,
  113.         poll:           voipblaster_poll,
  114.         ioctl:          voipblaster_ioctl,
  115.         release:        voipblaster_release,
  116.         fasync:         voipblaster_fasync
  117. };
  120. #define VOIP_DEBUG
  121. #ifdef VOIP_DEBUG
  122. static int VOIPdebug = 1;
  123. #else
  124. static int VOIPdebug = 0;
  125. #endif
  127. char VOIPversion[32];
  128. static int hertz;
  130. /* Use our own dbg macro */
  131. #undef dbg
  132. #define dbg(format, arg...) do { if (VOIPdebug) printk(KERN_DEBUG __FUNCTION__ ": " format "n" , ## arg); } while (0)
  134. #undef info
  135. #define info(format, arg...) printk(KERN_INFO __FUNCTION__ ": " format "n" , ## arg)
  137. #define get_voipblaster(b) voipblaster_table[(b)]
  139. extern __inline__ void voipblaster_kill_fasync(struct usb_voipblaster *dev, IXJ_SIGEVENT event, int dir)
  140. {
  141. dbg("minor %d, event = %d", dev->minor, event);
  143. if(dev->signals[event]) {
  144. dbg("Sending signal for event %d", event);
  145. /* Send apps notice of change */
  146. /* see config.h for macro definition */
  147. VOIP_KILL_FASYNC(dev->async_queue, dev->signals[event], dir);
  148. }
  149. }
  151. static int capabilities_check(struct usb_voipblaster *dev, struct phone_capability *pcreq)
  152. {
  153. int cnt;
  154. int retval = 0;
  155. for (cnt = 0; cnt < dev->caps; cnt++) {
  156. if (pcreq->captype == dev->caplist[cnt].captype
  157.     && pcreq->cap == dev->caplist[cnt].cap) {
  158. retval = 1;
  159. break;
  160. }
  161. }
  162. return retval;
  163. }
  165. static void add_caps(struct usb_voipblaster *j)
  166. {
  168. j->caps = 0;
  169. j->caplist[j->caps].cap = PHONE_VENDOR_VOIPBLASTER;
  170. strcpy(j->caplist[j->caps].desc, "Linux Hackers, Inc");
  171. j->caplist[j->caps].captype = vendor;
  172. j->caplist[j->caps].handle = j->caps++;
  173. j->caplist[j->caps].captype = device;
  175. switch (j->cardtype) {
  176. case CREATIVE_VOIPBLASTER:
  177. strcpy(j->caplist[j->caps].desc, "Creative VOIP Blaster/USB");
  178. break;
  179. default:
  180. strcpy(j->caplist[j->caps].desc, "Unknown Card");
  181. break;
  182. }
  184. j->caplist[j->caps].cap = j->cardtype;
  185. j->caplist[j->caps].handle = j->caps++;
  186. strcpy(j->caplist[j->caps].desc, "POTS");
  187. j->caplist[j->caps].captype = port;
  188. j->caplist[j->caps].cap = pots;
  189. j->caplist[j->caps].handle = j->caps++;
  191.   /* add devices that can do speaker/mic */
  192. switch (j->cardtype) {
  193. case CREATIVE_VOIPBLASTER:
  194. strcpy(j->caplist[j->caps].desc, "SPEAKER");
  195. j->caplist[j->caps].captype = port;
  196. j->caplist[j->caps].cap = speaker;
  197. j->caplist[j->caps].handle = j->caps++;
  198.         default:
  199.       break;
  200. }
  202. #if 0
  203.   /* add devices that can do handset */
  204. switch (j->cardtype) {
  205. case CREATIVE_VOIPBLASTER:
  206. strcpy(j->caplist[j->caps].desc, "HANDSET");
  207. j->caplist[j->caps].captype = port;
  208. j->caplist[j->caps].cap = handset;
  209. j->caplist[j->caps].handle = j->caps++;
  210. break;
  211.         default:
  212.       break;
  213. }
  214. #endif
  216. #define ENABLE_G723_63 1
  218. #if defined(ENABLE_G723_63)
  219. strcpy(j->caplist[j->caps].desc, "G.723.1 6.3kbps");
  220. j->caplist[j->caps].captype = codec;
  221. j->caplist[j->caps].cap = G723_63;
  222. j->caplist[j->caps].handle = j->caps++;
  223. #endif
  225. strcpy(j->caplist[j->caps].desc, "G.723.1 5.3kbps");
  226. j->caplist[j->caps].captype = codec;
  227. j->caplist[j->caps].cap = G723_53;
  228. j->caplist[j->caps].handle = j->caps++;
  229. }
  231. static void voipblaster_event_irq(urb_t *urb)
  232. {
  233. struct usb_voipblaster *dev = urb->context;
  234. char event;
  235. unsigned long flags;
  237. /* Received an event from the voipblaster.  Place it in the event
  238.    buffer if there is any room.  If it is DTMF data place it in the
  239.    DTMF buffer instead.  Maybe signal somebody that some new stuff
  240.    has arrived. */
  242. spin_lock_irqsave(&dev->io_lock,flags);
  244. /* Figure out what we have. */
  245. event = dev->event_data[0];
  246. dbg("Event Received: 0x%02x, dtmf_ready = %d",event, dev->ex.bits.dtmf_ready);
  248. if ((event >= VB_EVENT_DTMF0 && event <= VB_EVENT_DTMF9) 
  249. || event == VB_EVENT_DTMFSTAR || event == VB_EVENT_DTMFPND) {
  251. /* This is DTMF Information.  Convert to char and add to
  252.    the DTMF buffer if there is room available.  If not,
  253.    drop it. */
  254. char dtmf;
  256. switch (event) {
  257. case VB_EVENT_DTMFSTAR:
  258. dbg("*");
  259. dtmf = 10;
  260. break;
  261.                 case VB_EVENT_DTMFPND:
  262. dbg("#");
  263. dtmf = 12;
  264. break;
  265. case VB_EVENT_DTMF0:
  266. dbg("0");
  267. dtmf = 11;
  268. break;
  269. default:
  270. dtmf = event - VB_EVENT_DTMF0;
  271. break;
  272. }
  274.       
  275. dbg("DTMF decoded: 0x%02x", dtmf & 0xff);
  277. if (dev->dtmf_buffer_len > VB_DTMF_BUFF_LENGTH) {
  278. info("No more room for DTMF data.  Discarding");
  279. } else {
  280. /* Add this DTMF data to the end of the DTMF buffer */
  281. dev->ex.bits.dtmf_ready = 1;
  282. if (dev->ex_sig.bits.dtmf_ready) {
  283. voipblaster_kill_fasync(dev, SIG_DTMF_READY, POLL_IN);
  284. }
  285. dev->dtmf_buffer[dev->dtmf_buffer_in] = dtmf;
  286. dev->dtmf_buffer_len++;
  287. dev->dtmf_buffer_in++;
  289. if (dev->dtmf_buffer_in > VB_DTMF_BUFF_LENGTH)
  290. dev->dtmf_buffer_in = 0;
  292. }
  293. } else {
  294. /* Determine what, if any flags to set. */
  295. switch (event) {
  296. case VB_EVENT_OFFHOOK:
  297. dbg("VB_EVENT_OFFHOOK");
  298. dev->hookstate = 1;
  299. dev->ex.bits.hookstate = 1;
  300. voipblaster_kill_fasync(dev, SIG_HOOKSTATE, POLL_IN);
  301. break;
  302. case VB_EVENT_ONHOOK:
  303. dbg("VB_EVENT_ONHOOK");
  304. dev->hookstate = 0;
  305. dev->ex.bits.hookstate = 1;
  306. voipblaster_kill_fasync(dev, SIG_HOOKSTATE, POLL_IN);
  307. break;
  308. case VB_EVENT_RINGING_OFF:
  309. dbg("VB_EVENT_RINGING_OFF");
  310. dev->ringing = 0;
  311. break;
  312. case VB_EVENT_RINGING_ON:
  313. dbg("VB_EVENT_RINGING_ON");
  314. dev->ringing = 1;
  315. break;
  316. default:
  317. /* This is not DTMF data.  It is some other event */
  318. if (dev->event_buffer_len > VB_EVENT_BUFF_LENGTH) {
  319. info("No more room for EVENT data.  Discarding");
  320. } else {
  321. /* Add this EVENT data to the end of the EVENT buffer */
  322. dev->event_buffer_len++;
  323. dev->event_buffer_in++;
  324. if (dev->event_buffer_in > VB_EVENT_BUFF_LENGTH)
  325. dev->event_buffer_in = 0;
  327. dev->event_buffer[dev->event_buffer_in] = event;
  328. }
  329. dbg("got event 0x%02x", event);
  330. break;
  331. }
  333. }
  335. #if 0
  336. #if !defined(USB_INT_URB)
  337. if (dev->udev != NULL) {
  338. /* Prepare the event urb... */
  339. FILL_BULK_URB(dev->event_urb, dev->udev,
  340.       usb_rcvbulkpipe(dev->udev, 0x81),
  341.       dev->event_data, 1,
  342.       voipblaster_event_irq, dev);
  344. dbg("Starting Event URB");
  345. if (usb_submit_urb(dev->event_urb) != 0) {
  346. dbg("error with event_urb, status = %d", dev->event_urb->status);
  347. }
  348. } else {
  349. dbg("udev = NULL");
  350. }
  351. #endif
  352. #endif
  354. /* Notify driver of new event data... */
  355. dbg("waking sleeper(s)..");
  357. wake_up(&dev->event_q);
  358. wake_up(&dev->poll_q);
  359. wake_up(&dev->read_q);
  361. spin_unlock_irqrestore(&dev->io_lock,flags);
  362. }
  364. static void voipblaster_event_poll(struct usb_voipblaster *dev, int timeout)
  365. {
  366. interruptible_sleep_on_timeout(&dev->event_q, timeout);
  367. }
  369. #if 0
  370. static int voipblaster_status(struct usb_voipblaster *dev)
  371. {
  372. int retval;
  374. dbg("%d events in buffer", dev->event_buffer_len);
  376. if (dev->event_buffer_len > 0) {
  377. dev->event_buffer_len--;
  378. dev->event_buffer_out++;
  379. if (dev->event_buffer_out > VB_EVENT_BUFF_LENGTH) 
  380. dev->event_buffer_out = 0;
  381. retval = dev->event_buffer[dev->event_buffer_in];
  382. } else {
  383. retval = -1;
  384. }
  385. dbg("retval = %d", retval);
  386. return retval;
  387. }
  388. #endif
  390. static void voipblaster_cmd_irq(urb_t *urb)
  391. {
  392. struct usb_voipblaster *dev = urb->context;
  393. unsigned long flags;
  395. /* The last command was sent to the voipblaster.  If there are
  396.    any more commands send them off too.  If there aren't anymore
  397.    then unlink this urb.  This completion handler may also be
  398.    called when we unlink the URB... */
  400. dbg("URB Returned, urb->status = %d", urb->status);
  401. spin_lock_irqsave(&dev->io_lock,flags);
  403. if (urb->status != 0) {
  404. if ((urb->status != -ENOENT) && 
  405.     (urb->status != -ECONNRESET)) {
  406. dbg(" nonzero status received: %d", urb->status);
  407.                 }
  408. spin_unlock_irqrestore(&dev->io_lock,flags);
  409. goto exit;
  410.         }                        
  412. spin_unlock_irqrestore(&dev->io_lock,flags);
  414. dbg("waking sleeper..");
  416. wake_up(&dev->cmd_q);
  418.  exit:
  419. dbg("CMD completed");
  420. }
  422. static int voipblaster_cmd(struct usb_voipblaster *dev, char cmd)
  423. {
  424. /* Send a command to the voipblaster using a single shot
  425.    interupt URB.  This command will wait for completion before
  426.    returning control */
  427.  
  428. unsigned long flags;
  429. int urb_err;
  431. dbg("Queuing command: 0x%02x", cmd);
  433. /* see if we are already in the middle of a write */
  434. if (dev->cmd_urb->status == -EINPROGRESS) {
  435. dbg ("already writing");
  436. return -1;
  437. }
  439. spin_lock_irqsave(&dev->io_lock,flags);
  440. if (dev->cmd_buffer_len > VB_CMD_BUFF_LENGTH) {
  441. info(" No room in command buffer for new command");
  442. spin_unlock_irqrestore(&dev->io_lock,flags);
  443. return -1;
  444. }
  446. /* A fresh URB needs to be sent off */
  447. dbg("Submitting CMD URB");
  448. dev->cmd_data[0] = cmd;
  450. /* Prepare the command urb... */
  451. #if defined(USE_INT_URB)
  452. FILL_INT_URB(dev->cmd_urb, 
  453.      dev->udev,
  454.      usb_sndintpipe(dev->udev,0x01),
  455.      dev->cmd_data, 
  456.      1,
  457.      voipblaster_cmd_irq, 
  458.      dev,
  459.      0);
  460. #else
  461. FILL_BULK_URB(dev->cmd_urb, 
  462.      dev->udev,
  463.      usb_sndbulkpipe(dev->udev,0x01),
  464.      dev->cmd_data, 
  465.      1,
  466.      voipblaster_cmd_irq, 
  467.      dev);
  468. #endif
  470. urb_err = usb_submit_urb(dev->cmd_urb);
  471. if ( urb_err != 0) {
  472. info("error submitting CMD URB: %d, %d",dev->cmd_urb->status, urb_err);
  473. spin_unlock_irqrestore(&dev->io_lock,flags);
  474. return dev->cmd_urb->status;
  475. }
  477. spin_unlock_irqrestore(&dev->io_lock,flags);
  479. /* now wait for the IRQ to complete. */
  481. interruptible_sleep_on(&dev->cmd_q);
  483. dbg("completed");
  485. return 0;
  486. }
  488. static void voipblaster_snd_voice_irq(urb_t *urb)
  489. {
  490. struct usb_voipblaster *dev = urb->context;
  491. unsigned long flags;
  493. spin_lock_irqsave(&dev->io_lock,flags);
  494. dbg("URB Returned, urb->status = %d", urb->status);
  495.  
  496. /* The current voice block has been processed... */
  497. dev->write_buffer_len = 0;
  499. spin_unlock_irqrestore(&dev->io_lock,flags);
  501. dbg("waking sleeper..");
  503. wake_up(&dev->write_q);
  505. dbg("completed");
  506. }
  508. static int voipblaster_snd_voice(struct usb_voipblaster *dev,
  509. u_char *data, int length)
  510. {
  512. /* Send voice data to the voipblaster using a single shot
  513.    interupt URB.  This command will wait for completion before
  514.    returning control */
  515.  
  516. unsigned long flags;
  517. int i;
  519. dbg("sending %d bytes of voice data.", length);
  521. /* see if we are already in the middle of a write */
  522. if (dev->write_urb->status == -EINPROGRESS) {
  523. dbg ("already writing");
  524. return -1;
  525. }
  527. spin_lock_irqsave(&dev->io_lock,flags);
  528. if (length > VB_W_BUFF_LENGTH) {
  529. dbg("No room in write buffer for new voice data");
  530. spin_unlock_irqrestore(&dev->io_lock,flags);
  531. return -1;
  532. }
  534. /* Add this voice data to the write buffer. */
  535. for (i=0; i<length; i++) {
  536. dev->write_buffer[i] = data[i];
  537. }
  539. dev->write_buffer_len = length;
  541. /* A fresh URB needs to be sent off */
  542. dbg("submitting write URB..");
  544. /* Prepare the write urb... */
  545. #if defined(USE_INT_URB)
  546. FILL_INT_URB(dev->write_urb, dev->udev,
  547. usb_sndintpipe(dev->udev,0x2),
  548. dev->write_buffer, dev->write_buffer_len,
  549. voipblaster_snd_voice_irq, dev,
  550. 0);
  551. #else
  552. FILL_BULK_URB(dev->write_urb, dev->udev,
  553. usb_sndbulkpipe(dev->udev,0x2),
  554. dev->write_buffer, dev->write_buffer_len,
  555. voipblaster_snd_voice_irq, dev);
  556. #endif
  558. if  (usb_submit_urb(dev->write_urb) != 0) {
  559. dbg("error submitting WRITE URB: %d",dev->write_urb->status);
  560. spin_unlock_irqrestore(&dev->io_lock,flags);
  561. return dev->write_urb->status;
  562. }
  564. spin_unlock_irqrestore(&dev->io_lock,flags);
  566. dbg("sleeping..");
  568. interruptible_sleep_on(&dev->write_q);
  570. dbg("done.");
  572. return 0;
  573. }
  575. static void voipblaster_read_irq(urb_t *urb)
  576. {
  577. struct usb_voipblaster *dev = urb->context;
  578. unsigned long flags;
  580. spin_lock_irqsave(&dev->io_lock,flags);
  581. dbg("URB Returned, status = %d", urb->status);
  583. if (urb->status != 0) {
  584. if ((urb->status != -ENOENT) && 
  585.     (urb->status != -ECONNRESET)) {
  586. dbg(" - nonzero status received: %d", urb->status);
  587.                 }
  588. spin_unlock_irqrestore(&dev->io_lock,flags);
  589. goto exit;
  590.         }                        
  592. if (!dev->ispresent) {
  593. dev->ispresent = 1;
  594. memcpy(dev->dsp_version, dev->read_buffer_urb, 10);
  595. memcpy(dev->dsp_serial, &dev->read_buffer_urb[10], 10);
  596. } else {
  597. memcpy(dev->read_buffer, dev->read_buffer_urb, 20);
  598. dev->read_buffer_ready = 1;
  599. dev->read_buffer_in = 20;
  600. }
  602. /* A fresh URB needs to be sent off */
  603. dbg("submitting read URB..");
  605. /* Prepare the read urb... */
  606. FILL_BULK_URB(dev->read_urb, dev->udev,
  607. usb_rcvbulkpipe(dev->udev, 0x82),
  608. dev->read_buffer_urb, 20,
  609. voipblaster_read_irq, dev);
  611. dbg("Starting read URB");
  612. if (usb_submit_urb(dev->read_urb) != 0) {
  613. dbg("error with read_urb, status = %d", dev->read_urb->status);
  614. }
  616. spin_unlock_irqrestore(&dev->io_lock,flags);
  618. dbg("waking sleeper..");
  620. //wake_up(&dev->poll_q);
  621. wake_up(&dev->read_q);
  623.  exit:
  624. dbg("CMD completed");
  625. }
  627. /*
  628.  * voipblaster_read
  629.  */
  630. static ssize_t voipblaster_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
  631. {
  632. struct usb_voipblaster *dev;
  633. int retval = 0;
  635. dev = (struct usb_voipblaster *)file->private_data;
  637. dbg("minor %d, count = %d, read_buffer_ready = %d, read_wait = %ld", dev->minor, 
  638.     count, dev->read_buffer_ready, dev->read_wait);
  640. /* lock this object */
  641. down (&dev->sem);
  643. if (dev->flags.inread) {
  644. up (&dev->sem);
  645. return -EALREADY;
  646. }
  648. dev->flags.inread = 1;
  650. #if 0
  651. while (dev->read_buffer_ready || (dev->dtmf_state && dev->flags.dtmf_oob)) {
  652. #else
  653. while (!dev->read_buffer_ready) {
  654. #endif
  655. ++dev->read_wait;
  656. if (file->f_flags & O_NONBLOCK) {
  657. dbg("O_NONBLOCK");
  658. dev->flags.inread = 0;
  659. up (&dev->sem);
  660. return -EAGAIN;
  661. }
  663. if (!dev->hookstate) {
  664. dbg("on hook..");
  665. dev->flags.inread = 0;
  666. up (&dev->sem);
  667. return 0;
  668. }
  670. interruptible_sleep_on(&dev->read_q);
  671. if (signal_pending(current)) {
  672. dbg("signal_pending");
  673. dev->flags.inread = 0;
  674. up (&dev->sem);
  675. return -EINTR;
  676. }
  677. }
  679. dev->read_buffer_ready = 0;
  680. dev->flags.inread = 0;
  682. if (copy_to_user(buffer, dev->read_buffer, dev->read_buffer_in)) {
  683. retval = -EFAULT;
  684. } else {
  685. if (count == 24 && dev->read_buffer_in == 20) {
  686. retval = count;
  687. } else {
  688. retval =  dev->read_buffer_in;
  689. dev->read_buffer_in = 0;
  690. }
  691. }
  693. up (&dev->sem);
  695. dbg("done, retval = %d", retval);
  697. return retval;
  699. #if 0
  700. /* verify that the device wasn't unplugged */
  701. if (dev->udev == NULL) {
  702. up (&dev->sem);
  703. return -ENODEV;
  704. }
  707. /* do an immediate bulk read to get data from the device */
  708. retval = usb_bulk_msg (dev->udev,
  709.        usb_rcvbulkpipe (dev->udev, 0x82),
  710.        dev->read_buffer, 20,
  711.        &count, 60);
  713. /* if the read was successful, copy the data to userspace */
  714. if (!retval) {
  715. if (copy_to_user (buffer, dev->read_buffer, count))
  716. retval = -EFAULT;
  717. else
  718. retval = count;
  719. }
  720. #endif
  721. }
  723. /**
  724.  *      skel_write_bulk_callback
  725.  */
  726. static void voipblaster_write_callback (struct urb *urb)
  727. {
  728.         struct usb_voipblaster *dev = (struct usb_voipblaster *)urb->context;
  730.         dbg("minor %d", dev->minor);
  732.         if ((urb->status != -ENOENT) && 
  733.             (urb->status != -ECONNRESET)) {
  734.                 dbg("write bulk status received: %d", urb->status);
  735.         }
  737. wake_up(&dev->write_q);
  739.         return;
  740. }
  743. /*
  744.  * voipblaster_write
  745.  */
  746.  static u_char G723count[4] = { 24, 20, 4, 1};
  748. static ssize_t voipblaster_write (struct file *file, const char *buffer, size_t count, loff_t *ppos)
  749. {
  750. struct usb_voipblaster *dev;
  751. ssize_t bytes_written = 0;
  752. int retval = 0;
  754. dev = (struct usb_voipblaster *)file->private_data;
  756. dbg("minor %d, count = %d", dev->minor, count);
  758. /* lock this object */
  759. down (&dev->sem);
  761. /* verify that the device wasn't unplugged */
  762. if (dev->udev == NULL) {
  763. retval = -ENODEV;
  764. goto exit;
  765. }
  767. /* verify that we actually have some data to write */
  768. if (count < 4) {
  769. dbg("write request of too few bytes");
  770. goto exit;
  771. }
  773. /* see if we are already in the middle of a write */
  774. if (dev->write_urb->status == -EINPROGRESS) {
  775. dbg ("already writing");
  776. goto exit;
  777. }
  778.         /* the least significant two bits of the start of the frame
  779.            tell us how big the frame really is */
  780. bytes_written = G723count[(*(u_char *)buffer)&3];
  782. /* we can only write as much as 1 urb will hold */
  783. bytes_written = (bytes_written > VB_W_BUFF_LENGTH) ? 
  784. VB_W_BUFF_LENGTH : bytes_written;
  786. if (count < bytes_written) {
  787. dbg("write request of too few bytes %d vs %d",count,bytes_written);
  788. goto exit;
  789. }
  791. /* copy the data from userspace into our urb */
  792. if (copy_from_user(dev->write_urb->transfer_buffer, buffer, 
  793.    bytes_written)) {
  794. retval = -EFAULT;
  795. goto exit;
  796. }
  798. #if 0
  799. usb_skel_debug_data (__FUNCTION__, bytes_written, 
  800.      dev->write_urb->transfer_buffer);
  801. #endif
  803. /* set up our urb */
  804. FILL_BULK_URB(dev->write_urb, dev->udev, 
  805.       usb_sndbulkpipe(dev->udev, 0x02 ),
  806.       dev->write_buffer, bytes_written,
  807.       voipblaster_write_callback, dev);
  809. /* send the data out the bulk port */
  810. if (usb_submit_urb(dev->write_urb) != 0) {
  811. err("failed submitting write urb, error %d",
  812.     dev->write_urb->status);
  813. } else { /*return full frame size or max buffer size */
  814. retval = (count > VB_W_BUFF_LENGTH) ? 
  815.                                 VB_W_BUFF_LENGTH : count;
  816. }
  818. interruptible_sleep_on(&dev->write_q);
  819. exit:
  821. /* unlock the device */
  822. up (&dev->sem);
  824. return retval;
  825. }
  827. static void voipblaster_ring_start(struct usb_voipblaster *dev)
  828. {
  829. voipblaster_cmd(dev,VB_CMD_RING_ON);
  830. voipblaster_event_poll(dev, 10000);
  831. }
  833. static void voipblaster_ring_stop(struct usb_voipblaster *dev)
  834. {
  835. voipblaster_cmd(dev,VB_CMD_RING_OFF);
  836. voipblaster_event_poll(dev, 10000);
  837. }
  839. static void voipblaster_record_start(struct usb_voipblaster *dev)
  840. {
  841. voipblaster_cmd(dev,VB_CMD_VINP_START);
  842. // voipblaster_event_poll(dev, 10000);
  843. }
  845. static void voipblaster_record_stop(struct usb_voipblaster *dev)
  846. {
  847. voipblaster_cmd(dev,VB_CMD_VINP_STOP);
  848. // voipblaster_event_poll(dev, 10000);
  849. }
  851. static void voipblaster_play_start(struct usb_voipblaster *dev)
  852. {
  853. voipblaster_cmd(dev,VB_CMD_VOUT_START);
  854. voipblaster_cmd(dev,VB_CMD_0x10);
  855. voipblaster_cmd(dev,VB_CMD_0x11);
  856. // voipblaster_event_poll(dev, 10000);
  857. }
  859. static void voipblaster_play_stop(struct usb_voipblaster *dev)
  860. {
  861. voipblaster_cmd(dev,VB_CMD_VOUT_DONE);
  862. voipblaster_event_poll(dev, 10000);
  863. }
  865. static unsigned int voipblaster_poll(struct file *file, poll_table * wait)
  866. {
  867. unsigned int mask = 0;
  869. struct usb_voipblaster *dev;
  871. dev = (struct usb_voipblaster *) file->private_data;
  873. dbg("minor = %d, read_buffer_in = %d, write_buffer_in = %d", dev->minor,
  874.     dev->read_buffer_in, dev->write_buffer_in);
  876. poll_wait(file, &(dev->poll_q), wait);
  877. poll_wait(file, &(dev->read_q), wait);
  879. dbg("poll wakeup");
  881. if (dev->read_buffer_in > 0) {
  882. dbg("read_buffer_in = %d", dev->read_buffer_in);
  883. mask |= POLLIN | POLLRDNORM; /* readable */
  884. }
  886. #if 0
  887. if (dev->write_buffer_in > 0) {
  888. mask |= POLLOUT | POLLWRNORM; /* writable */
  889. }
  890. #endif
  891. mask |= POLLOUT | POLLWRNORM; /* writable */
  893. if (dev->ex.bytes) {
  894. dbg("ex.bytes = %d", dev->ex.bytes);
  895. mask |= POLLPRI;
  896. }
  898. dbg("mask = 0x%04x", mask);
  900. return mask;
  901. }
  903. static int voipblaster_fasync(int fd, struct file *file, int mode)
  904. {
  905. struct usb_voipblaster *dev;
  907. dev = (struct usb_voipblaster *) file->private_data;
  908. dbg("minor = %d", dev->minor);
  910. return fasync_helper(fd, file, mode, &dev->async_queue);
  911. }
  913. /*
  914.  * voipblaster_ioctl
  915.  */
  916. static int voipblaster_ioctl(struct inode *inode, struct file *file, 
  917.      unsigned int cmd, unsigned long arg)
  918. {
  919. struct usb_voipblaster *dev;
  920. int retval = -ENOTTY;
  921. int raise, mant;
  922. #if 0
  923. int c;
  924. #endif
  926. dev = (struct usb_voipblaster *)file->private_data;
  928. /* lock this object */
  929. down (&dev->sem);
  931. /* verify that the device wasn't unplugged */
  932. if (dev->udev == NULL) {
  933. up (&dev->sem);
  934. return -ENODEV;
  935. }
  937. dbg("dev %d, minor %d, cmd 0x%.4x, arg 0x%.8lx", 
  938.     dev->udev->devnum, dev->minor, cmd, arg);
  941. /* fill in your device specific stuff here */
  942. if (!capable(CAP_SYS_ADMIN)) {
  943. switch (cmd) {
  944. case IXJCTL_TESTRAM:
  945. case IXJCTL_HZ:
  946. retval = -EPERM;
  947. }
  948. }
  949. switch (cmd) {
  950. case IXJCTL_TESTRAM:
  951. dbg("IXJCTL_TESTRAM");
  952. retval = 0;
  953. break;
  954. case IXJCTL_CARDTYPE:
  955. dbg("IXJCTL_CARDTYPE");
  956. retval = dev->cardtype;
  957. break;
  958. case IXJCTL_SERIAL:
  959. dbg("IXJCTL_SERIAL");
  960. retval = dev->serial;
  961. break;
  962. case IXJCTL_VERSION:
  963. dbg("IXJCTL_VERSION");
  964. if (copy_to_user((char *) arg, VOIPversion, strlen(VOIPversion)))
  965. retval = -EFAULT;
  966. break;
  967. case PHONE_RING_CADENCE:
  968. dbg("PHONE_RING_CADENCE");
  969. retval = -EPERM;
  970. break;
  971. case IXJCTL_CIDCW:
  972. dbg("IXJCTL_CIDCW");
  973. retval = -EPERM;
  974. break;
  975.         /* Binary compatbility */
  976.         case OLD_PHONE_RING_START:
  977. dbg("OLD_PHONE_RING_START");
  978.                 arg = 0;
  979.                 /* Fall through */
  980.   case PHONE_RING_START:
  981. dbg("PHONE_RING_START");
  982. memset(&dev->cid_send, 0, sizeof(PHONE_CID));
  983. voipblaster_ring_start(dev);
  984. retval = 0;
  985. break;
  986. case PHONE_RING_STOP:
  987. dbg("PHONE_RING_STOP");
  988. dev->flags.cringing = 0;
  989. if (dev->cadence_f[5].enable) {
  990. dev->cadence_f[5].state = 0;
  991. }
  992. voipblaster_ring_stop(dev);
  993. retval = 0;
  994. break;
  995. case PHONE_RING:
  996. dbg("PHONE_RING, maxrings = %d", dev->maxrings);
  997. if (dev->maxrings == 0) {
  998. dbg("setting maxrings = 2");
  999. dev->maxrings = 2;
  1000. }
  1001. dev->ringcnt = 0;
  1002. retval = 0;
  1003. while (dev->ringcnt < dev->maxrings) {
  1004. voipblaster_ring_start(dev);
  1005. voipblaster_event_poll(dev, 10000);
  1006. dbg("poll returned; ringcnt = %d, hookstate = %d", 
  1007.     dev->ringcnt, dev->hookstate);
  1008. if (dev->hookstate == 1) {
  1009. dbg("phone answered, stop ringing");
  1010. retval = 1;
  1011. break;
  1012. }
  1014. dev->ringcnt++;
  1015. }
  1017. dbg("ringcnt = %d, maxrings = %d", dev->ringcnt, dev->maxrings);
  1018. if (!dev->hookstate) {
  1019. voipblaster_ring_stop(dev);
  1020. }
  1021. break;
  1022. case PHONE_EXCEPTION:
  1023. dbg("PHONE_EXCEPTION");
  1024. retval = dev->ex.bytes;
  1025. #if 0
  1026. if(dev->ex.bits.flash) {
  1027. dev->flash_end = 0;
  1028. dev->ex.bits.flash = 0;
  1029. }
  1030. #endif
  1031. dev->ex.bits.pstn_ring = 0;
  1032. dev->ex.bits.caller_id = 0;
  1033. dev->ex.bits.pstn_wink = 0;
  1034. dev->ex.bits.f0 = 0;
  1035. dev->ex.bits.f1 = 0;
  1036. dev->ex.bits.f2 = 0;
  1037. dev->ex.bits.f3 = 0;
  1038. dev->ex.bits.fc0 = 0;
  1039. dev->ex.bits.fc1 = 0;
  1040. dev->ex.bits.fc2 = 0;
  1041. dev->ex.bits.fc3 = 0;
  1042. dev->ex.bits.reserved = 0;
  1043. break;
  1044. case PHONE_HOOKSTATE:
  1045. dbg("PHONE_HOOKSTATE");
  1046. dev->ex.bits.hookstate = 0;
  1047. retval = dev->hookstate;
  1048. break;
  1049. case IXJCTL_SET_LED:
  1050. dbg("IXJCTL_SET_LED");
  1051. return 0;
  1052. break;
  1053. case PHONE_FRAME:
  1054. dbg("PHONE_FRAME");
  1055. if (arg == 30) {
  1056. retval = arg;
  1057. } else {
  1058. retval = -1;
  1059. }
  1060. break;
  1061. case PHONE_REC_CODEC:
  1062. dbg("PHONE_REC_CODEC");
  1063. switch (arg) {
  1064. case G723_53:
  1065. dbg("G723_53");
  1066. dev->rec_codec = arg;
  1067. retval = 0;
  1068. break;
  1069. #if defined(ENABLE_G723_63)
  1070. case G723_63:
  1071. dbg("G723_63");
  1072. dev->rec_codec = arg;
  1073. retval = 0;
  1074. break;
  1075. #endif
  1076. default:
  1077. dbg("default; %ld not supported.", arg);
  1078. retval = 1;
  1079. break;
  1080. }
  1081. break;
  1082. case PHONE_VAD:
  1083. dbg("PHONE_VAD");
  1084. #if 0
  1085. blaster_vad(dev, arg);
  1086. #endif
  1087. break;
  1088. case PHONE_REC_START:
  1089. dbg("PHONE_REC_START");
  1090. voipblaster_record_start(dev);
  1091. retval = 0;
  1092. break;
  1093. case PHONE_REC_STOP:
  1094. dbg("PHONE_REC_STOP");
  1095. voipblaster_record_stop(dev);
  1096. retval = 0;
  1097. break;
  1098. case PHONE_REC_DEPTH:
  1099. dbg("PHONE_REC_DEPTH");
  1100. #if 0
  1101. set_rec_depth(dev, arg);
  1102. #endif
  1103. retval = 1;
  1104. break;
  1105. case PHONE_REC_VOLUME:
  1106. dbg("PHONE_REC_VOLUME");
  1107. #if 0
  1108. if(arg == -1) {
  1109. retval = get_rec_volume(dev);
  1110. }
  1111. else {
  1112. set_rec_volume(dev, arg);
  1113. retval = arg;
  1114. }
  1115. #endif
  1116. break;
  1117. case PHONE_REC_VOLUME_LINEAR:
  1118. dbg("PHONE_REC_VOLUME_LINEAR");
  1119. #if 0
  1120. if(arg == -1) {
  1121. retval = get_rec_volume_linear(dev);
  1122. }
  1123. else {
  1124. set_rec_volume_linear(dev, arg);
  1125. retval = arg;
  1126. }
  1127. #endif
  1128. break;
  1129. case IXJCTL_DTMF_PRESCALE:
  1130. dbg("IXJCTL_DTMF_PRESCALE");
  1131. #if 0
  1132. if(arg == -1) {
  1133. retval = get_dtmf_prescale(dev);
  1134. }
  1135. else {
  1136. set_dtmf_prescale(dev, arg);
  1137. retval = arg;
  1138. }
  1139. #endif
  1140. break;
  1141. case PHONE_REC_LEVEL:
  1142. dbg("PHONE_REC_LEVEL");
  1143. #if 0
  1144. retval = get_rec_level(dev);
  1145. #endif
  1146. break;
  1147. case IXJCTL_SC_RXG:
  1148. dbg("IXJCTL_SC_RXG");
  1149. #if 0
  1150. retval = VOIPblaster_siadc(dev, arg);
  1151. #endif
  1152. break;
  1153. case IXJCTL_SC_TXG:
  1154. dbg("IXJCTL_SC_TXG");
  1155. #if 0
  1156. retval = VOIPblaster_sidac(dev, arg);
  1157. #endif
  1158. break;
  1159. case IXJCTL_AEC_START:
  1160. dbg("IXJCTL_AEC_START");
  1161. retval = -EPERM;
  1162. break;
  1163. case IXJCTL_AEC_STOP:
  1164. dbg("IXJCTL_AEC_STOP");
  1165. retval = -EPERM;
  1166. break;
  1167. case IXJCTL_AEC_GET_LEVEL:
  1168. dbg("IXJCTL_AEC_GET_LEVEL");
  1169. retval = AEC_OFF;
  1170. break;
  1171. case PHONE_PLAY_CODEC:
  1172. dbg("PHONE_PLAY_CODEC");
  1173. #if 0
  1174. retval = set_play_codec(dev, arg);
  1175. #endif
  1176. retval = 0;
  1177. break;
  1178. case PHONE_PLAY_START:
  1179. dbg("PHONE_PLAY_START");
  1180. voipblaster_play_start(dev);
  1181. dev->drybuffer = 0;
  1182. retval = 0;
  1183. break;
  1184. case PHONE_PLAY_STOP:
  1185. dbg("PHONE_PLAY_STOP");
  1186. voipblaster_play_stop(dev);
  1187. retval = 0;
  1188. break;
  1189. case PHONE_PLAY_DEPTH:
  1190. dbg("PHONE_PLAY_DEPTH");
  1191. #if 0
  1192. set_play_depth(dev, arg);
  1193. #endif
  1194. break;
  1195. case PHONE_PLAY_VOLUME:
  1196. dbg("PHONE_PLAY_VOLUME");
  1197. #if 0
  1198. if (arg == -1) {
  1199. retval = get_play_volume(dev);
  1200. } else {
  1201. set_play_volume(dev, arg);
  1202. retval = arg;
  1203. }
  1204. #endif
  1205. break;
  1206. case PHONE_PLAY_VOLUME_LINEAR:
  1207. dbg("PHONE_PLAY_VOLUME_LINEAR");
  1208. #if 0
  1209. if (arg == -1) {
  1210. retval = get_play_volume_linear(dev);
  1211. } else {
  1212. set_play_volume_linear(dev, arg);
  1213. retval = arg;
  1214. }
  1215. #endif
  1216. break;
  1217. case PHONE_PLAY_LEVEL:
  1218. dbg("PHONE_PLAY_LEVEL");
  1219. #if 0
  1220. retval = get_play_level(dev);
  1221. #endif
  1222. retval = 0;
  1223. break;
  1224. case IXJCTL_DSP_TYPE:
  1225. dbg("dsp_serial[5] = 0x%02x, dsp_serial[8] = 0x%02x", 
  1226.     dev->dsp_version[5], dev->dsp_version[8]);
  1227. retval = ((dev->dsp_version[5] << 8) | (dev->dsp_version[8] & 0xff)) & 0xffff;
  1228. break;
  1229. case IXJCTL_DSP_VERSION:
  1230. dbg("dsp_serial[1] = 0x%02x, dsp_serial[2] = 0x%02x", 
  1231.     dev->dsp_version[1], dev->dsp_version[2]);
  1232. retval = ((dev->dsp_version[1] << 8) | (dev->dsp_version[2] & 0xff)) & 0xffff;
  1233. break;
  1234. case IXJCTL_HZ:
  1235. dbg("IXJCTL_HZ");
  1236. hertz = arg;
  1237. retval = 0;
  1238. break;
  1239. case IXJCTL_RATE:
  1240. dbg("IXJCTL_RATE");
  1241. retval = -EPERM;
  1242. break;
  1243. case IXJCTL_DRYBUFFER_READ:
  1244. dbg("IXJCTL_DRYBUFFER_READ");
  1245. put_user(dev->drybuffer, (unsigned long *) arg);
  1246. retval = 0;
  1247. break;
  1248. case IXJCTL_DRYBUFFER_CLEAR:
  1249. dbg("IXJCTL_DRYBUFFER_CLEAR");
  1250. dev->drybuffer = 0;
  1251. retval = 0;
  1252. break;
  1253. case IXJCTL_FRAMES_READ:
  1254. dbg("IXJCTL_FRAMES_READ");
  1255. put_user(dev->framesread, (unsigned long *) arg);
  1256. retval = 0;
  1257. break;
  1258. case IXJCTL_FRAMES_WRITTEN:
  1259. dbg("IXJCTL_FRAMES_WRITTEN");
  1260. put_user(dev->frameswritten, (unsigned long *) arg);
  1261. retval = 0;
  1262. break;
  1263. case IXJCTL_READ_WAIT:
  1264. dbg("IXJCTL_READ_WAIT");
  1265. put_user(dev->read_wait, (unsigned long *) arg);
  1266. retval = 0;
  1267. break;
  1268. case IXJCTL_WRITE_WAIT:
  1269. dbg("IXJCTL_WRITE_WAIT");
  1270. put_user(dev->write_wait, (unsigned long *) arg);
  1271. retval = 0;
  1272. break;
  1273. case PHONE_MAXRINGS:
  1274. dbg("IXJCTL_MAXRINGS");
  1275. dev->maxrings = arg;
  1276. break;
  1277. case PHONE_SET_TONE_ON_TIME:
  1278. dbg("PHONE_SET_TONE_ON_TIME");
  1279. retval = -EPERM;
  1280. break;
  1281. case PHONE_SET_TONE_OFF_TIME:
  1282. dbg("PHONE_SET_TONE_OFF_TIME");
  1283. retval = -EPERM;
  1284. break;
  1285. case PHONE_GET_TONE_ON_TIME:
  1286. dbg("PHONE_GET_TONE_ON_TIME");
  1287. retval = -EPERM;
  1288. break;
  1289. case PHONE_GET_TONE_OFF_TIME:
  1290. dbg("PHONE_GET_TONE_OFF_TIME");
  1291. retval = -EPERM;
  1292. break;
  1293. case PHONE_PLAY_TONE:
  1294. dbg("PHONE_PLAY_TONE");
  1295. retval = -EPERM;
  1296. break;
  1297. case PHONE_GET_TONE_STATE:
  1298. dbg("PHONE_GET_TONE_STATE");
  1299. retval = dev->tonestate;
  1300. break;
  1301. case PHONE_DTMF_READY:
  1302. dbg("PHONE_DTMF_READY, %d", dev->ex.bits.dtmf_ready);
  1303. retval = dev->ex.bits.dtmf_ready;
  1304. break;
  1305. case PHONE_GET_DTMF:
  1306. dbg("PHONE_GET_DTMF");
  1307. dbg("hookstate = %d, len = %d, out = %d, in = %d, retval = %d", 
  1308.     dev->hookstate, dev->dtmf_buffer_len, dev->dtmf_buffer_out,
  1309.     dev->dtmf_buffer_in, dev->dtmf_buffer[dev->dtmf_buffer_out]);
  1310. if (dev->hookstate) {
  1311. if (dev->dtmf_buffer_len > 0) {
  1312. retval = dev->dtmf_buffer[dev->dtmf_buffer_out];
  1313. dev->dtmf_buffer_out++;
  1314. dev->dtmf_buffer_len--;
  1315. if (dev->dtmf_buffer_out == VB_DTMF_BUFF_LENGTH)
  1316. dev->dtmf_buffer_out = 0;
  1317. if (dev->dtmf_buffer_len == 0) {
  1318. dev->ex.bits.dtmf_ready = 0;
  1319. dev->dtmf_buffer_out = 0;
  1320. dev->dtmf_buffer_in = 0;
  1321. }
  1322. }
  1323. }
  1324. break;
  1325. case PHONE_GET_DTMF_ASCII:
  1326. dbg("PHONE_GET_DTMF_ASCII");
  1327. if (dev->hookstate) {
  1328. if (dev->dtmf_buffer_len > 0) {
  1329. switch (dev->dtmf_buffer[dev->dtmf_buffer_out]) {
  1330. case 10:
  1331. dbg("10");
  1332. retval = 42; /* '*'; */
  1333. break;
  1334. case 11:
  1335. dbg("11");
  1336. retval = 48; /*'0'; */
  1337. break;
  1338. case 12:
  1339. dbg("12");
  1340. retval = 35; /*'#'; */
  1341. break;
  1342. case 28:
  1343. dbg("28");
  1344. retval = 65; /*'A'; */
  1345. break;
  1346. case 29:
  1347. dbg("29");
  1348. retval = 66; /*'B'; */
  1349. break;
  1350. case 30:
  1351. dbg("30");
  1352. retval = 67; /*'C'; */
  1353. break;
  1354. case 31:
  1355. dbg("31");
  1356. retval = 68; /*'D'; */
  1357. break;
  1358. default:
  1359. dbg("default");
  1360. retval = 48 + dev->dtmf_buffer[dev->dtmf_buffer_out];
  1361. break;
  1362. }
  1363. dev->dtmf_buffer_out++;
  1364. dev->dtmf_buffer_len--;
  1365. if (dev->dtmf_buffer_out == VB_DTMF_BUFF_LENGTH)
  1366. dev->dtmf_buffer_out = 0;
  1367. if (dev->dtmf_buffer_len == 0) {
  1368. dev->ex.bits.dtmf_ready = 0;
  1369. dev->dtmf_buffer_out = 0;
  1370. dev->dtmf_buffer_in = 0;
  1371. }
  1372. }
  1373. }
  1374. break;
  1375. case PHONE_DTMF_OOB:
  1376. dbg("PHONE_DTMF_OOB");
  1377. dev->flags.dtmf_oob = arg;
  1378. break;
  1379. case PHONE_DIALTONE:
  1380. dbg("PHONE_DIALTONE");
  1381. #if 0
  1382. blaster_dialtone(dev);
  1383. #endif
  1384. break;
  1385. case PHONE_BUSY:
  1386. dbg("PHONE_BUSY");
  1387. #if 0
  1388. blaster_busytone(dev);
  1389. #endif
  1390. break;
  1391. case PHONE_RINGBACK:
  1392. dbg("PHONE_RINGBACK");
  1393. #if 0
  1394. blaster_ringback(dev);
  1395. #endif
  1396. break;
  1397. case PHONE_WINK:
  1398. dbg("PHONE_WINK");
  1399. retval = -EPERM;
  1400. break;
  1401. case PHONE_CPT_STOP:
  1402. dbg("PHONE_CPT_STOP");
  1403. #if 0
  1404. blaster_cpt_stop(dev);
  1405. retval = -EPERM;
  1406. #endif
  1407. retval = 0;
  1408. break;
  1409.         case PHONE_QUERY_CODEC:
  1410.         {
  1411.                 struct phone_codec_data pd;
  1412.                 int val;
  1413.                 int proto_size[] = {
  1414.                         -1,
  1415.                         12, 10, 16, 9, 8, 48, 5,
  1416.                         40, 40, 80, 40, 40, 6
  1417.                 };
  1419. dbg("PHONE_QUERY_CODEC");
  1421.                 if (copy_from_user(&pd, (void *)arg, sizeof(pd))) {
  1422.                         retval = -EFAULT;
  1423. break;
  1424. }
  1425. #if defined(ENABLE_G723_63)
  1426.                 if (pd.type <1 || pd.type>2) {
  1427.                         retval = -EPROTONOSUPPORT;
  1428. break;
  1429. }
  1430. #else
  1431. if (pd.type != 2) {
  1432. retval = -EPROTONOSUPPORT;
  1433. break;
  1434. }
  1435. #endif
  1436. val=proto_size[pd.type];
  1437.                 pd.buf_min=pd.buf_max=pd.buf_opt=val;
  1438. dbg("type = 0x%02x", pd.type);
  1440.                 if (copy_to_user((void *)arg, &pd, sizeof(pd)))
  1441.                         retval = -EFAULT;
  1442. retval = 0;
  1443.          break;
  1444.         }
  1445. case IXJCTL_DSP_IDLE:
  1446. dbg("IXJCTL_DSP_IDLE");
  1447. retval = 0;
  1448. break;
  1449. case IXJCTL_MIXER:
  1450. dbg("IXJCTL_MIXER");
  1451. retval = -EPERM;
  1452. break;
  1453. case IXJCTL_DAA_COEFF_SET:
  1454. dbg("IXJCTL_DAA_COEFF_SET");
  1455. switch (arg) {
  1456. case DAA_US:
  1457. dbg("DAA_US");
  1458. dev->daa_country = DAA_US;
  1459. retval = 1;
  1460. break;
  1461. case DAA_UK:
  1462. dbg("DAA_UK");
  1463. retval = 0;
  1464. break;
  1465. case DAA_FRANCE:
  1466. dbg("DAA_FRANCE");
  1467. retval = 0;
  1468. break;
  1469. case DAA_GERMANY:
  1470. dbg("DAA_GERMANY");
  1471. retval = 0;
  1472. break;
  1473. case DAA_AUSTRALIA:
  1474. dbg("DAA_AUSTRALIA");
  1475. retval = 0;
  1476. break;
  1477. case DAA_JAPAN:
  1478. dbg("DAA_JAPAN");
  1479. retval = 0;
  1480. break;
  1481. default:
  1482. retval = 0;
  1483. break;
  1484. }
  1485. break;
  1486. case IXJCTL_DAA_AGAIN:
  1487. dbg("IXJCTL_DAA_AGAIN");
  1488. retval = -EPERM;
  1489. break;
  1490. case IXJCTL_PSTN_LINETEST:
  1491. dbg("IXJCTL_PSTN_LINETEST");
  1492. retval = -EPERM;
  1493. break;
  1494. case IXJCTL_VMWI:
  1495. dbg("IXJCTL_VMWI");
  1496. retval = -EPERM;
  1497. break;
  1498. case IXJCTL_CID:
  1499. dbg("IXJCTL_CID");
  1500. if (copy_to_user((char *) arg, &dev->cid, sizeof(PHONE_CID))) 
  1501. retval = -EFAULT;
  1502. dev->ex.bits.caller_id = 0;
  1503. retval = -EPERM;
  1504. break;
  1505. case IXJCTL_WINK_DURATION:
  1506. dbg("IXJCTL_WINK_DURATION");
  1507. dev->winktime = arg;
  1508. retval = -EPERM;
  1509. break;
  1510. case IXJCTL_PORT:
  1511. dbg("IXJCTL_PORT");
  1512. /* VOIP Blaster have only one port to be used (Telephone) */
  1513. if ((arg == PORT_POTS) || (arg == PORT_HANDSET)) {
  1514. dev->port = PORT_POTS;
  1515. retval = 0;
  1516. } else if (arg == PORT_QUERY) {
  1517. retval = dev->port;
  1518. } else {
  1519. retval = -EPERM;
  1520. }
  1521. break;
  1522. case IXJCTL_POTS_PSTN:
  1523. dbg("IXJCTL_POTS_PSTN");
  1524. #if 0
  1525. retval = voipblaster_set_pots(dev, arg);
  1526. #endif
  1527. break;
  1528. case PHONE_CAPABILITIES:
  1529. dbg("PHONE_CAPABILITIES");
  1530. add_caps(dev);
  1531. retval = dev->caps;
  1532. break;
  1533. case PHONE_CAPABILITIES_LIST:
  1534. dbg("PHONE_CAPABILITIES_LIST");
  1535. add_caps(dev);
  1536. if (copy_to_user((char *) arg, dev->caplist, 
  1537.  sizeof(struct phone_capability) * dev->caps)) 
  1538. retval = -EFAULT;
  1539. retval = 0;
  1540. break;
  1541. case PHONE_CAPABILITIES_CHECK:
  1542. dbg("PHONE_CAPABILITIES_CHECK");
  1543. {
  1544. struct phone_capability cap;
  1545. if (copy_from_user(&cap, (char *) arg, sizeof(cap))) 
  1546. retval = -EFAULT;
  1547. else {
  1548. add_caps(dev);
  1549. retval = capabilities_check(dev, &cap);
  1550. }
  1551. }
  1552. break;
  1553. case PHONE_PSTN_SET_STATE:
  1554. dbg("PHONE_PSTN_SET_STATE");
  1555. #if 0
  1556. daa_set_mode(dev, arg);
  1557. #endif
  1558. retval = 0;
  1559. break;
  1560. case PHONE_PSTN_GET_STATE:
  1561. dbg("PHONE_PSTN_GET_STATE");
  1562. #if 0
  1563. retval = dev->daa_mode;
  1564. #endif
  1565. dev->ex.bits.pstn_ring = 0;
  1566. retval = 0;
  1567. break;
  1568. case IXJCTL_SET_FILTER:
  1569. dbg("IXJCTL_SET_FILTER");
  1570. retval = -EPERM;
  1571. break;
  1572. case IXJCTL_SET_FILTER_RAW:
  1573. dbg("IXJCTL_SET_FILTER_RAW");
  1574. retval = -EPERM;
  1575. break;
  1576. case IXJCTL_GET_FILTER_HIST:
  1577. dbg("IXJCTL_GET_FILTER_HIST");
  1578. retval = -EINVAL;
  1579. break;
  1580. case IXJCTL_INIT_TONE:
  1581. dbg("IXJCTL_INIT_TONE");
  1582. retval = -EPERM;
  1583. break;
  1584. case IXJCTL_TONE_CADENCE:
  1585. dbg("IXJCTL_TONE_CADENCE");
  1586. retval = -EPERM;
  1587. break;
  1588. case IXJCTL_FILTER_CADENCE:
  1589. dbg("IXJCTL_FILTER_CADENCE");
  1590. retval = -EPERM;
  1591. break;
  1592. case IXJCTL_SIGCTL:
  1593. dbg("IXJCTL_SIGCTL");
  1594. if (copy_from_user(&dev->sigdef, (char *)arg, sizeof(IXJ_SIGDEF)))
  1595. retval = -EFAULT;
  1596. dbg("sigdef.event = %d, signal = %d", dev->sigdef.event, dev->sigdef.signal);
  1597. dev->signals[dev->sigdef.event] = dev->sigdef.signal;
  1598. if(dev->sigdef.event < 33) {
  1599. raise = 1;
  1600. for(mant = 0; mant < dev->sigdef.event; mant++){
  1601. raise *= 2;
  1602. }
  1603. if(dev->sigdef.signal)
  1604. dev->ex_sig.bytes |= raise; 
  1605. else
  1606. dev->ex_sig.bytes &= (raise^0xffff); 
  1607. }
  1608. retval = 0;;
  1609. break;
  1610. case IXJCTL_INTERCOM_STOP:
  1611. dbg("IXJCTL_INTERCOM_STOP");
  1612. #if 0
  1613. if(arg < 0 || arg >= IXJMAX)
  1614. return -EINVAL;
  1615. dev->intercom = -1;
  1616. blaster_record_stop(dev);
  1617. blaster_play_stop(dev);
  1618. idle(dev);
  1619. get_ixj(arg)->intercom = -1;
  1620. blaster_record_stop(get_ixj(arg));
  1621. blaster_play_stop(get_ixj(arg));
  1622. idle(get_ixj(arg));
  1623. #endif
  1624. break;
  1625. case IXJCTL_INTERCOM_START:
  1626. dbg("IXJCTL_INTERCOM_START");
  1627. #if 0
  1628. if(arg < 0 || arg >= IXJMAX)
  1629. return -EINVAL;
  1630. dev->intercom = arg;
  1631. blaster_record_start(dev);
  1632. blaster_play_start(dev);
  1633. get_ixj(arg)->intercom = board;
  1634. blaster_play_start(get_ixj(arg));
  1635. blaster_record_start(get_ixj(arg));
  1636. #endif
  1637. break;
  1638. }
  1640. dbg("phone%d ioctl end, cmd: 0x%x, arg: 0x%lx, retval: 0x%.8x", 
  1641.     dev->minor, cmd, arg, retval);
  1643. /* unlock the device */
  1644. up (&dev->sem);
  1646. /* return that we did not understand this ioctl call */
  1647. return retval;
  1648. }
  1650. static inline void voipblaster_delete (struct usb_voipblaster *dev)
  1651. {
  1652. int status;
  1654. dbg("deleting USB device %d", dev->udev->devnum);
  1656.         voipblaster_table[dev->board] = NULL;
  1658. /* Unlinking can be performed even if URB is not active */
  1659. if ((status = usb_unlink_urb(dev->cmd_urb)))
  1660. dbg("trouble unlinking Command URB on close: %d", status);
  1662. if ((status = usb_unlink_urb(dev->event_urb)))
  1663. dbg("trouble unlinking Event URB on close: %d", status);
  1665. /* Unlinking can be performed even if URB is not active */
  1666. status = usb_unlink_urb(dev->write_urb);
  1667. if (status > 0)
  1668. dbg("trouble unlinking write URB on close; status = %d", status);
  1670. /* Unlinking can be performed even if URB is not active */
  1671. status = usb_unlink_urb(dev->read_urb);
  1672. if (status != 0)
  1673. dbg("trouble unlinking read URB on close; status = %d", status);
  1675. if (dev->cq.buffer != NULL) {
  1676. dbg("freeing cq buffer");
  1677. kfree (dev->cq.buffer);
  1678. }
  1679. if (dev->rq.buffer != NULL) {
  1680. dbg("freeing rq buffer");
  1681. kfree (dev->rq.buffer);
  1682. }
  1683. if (dev->wq.buffer != NULL) {
  1684. dbg("freeing wq buffer");
  1685. kfree (dev->wq.buffer);
  1686. }
  1687. if (dev->eq.buffer != NULL) {
  1688. dbg("freeing eq buffer");
  1689. kfree (dev->eq.buffer);
  1690. }
  1692. if (dev->event_urb != NULL) {
  1693. dbg("freeing event_urb");
  1694. usb_free_urb(dev->event_urb);
  1695. }
  1696. if (dev->cmd_urb != NULL) {
  1697. dbg("freeing cmd_urb");
  1698. usb_free_urb(dev->cmd_urb);
  1699. }
  1700. if (dev->read_urb != NULL) {
  1701. dbg("freeing read_urb");
  1702. usb_free_urb(dev->read_urb);
  1703. }
  1704. if (dev->write_urb != NULL) {
  1705. dbg("freeing write_urb");
  1706. usb_free_urb(dev->write_urb);
  1707. }
  1709. kfree (dev);
  1710. }
  1712. static inline void voipblaster_flush (struct usb_voipblaster *dev)
  1713. {
  1715. dbg("flushing USB device %d", dev->udev->devnum);
  1716. dev->dtmf_buffer_in = dev->dtmf_buffer_out = dev->dtmf_buffer_len = 0;
  1717. dev->ex.bits.dtmf_ready = 0;
  1718. dev->event_buffer_in = dev->event_buffer_out = dev->event_buffer_len = 0;
  1719. dev->read_buffer_in = 0;
  1721. }
  1723. static int voipblaster_release(struct inode *inode, struct file *file)
  1724. {
  1725. struct usb_voipblaster *dev;
  1726. int retval = 0;
  1728. dev = (struct usb_voipblaster *)file->private_data;
  1731. if (dev == NULL) {
  1732. dbg ("object is NULL");
  1733. return -ENODEV;
  1734. }
  1736. dbg("VOIP blaster device %d, minor %d,  (USB dev %d) closed", dev->board, 
  1737.     dev->minor, dev->udev->devnum);
  1739. /* lock our minor table */
  1740. down (&voipblaster_table_mutex);
  1742. /* lock our device */
  1743. down (&dev->sem);
  1745. if (dev->open_count <= 0) {
  1746. dbg ("minordevice not opened");
  1747. retval = -ENODEV;
  1748. goto exit_not_opened;
  1749. }
  1751. #if 0
  1752. voipblaster_fasync(-1, file, 0);
  1753. #endif
  1755. if (dev->udev == NULL) {
  1756. /* the device was unplugged before the file was released */
  1757. up (&dev->sem);
  1758. voipblaster_delete(dev);
  1759. // MOD_DEC_USE_COUNT;
  1760. up (&voipblaster_table_mutex);
  1761. return 0;
  1762. }
  1764. /* decrement our usage count for the device */
  1765. --dev->open_count;
  1767. // MOD_DEC_USE_COUNT;
  1769. dbg("VoIP Blaster closed");
  1772. exit_not_opened:
  1773. up (&dev->sem);
  1774. up (&voipblaster_table_mutex);
  1776. return retval;
  1777. }
  1779. int voipblaster_open(struct phone_device *phone, struct file *file)
  1780. {
  1781. struct usb_voipblaster *dev;
  1782. int retval = 0;
  1784. /* increment our usage count for the module */
  1785. // MOD_INC_USE_COUNT;
  1787. /* lock our minor table and get our local data for this minor */
  1788. down (&voipblaster_table_mutex);
  1790. dev = voipblaster_table[phone->board];
  1792. if (dev == NULL) {
  1793. err("No device passed found!");
  1794. up (&voipblaster_table_mutex);
  1795. // MOD_DEC_USE_COUNT;
  1796. return -ENODEV;
  1797. }
  1799. dbg("VOIP Blaster device %d (USB device %d) open...", phone->board, dev->udev->devnum);
  1801. /* unlock the minor table */
  1802. up (&voipblaster_table_mutex);
  1804. /* lock this device */
  1805. down (&dev->sem);
  1807. /* increment our usage count for the driver */
  1808. ++dev->open_count;
  1810. /* save our object in the file's private structure */
  1811. file->private_data = dev;
  1814. voipblaster_flush(dev);
  1816. dbg("dtmf = %d", dev->ex.bits.dtmf_ready);
  1818. #if 0
  1819. /* Send off an interupt urb to retrieve voice packets from the hardware */
  1820. dbg("Starting read URB");
  1821. if (usb_submit_urb(&dev->read_urb))
  1822. return -EIO;
  1823. #endif
  1825. /* unlock this device */
  1826. up (&dev->sem);
  1828. return retval;
  1830. }
  1832. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,3,0)
  1833. static void *voipblaster_probe(struct usb_device *udev, unsigned int ifnum
  1834.        ,const struct usb_device_id *id)
  1835. #else
  1836. static void *voipblaster_probe(struct usb_device *udev, unsigned int ifnum)
  1838. #endif
  1839. {
  1840. struct usb_voipblaster *dev;
  1842. int board;
  1843. int i;
  1844. int status;
  1846. dbg(__FUNCTION__);
  1848. /* allocate memory for our device state and intialize it */
  1849. dev = kmalloc (sizeof(struct usb_voipblaster), GFP_KERNEL);
  1850. if (dev == NULL) {
  1851. err ("Out of memory");
  1852. goto error;
  1853. }
  1855. down (&voipblaster_table_mutex);
  1857. for (board = 0; board < VOIP_MAX; ++board) {
  1858. if (voipblaster_table[board] == NULL)
  1859. break;
  1860. }
  1862. if (board >= VOIP_MAX) {
  1863. info ("Too many devices plugged in, can not handle this device.");
  1864. goto error;
  1865. }
  1867. dbg("allocated board %d", board);
  1869. voipblaster_table[board] = dev;
  1871. up (&voipblaster_table_mutex);
  1873. memset(dev, 0, sizeof(struct usb_voipblaster));
  1875. spin_lock_init(&dev->io_lock);
  1877. init_MUTEX (&dev->sem);
  1879. if (udev != NULL) {
  1880. dbg("udev->devnum = %d", udev->devnum);
  1881. } else {
  1882. dbg("udev is null!");
  1883. }
  1885. dev->udev = udev;
  1886. dev->interface = &udev->actconfig->interface[ifnum];
  1888. dev->board = board;
  1889. memcpy(dev->dsp_serial, "0", 1);
  1891. dbg("USB VoIP Blaster device %d", dev->udev->devnum);
  1893. dev->wq.buffer = kmalloc(256, GFP_KERNEL);
  1895. if (dev->wq.buffer == NULL) {
  1896. err("no memory for wq.buffer");
  1897. }
  1899. dev->wq.size = 256;
  1900. dev->rq.buffer = kmalloc(80, GFP_KERNEL);
  1902. if (dev->rq.buffer == NULL) {
  1903. err("no memory for rq.buffer");
  1904. }
  1906. dev->rq.size = 80;
  1908. init_waitqueue_head(&dev->cmd_q);
  1909. init_waitqueue_head(&dev->write_q);
  1910. init_waitqueue_head(&dev->read_q);
  1911. init_waitqueue_head(&dev->poll_q);
  1912. init_waitqueue_head(&dev->event_q);
  1914. dev->event_urb = usb_alloc_urb(0);
  1915. dev->cmd_urb = usb_alloc_urb(0);
  1916. dev->write_urb = usb_alloc_urb(0);
  1917. dev->read_urb = usb_alloc_urb(0);
  1919. /* Prepare the event urb... */
  1920. FILL_INT_URB(dev->event_urb, udev,
  1921. usb_rcvintpipe( udev, 0x81),
  1922. dev->event_data, 1,
  1923. voipblaster_event_irq, dev,
  1924. 30);
  1926. /* Prepare the read urb... */
  1927. FILL_BULK_URB(dev->read_urb, dev->udev,
  1928. usb_rcvbulkpipe(dev->udev,0x82),
  1929. dev->read_buffer_urb, 20,
  1930. voipblaster_read_irq, dev);
  1932. /* Send off an interupt urb to retrieve command events from the hardware */
  1933. dbg("Starting Event URB");
  1934. if ((status = usb_submit_urb(dev->event_urb)) != 0) {
  1935. dbg("error with event_urb, status = %d, %d", dev->event_urb->status, status);
  1936. }
  1938. dbg("Starting Read URB");
  1939. if (usb_submit_urb(dev->read_urb) != 0) {
  1940. dbg("error with read_urb, status = %d", dev->read_urb->status);
  1941. }
  1943. voipblaster_cmd(dev, VB_CMD_SETUP_MODE);
  1944. voipblaster_flush(dev);
  1946. voipblaster_snd_voice(dev, init_1, sizeof(init_1));
  1947. voipblaster_flush(dev);
  1949. voipblaster_snd_voice(dev, init_2, sizeof(init_2));
  1950. voipblaster_flush(dev);
  1952. voipblaster_event_poll(dev, 500);
  1954. dbg ("init done.");
  1955. dev->ringing = 1;
  1957. for (i = 0; i < 2; i++) {
  1958. int j = 10;
  1960. voipblaster_cmd(dev, VB_CMD_VOL_3);
  1961. voipblaster_cmd(dev, VB_CMD_RING_OFF);
  1962. voipblaster_cmd(dev, VB_CMD_PHONE_ON);
  1964. while (1) {
  1965. j--;
  1966. dbg("polling; j = %d, dev->ringing = %d", j, dev->ringing);
  1967. voipblaster_event_poll(dev, 100);
  1968. if (!dev->ringing) {
  1969. break;
  1970. }
  1971. if (j == 0) {
  1972. dbg ("exiting while loop..");
  1973. break;
  1974. }
  1975. }
  1976. if (!dev->ringing) {
  1977. break;
  1978. }
  1979. }
  1981. voipblaster_cmd(dev, VB_CMD_VOL_3);
  1982. voipblaster_cmd(dev, VB_CMD_MUTE_OFF);
  1984. dev->hookstate = 0;
  1985. dev->cardtype = CREATIVE_VOIPBLASTER;
  1986. dev->aec_level = AEC_OFF;
  1987. dev->play_codec = G723_53;
  1988. dev->rec_codec = G723_53;
  1989. dev->port = PORT_POTS;
  1991. snprintf(dev->serialnum, 18, "%02x:%02x:%02x:%02x:%02x:%02x",
  1992.  dev->dsp_serial[0] & 0xff, dev->dsp_serial[1] & 0xff,
  1993.  dev->dsp_serial[2] & 0xff, dev->dsp_serial[3] & 0xff,
  1994.  dev->dsp_serial[4] & 0xff, dev->dsp_serial[5] & 0xff);
  1995.  
  1996. snprintf(dev->revision, 30, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
  1997.  dev->dsp_version[0] & 0xff, dev->dsp_version[1] & 0xff,
  1998.  dev->dsp_version[2] & 0xff, dev->dsp_version[3] & 0xff,
  1999.  dev->dsp_version[4] & 0xff, dev->dsp_version[5] & 0xff,
  2000.  dev->dsp_version[6] & 0xff, dev->dsp_version[7] & 0xff,
  2001.  dev->dsp_version[8] & 0xff, dev->dsp_version[9] & 0xff);
  2002.  
  2003. dbg("serial: %s", dev->serialnum);
  2004. dbg("revision: %s", dev->revision);
  2006. voipblaster_register_device(dev);
  2008. dev->phone.f_op = &voipblaster_fops;
  2009. dev->phone.open = voipblaster_open;
  2010. dev->phone.board = board;
  2011. phone_register_device(&dev->phone, PHONE_UNIT_ANY);
  2012. dbg("USB VoIP Blaster registered with Linux Telephony sub system");
  2014. goto exit;
  2016. error:
  2017. voipblaster_delete (dev);
  2018. dev = NULL;
  2020. exit:
  2021. return dev;
  2022. }
  2024. static void voipblaster_disconnect(struct usb_device *udev, void *ptr)
  2025. {
  2026. struct usb_voipblaster *dev = (struct usb_voipblaster *) ptr;
  2028. phone_unregister_device(&dev->phone);
  2029. dbg("USB VoIP Blaster deregistered with Linux Telephony sub system");
  2031. voipblaster_deregister_device(dev);
  2032. voipblaster_delete(dev);
  2034. dbg("USB VoIP Blaster disconnected");
  2035. }
  2037. static struct usb_driver voipblaster_driver = {
  2038. name: "voipblaster",
  2039. probe: voipblaster_probe,
  2040. disconnect: voipblaster_disconnect,
  2041. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,3,0)
  2042. id_table: voipblaster_ids,
  2043. #endif
  2044. fops: &voipblaster_fops,
  2045. };
  2047. int __init voipblaster_init(void)
  2048. {
  2049.         int result;
  2051. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,3,0)
  2052. voipblaster_proc_init();
  2053. snprintf(VOIPversion, 32, "%d.%d.%d", VOIP_VER_MAJOR, VOIP_VER_MINOR, VOIP_BLD_VER);
  2054. #else 
  2055. /* 2.2.19 does not like create_proc_read_entry and snprintf */
  2056. sprintf(VOIPversion, "%d.%d.%d", VOIP_VER_MAJOR, VOIP_VER_MINOR, VOIP_BLD_VER);
  2057. #endif
  2058. result = usb_register(&voipblaster_driver);
  2060. if (result < 0) {
  2061. err("usb_register failed for the "__FILE__" driver. Error number %d",
  2062.     result);
  2063. return -1;
  2064. }
  2066. info(DRIVER_DESC " v%s", VOIPversion);
  2067. info("using %s", ixjuser_h_rcsid);
  2069. return 0;
  2070. }
  2072. void __exit voipblaster_exit(void)
  2073. {
  2074. voipblaster_proc_destroy();
  2075. usb_deregister(&voipblaster_driver);
  2076. }
  2078. module_init(voipblaster_init);
  2079. module_exit(voipblaster_exit);
  2082. MODULE_AUTHOR("Michael Bosland, <mike@ring.org>, Thomas Davis, <tadavis@veriomail.com>");
  2083. MODULE_DESCRIPTION("USB Driver for Creative Labs VoIP Blaster");
  2085. #ifdef MODULE_LICENSE
  2086.   MODULE_LICENSE("GPL");
  2087. #endif
  2089. /*
  2090.  * Local variables:
  2091.  *  c-indent-level: 8
  2092.  *  c-basic-offset: 8
  2093.  *  tab-width: 8
  2094.  * End:
  2095.  */