/drivers/staging/easycap/easycap_sound_oss.c

https://bitbucket.org/slukk/jb-tsm-kernel-4.2 · C · 954 lines · 757 code · 60 blank · 137 comment · 143 complexity · 73121be98a6db40b142e8ad55bd5295c MD5 · raw file

  1. /******************************************************************************
  2. * *
  3. * easycap_sound.c *
  4. * *
  5. * Audio driver for EasyCAP USB2.0 Video Capture Device DC60 *
  6. * *
  7. * *
  8. ******************************************************************************/
  9. /*
  10. *
  11. * Copyright (C) 2010 R.M. Thomas <rmthomas@sciolus.org>
  12. *
  13. *
  14. * This is free software; you can redistribute it and/or modify
  15. * it under the terms of the GNU General Public License as published by
  16. * the Free Software Foundation; either version 2 of the License, or
  17. * (at your option) any later version.
  18. *
  19. * The software is distributed in the hope that it will be useful,
  20. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  22. * GNU General Public License for more details.
  23. *
  24. * You should have received a copy of the GNU General Public License
  25. * along with this software; if not, write to the Free Software
  26. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  27. *
  28. */
  29. /*****************************************************************************/
  30. #include "easycap.h"
  31. /*****************************************************************************/
  32. /**************************** **************************/
  33. /**************************** Open Sound System **************************/
  34. /**************************** **************************/
  35. /*****************************************************************************/
  36. /*--------------------------------------------------------------------------*/
  37. /*
  38. * PARAMETERS USED WHEN REGISTERING THE AUDIO INTERFACE
  39. */
  40. /*--------------------------------------------------------------------------*/
  41. /*****************************************************************************/
  42. /*---------------------------------------------------------------------------*/
  43. /*
  44. * ON COMPLETION OF AN AUDIO URB ITS DATA IS COPIED TO THE AUDIO BUFFERS
  45. * PROVIDED peasycap->audio_idle IS ZERO. REGARDLESS OF THIS BEING TRUE,
  46. * IT IS RESUBMITTED PROVIDED peasycap->audio_isoc_streaming IS NOT ZERO.
  47. */
  48. /*---------------------------------------------------------------------------*/
  49. void
  50. easyoss_complete(struct urb *purb)
  51. {
  52. struct easycap *peasycap;
  53. struct data_buffer *paudio_buffer;
  54. u8 *p1, *p2;
  55. s16 tmp;
  56. int i, j, more, much, leap, rc;
  57. #ifdef UPSAMPLE
  58. int k;
  59. s16 oldaudio, newaudio, delta;
  60. #endif /*UPSAMPLE*/
  61. JOT(16, "\n");
  62. if (!purb) {
  63. SAY("ERROR: purb is NULL\n");
  64. return;
  65. }
  66. peasycap = purb->context;
  67. if (!peasycap) {
  68. SAY("ERROR: peasycap is NULL\n");
  69. return;
  70. }
  71. if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
  72. SAY("ERROR: bad peasycap\n");
  73. return;
  74. }
  75. much = 0;
  76. if (peasycap->audio_idle) {
  77. JOM(16, "%i=audio_idle %i=audio_isoc_streaming\n",
  78. peasycap->audio_idle, peasycap->audio_isoc_streaming);
  79. if (peasycap->audio_isoc_streaming) {
  80. rc = usb_submit_urb(purb, GFP_ATOMIC);
  81. if (rc) {
  82. if (-ENODEV != rc && -ENOENT != rc) {
  83. SAM("ERROR: while %i=audio_idle, "
  84. "usb_submit_urb() failed with rc: -%s: %d\n",
  85. peasycap->audio_idle,
  86. strerror(rc), rc);
  87. }
  88. }
  89. }
  90. return;
  91. }
  92. /*---------------------------------------------------------------------------*/
  93. if (purb->status) {
  94. if ((-ESHUTDOWN == purb->status) || (-ENOENT == purb->status)) {
  95. JOM(16, "urb status -ESHUTDOWN or -ENOENT\n");
  96. return;
  97. }
  98. SAM("ERROR: non-zero urb status: -%s: %d\n",
  99. strerror(purb->status), purb->status);
  100. goto resubmit;
  101. }
  102. /*---------------------------------------------------------------------------*/
  103. /*
  104. * PROCEED HERE WHEN NO ERROR
  105. */
  106. /*---------------------------------------------------------------------------*/
  107. #ifdef UPSAMPLE
  108. oldaudio = peasycap->oldaudio;
  109. #endif /*UPSAMPLE*/
  110. for (i = 0; i < purb->number_of_packets; i++) {
  111. if (!purb->iso_frame_desc[i].status) {
  112. SAM("-%s\n", strerror(purb->iso_frame_desc[i].status));
  113. more = purb->iso_frame_desc[i].actual_length;
  114. if (!more)
  115. peasycap->audio_mt++;
  116. else {
  117. if (peasycap->audio_mt) {
  118. JOM(12, "%4i empty audio urb frames\n",
  119. peasycap->audio_mt);
  120. peasycap->audio_mt = 0;
  121. }
  122. p1 = (u8 *)(purb->transfer_buffer + purb->iso_frame_desc[i].offset);
  123. leap = 0;
  124. p1 += leap;
  125. more -= leap;
  126. /*
  127. * COPY more BYTES FROM ISOC BUFFER
  128. * TO AUDIO BUFFER, CONVERTING
  129. * 8-BIT MONO TO 16-BIT SIGNED
  130. * LITTLE-ENDIAN SAMPLES IF NECESSARY
  131. */
  132. while (more) {
  133. if (0 > more) {
  134. SAM("MISTAKE: more is negative\n");
  135. return;
  136. }
  137. if (peasycap->audio_buffer_page_many <= peasycap->audio_fill) {
  138. SAM("ERROR: bad peasycap->audio_fill\n");
  139. return;
  140. }
  141. paudio_buffer = &peasycap->audio_buffer[peasycap->audio_fill];
  142. if (PAGE_SIZE < (paudio_buffer->pto - paudio_buffer->pgo)) {
  143. SAM("ERROR: bad paudio_buffer->pto\n");
  144. return;
  145. }
  146. if (PAGE_SIZE == (paudio_buffer->pto - paudio_buffer->pgo)) {
  147. paudio_buffer->pto = paudio_buffer->pgo;
  148. (peasycap->audio_fill)++;
  149. if (peasycap->audio_buffer_page_many <= peasycap->audio_fill)
  150. peasycap->audio_fill = 0;
  151. JOM(8, "bumped peasycap->"
  152. "audio_fill to %i\n",
  153. peasycap->audio_fill);
  154. paudio_buffer = &peasycap->audio_buffer[peasycap->audio_fill];
  155. paudio_buffer->pto = paudio_buffer->pgo;
  156. if (!(peasycap->audio_fill % peasycap->audio_pages_per_fragment)) {
  157. JOM(12, "wakeup call on wq_audio, %i=frag reading %i=fragment fill\n",
  158. (peasycap->audio_read / peasycap->audio_pages_per_fragment),
  159. (peasycap->audio_fill / peasycap->audio_pages_per_fragment));
  160. wake_up_interruptible(&(peasycap->wq_audio));
  161. }
  162. }
  163. much = PAGE_SIZE - (int)(paudio_buffer->pto - paudio_buffer->pgo);
  164. if (!peasycap->microphone) {
  165. if (much > more)
  166. much = more;
  167. memcpy(paudio_buffer->pto, p1, much);
  168. p1 += much;
  169. more -= much;
  170. } else {
  171. #ifdef UPSAMPLE
  172. if (much % 16)
  173. JOM(8, "MISTAKE? much"
  174. " is not divisible by 16\n");
  175. if (much > (16 * more))
  176. much = 16 * more;
  177. p2 = (u8 *)paudio_buffer->pto;
  178. for (j = 0; j < (much/16); j++) {
  179. newaudio = ((int) *p1) - 128;
  180. newaudio = 128 * newaudio;
  181. delta = (newaudio - oldaudio) / 4;
  182. tmp = oldaudio + delta;
  183. for (k = 0; k < 4; k++) {
  184. *p2 = (0x00FF & tmp);
  185. *(p2 + 1) = (0xFF00 & tmp) >> 8;
  186. p2 += 2;
  187. *p2 = (0x00FF & tmp);
  188. *(p2 + 1) = (0xFF00 & tmp) >> 8;
  189. p2 += 2;
  190. tmp += delta;
  191. }
  192. p1++;
  193. more--;
  194. oldaudio = tmp;
  195. }
  196. #else /*!UPSAMPLE*/
  197. if (much > (2 * more))
  198. much = 2 * more;
  199. p2 = (u8 *)paudio_buffer->pto;
  200. for (j = 0; j < (much / 2); j++) {
  201. tmp = ((int) *p1) - 128;
  202. tmp = 128 * tmp;
  203. *p2 = (0x00FF & tmp);
  204. *(p2 + 1) = (0xFF00 & tmp) >> 8;
  205. p1++;
  206. p2 += 2;
  207. more--;
  208. }
  209. #endif /*UPSAMPLE*/
  210. }
  211. (paudio_buffer->pto) += much;
  212. }
  213. }
  214. } else {
  215. JOM(12, "discarding audio samples because "
  216. "%i=purb->iso_frame_desc[i].status\n",
  217. purb->iso_frame_desc[i].status);
  218. }
  219. #ifdef UPSAMPLE
  220. peasycap->oldaudio = oldaudio;
  221. #endif /*UPSAMPLE*/
  222. }
  223. /*---------------------------------------------------------------------------*/
  224. /*
  225. * RESUBMIT THIS URB
  226. */
  227. /*---------------------------------------------------------------------------*/
  228. resubmit:
  229. if (peasycap->audio_isoc_streaming) {
  230. rc = usb_submit_urb(purb, GFP_ATOMIC);
  231. if (rc) {
  232. if (-ENODEV != rc && -ENOENT != rc) {
  233. SAM("ERROR: while %i=audio_idle, "
  234. "usb_submit_urb() failed "
  235. "with rc: -%s: %d\n", peasycap->audio_idle,
  236. strerror(rc), rc);
  237. }
  238. }
  239. }
  240. return;
  241. }
  242. /*****************************************************************************/
  243. /*---------------------------------------------------------------------------*/
  244. /*
  245. * THE AUDIO URBS ARE SUBMITTED AT THIS EARLY STAGE SO THAT IT IS POSSIBLE TO
  246. * STREAM FROM /dev/easyoss1 WITH SIMPLE PROGRAMS SUCH AS cat WHICH DO NOT
  247. * HAVE AN IOCTL INTERFACE.
  248. */
  249. /*---------------------------------------------------------------------------*/
  250. static int easyoss_open(struct inode *inode, struct file *file)
  251. {
  252. struct usb_interface *pusb_interface;
  253. struct easycap *peasycap;
  254. int subminor;
  255. struct v4l2_device *pv4l2_device;
  256. JOT(4, "begins\n");
  257. subminor = iminor(inode);
  258. pusb_interface = usb_find_interface(&easycap_usb_driver, subminor);
  259. if (!pusb_interface) {
  260. SAY("ERROR: pusb_interface is NULL\n");
  261. SAY("ending unsuccessfully\n");
  262. return -1;
  263. }
  264. peasycap = usb_get_intfdata(pusb_interface);
  265. if (!peasycap) {
  266. SAY("ERROR: peasycap is NULL\n");
  267. SAY("ending unsuccessfully\n");
  268. return -1;
  269. }
  270. /*---------------------------------------------------------------------------*/
  271. /*
  272. * SOME VERSIONS OF THE videodev MODULE OVERWRITE THE DATA WHICH HAS
  273. * BEEN WRITTEN BY THE CALL TO usb_set_intfdata() IN easycap_usb_probe(),
  274. * REPLACING IT WITH A POINTER TO THE EMBEDDED v4l2_device STRUCTURE.
  275. * TO DETECT THIS, THE STRING IN THE easycap.telltale[] BUFFER IS CHECKED.
  276. */
  277. /*---------------------------------------------------------------------------*/
  278. if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
  279. pv4l2_device = usb_get_intfdata(pusb_interface);
  280. if (!pv4l2_device) {
  281. SAY("ERROR: pv4l2_device is NULL\n");
  282. return -EFAULT;
  283. }
  284. peasycap = container_of(pv4l2_device,
  285. struct easycap, v4l2_device);
  286. }
  287. /*---------------------------------------------------------------------------*/
  288. if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
  289. SAY("ERROR: bad peasycap: %p\n", peasycap);
  290. return -EFAULT;
  291. }
  292. /*---------------------------------------------------------------------------*/
  293. file->private_data = peasycap;
  294. if (0 != easycap_sound_setup(peasycap)) {
  295. ;
  296. ;
  297. }
  298. return 0;
  299. }
  300. /*****************************************************************************/
  301. static int easyoss_release(struct inode *inode, struct file *file)
  302. {
  303. struct easycap *peasycap;
  304. JOT(4, "begins\n");
  305. peasycap = file->private_data;
  306. if (!peasycap) {
  307. SAY("ERROR: peasycap is NULL.\n");
  308. return -EFAULT;
  309. }
  310. if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
  311. SAY("ERROR: bad peasycap: %p\n", peasycap);
  312. return -EFAULT;
  313. }
  314. if (0 != kill_audio_urbs(peasycap)) {
  315. SAM("ERROR: kill_audio_urbs() failed\n");
  316. return -EFAULT;
  317. }
  318. JOM(4, "ending successfully\n");
  319. return 0;
  320. }
  321. /*****************************************************************************/
  322. static ssize_t easyoss_read(struct file *file, char __user *puserspacebuffer,
  323. size_t kount, loff_t *poff)
  324. {
  325. struct timeval timeval;
  326. long long int above, below, mean;
  327. struct signed_div_result sdr;
  328. unsigned char *p0;
  329. long int kount1, more, rc, l0, lm;
  330. int fragment, kd;
  331. struct easycap *peasycap;
  332. struct data_buffer *pdata_buffer;
  333. size_t szret;
  334. /*---------------------------------------------------------------------------*/
  335. /*
  336. * DO A BLOCKING READ TO TRANSFER DATA TO USER SPACE.
  337. *
  338. ******************************************************************************
  339. ***** N.B. IF THIS FUNCTION RETURNS 0, NOTHING IS SEEN IN USER SPACE. ******
  340. ***** THIS CONDITION SIGNIFIES END-OF-FILE. ******
  341. ******************************************************************************
  342. */
  343. /*---------------------------------------------------------------------------*/
  344. JOT(8, "%5zd=kount %5lld=*poff\n", kount, *poff);
  345. if (!file) {
  346. SAY("ERROR: file is NULL\n");
  347. return -ERESTARTSYS;
  348. }
  349. peasycap = file->private_data;
  350. if (!peasycap) {
  351. SAY("ERROR in easyoss_read(): peasycap is NULL\n");
  352. return -EFAULT;
  353. }
  354. if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
  355. SAY("ERROR: bad peasycap: %p\n", peasycap);
  356. return -EFAULT;
  357. }
  358. if (!peasycap->pusb_device) {
  359. SAY("ERROR: peasycap->pusb_device is NULL\n");
  360. return -EFAULT;
  361. }
  362. kd = isdongle(peasycap);
  363. if (0 <= kd && DONGLE_MANY > kd) {
  364. if (mutex_lock_interruptible(&(easycapdc60_dongle[kd].mutex_audio))) {
  365. SAY("ERROR: "
  366. "cannot lock dongle[%i].mutex_audio\n", kd);
  367. return -ERESTARTSYS;
  368. }
  369. JOM(4, "locked dongle[%i].mutex_audio\n", kd);
  370. /*
  371. * MEANWHILE, easycap_usb_disconnect()
  372. * MAY HAVE FREED POINTER peasycap,
  373. * IN WHICH CASE A REPEAT CALL TO isdongle() WILL FAIL.
  374. * IF NECESSARY, BAIL OUT.
  375. */
  376. if (kd != isdongle(peasycap))
  377. return -ERESTARTSYS;
  378. if (!file) {
  379. SAY("ERROR: file is NULL\n");
  380. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  381. return -ERESTARTSYS;
  382. }
  383. peasycap = file->private_data;
  384. if (!peasycap) {
  385. SAY("ERROR: peasycap is NULL\n");
  386. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  387. return -ERESTARTSYS;
  388. }
  389. if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
  390. SAY("ERROR: bad peasycap: %p\n", peasycap);
  391. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  392. return -ERESTARTSYS;
  393. }
  394. if (!peasycap->pusb_device) {
  395. SAM("ERROR: peasycap->pusb_device is NULL\n");
  396. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  397. return -ERESTARTSYS;
  398. }
  399. } else {
  400. /*
  401. * IF easycap_usb_disconnect()
  402. * HAS ALREADY FREED POINTER peasycap BEFORE THE
  403. * ATTEMPT TO ACQUIRE THE SEMAPHORE,
  404. * isdongle() WILL HAVE FAILED. BAIL OUT.
  405. */
  406. return -ERESTARTSYS;
  407. }
  408. /*---------------------------------------------------------------------------*/
  409. JOT(16, "%sBLOCKING kount=%zd, *poff=%lld\n",
  410. (file->f_flags & O_NONBLOCK) ? "NON" : "", kount, *poff);
  411. if ((0 > peasycap->audio_read) ||
  412. (peasycap->audio_buffer_page_many <= peasycap->audio_read)) {
  413. SAM("ERROR: peasycap->audio_read out of range\n");
  414. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  415. return -EFAULT;
  416. }
  417. pdata_buffer = &peasycap->audio_buffer[peasycap->audio_read];
  418. if (!pdata_buffer) {
  419. SAM("ERROR: pdata_buffer is NULL\n");
  420. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  421. return -EFAULT;
  422. }
  423. JOM(12, "before wait, %i=frag read %i=frag fill\n",
  424. (peasycap->audio_read / peasycap->audio_pages_per_fragment),
  425. (peasycap->audio_fill / peasycap->audio_pages_per_fragment));
  426. fragment = (peasycap->audio_read / peasycap->audio_pages_per_fragment);
  427. while ((fragment == (peasycap->audio_fill / peasycap->audio_pages_per_fragment)) ||
  428. (0 == (PAGE_SIZE - (pdata_buffer->pto - pdata_buffer->pgo)))) {
  429. if (file->f_flags & O_NONBLOCK) {
  430. JOM(16, "returning -EAGAIN as instructed\n");
  431. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  432. return -EAGAIN;
  433. }
  434. rc = wait_event_interruptible(peasycap->wq_audio,
  435. (peasycap->audio_idle || peasycap->audio_eof ||
  436. ((fragment !=
  437. (peasycap->audio_fill / peasycap->audio_pages_per_fragment)) &&
  438. (0 < (PAGE_SIZE - (pdata_buffer->pto - pdata_buffer->pgo))))));
  439. if (rc) {
  440. SAM("aborted by signal\n");
  441. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  442. return -ERESTARTSYS;
  443. }
  444. if (peasycap->audio_eof) {
  445. JOM(8, "returning 0 because %i=audio_eof\n",
  446. peasycap->audio_eof);
  447. kill_audio_urbs(peasycap);
  448. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  449. return 0;
  450. }
  451. if (peasycap->audio_idle) {
  452. JOM(16, "returning 0 because %i=audio_idle\n",
  453. peasycap->audio_idle);
  454. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  455. return 0;
  456. }
  457. if (!peasycap->audio_isoc_streaming) {
  458. JOM(16, "returning 0 because audio urbs not streaming\n");
  459. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  460. return 0;
  461. }
  462. }
  463. JOM(12, "after wait, %i=frag read %i=frag fill\n",
  464. (peasycap->audio_read / peasycap->audio_pages_per_fragment),
  465. (peasycap->audio_fill / peasycap->audio_pages_per_fragment));
  466. szret = (size_t)0;
  467. fragment = (peasycap->audio_read / peasycap->audio_pages_per_fragment);
  468. while (fragment == (peasycap->audio_read / peasycap->audio_pages_per_fragment)) {
  469. if (!pdata_buffer->pgo) {
  470. SAM("ERROR: pdata_buffer->pgo is NULL\n");
  471. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  472. return -EFAULT;
  473. }
  474. if (!pdata_buffer->pto) {
  475. SAM("ERROR: pdata_buffer->pto is NULL\n");
  476. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  477. return -EFAULT;
  478. }
  479. kount1 = PAGE_SIZE - (pdata_buffer->pto - pdata_buffer->pgo);
  480. if (0 > kount1) {
  481. SAM("MISTAKE: kount1 is negative\n");
  482. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  483. return -ERESTARTSYS;
  484. }
  485. if (!kount1) {
  486. peasycap->audio_read++;
  487. if (peasycap->audio_buffer_page_many <= peasycap->audio_read)
  488. peasycap->audio_read = 0;
  489. JOM(12, "bumped peasycap->audio_read to %i\n",
  490. peasycap->audio_read);
  491. if (fragment != (peasycap->audio_read / peasycap->audio_pages_per_fragment))
  492. break;
  493. if ((0 > peasycap->audio_read) ||
  494. (peasycap->audio_buffer_page_many <= peasycap->audio_read)) {
  495. SAM("ERROR: peasycap->audio_read out of range\n");
  496. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  497. return -EFAULT;
  498. }
  499. pdata_buffer = &peasycap->audio_buffer[peasycap->audio_read];
  500. if (!pdata_buffer) {
  501. SAM("ERROR: pdata_buffer is NULL\n");
  502. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  503. return -EFAULT;
  504. }
  505. if (!pdata_buffer->pgo) {
  506. SAM("ERROR: pdata_buffer->pgo is NULL\n");
  507. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  508. return -EFAULT;
  509. }
  510. if (!pdata_buffer->pto) {
  511. SAM("ERROR: pdata_buffer->pto is NULL\n");
  512. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  513. return -EFAULT;
  514. }
  515. kount1 = PAGE_SIZE - (pdata_buffer->pto - pdata_buffer->pgo);
  516. }
  517. JOM(12, "ready to send %zd bytes\n", kount1);
  518. JOM(12, "still to send %li bytes\n", (long int) kount);
  519. more = kount1;
  520. if (more > kount)
  521. more = kount;
  522. JOM(12, "agreed to send %li bytes from page %i\n",
  523. more, peasycap->audio_read);
  524. if (!more)
  525. break;
  526. /*
  527. * ACCUMULATE DYNAMIC-RANGE INFORMATION
  528. */
  529. p0 = (unsigned char *)pdata_buffer->pgo;
  530. l0 = 0;
  531. lm = more/2;
  532. while (l0 < lm) {
  533. SUMMER(p0, &peasycap->audio_sample,
  534. &peasycap->audio_niveau,
  535. &peasycap->audio_square);
  536. l0++;
  537. p0 += 2;
  538. }
  539. /*-----------------------------------------------------------*/
  540. rc = copy_to_user(puserspacebuffer, pdata_buffer->pto, more);
  541. if (rc) {
  542. SAM("ERROR: copy_to_user() returned %li\n", rc);
  543. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  544. return -EFAULT;
  545. }
  546. *poff += (loff_t)more;
  547. szret += (size_t)more;
  548. pdata_buffer->pto += more;
  549. puserspacebuffer += more;
  550. kount -= (size_t)more;
  551. }
  552. JOM(12, "after read, %i=frag read %i=frag fill\n",
  553. (peasycap->audio_read / peasycap->audio_pages_per_fragment),
  554. (peasycap->audio_fill / peasycap->audio_pages_per_fragment));
  555. if (kount < 0) {
  556. SAM("MISTAKE: %li=kount %li=szret\n",
  557. (long int)kount, (long int)szret);
  558. }
  559. /*---------------------------------------------------------------------------*/
  560. /*
  561. * CALCULATE DYNAMIC RANGE FOR (VAPOURWARE) AUTOMATIC VOLUME CONTROL
  562. */
  563. /*---------------------------------------------------------------------------*/
  564. if (peasycap->audio_sample) {
  565. below = peasycap->audio_sample;
  566. above = peasycap->audio_square;
  567. sdr = signed_div(above, below);
  568. above = sdr.quotient;
  569. mean = peasycap->audio_niveau;
  570. sdr = signed_div(mean, peasycap->audio_sample);
  571. JOM(8, "%8lli=mean %8lli=meansquare after %lli samples, =>\n",
  572. sdr.quotient, above, peasycap->audio_sample);
  573. sdr = signed_div(above, 32768);
  574. JOM(8, "audio dynamic range is roughly %lli\n", sdr.quotient);
  575. }
  576. /*---------------------------------------------------------------------------*/
  577. /*
  578. * UPDATE THE AUDIO CLOCK
  579. */
  580. /*---------------------------------------------------------------------------*/
  581. do_gettimeofday(&timeval);
  582. if (!peasycap->timeval1.tv_sec) {
  583. peasycap->audio_bytes = 0;
  584. peasycap->timeval3 = timeval;
  585. peasycap->timeval1 = peasycap->timeval3;
  586. sdr.quotient = 192000;
  587. } else {
  588. peasycap->audio_bytes += (long long int) szret;
  589. below = ((long long int)(1000000)) *
  590. ((long long int)(timeval.tv_sec - peasycap->timeval3.tv_sec)) +
  591. (long long int)(timeval.tv_usec - peasycap->timeval3.tv_usec);
  592. above = 1000000 * ((long long int) peasycap->audio_bytes);
  593. if (below)
  594. sdr = signed_div(above, below);
  595. else
  596. sdr.quotient = 192000;
  597. }
  598. JOM(8, "audio streaming at %lli bytes/second\n", sdr.quotient);
  599. peasycap->dnbydt = sdr.quotient;
  600. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  601. JOM(4, "unlocked easycapdc60_dongle[%i].mutex_audio\n", kd);
  602. JOM(8, "returning %li\n", (long int)szret);
  603. return szret;
  604. }
  605. /*---------------------------------------------------------------------------*/
  606. static long easyoss_unlocked_ioctl(struct file *file,
  607. unsigned int cmd, unsigned long arg)
  608. {
  609. struct easycap *peasycap;
  610. struct usb_device *p;
  611. int kd;
  612. if (!file) {
  613. SAY("ERROR: file is NULL\n");
  614. return -ERESTARTSYS;
  615. }
  616. peasycap = file->private_data;
  617. if (!peasycap) {
  618. SAY("ERROR: peasycap is NULL.\n");
  619. return -EFAULT;
  620. }
  621. if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
  622. SAY("ERROR: bad peasycap\n");
  623. return -EFAULT;
  624. }
  625. p = peasycap->pusb_device;
  626. if (!p) {
  627. SAM("ERROR: peasycap->pusb_device is NULL\n");
  628. return -EFAULT;
  629. }
  630. kd = isdongle(peasycap);
  631. if (0 <= kd && DONGLE_MANY > kd) {
  632. if (mutex_lock_interruptible(&easycapdc60_dongle[kd].mutex_audio)) {
  633. SAY("ERROR: cannot lock "
  634. "easycapdc60_dongle[%i].mutex_audio\n", kd);
  635. return -ERESTARTSYS;
  636. }
  637. JOM(4, "locked easycapdc60_dongle[%i].mutex_audio\n", kd);
  638. /*
  639. * MEANWHILE, easycap_usb_disconnect()
  640. * MAY HAVE FREED POINTER peasycap,
  641. * IN WHICH CASE A REPEAT CALL TO isdongle() WILL FAIL.
  642. * IF NECESSARY, BAIL OUT.
  643. */
  644. if (kd != isdongle(peasycap))
  645. return -ERESTARTSYS;
  646. if (!file) {
  647. SAY("ERROR: file is NULL\n");
  648. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  649. return -ERESTARTSYS;
  650. }
  651. peasycap = file->private_data;
  652. if (!peasycap) {
  653. SAY("ERROR: peasycap is NULL\n");
  654. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  655. return -ERESTARTSYS;
  656. }
  657. if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
  658. SAY("ERROR: bad peasycap\n");
  659. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  660. return -EFAULT;
  661. }
  662. p = peasycap->pusb_device;
  663. if (!peasycap->pusb_device) {
  664. SAM("ERROR: peasycap->pusb_device is NULL\n");
  665. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  666. return -ERESTARTSYS;
  667. }
  668. } else {
  669. /*
  670. * IF easycap_usb_disconnect()
  671. * HAS ALREADY FREED POINTER peasycap BEFORE THE
  672. * ATTEMPT TO ACQUIRE THE SEMAPHORE,
  673. * isdongle() WILL HAVE FAILED. BAIL OUT.
  674. */
  675. return -ERESTARTSYS;
  676. }
  677. /*---------------------------------------------------------------------------*/
  678. switch (cmd) {
  679. case SNDCTL_DSP_GETCAPS: {
  680. int caps;
  681. JOM(8, "SNDCTL_DSP_GETCAPS\n");
  682. #ifdef UPSAMPLE
  683. if (peasycap->microphone)
  684. caps = 0x04400000;
  685. else
  686. caps = 0x04400000;
  687. #else
  688. if (peasycap->microphone)
  689. caps = 0x02400000;
  690. else
  691. caps = 0x04400000;
  692. #endif /*UPSAMPLE*/
  693. if (copy_to_user((void __user *)arg, &caps, sizeof(int))) {
  694. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  695. return -EFAULT;
  696. }
  697. break;
  698. }
  699. case SNDCTL_DSP_GETFMTS: {
  700. int incoming;
  701. JOM(8, "SNDCTL_DSP_GETFMTS\n");
  702. #ifdef UPSAMPLE
  703. if (peasycap->microphone)
  704. incoming = AFMT_S16_LE;
  705. else
  706. incoming = AFMT_S16_LE;
  707. #else
  708. if (peasycap->microphone)
  709. incoming = AFMT_S16_LE;
  710. else
  711. incoming = AFMT_S16_LE;
  712. #endif /*UPSAMPLE*/
  713. if (copy_to_user((void __user *)arg, &incoming, sizeof(int))) {
  714. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  715. return -EFAULT;
  716. }
  717. break;
  718. }
  719. case SNDCTL_DSP_SETFMT: {
  720. int incoming, outgoing;
  721. JOM(8, "SNDCTL_DSP_SETFMT\n");
  722. if (copy_from_user(&incoming, (void __user *)arg, sizeof(int))) {
  723. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  724. return -EFAULT;
  725. }
  726. JOM(8, "........... %i=incoming\n", incoming);
  727. #ifdef UPSAMPLE
  728. if (peasycap->microphone)
  729. outgoing = AFMT_S16_LE;
  730. else
  731. outgoing = AFMT_S16_LE;
  732. #else
  733. if (peasycap->microphone)
  734. outgoing = AFMT_S16_LE;
  735. else
  736. outgoing = AFMT_S16_LE;
  737. #endif /*UPSAMPLE*/
  738. if (incoming != outgoing) {
  739. JOM(8, "........... %i=outgoing\n", outgoing);
  740. JOM(8, " cf. %i=AFMT_S16_LE\n", AFMT_S16_LE);
  741. JOM(8, " cf. %i=AFMT_U8\n", AFMT_U8);
  742. if (copy_to_user((void __user *)arg, &outgoing, sizeof(int))) {
  743. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  744. return -EFAULT;
  745. }
  746. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  747. return -EINVAL ;
  748. }
  749. break;
  750. }
  751. case SNDCTL_DSP_STEREO: {
  752. int incoming;
  753. JOM(8, "SNDCTL_DSP_STEREO\n");
  754. if (copy_from_user(&incoming, (void __user *)arg, sizeof(int))) {
  755. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  756. return -EFAULT;
  757. }
  758. JOM(8, "........... %i=incoming\n", incoming);
  759. #ifdef UPSAMPLE
  760. if (peasycap->microphone)
  761. incoming = 1;
  762. else
  763. incoming = 1;
  764. #else
  765. if (peasycap->microphone)
  766. incoming = 0;
  767. else
  768. incoming = 1;
  769. #endif /*UPSAMPLE*/
  770. if (copy_to_user((void __user *)arg, &incoming, sizeof(int))) {
  771. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  772. return -EFAULT;
  773. }
  774. break;
  775. }
  776. case SNDCTL_DSP_SPEED: {
  777. int incoming;
  778. JOM(8, "SNDCTL_DSP_SPEED\n");
  779. if (copy_from_user(&incoming, (void __user *)arg, sizeof(int))) {
  780. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  781. return -EFAULT;
  782. }
  783. JOM(8, "........... %i=incoming\n", incoming);
  784. #ifdef UPSAMPLE
  785. if (peasycap->microphone)
  786. incoming = 32000;
  787. else
  788. incoming = 48000;
  789. #else
  790. if (peasycap->microphone)
  791. incoming = 8000;
  792. else
  793. incoming = 48000;
  794. #endif /*UPSAMPLE*/
  795. if (copy_to_user((void __user *)arg, &incoming, sizeof(int))) {
  796. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  797. return -EFAULT;
  798. }
  799. break;
  800. }
  801. case SNDCTL_DSP_GETTRIGGER: {
  802. int incoming;
  803. JOM(8, "SNDCTL_DSP_GETTRIGGER\n");
  804. if (copy_from_user(&incoming, (void __user *)arg, sizeof(int))) {
  805. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  806. return -EFAULT;
  807. }
  808. JOM(8, "........... %i=incoming\n", incoming);
  809. incoming = PCM_ENABLE_INPUT;
  810. if (copy_to_user((void __user *)arg, &incoming, sizeof(int))) {
  811. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  812. return -EFAULT;
  813. }
  814. break;
  815. }
  816. case SNDCTL_DSP_SETTRIGGER: {
  817. int incoming;
  818. JOM(8, "SNDCTL_DSP_SETTRIGGER\n");
  819. if (copy_from_user(&incoming, (void __user *)arg, sizeof(int))) {
  820. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  821. return -EFAULT;
  822. }
  823. JOM(8, "........... %i=incoming\n", incoming);
  824. JOM(8, "........... cf 0x%x=PCM_ENABLE_INPUT "
  825. "0x%x=PCM_ENABLE_OUTPUT\n",
  826. PCM_ENABLE_INPUT, PCM_ENABLE_OUTPUT);
  827. ;
  828. ;
  829. ;
  830. ;
  831. break;
  832. }
  833. case SNDCTL_DSP_GETBLKSIZE: {
  834. int incoming;
  835. JOM(8, "SNDCTL_DSP_GETBLKSIZE\n");
  836. if (copy_from_user(&incoming, (void __user *)arg, sizeof(int))) {
  837. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  838. return -EFAULT;
  839. }
  840. JOM(8, "........... %i=incoming\n", incoming);
  841. incoming = peasycap->audio_bytes_per_fragment;
  842. if (copy_to_user((void __user *)arg, &incoming, sizeof(int))) {
  843. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  844. return -EFAULT;
  845. }
  846. break;
  847. }
  848. case SNDCTL_DSP_GETISPACE: {
  849. struct audio_buf_info audio_buf_info;
  850. JOM(8, "SNDCTL_DSP_GETISPACE\n");
  851. audio_buf_info.bytes = peasycap->audio_bytes_per_fragment;
  852. audio_buf_info.fragments = 1;
  853. audio_buf_info.fragsize = 0;
  854. audio_buf_info.fragstotal = 0;
  855. if (copy_to_user((void __user *)arg, &audio_buf_info, sizeof(int))) {
  856. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  857. return -EFAULT;
  858. }
  859. break;
  860. }
  861. case 0x00005401:
  862. case 0x00005402:
  863. case 0x00005403:
  864. case 0x00005404:
  865. case 0x00005405:
  866. case 0x00005406: {
  867. JOM(8, "SNDCTL_TMR_...: 0x%08X unsupported\n", cmd);
  868. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  869. return -ENOIOCTLCMD;
  870. }
  871. default: {
  872. JOM(8, "ERROR: unrecognized DSP IOCTL command: 0x%08X\n", cmd);
  873. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  874. return -ENOIOCTLCMD;
  875. }
  876. }
  877. mutex_unlock(&easycapdc60_dongle[kd].mutex_audio);
  878. return 0;
  879. }
  880. /*****************************************************************************/
  881. static const struct file_operations easyoss_fops = {
  882. .owner = THIS_MODULE,
  883. .open = easyoss_open,
  884. .release = easyoss_release,
  885. .unlocked_ioctl = easyoss_unlocked_ioctl,
  886. .read = easyoss_read,
  887. .llseek = no_llseek,
  888. };
  889. struct usb_class_driver easyoss_class = {
  890. .name = "usb/easyoss%d",
  891. .fops = &easyoss_fops,
  892. .minor_base = USB_SKEL_MINOR_BASE,
  893. };
  894. /*****************************************************************************/