memory.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570
  1. /*
  2. * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
  3. * Copyright (c) by Takashi Iwai <tiwai@suse.de>
  4. *
  5. * EMU10K1 memory page allocation (PTB area)
  6. *
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation; either version 2 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program; if not, write to the Free Software
  20. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21. *
  22. */
  23. #include <linux/pci.h>
  24. #include <linux/time.h>
  25. #include <linux/mutex.h>
  26. #include <sound/core.h>
  27. #include <sound/emu10k1.h>
  28. /* page arguments of these two macros are Emu page (4096 bytes), not like
  29. * aligned pages in others
  30. */
  31. #define __set_ptb_entry(emu,page,addr) \
  32. (((u32 *)(emu)->ptb_pages.area)[page] = cpu_to_le32(((addr) << 1) | (page)))
  33. #define UNIT_PAGES (PAGE_SIZE / EMUPAGESIZE)
  34. #define MAX_ALIGN_PAGES (MAXPAGES / UNIT_PAGES)
  35. /* get aligned page from offset address */
  36. #define get_aligned_page(offset) ((offset) >> PAGE_SHIFT)
  37. /* get offset address from aligned page */
  38. #define aligned_page_offset(page) ((page) << PAGE_SHIFT)
  39. #if PAGE_SIZE == 4096
  40. /* page size == EMUPAGESIZE */
  41. /* fill PTB entrie(s) corresponding to page with addr */
  42. #define set_ptb_entry(emu,page,addr) __set_ptb_entry(emu,page,addr)
  43. /* fill PTB entrie(s) corresponding to page with silence pointer */
  44. #define set_silent_ptb(emu,page) __set_ptb_entry(emu,page,emu->silent_page.addr)
  45. #else
  46. /* fill PTB entries -- we need to fill UNIT_PAGES entries */
  47. static inline void set_ptb_entry(struct snd_emu10k1 *emu, int page, dma_addr_t addr)
  48. {
  49. int i;
  50. page *= UNIT_PAGES;
  51. for (i = 0; i < UNIT_PAGES; i++, page++) {
  52. __set_ptb_entry(emu, page, addr);
  53. addr += EMUPAGESIZE;
  54. }
  55. }
  56. static inline void set_silent_ptb(struct snd_emu10k1 *emu, int page)
  57. {
  58. int i;
  59. page *= UNIT_PAGES;
  60. for (i = 0; i < UNIT_PAGES; i++, page++)
  61. /* do not increment ptr */
  62. __set_ptb_entry(emu, page, emu->silent_page.addr);
  63. }
  64. #endif /* PAGE_SIZE */
  65. /*
  66. */
  67. static int synth_alloc_pages(struct snd_emu10k1 *hw, struct snd_emu10k1_memblk *blk);
  68. static int synth_free_pages(struct snd_emu10k1 *hw, struct snd_emu10k1_memblk *blk);
  69. #define get_emu10k1_memblk(l,member) list_entry(l, struct snd_emu10k1_memblk, member)
  70. /* initialize emu10k1 part */
  71. static void emu10k1_memblk_init(struct snd_emu10k1_memblk *blk)
  72. {
  73. blk->mapped_page = -1;
  74. INIT_LIST_HEAD(&blk->mapped_link);
  75. INIT_LIST_HEAD(&blk->mapped_order_link);
  76. blk->map_locked = 0;
  77. blk->first_page = get_aligned_page(blk->mem.offset);
  78. blk->last_page = get_aligned_page(blk->mem.offset + blk->mem.size - 1);
  79. blk->pages = blk->last_page - blk->first_page + 1;
  80. }
  81. /*
  82. * search empty region on PTB with the given size
  83. *
  84. * if an empty region is found, return the page and store the next mapped block
  85. * in nextp
  86. * if not found, return a negative error code.
  87. */
  88. static int search_empty_map_area(struct snd_emu10k1 *emu, int npages, struct list_head **nextp)
  89. {
  90. int page = 0, found_page = -ENOMEM;
  91. int max_size = npages;
  92. int size;
  93. struct list_head *candidate = &emu->mapped_link_head;
  94. struct list_head *pos;
  95. list_for_each (pos, &emu->mapped_link_head) {
  96. struct snd_emu10k1_memblk *blk = get_emu10k1_memblk(pos, mapped_link);
  97. if (blk->mapped_page < 0)
  98. continue;
  99. size = blk->mapped_page - page;
  100. if (size == npages) {
  101. *nextp = pos;
  102. return page;
  103. }
  104. else if (size > max_size) {
  105. /* we look for the maximum empty hole */
  106. max_size = size;
  107. candidate = pos;
  108. found_page = page;
  109. }
  110. page = blk->mapped_page + blk->pages;
  111. }
  112. size = MAX_ALIGN_PAGES - page;
  113. if (size >= max_size) {
  114. *nextp = pos;
  115. return page;
  116. }
  117. *nextp = candidate;
  118. return found_page;
  119. }
  120. /*
  121. * map a memory block onto emu10k1's PTB
  122. *
  123. * call with memblk_lock held
  124. */
  125. static int map_memblk(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk *blk)
  126. {
  127. int page, pg;
  128. struct list_head *next;
  129. page = search_empty_map_area(emu, blk->pages, &next);
  130. if (page < 0) /* not found */
  131. return page;
  132. /* insert this block in the proper position of mapped list */
  133. list_add_tail(&blk->mapped_link, next);
  134. /* append this as a newest block in order list */
  135. list_add_tail(&blk->mapped_order_link, &emu->mapped_order_link_head);
  136. blk->mapped_page = page;
  137. /* fill PTB */
  138. for (pg = blk->first_page; pg <= blk->last_page; pg++) {
  139. set_ptb_entry(emu, page, emu->page_addr_table[pg]);
  140. page++;
  141. }
  142. return 0;
  143. }
  144. /*
  145. * unmap the block
  146. * return the size of resultant empty pages
  147. *
  148. * call with memblk_lock held
  149. */
  150. static int unmap_memblk(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk *blk)
  151. {
  152. int start_page, end_page, mpage, pg;
  153. struct list_head *p;
  154. struct snd_emu10k1_memblk *q;
  155. /* calculate the expected size of empty region */
  156. if ((p = blk->mapped_link.prev) != &emu->mapped_link_head) {
  157. q = get_emu10k1_memblk(p, mapped_link);
  158. start_page = q->mapped_page + q->pages;
  159. } else
  160. start_page = 0;
  161. if ((p = blk->mapped_link.next) != &emu->mapped_link_head) {
  162. q = get_emu10k1_memblk(p, mapped_link);
  163. end_page = q->mapped_page;
  164. } else
  165. end_page = MAX_ALIGN_PAGES;
  166. /* remove links */
  167. list_del(&blk->mapped_link);
  168. list_del(&blk->mapped_order_link);
  169. /* clear PTB */
  170. mpage = blk->mapped_page;
  171. for (pg = blk->first_page; pg <= blk->last_page; pg++) {
  172. set_silent_ptb(emu, mpage);
  173. mpage++;
  174. }
  175. blk->mapped_page = -1;
  176. return end_page - start_page; /* return the new empty size */
  177. }
  178. /*
  179. * search empty pages with the given size, and create a memory block
  180. *
  181. * unlike synth_alloc the memory block is aligned to the page start
  182. */
  183. static struct snd_emu10k1_memblk *
  184. search_empty(struct snd_emu10k1 *emu, int size)
  185. {
  186. struct list_head *p;
  187. struct snd_emu10k1_memblk *blk;
  188. int page, psize;
  189. psize = get_aligned_page(size + PAGE_SIZE -1);
  190. page = 0;
  191. list_for_each(p, &emu->memhdr->block) {
  192. blk = get_emu10k1_memblk(p, mem.list);
  193. if (page + psize <= blk->first_page)
  194. goto __found_pages;
  195. page = blk->last_page + 1;
  196. }
  197. if (page + psize > emu->max_cache_pages)
  198. return NULL;
  199. __found_pages:
  200. /* create a new memory block */
  201. blk = (struct snd_emu10k1_memblk *)__snd_util_memblk_new(emu->memhdr, psize << PAGE_SHIFT, p->prev);
  202. if (blk == NULL)
  203. return NULL;
  204. blk->mem.offset = aligned_page_offset(page); /* set aligned offset */
  205. emu10k1_memblk_init(blk);
  206. return blk;
  207. }
  208. /*
  209. * check if the given pointer is valid for pages
  210. */
  211. static int is_valid_page(struct snd_emu10k1 *emu, dma_addr_t addr)
  212. {
  213. if (addr & ~emu->dma_mask) {
  214. snd_printk(KERN_ERR "max memory size is 0x%lx (addr = 0x%lx)!!\n", emu->dma_mask, (unsigned long)addr);
  215. return 0;
  216. }
  217. if (addr & (EMUPAGESIZE-1)) {
  218. snd_printk(KERN_ERR "page is not aligned\n");
  219. return 0;
  220. }
  221. return 1;
  222. }
  223. /*
  224. * map the given memory block on PTB.
  225. * if the block is already mapped, update the link order.
  226. * if no empty pages are found, tries to release unsed memory blocks
  227. * and retry the mapping.
  228. */
  229. int snd_emu10k1_memblk_map(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk *blk)
  230. {
  231. int err;
  232. int size;
  233. struct list_head *p, *nextp;
  234. struct snd_emu10k1_memblk *deleted;
  235. unsigned long flags;
  236. spin_lock_irqsave(&emu->memblk_lock, flags);
  237. if (blk->mapped_page >= 0) {
  238. /* update order link */
  239. list_del(&blk->mapped_order_link);
  240. list_add_tail(&blk->mapped_order_link, &emu->mapped_order_link_head);
  241. spin_unlock_irqrestore(&emu->memblk_lock, flags);
  242. return 0;
  243. }
  244. if ((err = map_memblk(emu, blk)) < 0) {
  245. /* no enough page - try to unmap some blocks */
  246. /* starting from the oldest block */
  247. p = emu->mapped_order_link_head.next;
  248. for (; p != &emu->mapped_order_link_head; p = nextp) {
  249. nextp = p->next;
  250. deleted = get_emu10k1_memblk(p, mapped_order_link);
  251. if (deleted->map_locked)
  252. continue;
  253. size = unmap_memblk(emu, deleted);
  254. if (size >= blk->pages) {
  255. /* ok the empty region is enough large */
  256. err = map_memblk(emu, blk);
  257. break;
  258. }
  259. }
  260. }
  261. spin_unlock_irqrestore(&emu->memblk_lock, flags);
  262. return err;
  263. }
  264. EXPORT_SYMBOL(snd_emu10k1_memblk_map);
  265. /*
  266. * page allocation for DMA
  267. */
  268. struct snd_util_memblk *
  269. snd_emu10k1_alloc_pages(struct snd_emu10k1 *emu, struct snd_pcm_substream *substream)
  270. {
  271. struct snd_pcm_runtime *runtime = substream->runtime;
  272. struct snd_util_memhdr *hdr;
  273. struct snd_emu10k1_memblk *blk;
  274. int page, err, idx;
  275. if (snd_BUG_ON(!emu))
  276. return NULL;
  277. if (snd_BUG_ON(runtime->dma_bytes <= 0 ||
  278. runtime->dma_bytes >= MAXPAGES * EMUPAGESIZE))
  279. return NULL;
  280. hdr = emu->memhdr;
  281. if (snd_BUG_ON(!hdr))
  282. return NULL;
  283. mutex_lock(&hdr->block_mutex);
  284. blk = search_empty(emu, runtime->dma_bytes);
  285. if (blk == NULL) {
  286. mutex_unlock(&hdr->block_mutex);
  287. return NULL;
  288. }
  289. /* fill buffer addresses but pointers are not stored so that
  290. * snd_free_pci_page() is not called in in synth_free()
  291. */
  292. idx = 0;
  293. for (page = blk->first_page; page <= blk->last_page; page++, idx++) {
  294. unsigned long ofs = idx << PAGE_SHIFT;
  295. dma_addr_t addr;
  296. addr = snd_pcm_sgbuf_get_addr(substream, ofs);
  297. if (! is_valid_page(emu, addr)) {
  298. printk(KERN_ERR "emu: failure page = %d\n", idx);
  299. mutex_unlock(&hdr->block_mutex);
  300. return NULL;
  301. }
  302. emu->page_addr_table[page] = addr;
  303. emu->page_ptr_table[page] = NULL;
  304. }
  305. /* set PTB entries */
  306. blk->map_locked = 1; /* do not unmap this block! */
  307. err = snd_emu10k1_memblk_map(emu, blk);
  308. if (err < 0) {
  309. __snd_util_mem_free(hdr, (struct snd_util_memblk *)blk);
  310. mutex_unlock(&hdr->block_mutex);
  311. return NULL;
  312. }
  313. mutex_unlock(&hdr->block_mutex);
  314. return (struct snd_util_memblk *)blk;
  315. }
  316. /*
  317. * release DMA buffer from page table
  318. */
  319. int snd_emu10k1_free_pages(struct snd_emu10k1 *emu, struct snd_util_memblk *blk)
  320. {
  321. if (snd_BUG_ON(!emu || !blk))
  322. return -EINVAL;
  323. return snd_emu10k1_synth_free(emu, blk);
  324. }
  325. /*
  326. * memory allocation using multiple pages (for synth)
  327. * Unlike the DMA allocation above, non-contiguous pages are assined.
  328. */
  329. /*
  330. * allocate a synth sample area
  331. */
  332. struct snd_util_memblk *
  333. snd_emu10k1_synth_alloc(struct snd_emu10k1 *hw, unsigned int size)
  334. {
  335. struct snd_emu10k1_memblk *blk;
  336. struct snd_util_memhdr *hdr = hw->memhdr;
  337. mutex_lock(&hdr->block_mutex);
  338. blk = (struct snd_emu10k1_memblk *)__snd_util_mem_alloc(hdr, size);
  339. if (blk == NULL) {
  340. mutex_unlock(&hdr->block_mutex);
  341. return NULL;
  342. }
  343. if (synth_alloc_pages(hw, blk)) {
  344. __snd_util_mem_free(hdr, (struct snd_util_memblk *)blk);
  345. mutex_unlock(&hdr->block_mutex);
  346. return NULL;
  347. }
  348. snd_emu10k1_memblk_map(hw, blk);
  349. mutex_unlock(&hdr->block_mutex);
  350. return (struct snd_util_memblk *)blk;
  351. }
  352. EXPORT_SYMBOL(snd_emu10k1_synth_alloc);
  353. /*
  354. * free a synth sample area
  355. */
  356. int
  357. snd_emu10k1_synth_free(struct snd_emu10k1 *emu, struct snd_util_memblk *memblk)
  358. {
  359. struct snd_util_memhdr *hdr = emu->memhdr;
  360. struct snd_emu10k1_memblk *blk = (struct snd_emu10k1_memblk *)memblk;
  361. unsigned long flags;
  362. mutex_lock(&hdr->block_mutex);
  363. spin_lock_irqsave(&emu->memblk_lock, flags);
  364. if (blk->mapped_page >= 0)
  365. unmap_memblk(emu, blk);
  366. spin_unlock_irqrestore(&emu->memblk_lock, flags);
  367. synth_free_pages(emu, blk);
  368. __snd_util_mem_free(hdr, memblk);
  369. mutex_unlock(&hdr->block_mutex);
  370. return 0;
  371. }
  372. EXPORT_SYMBOL(snd_emu10k1_synth_free);
  373. /* check new allocation range */
  374. static void get_single_page_range(struct snd_util_memhdr *hdr,
  375. struct snd_emu10k1_memblk *blk,
  376. int *first_page_ret, int *last_page_ret)
  377. {
  378. struct list_head *p;
  379. struct snd_emu10k1_memblk *q;
  380. int first_page, last_page;
  381. first_page = blk->first_page;
  382. if ((p = blk->mem.list.prev) != &hdr->block) {
  383. q = get_emu10k1_memblk(p, mem.list);
  384. if (q->last_page == first_page)
  385. first_page++; /* first page was already allocated */
  386. }
  387. last_page = blk->last_page;
  388. if ((p = blk->mem.list.next) != &hdr->block) {
  389. q = get_emu10k1_memblk(p, mem.list);
  390. if (q->first_page == last_page)
  391. last_page--; /* last page was already allocated */
  392. }
  393. *first_page_ret = first_page;
  394. *last_page_ret = last_page;
  395. }
  396. /* release allocated pages */
  397. static void __synth_free_pages(struct snd_emu10k1 *emu, int first_page,
  398. int last_page)
  399. {
  400. int page;
  401. for (page = first_page; page <= last_page; page++) {
  402. free_page((unsigned long)emu->page_ptr_table[page]);
  403. emu->page_addr_table[page] = 0;
  404. emu->page_ptr_table[page] = NULL;
  405. }
  406. }
  407. /*
  408. * allocate kernel pages
  409. */
  410. static int synth_alloc_pages(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk *blk)
  411. {
  412. int page, first_page, last_page;
  413. emu10k1_memblk_init(blk);
  414. get_single_page_range(emu->memhdr, blk, &first_page, &last_page);
  415. /* allocate kernel pages */
  416. for (page = first_page; page <= last_page; page++) {
  417. /* first try to allocate from <4GB zone */
  418. struct page *p = alloc_page(GFP_KERNEL | GFP_DMA32 |
  419. __GFP_NOWARN);
  420. if (!p || (page_to_pfn(p) & ~(emu->dma_mask >> PAGE_SHIFT))) {
  421. if (p)
  422. __free_page(p);
  423. /* try to allocate from <16MB zone */
  424. p = alloc_page(GFP_ATOMIC | GFP_DMA |
  425. __GFP_NORETRY | /* no OOM-killer */
  426. __GFP_NOWARN);
  427. }
  428. if (!p) {
  429. __synth_free_pages(emu, first_page, page - 1);
  430. return -ENOMEM;
  431. }
  432. emu->page_addr_table[page] = page_to_phys(p);
  433. emu->page_ptr_table[page] = page_address(p);
  434. }
  435. return 0;
  436. }
  437. /*
  438. * free pages
  439. */
  440. static int synth_free_pages(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk *blk)
  441. {
  442. int first_page, last_page;
  443. get_single_page_range(emu->memhdr, blk, &first_page, &last_page);
  444. __synth_free_pages(emu, first_page, last_page);
  445. return 0;
  446. }
  447. /* calculate buffer pointer from offset address */
  448. static inline void *offset_ptr(struct snd_emu10k1 *emu, int page, int offset)
  449. {
  450. char *ptr;
  451. if (snd_BUG_ON(page < 0 || page >= emu->max_cache_pages))
  452. return NULL;
  453. ptr = emu->page_ptr_table[page];
  454. if (! ptr) {
  455. printk(KERN_ERR "emu10k1: access to NULL ptr: page = %d\n", page);
  456. return NULL;
  457. }
  458. ptr += offset & (PAGE_SIZE - 1);
  459. return (void*)ptr;
  460. }
  461. /*
  462. * bzero(blk + offset, size)
  463. */
  464. int snd_emu10k1_synth_bzero(struct snd_emu10k1 *emu, struct snd_util_memblk *blk,
  465. int offset, int size)
  466. {
  467. int page, nextofs, end_offset, temp, temp1;
  468. void *ptr;
  469. struct snd_emu10k1_memblk *p = (struct snd_emu10k1_memblk *)blk;
  470. offset += blk->offset & (PAGE_SIZE - 1);
  471. end_offset = offset + size;
  472. page = get_aligned_page(offset);
  473. do {
  474. nextofs = aligned_page_offset(page + 1);
  475. temp = nextofs - offset;
  476. temp1 = end_offset - offset;
  477. if (temp1 < temp)
  478. temp = temp1;
  479. ptr = offset_ptr(emu, page + p->first_page, offset);
  480. if (ptr)
  481. memset(ptr, 0, temp);
  482. offset = nextofs;
  483. page++;
  484. } while (offset < end_offset);
  485. return 0;
  486. }
  487. EXPORT_SYMBOL(snd_emu10k1_synth_bzero);
  488. /*
  489. * copy_from_user(blk + offset, data, size)
  490. */
  491. int snd_emu10k1_synth_copy_from_user(struct snd_emu10k1 *emu, struct snd_util_memblk *blk,
  492. int offset, const char __user *data, int size)
  493. {
  494. int page, nextofs, end_offset, temp, temp1;
  495. void *ptr;
  496. struct snd_emu10k1_memblk *p = (struct snd_emu10k1_memblk *)blk;
  497. offset += blk->offset & (PAGE_SIZE - 1);
  498. end_offset = offset + size;
  499. page = get_aligned_page(offset);
  500. do {
  501. nextofs = aligned_page_offset(page + 1);
  502. temp = nextofs - offset;
  503. temp1 = end_offset - offset;
  504. if (temp1 < temp)
  505. temp = temp1;
  506. ptr = offset_ptr(emu, page + p->first_page, offset);
  507. if (ptr && copy_from_user(ptr, data, temp))
  508. return -EFAULT;
  509. offset = nextofs;
  510. data += temp;
  511. page++;
  512. } while (offset < end_offset);
  513. return 0;
  514. }
  515. EXPORT_SYMBOL(snd_emu10k1_synth_copy_from_user);