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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
isapnp_proc.c
资源名称：rtsp-1.0.1.tar.gz　[点击查看]
上传用户：sy_wanhua
上传日期：2013-07-25
资源大小：3048k
文件大小：24k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

C/C++

isapnp_proc.c：源码内容
  1. /*
  2.  *  ISA Plug & Play support
  3.  *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
  4.  *
  5.  *  Modified by Ed Okerson <eokerson@quicknet.net> to work with the 2.2.x
  6.  *  series of Linux kernels. 11/17/99
  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., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  *
  22.  */
  24. static void *isapnp_alloc(long size);
  25. struct pnp_bus *isapnp_cards;
  26. struct pnp_dev *isapnp_devices;
  28. struct isapnp_info_buffer {
  29. char *buffer; /* pointer to begin of buffer */
  30. char *curr; /* current position in buffer */
  31. unsigned long size; /* current size */
  32. unsigned long len; /* total length of buffer */
  33. int stop; /* stop flag */
  34. int error; /* error code */
  35. };
  37. typedef struct isapnp_info_buffer isapnp_info_buffer_t;
  39. static struct proc_dir_entry *isapnp_proc_entry = NULL;
  41. static void isapnp_info_read(isapnp_info_buffer_t *buffer);
  42. static void isapnp_info_write(isapnp_info_buffer_t *buffer);
  44. int isapnp_printf(isapnp_info_buffer_t * buffer, char *fmt,...)
  45. {
  46. va_list args;
  47. int res;
  48. char sbuffer[512];
  50. if (buffer->stop || buffer->error)
  51. return 0;
  52. va_start(args, fmt);
  53. res = vsprintf(sbuffer, fmt, args);
  54. va_end(args);
  55. if (buffer->size + res >= buffer->len) {
  56. buffer->stop = 1;
  57. return 0;
  58. }
  59. strcpy(buffer->curr, sbuffer);
  60. buffer->curr += res;
  61. buffer->size += res;
  62. return res;
  63. }
  65. static loff_t isapnp_info_entry_lseek(struct file *file, loff_t offset, int orig)
  66. {
  67. switch (orig) {
  68. case 0: /* SEEK_SET */
  69. file->f_pos = offset;
  70. return file->f_pos;
  71. case 1: /* SEEK_CUR */
  72. file->f_pos += offset;
  73. return file->f_pos;
  74. case 2: /* SEEK_END */
  75. default:
  76. return -EINVAL;
  77. }
  78. return -ENXIO;
  79. }
  81. static ssize_t isapnp_info_entry_read(struct file *file, char *buffer,
  82.       size_t count, loff_t * offset)
  83. {
  84. isapnp_info_buffer_t *buf;
  85. long size = 0, size1;
  86. int mode;
  88. mode = file->f_flags & O_ACCMODE;
  89. if (mode != O_RDONLY)
  90. return -EINVAL;
  91. buf = (isapnp_info_buffer_t *) file->private_data;
  92. if (!buf)
  93. return -EIO;
  94. if (file->f_pos >= buf->size)
  95. return 0;
  96. size = buf->size < count ? buf->size : count;
  97. size1 = buf->size - file->f_pos;
  98. if (size1 < size)
  99. size = size1;
  100. if (copy_to_user(buffer, buf->buffer + file->f_pos, size))
  101. return -EFAULT;
  102. file->f_pos += size;
  103. return size;
  104. }
  106. static ssize_t isapnp_info_entry_write(struct file *file, const char *buffer,
  107.        size_t count, loff_t * offset)
  108. {
  109. isapnp_info_buffer_t *buf;
  110. long size = 0, size1;
  111. int mode;
  113. mode = file->f_flags & O_ACCMODE;
  114. if (mode != O_WRONLY)
  115. return -EINVAL;
  116. buf = (isapnp_info_buffer_t *) file->private_data;
  117. if (!buf)
  118. return -EIO;
  119. if (file->f_pos < 0)
  120. return -EINVAL;
  121. if (file->f_pos >= buf->len)
  122. return -ENOMEM;
  123. size = buf->len < count ? buf->len : count;
  124. size1 = buf->len - file->f_pos;
  125. if (size1 < size)
  126. size = size1;
  127. if (copy_from_user(buf->buffer + file->f_pos, buffer, size))
  128. return -EFAULT;
  129. if (buf->size < file->f_pos + size)
  130. buf->size = file->f_pos + size;
  131. file->f_pos += size;
  132. return size;
  133. }
  135. static int isapnp_info_entry_open(struct inode *inode, struct file *file)
  136. {
  137. isapnp_info_buffer_t *buffer;
  138. int mode;
  140. mode = file->f_flags & O_ACCMODE;
  141. if (mode != O_RDONLY && mode != O_WRONLY)
  142. return -EINVAL;
  143. buffer = (isapnp_info_buffer_t *)
  144. isapnp_alloc(sizeof(isapnp_info_buffer_t));
  145. if (!buffer)
  146. return -ENOMEM;
  147. buffer->len = 4 * PAGE_SIZE;
  148. buffer->buffer = vmalloc(buffer->len);
  149. if (!buffer->buffer) {
  150. kfree(buffer);
  151. return -ENOMEM;
  152. }
  153. buffer->curr = buffer->buffer;
  154. file->private_data = buffer;
  155. MOD_INC_USE_COUNT;
  156. if (mode == O_RDONLY)
  157. isapnp_info_read(buffer);
  158. return 0;
  159. }
  161. static int isapnp_info_entry_release(struct inode *inode, struct file *file)
  162. {
  163. isapnp_info_buffer_t *buffer;
  164. int mode;
  166. if ((buffer = (isapnp_info_buffer_t *) file->private_data) == NULL)
  167. return -EINVAL;
  168. mode = file->f_flags & O_ACCMODE;
  169. if (mode == O_WRONLY)
  170. isapnp_info_write(buffer);
  171. vfree(buffer->buffer);
  172. kfree(buffer);
  173. MOD_DEC_USE_COUNT;
  174. return 0;
  175. }
  177. static unsigned int isapnp_info_entry_poll(struct file *file, poll_table * wait)
  178. {
  179. if (!file->private_data)
  180. return 0;
  181. return POLLIN | POLLRDNORM;
  182. }
  184. static int isapnp_info_entry_ioctl(struct inode *inode, struct file *file,
  185.    unsigned int cmd, unsigned long arg)
  186. {
  187. return -EINVAL;
  188. }
  190. static int isapnp_info_entry_mmap(struct file *file, struct vm_area_struct *vma)
  191. {
  192. return -ENXIO;
  193. }
  195. static struct file_operations isapnp_info_entry_operations =
  196. {
  197. isapnp_info_entry_lseek, /* lseek */
  198. isapnp_info_entry_read, /* read */
  199. isapnp_info_entry_write, /* write */
  200. NULL, /* readdir */
  201. isapnp_info_entry_poll, /* poll */
  202. isapnp_info_entry_ioctl, /* ioctl - default */
  203. isapnp_info_entry_mmap, /* mmap */
  204. isapnp_info_entry_open, /* open */
  205. NULL, /* flush */
  206. isapnp_info_entry_release, /* release */
  207. NULL, /* can't fsync */
  208. NULL, /* fasync */
  209. NULL, /* check_media_change */
  210. NULL, /* revalidate */
  211. NULL, /* lock */
  212. };
  214. static struct inode_operations isapnp_info_entry_inode_operations =
  215. {
  216. &isapnp_info_entry_operations, /* default sound info directory file-ops */
  217. NULL, /* create */
  218. NULL, /* lookup */
  219. NULL, /* link */
  220. NULL, /* unlink */
  221. NULL, /* symlink */
  222. NULL, /* mkdir */
  223. NULL, /* rmdir */
  224. NULL, /* mknod */
  225. NULL, /* rename */
  226. NULL, /* readlink */
  227. NULL, /* follow_link */
  228. NULL, /* readpage */
  229. NULL, /* writepage */
  230. NULL, /* bmap */
  231. NULL, /* truncate */
  232. NULL /* permission */
  233. };
  235. static int __init isapnp_proc_init(void)
  236. {
  237. struct proc_dir_entry *p;
  239. isapnp_proc_entry = NULL;
  240. p = create_proc_entry("isapnp", S_IFREG | S_IRUGO | S_IWUSR, &proc_root);
  241. if (!p)
  242. return -ENOMEM;
  243. p->ops = &isapnp_info_entry_inode_operations;
  244. isapnp_proc_entry = p;
  245. return 0;
  246. }
  248. #ifdef MODULE
  249. static int isapnp_proc_done(void)
  250. {
  251. if (isapnp_proc_entry)
  252. remove_proc_entry("isapnp",&proc_root);
  253. return 0;
  254. }
  255. #endif /* MODULE */
  257. /*
  258.  *
  259.  */
  261. static void isapnp_print_devid(isapnp_info_buffer_t *buffer, unsigned short vendor, unsigned short device)
  262. {
  263. char tmp[8];
  265. sprintf(tmp, "%c%c%c%x%x%x%x",
  266. 'A' + ((vendor >> 2) & 0x3f) - 1,
  267. 'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1,
  268. 'A' + ((vendor >> 8) & 0x1f) - 1,
  269. (device >> 4) & 0x0f,
  270. device & 0x0f,
  271. (device >> 12) & 0x0f,
  272. (device >> 8) & 0x0f);
  273. isapnp_printf(buffer, tmp);
  274. }
  276. static void isapnp_print_compatible(isapnp_info_buffer_t *buffer, struct pnp_dev *dev)
  277. {
  278. int idx;
  280. for (idx = 0; idx < DEVICE_COUNT_COMPATIBLE; idx++) {
  281. if (dev->vendor_compatible[idx] == 0)
  282. continue;
  283. isapnp_printf(buffer, "    Compatible device ");
  284. isapnp_print_devid(buffer,
  285.    dev->vendor_compatible[idx],
  286.    dev->device_compatible[idx]);
  287. isapnp_printf(buffer, "n");
  288. }
  289. }
  291. static void isapnp_print_port(isapnp_info_buffer_t *buffer, char *space, struct isapnp_port *port)
  292. {
  293. isapnp_printf(buffer, "%sPort 0x%x-0x%x, align 0x%x, size 0x%x, %i-bit address decodingn",
  294. space, port->min, port->max, port->align ? (port->align-1) : 0, port->size,
  295. port->flags & ISAPNP_PORT_FLAG_16BITADDR ? 16 : 10);
  296. }
  298. static void isapnp_print_irq(isapnp_info_buffer_t *buffer, char *space, struct isapnp_irq *irq)
  299. {
  300. int first = 1, i;
  302. isapnp_printf(buffer, "%sIRQ ", space);
  303. for (i = 0; i < 16; i++)
  304. if (irq->map & (1<<i)) {
  305. if (!first) {
  306. isapnp_printf(buffer, ",");
  307. } else {
  308. first = 0;
  309. }
  310. if (i == 2 || i == 9)
  311. isapnp_printf(buffer, "2/9");
  312. else
  313. isapnp_printf(buffer, "%i", i);
  314. }
  315. if (!irq->map)
  316. isapnp_printf(buffer, "<none>");
  317. if (irq->flags & IORESOURCE_IRQ_HIGHEDGE)
  318. isapnp_printf(buffer, " High-Edge");
  319. if (irq->flags & IORESOURCE_IRQ_LOWEDGE)
  320. isapnp_printf(buffer, " Low-Edge");
  321. if (irq->flags & IORESOURCE_IRQ_HIGHLEVEL)
  322. isapnp_printf(buffer, " High-Level");
  323. if (irq->flags & IORESOURCE_IRQ_LOWLEVEL)
  324. isapnp_printf(buffer, " Low-Level");
  325. isapnp_printf(buffer, "n");
  326. }
  328. static void isapnp_print_dma(isapnp_info_buffer_t *buffer, char *space, struct isapnp_dma *dma)
  329. {
  330. int first = 1, i;
  331. char *s;
  333. isapnp_printf(buffer, "%sDMA ", space);
  334. for (i = 0; i < 8; i++)
  335. if (dma->map & (1<<i)) {
  336. if (!first) {
  337. isapnp_printf(buffer, ",");
  338. } else {
  339. first = 0;
  340. }
  341. isapnp_printf(buffer, "%i", i);
  342. }
  343. if (!dma->map)
  344. isapnp_printf(buffer, "<none>");
  345. switch (dma->flags & IORESOURCE_DMA_TYPE_MASK) {
  346. case IORESOURCE_DMA_8BIT:
  347. s = "8-bit";
  348. break;
  349. case IORESOURCE_DMA_8AND16BIT:
  350. s = "8-bit&16-bit";
  351. break;
  352. default:
  353. s = "16-bit";
  354. }
  355. isapnp_printf(buffer, " %s", s);
  356. if (dma->flags & IORESOURCE_DMA_MASTER)
  357. isapnp_printf(buffer, " master");
  358. if (dma->flags & IORESOURCE_DMA_BYTE)
  359. isapnp_printf(buffer, " byte-count");
  360. if (dma->flags & IORESOURCE_DMA_WORD)
  361. isapnp_printf(buffer, " word-count");
  362. switch (dma->flags & IORESOURCE_DMA_SPEED_MASK) {
  363. case IORESOURCE_DMA_TYPEA:
  364. s = "type-A";
  365. break;
  366. case IORESOURCE_DMA_TYPEB:
  367. s = "type-B";
  368. break;
  369. case IORESOURCE_DMA_TYPEF:
  370. s = "type-F";
  371. break;
  372. default:
  373. s = "compatible";
  374. break;
  375. }
  376. isapnp_printf(buffer, " %sn", s);
  377. }
  379. static void isapnp_print_mem(isapnp_info_buffer_t *buffer, char *space, struct isapnp_mem *mem)
  380. {
  381. char *s;
  383. isapnp_printf(buffer, "%sMemory 0x%x-0x%x, align 0x%x, size 0x%x",
  384. space, mem->min, mem->max, mem->align, mem->size);
  385. if (mem->flags & IORESOURCE_MEM_WRITEABLE)
  386. isapnp_printf(buffer, ", writeable");
  387. if (mem->flags & IORESOURCE_MEM_CACHEABLE)
  388. isapnp_printf(buffer, ", cacheable");
  389. if (mem->flags & IORESOURCE_MEM_RANGELENGTH)
  390. isapnp_printf(buffer, ", range-length");
  391. if (mem->flags & IORESOURCE_MEM_SHADOWABLE)
  392. isapnp_printf(buffer, ", shadowable");
  393. if (mem->flags & IORESOURCE_MEM_EXPANSIONROM)
  394. isapnp_printf(buffer, ", expansion ROM");
  395. switch (mem->flags & IORESOURCE_MEM_TYPE_MASK) {
  396. case IORESOURCE_MEM_8BIT:
  397. s = "8-bit";
  398. break;
  399. case IORESOURCE_MEM_8AND16BIT:
  400. s = "8-bit&16-bit";
  401. break;
  402. default:
  403. s = "16-bit";
  404. }
  405. isapnp_printf(buffer, ", %sn", s);
  406. }
  408. static void isapnp_print_mem32(isapnp_info_buffer_t *buffer, char *space, struct isapnp_mem32 *mem32)
  409. {
  410. int first = 1, i;
  412. isapnp_printf(buffer, "%s32-bit memory ", space);
  413. for (i = 0; i < 17; i++) {
  414. if (first) {
  415. first = 0;
  416. } else {
  417. isapnp_printf(buffer, ":");
  418. }
  419. isapnp_printf(buffer, "%02x", mem32->data[i]);
  420. }
  421. }
  423. static void isapnp_print_resources(isapnp_info_buffer_t *buffer, char *space, struct isapnp_resources *res)
  424. {
  425. char *s;
  426. struct isapnp_port *port;
  427. struct isapnp_irq *irq;
  428. struct isapnp_dma *dma;
  429. struct isapnp_mem *mem;
  430. struct isapnp_mem32 *mem32;
  432. switch (res->priority) {
  433. case ISAPNP_RES_PRIORITY_PREFERRED:
  434. s = "preferred";
  435. break;
  436. case ISAPNP_RES_PRIORITY_ACCEPTABLE:
  437. s = "acceptable";
  438. break;
  439. case ISAPNP_RES_PRIORITY_FUNCTIONAL:
  440. s = "functional";
  441. break;
  442. default:
  443. s = "invalid";
  444. }
  445. isapnp_printf(buffer, "%sPriority %sn", space, s);
  446. for (port = res->port; port; port = port->next)
  447. isapnp_print_port(buffer, space, port);
  448. for (irq = res->irq; irq; irq = irq->next)
  449. isapnp_print_irq(buffer, space, irq);
  450. for (dma = res->dma; dma; dma = dma->next)
  451. isapnp_print_dma(buffer, space, dma);
  452. for (mem = res->mem; mem; mem = mem->next)
  453. isapnp_print_mem(buffer, space, mem);
  454. for (mem32 = res->mem32; mem32; mem32 = mem32->next)
  455. isapnp_print_mem32(buffer, space, mem32);
  456. }
  458. static void isapnp_print_configuration(isapnp_info_buffer_t *buffer, struct pnp_dev *dev)
  459. {
  460. int i, tmp, next;
  461. char *space = "    ";
  463. isapnp_cfg_begin(dev->bus->number, dev->devfn);
  464. isapnp_printf(buffer, "%sDevice is %sactiven",
  465. space, isapnp_read_byte(ISAPNP_CFG_ACTIVATE)?"":"not ");
  466. for (i = next = 0; i < 8; i++) {
  467. tmp = isapnp_read_word(ISAPNP_CFG_PORT + (i << 1));
  468. if (!tmp)
  469. continue;
  470. if (!next) {
  471. isapnp_printf(buffer, "%sActive port ", space);
  472. next = 1;
  473. }
  474. isapnp_printf(buffer, "%s0x%x", i > 0 ? "," : "", tmp);
  475. }
  476. if (next)
  477. isapnp_printf(buffer, "n");
  478. for (i = next = 0; i < 2; i++) {
  479. tmp = isapnp_read_word(ISAPNP_CFG_IRQ + (i << 1));
  480. if (!(tmp >> 8))
  481. continue;
  482. if (!next) {
  483. isapnp_printf(buffer, "%sActive IRQ ", space);
  484. next = 1;
  485. }
  486. isapnp_printf(buffer, "%s%i", i > 0 ? "," : "", tmp >> 8);
  487. if (tmp & 0xff)
  488. isapnp_printf(buffer, " [0x%x]", tmp & 0xff);
  489. }
  490. if (next)
  491. isapnp_printf(buffer, "n");
  492. for (i = next = 0; i < 2; i++) {
  493. tmp = isapnp_read_byte(ISAPNP_CFG_DMA + i);
  494. if (tmp == 4)
  495. continue;
  496. if (!next) {
  497. isapnp_printf(buffer, "%sActive DMA ", space);
  498. next = 1;
  499. }
  500. isapnp_printf(buffer, "%s%i", i > 0 ? "," : "", tmp);
  501. }
  502. if (next)
  503. isapnp_printf(buffer, "n");
  504. for (i = next = 0; i < 4; i++) {
  505. tmp = isapnp_read_dword(ISAPNP_CFG_MEM + (i << 3));
  506. if (!tmp)
  507. continue;
  508. if (!next) {
  509. isapnp_printf(buffer, "%sActive memory ", space);
  510. next = 1;
  511. }
  512. isapnp_printf(buffer, "%s0x%x", i > 0 ? "," : "", tmp);
  513. }
  514. if (next)
  515. isapnp_printf(buffer, "n");
  516. isapnp_cfg_end();
  517. }
  519. static void isapnp_print_device(isapnp_info_buffer_t *buffer, struct pnp_dev *dev)
  520. {
  521. int block, block1;
  522. char *space = "    ";
  523. struct isapnp_resources *res, *resa;
  525. if (!dev)
  526. return;
  527. isapnp_printf(buffer, "  Logical device %i '", dev->devfn);
  528. isapnp_print_devid(buffer, dev->vendor, dev->device);
  529. isapnp_printf(buffer, ":%s'", dev->name[0]?dev->name:"Unknown");
  530. isapnp_printf(buffer, "n");
  531. #if 0
  532. isapnp_cfg_begin(dev->bus->number, dev->devfn);
  533. for (block = 0; block < 128; block++)
  534. if ((block % 16) == 15)
  535. isapnp_printf(buffer, "%02xn", isapnp_read_byte(block));
  536. else
  537. isapnp_printf(buffer, "%02x:", isapnp_read_byte(block));
  538. isapnp_cfg_end();
  539. #endif
  540. if (dev->regs)
  541. isapnp_printf(buffer, "%sSupported registers 0x%xn", space, dev->regs);
  542. isapnp_print_compatible(buffer, dev);
  543. isapnp_print_configuration(buffer, dev);
  544. for (res = (struct isapnp_resources *)dev->sysdata, block = 0; res; res = res->next, block++) {
  545. isapnp_printf(buffer, "%sResources %in", space, block);
  546. isapnp_print_resources(buffer, "      ", res);
  547. for (resa = res->alt, block1 = 1; resa; resa = resa->alt, block1++) {
  548. isapnp_printf(buffer, "%s  Alternate resources %i:%in", space, block, block1);
  549. isapnp_print_resources(buffer, "        ", resa);
  550. }
  551. }
  552. }
  554. /*
  555.  *  Main read routine
  556.  */
  557.  
  558. static void isapnp_info_read(isapnp_info_buffer_t *buffer)
  559. {
  560. struct pnp_bus *card;
  561. struct pnp_dev *dev;
  563. for (card = isapnp_cards; card; 
  564.              card = card->next) {
  565. isapnp_printf(buffer, "Card %i '", card->number);
  566. isapnp_print_devid(buffer, card->vendor, card->device);
  567. isapnp_printf(buffer, ":%s'", card->name[0]?card->name:"Unknown");
  568. if (card->pnpver)
  569. isapnp_printf(buffer, " PnP version %x.%x", card->pnpver >> 4, card->pnpver & 0x0f);
  570. if (card->productver)
  571. isapnp_printf(buffer, " Product version %x.%x", card->productver >> 4, card->productver & 0x0f);
  572. isapnp_printf(buffer,"n");
  573. for (dev = card->devices; dev; dev = dev->sibling)
  574. isapnp_print_device(buffer, dev);
  575. }
  576. }
  578. /*
  579.  *
  580.  */
  582. static struct pnp_bus *isapnp_info_card;
  583. static struct pnp_dev *isapnp_info_device;
  585. static char *isapnp_get_str(char *dest, char *src, int len)
  586. {
  587. int c;
  589. while (*src == ' ' || *src == 't')
  590. src++;
  591. if (*src == '"' || *src == ''') {
  592. c = *src++;
  593. while (--len > 0 && *src && *src != c) {
  594. *dest++ = *src++;
  595. }
  596. if (*src == c)
  597. src++;
  598. } else {
  599. while (--len > 0 && *src && *src != ' ' && *src != 't') {
  600. *dest++ = *src++;
  601. }
  602. }
  603. *dest = 0;
  604. while (*src == ' ' || *src == 't')
  605. src++;
  606. return src;
  607. }
  609. static unsigned char isapnp_get_hex(unsigned char c)
  610. {
  611. if (c >= '0' || c <= '9')
  612. return c - '0';
  613. if (c >= 'a' || c <= 'f')
  614. return (c - 'a') + 10;
  615. if (c >= 'A' || c <= 'F')
  616. return (c - 'A') + 10;
  617. return 0;
  618. }
  620. static unsigned int isapnp_parse_id(const char *id)
  621. {
  622. if (strlen(id) != 7) {
  623. printk("isapnp: wrong PnP IDn");
  624. return 0;
  625. }
  626. return (ISAPNP_VENDOR(id[0], id[1], id[2])<<16) |
  627. (isapnp_get_hex(id[3])<<4) |
  628. (isapnp_get_hex(id[4])<<0) |
  629. (isapnp_get_hex(id[5])<<12) |
  630. (isapnp_get_hex(id[6])<<8);
  631. }
  633. static int isapnp_set_card(char *line)
  634. {
  635. int idx, idx1;
  636. unsigned int id;
  637. char index[16], value[32];
  639. isapnp_info_card = NULL;
  640. line = isapnp_get_str(index, line, sizeof(index));
  641. isapnp_get_str(value, line, sizeof(value));
  642. idx = idx1 = simple_strtoul(index, NULL, 0);
  643. id = isapnp_parse_id(value);
  644. isapnp_info_card = isapnp_find_card(id >> 16, id & 0xffff, NULL);
  645. while (isapnp_info_card && idx1-- > 0)
  646. isapnp_info_card = isapnp_find_card(id >> 16, id & 0xffff, isapnp_info_card);
  647. if (isapnp_info_card == NULL) {
  648. printk("isapnp: card '%s' order %i not foundn", value, idx);
  649. return 1;
  650. }
  651. if (isapnp_cfg_begin(isapnp_info_card->number, -1)<0) {
  652. printk("isapnp: configuration start sequence for device '%s' failedn", value);
  653. isapnp_info_card = NULL;
  654. return 1;
  655. }
  656. return 0;
  657. }
  659. static int isapnp_select_csn(char *line)
  660. {
  661. int csn;
  662. char index[16], value[32];
  664. isapnp_info_device = NULL;
  665. isapnp_get_str(index, line, sizeof(index));
  666. csn = simple_strtoul(index, NULL, 0);
  667. for (isapnp_info_card = isapnp_cards; isapnp_info_card; isapnp_info_card = isapnp_info_card->next)
  668. if (isapnp_info_card->number == csn)
  669. break;
  670. if (isapnp_info_card == NULL) {
  671. printk("isapnp: cannot find CSN %in", csn);
  672. return 1;
  673. }
  674. if (isapnp_cfg_begin(isapnp_info_card->number, -1)<0) {
  675. printk("isapnp: configuration start sequence for device '%s' failedn", value);
  676. isapnp_info_card = NULL;
  677. return 1;
  678. }
  679. return 0;
  680. }
  682. static int isapnp_set_device(char *line)
  683. {
  684. int idx, idx1;
  685. unsigned int id;
  686. char index[16], value[32];
  688. line = isapnp_get_str(index, line, sizeof(index));
  689. isapnp_get_str(value, line, sizeof(value));
  690. idx = idx1 = simple_strtoul(index, NULL, 0);
  691. id = isapnp_parse_id(value);
  692. isapnp_info_device = isapnp_find_dev(isapnp_info_card, id >> 16, id & 0xffff, NULL);
  693. while (isapnp_info_device && idx-- > 0)
  694. isapnp_info_device = isapnp_find_dev(isapnp_info_card, id >> 16, id & 0xffff, isapnp_info_device);
  695. if (isapnp_info_device == NULL) {
  696. printk("isapnp: device '%s' order %i not foundn", value, idx);
  697. return 1;
  698. }
  699. isapnp_device(isapnp_info_device->devfn);
  700. return 0;
  701. }
  703. static int isapnp_autoconfigure(void)
  704. {
  705. if (isapnp_info_device == NULL) {
  706. printk("isapnp: device is not setn");
  707. return 0;
  708. }
  709. if (isapnp_info_device->active)
  710. isapnp_info_device->deactivate(isapnp_info_device);
  711. if (isapnp_info_device->prepare(isapnp_info_device) < 0) {
  712. printk("isapnp: cannot prepare device for the activation");
  713. return 0;
  714. }
  715. if (isapnp_info_device->activate(isapnp_info_device) < 0) {
  716. printk("isapnp: cannot activate device");
  717. return 0;
  718. }
  719. return 0;
  720. }
  722. static int isapnp_set_port(char *line)
  723. {
  724. int idx, port;
  725. char index[16], value[32];
  727. line = isapnp_get_str(index, line, sizeof(index));
  728. isapnp_get_str(value, line, sizeof(value));
  729. idx = simple_strtoul(index, NULL, 0);
  730. port = simple_strtoul(value, NULL, 0);
  731. if (idx < 0 || idx > 7) {
  732. printk("isapnp: wrong port index %in", idx);
  733. return 1;
  734. }
  735. if (port < 0 || port > 0xffff) {
  736. printk("isapnp: wrong port value 0x%xn", port);
  737. return 1;
  738. }
  739. isapnp_write_word(ISAPNP_CFG_PORT + (idx << 1), port);
  740. if (!isapnp_info_device->resource[idx].flags)
  741. return 0;
  742. if (isapnp_info_device->resource[idx].flags & IORESOURCE_AUTO) {
  743. isapnp_info_device->resource[idx].start = port;
  744. isapnp_info_device->resource[idx].end += port - 1;
  745. isapnp_info_device->resource[idx].flags &= ~IORESOURCE_AUTO;
  746. } else {
  747. isapnp_info_device->resource[idx].end -= isapnp_info_device->resource[idx].start;
  748. isapnp_info_device->resource[idx].start = port;
  749. isapnp_info_device->resource[idx].end += port;
  750. }
  751. return 0;
  752. }
  754. static void isapnp_set_irqresource(struct resource *res, int irq)
  755. {
  756. res->start = res->end = irq;
  757. res->flags = IORESOURCE_IRQ;
  758. }
  759.  
  760. static int isapnp_set_irq(char *line)
  761. {
  762. int idx, irq;
  763. char index[16], value[32];
  765. line = isapnp_get_str(index, line, sizeof(index));
  766. isapnp_get_str(value, line, sizeof(value));
  767. idx = simple_strtoul(index, NULL, 0);
  768. irq = simple_strtoul(value, NULL, 0);
  769. if (idx < 0 || idx > 1) {
  770. printk("isapnp: wrong IRQ index %in", idx);
  771. return 1;
  772. }
  773. if (irq == 2)
  774. irq = 9;
  775. if (irq < 0 || irq > 15) {
  776. printk("isapnp: wrong IRQ value %in", irq);
  777. return 1;
  778. }
  779. isapnp_write_byte(ISAPNP_CFG_IRQ + (idx << 1), irq);
  780. isapnp_set_irqresource(isapnp_info_device->irq_resource + idx, irq);
  781. return 0;
  782. }
  783.  
  784. static void isapnp_set_dmaresource(struct resource *res, int dma)
  785. {
  786. res->start = res->end = dma;
  787. res->flags = IORESOURCE_DMA;
  788. }
  789.  
  790. static int isapnp_set_dma(char *line)
  791. {
  792. int idx, dma;
  793. char index[16], value[32];
  795. line = isapnp_get_str(index, line, sizeof(index));
  796. isapnp_get_str(value, line, sizeof(value));
  797. idx = simple_strtoul(index, NULL, 0);
  798. dma = simple_strtoul(value, NULL, 0);
  799. if (idx < 0 || idx > 1) {
  800. printk("isapnp: wrong DMA index %in", idx);
  801. return 1;
  802. }
  803. if (dma < 0 || dma > 7) {
  804. printk("isapnp: wrong DMA value %in", dma);
  805. return 1;
  806. }
  807. isapnp_write_byte(ISAPNP_CFG_DMA + idx, dma);
  808. isapnp_set_dmaresource(isapnp_info_device->dma_resource + idx, dma);
  809. return 0;
  810. }
  811.  
  812. static int isapnp_set_mem(char *line)
  813. {
  814. int idx;
  815. unsigned int mem;
  816. char index[16], value[32];
  818. line = isapnp_get_str(index, line, sizeof(index));
  819. isapnp_get_str(value, line, sizeof(value));
  820. idx = simple_strtoul(index, NULL, 0);
  821. mem = simple_strtoul(value, NULL, 0);
  822. if (idx < 0 || idx > 3) {
  823. printk("isapnp: wrong memory index %in", idx);
  824. return 1;
  825. }
  826. mem >>= 8;
  827. isapnp_write_word(ISAPNP_CFG_MEM + (idx<<2), mem & 0xffff);
  828. if (!isapnp_info_device->resource[idx + 8].flags)
  829. return 0;
  830. if (isapnp_info_device->resource[idx + 8].flags & IORESOURCE_AUTO) {
  831. isapnp_info_device->resource[idx + 8].start = mem & ~0x00ffff00;
  832. isapnp_info_device->resource[idx + 8].end += (mem & ~0x00ffff00) - 1;
  833. isapnp_info_device->resource[idx + 8].flags &= ~IORESOURCE_AUTO;
  834. } else {
  835. isapnp_info_device->resource[idx + 8].end -= isapnp_info_device->resource[idx + 8].start;
  836. isapnp_info_device->resource[idx + 8].start = mem & ~0x00ffff00;
  837. isapnp_info_device->resource[idx + 8].end += mem & ~0x00ffff00;
  838. }
  839. return 0;
  840. }
  841.  
  842. static int isapnp_poke(char *line, int what)
  843. {
  844. int reg;
  845. unsigned int val;
  846. char index[16], value[32];
  848. line = isapnp_get_str(index, line, sizeof(index));
  849. isapnp_get_str(value, line, sizeof(value));
  850. reg = simple_strtoul(index, NULL, 0);
  851. val = simple_strtoul(value, NULL, 0);
  852. if (reg < 0 || reg > 127) {
  853. printk("isapnp: wrong register %in", reg);
  854. return 1;
  855. }
  856. switch (what) {
  857. case 1:
  858. isapnp_write_word(reg, val);
  859. break;
  860. case 2:
  861. isapnp_write_dword(reg, val);
  862. break;
  863. default:
  864. isapnp_write_byte(reg, val);
  865. break;
  866. }
  867. return 0;
  868. }
  869.  
  870. static int isapnp_decode_line(char *line)
  871. {
  872. char cmd[32];
  874. line = isapnp_get_str(cmd, line, sizeof(cmd));
  875. if (!strcmp(cmd, "card"))
  876. return isapnp_set_card(line);
  877. if (!strcmp(cmd, "csn"))
  878. return isapnp_select_csn(line);
  879. if (!isapnp_info_card) {
  880. printk("isapnp: card is not selectedn");
  881. return 1;
  882. }
  883. if (!strncmp(cmd, "dev", 3))
  884. return isapnp_set_device(line);
  885. if (!isapnp_info_device) {
  886. printk("isapnp: device is not selectedn");
  887. return 1;
  888. }
  889. if (!strncmp(cmd, "auto", 4))
  890. return isapnp_autoconfigure();
  891. if (!strncmp(cmd, "act", 3)) {
  892. isapnp_activate(isapnp_info_device->devfn);
  893. isapnp_info_device->active = 1;
  894. return 0;
  895. }
  896. if (!strncmp(cmd, "deact", 5)) {
  897. isapnp_deactivate(isapnp_info_device->devfn);
  898. isapnp_info_device->active = 0;
  899. return 0;
  900. }
  901. if (!strcmp(cmd, "port"))
  902. return isapnp_set_port(line);
  903. if (!strcmp(cmd, "irq"))
  904. return isapnp_set_irq(line);
  905. if (!strcmp(cmd, "dma"))
  906. return isapnp_set_dma(line);
  907. if (!strncmp(cmd, "mem", 3))
  908. return isapnp_set_mem(line);
  909. if (!strcmp(cmd, "poke"))
  910. return isapnp_poke(line, 0);
  911. if (!strcmp(cmd, "pokew"))
  912. return isapnp_poke(line, 1);
  913. if (!strcmp(cmd, "poked"))
  914. return isapnp_poke(line, 2);
  915. printk("isapnp: wrong command '%s'n", cmd);
  916. return 1;
  917. }
  919. /*
  920.  *  Main write routine
  921.  */
  923. static void isapnp_info_write(isapnp_info_buffer_t *buffer)
  924. {
  925. int c, idx, idx1 = 0;
  926. char line[128];
  928. if (buffer->size <= 0)
  929. return;
  930. isapnp_info_card = NULL;
  931. isapnp_info_device = NULL;
  932. for (idx = 0; idx < buffer->size; idx++) {
  933. c = buffer->buffer[idx];
  934. if (c == 'n') {
  935. line[idx1] = '';
  936. if (line[0] != '#') {
  937. if (isapnp_decode_line(line))
  938. goto __end;
  939. }
  940. idx1 = 0;
  941. continue;
  942. }
  943. if (idx1 >= sizeof(line)-1) {
  944. printk("isapnp: line too long, abortingn");
  945. return;
  946. }
  947. line[idx1++] = c;
  948. }
  949.       __end:
  950. if (isapnp_info_card)
  951. isapnp_cfg_end();
  952. }