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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
cpia_pp.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：19k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

cpia_pp.c：源码内容
  1. /*
  2.  * cpia_pp CPiA Parallel Port driver
  3.  *
  4.  * Supports CPiA based parallel port Video Camera's.
  5.  *
  6.  * (C) Copyright 1999 Bas Huisman <bhuism@cs.utwente.nl>
  7.  * (C) Copyright 1999-2000 Scott J. Bertin <sbertin@mindspring.com>,
  8.  * (C) Copyright 1999-2000 Peter Pregler <Peter_Pregler@email.com>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23.  */
  25. #include <linux/config.h>
  26. #include <linux/version.h>
  28. #include <linux/module.h>
  29. #include <linux/init.h>
  31. #include <linux/kernel.h>
  32. #include <linux/parport.h>
  33. #include <linux/interrupt.h>
  34. #include <linux/delay.h>
  35. #include <linux/smp_lock.h>
  37. #include <linux/kmod.h>
  39. /* #define _CPIA_DEBUG_ define for verbose debug output */
  40. #include "cpia.h"
  42. static int cpia_pp_open(void *privdata);
  43. static int cpia_pp_registerCallback(void *privdata, void (*cb) (void *cbdata),
  44.                                     void *cbdata);
  45. static int cpia_pp_transferCmd(void *privdata, u8 *command, u8 *data);
  46. static int cpia_pp_streamStart(void *privdata);
  47. static int cpia_pp_streamStop(void *privdata);
  48. static int cpia_pp_streamRead(void *privdata, u8 *buffer, int noblock);
  49. static int cpia_pp_close(void *privdata);
  51. #define ABOUT "Parallel port driver for Vision CPiA based cameras"
  53. /* IEEE 1284 Compatiblity Mode signal names  */
  54. #define nStrobe PARPORT_CONTROL_STROBE   /* inverted */
  55. #define nAutoFd PARPORT_CONTROL_AUTOFD   /* inverted */
  56. #define nInit PARPORT_CONTROL_INIT
  57. #define nSelectIn PARPORT_CONTROL_SELECT
  58. #define IntrEnable PARPORT_CONTROL_INTEN   /* normally zero for no IRQ */
  59. #define DirBit PARPORT_CONTROL_DIRECTION /* 0 = Forward, 1 = Reverse */
  61. #define nFault PARPORT_STATUS_ERROR
  62. #define Select PARPORT_STATUS_SELECT
  63. #define PError PARPORT_STATUS_PAPEROUT
  64. #define nAck PARPORT_STATUS_ACK
  65. #define Busy PARPORT_STATUS_BUSY   /* inverted */
  67. /* some more */
  68. #define HostClk nStrobe
  69. #define HostAck nAutoFd
  70. #define nReverseRequest nInit
  71. #define Active_1284 nSelectIn
  72. #define nPeriphRequest nFault
  73. #define XFlag Select
  74. #define nAckReverse PError
  75. #define PeriphClk nAck
  76. #define PeriphAck Busy
  78. /* these can be used to correct for the inversion on some bits */
  79. #define STATUS_INVERSION_MASK (Busy)
  80. #define CONTROL_INVERSION_MASK (nStrobe|nAutoFd|nSelectIn)
  82. #define ECR_empty 0x01
  83. #define ECR_full 0x02
  84. #define ECR_serviceIntr 0x04
  85. #define ECR_dmaEn 0x08
  86. #define ECR_nErrIntrEn 0x10
  88. #define ECR_mode_mask 0xE0
  89. #define ECR_SPP_mode 0x00
  90. #define ECR_PS2_mode 0x20
  91. #define ECR_FIFO_mode 0x40
  92. #define ECR_ECP_mode 0x60
  94. #define ECP_FIFO_SIZE 16
  95. #define DMA_BUFFER_SIZE               PAGE_SIZE
  96. /* for 16bit DMA make sure DMA_BUFFER_SIZE is 16 bit aligned */
  97. #define PARPORT_CHUNK_SIZE PAGE_SIZE/* >=2.3.x */
  98. /* we read this many bytes at once */
  100. #define GetECRMasked(port,mask) (parport_read_econtrol(port) & (mask))
  101. #define GetStatus(port) ((parport_read_status(port)^STATUS_INVERSION_MASK)&(0xf8))
  102. #define SetStatus(port,val) parport_write_status(port,(val)^STATUS_INVERSION_MASK)
  103. #define GetControl(port) ((parport_read_control(port)^CONTROL_INVERSION_MASK)&(0x3f))
  104. #define SetControl(port,val) parport_write_control(port,(val)^CONTROL_INVERSION_MASK)
  106. #define GetStatusMasked(port,mask) (GetStatus(port) & (mask))
  107. #define GetControlMasked(port,mask) (GetControl(port) & (mask))
  108. #define SetControlMasked(port,mask) SetControl(port,GetControl(port) | (mask));
  109. #define ClearControlMasked(port,mask) SetControl(port,GetControl(port)&~(mask));
  110. #define FrobControlBit(port,mask,value) SetControl(port,(GetControl(port)&~(mask))|((value)&(mask)));
  112. #define PACKET_LENGTH  8
  114. /* Magic numbers for defining port-device mappings */
  115. #define PPCPIA_PARPORT_UNSPEC -4
  116. #define PPCPIA_PARPORT_AUTO -3
  117. #define PPCPIA_PARPORT_OFF -2
  118. #define PPCPIA_PARPORT_NONE -1
  120. #ifdef MODULE
  121. static int parport_nr[PARPORT_MAX] = {[0 ... PARPORT_MAX - 1] = PPCPIA_PARPORT_UNSPEC};
  122. static char *parport[PARPORT_MAX] = {NULL,};
  124. MODULE_AUTHOR("B. Huisman <bhuism@cs.utwente.nl> & Peter Pregler <Peter_Pregler@email.com>");
  125. MODULE_DESCRIPTION("Parallel port driver for Vision CPiA based cameras");
  126. MODULE_LICENSE("GPL");
  128. MODULE_PARM(parport, "1-" __MODULE_STRING(PARPORT_MAX) "s");
  129. MODULE_PARM_DESC(parport, "'auto' or a list of parallel port numbers. Just like lp.");
  130. #else
  131. static int parport_nr[PARPORT_MAX] __initdata =
  132. {[0 ... PARPORT_MAX - 1] = PPCPIA_PARPORT_UNSPEC};
  133. static int parport_ptr = 0;
  134. #endif
  136. struct pp_cam_entry {
  137. struct pardevice *pdev;
  138. struct parport *port;
  139. struct tq_struct cb_task;
  140. int open_count;
  141. wait_queue_head_t wq_stream;
  142. /* image state flags */
  143. int image_ready; /* we got an interrupt */
  144. int image_complete; /* we have seen 4 EOI */
  146. int streaming; /* we are in streaming mode */
  147. int stream_irq;
  148. };
  150. static struct cpia_camera_ops cpia_pp_ops = 
  151. {
  152. cpia_pp_open,
  153. cpia_pp_registerCallback,
  154. cpia_pp_transferCmd,
  155. cpia_pp_streamStart,
  156. cpia_pp_streamStop,
  157. cpia_pp_streamRead,
  158. cpia_pp_close,
  159. 1
  160. };
  162. static struct cam_data *cam_list;
  163. static spinlock_t cam_list_lock_pp;
  165. #ifdef _CPIA_DEBUG_
  166. #define DEB_PORT(port) { 
  167. u8 controll = GetControl(port); 
  168. u8 statusss = GetStatus(port); 
  169. DBG("nsel %c per %c naut %c nstrob %c nak %c busy %c nfaul %c sel %c init %c dir %cn",
  170. ((controll & nSelectIn) ? 'U' : 'D'), 
  171. ((statusss & PError) ? 'U' : 'D'), 
  172. ((controll & nAutoFd) ? 'U' : 'D'), 
  173. ((controll & nStrobe) ? 'U' : 'D'), 
  174. ((statusss & nAck) ? 'U' : 'D'), 
  175. ((statusss & Busy) ? 'U' : 'D'), 
  176. ((statusss & nFault) ? 'U' : 'D'), 
  177. ((statusss & Select) ? 'U' : 'D'), 
  178. ((controll & nInit) ? 'U' : 'D'), 
  179. ((controll & DirBit) ? 'R' : 'F')  
  180. ); }
  181. #else
  182. #define DEB_PORT(port) {}
  183. #endif
  185. #define WHILE_OUT_TIMEOUT (HZ/10)
  186. #define DMA_TIMEOUT 10*HZ
  188. /* FIXME */
  189. static void cpia_parport_enable_irq( struct parport *port ) {
  190. parport_enable_irq(port);
  191. mdelay(10);
  192. return;
  193. }
  195. static void cpia_parport_disable_irq( struct parport *port ) {
  196. parport_disable_irq(port);
  197. mdelay(10);
  198. return;
  199. }
  201. /****************************************************************************
  202.  *
  203.  *  EndTransferMode
  204.  *
  205.  ***************************************************************************/
  206. static void EndTransferMode(struct pp_cam_entry *cam)
  207. {
  208. parport_negotiate(cam->port, IEEE1284_MODE_COMPAT);
  209. }
  211. /****************************************************************************
  212.  *
  213.  *  ForwardSetup
  214.  *
  215.  ***************************************************************************/
  216. static int ForwardSetup(struct pp_cam_entry *cam)
  217. {
  218. int retry;
  220. /* After some commands the camera needs extra time before
  221.  * it will respond again, so we try up to 3 times */
  222. for(retry=0; retry<3; ++retry) {
  223. if(!parport_negotiate(cam->port, IEEE1284_MODE_ECP)) {
  224. break;
  225. }
  226. }
  227. if(retry == 3) {
  228. DBG("Unable to negotiate ECP moden");
  229. return -1;
  230. }
  231. return 0;
  232. }
  234. /****************************************************************************
  235.  *
  236.  *  ReverseSetup
  237.  *
  238.  ***************************************************************************/
  239. static int ReverseSetup(struct pp_cam_entry *cam, int extensibility)
  240. {
  241. int retry;
  242. int mode = IEEE1284_MODE_ECP;
  243. if(extensibility) mode = 8|3|IEEE1284_EXT_LINK;
  245. /* After some commands the camera needs extra time before
  246.  * it will respond again, so we try up to 3 times */
  247. for(retry=0; retry<3; ++retry) {
  248. if(!parport_negotiate(cam->port, mode)) {
  249. break;
  250. }
  251. }
  252. if(retry == 3) {
  253. if(extensibility)
  254. DBG("Unable to negotiate extensibility moden");
  255. else
  256. DBG("Unable to negotiate ECP moden");
  257. return -1;
  258. }
  259. if(extensibility) cam->port->ieee1284.mode = IEEE1284_MODE_ECP;
  260. return 0;
  261. }
  263. /****************************************************************************
  264.  *
  265.  *  WritePacket
  266.  *
  267.  ***************************************************************************/
  268. static int WritePacket(struct pp_cam_entry *cam, const u8 *packet, size_t size)
  269. {
  270. int retval=0;
  271. int size_written;
  273. if (packet == NULL) {
  274. return -EINVAL;
  275. }
  276. if (ForwardSetup(cam)) {
  277. DBG("Write failed in setupn");
  278. return -EIO;
  279. }
  280. size_written = parport_write(cam->port, packet, size);
  281. if(size_written != size) {
  282. DBG("Write failed, wrote %d/%dn", size_written, size);
  283. retval = -EIO;
  284. }
  285. EndTransferMode(cam);
  286. return retval;
  287. }
  289. /****************************************************************************
  290.  *
  291.  *  ReadPacket
  292.  *
  293.  ***************************************************************************/
  294. static int ReadPacket(struct pp_cam_entry *cam, u8 *packet, size_t size)
  295. {
  296. int retval=0;
  297. if (packet == NULL) {
  298. return -EINVAL;
  299. }
  300. if (ReverseSetup(cam, 0)) {
  301. return -EIO;
  302. }
  303. if(parport_read(cam->port, packet, size) != size) {
  304. retval = -EIO;
  305. }
  306. EndTransferMode(cam);
  307. return retval;
  308. }
  310. /****************************************************************************
  311.  *
  312.  *  cpia_pp_streamStart
  313.  *
  314.  ***************************************************************************/
  315. static int cpia_pp_streamStart(void *privdata)
  316. {
  317. struct pp_cam_entry *cam = privdata;
  318. DBG("n");
  319. cam->streaming=1;
  320. cam->image_ready=0;
  321. //if (ReverseSetup(cam,1)) return -EIO;
  322. if(cam->stream_irq) cpia_parport_enable_irq(cam->port);
  323. return 0;
  324. }
  326. /****************************************************************************
  327.  *
  328.  *  cpia_pp_streamStop
  329.  *
  330.  ***************************************************************************/
  331. static int cpia_pp_streamStop(void *privdata)
  332. {
  333. struct pp_cam_entry *cam = privdata;
  335. DBG("n");
  336. cam->streaming=0;
  337. cpia_parport_disable_irq(cam->port);
  338. //EndTransferMode(cam);
  340. return 0;
  341. }
  343. static int cpia_pp_read(struct parport *port, u8 *buffer, int len)
  344. {
  345. int bytes_read, new_bytes;
  346. for(bytes_read=0; bytes_read<len; bytes_read += new_bytes) {
  347. new_bytes = parport_read(port, buffer+bytes_read,
  348.                  len-bytes_read);
  349. if(new_bytes < 0) break;
  350. }
  351. return bytes_read;
  352. }
  354. /****************************************************************************
  355.  *
  356.  *  cpia_pp_streamRead
  357.  *
  358.  ***************************************************************************/
  359. static int cpia_pp_streamRead(void *privdata, u8 *buffer, int noblock)
  360. {
  361. struct pp_cam_entry *cam = privdata;
  362. int read_bytes = 0;
  363. int i, endseen, block_size, new_bytes;
  365. if(cam == NULL) {
  366. DBG("Internal driver error: cam is NULLn");
  367. return -EINVAL;
  368. }
  369. if(buffer == NULL) {
  370. DBG("Internal driver error: buffer is NULLn");
  371. return -EINVAL;
  372. }
  373. //if(cam->streaming) DBG("%d / %dn", cam->image_ready, noblock);
  374. if( cam->stream_irq ) {
  375. DBG("%dn", cam->image_ready);
  376. cam->image_ready--;
  377. }
  378. cam->image_complete=0;
  379. if (0/*cam->streaming*/) {
  380. if(!cam->image_ready) {
  381. if(noblock) return -EWOULDBLOCK;
  382. interruptible_sleep_on(&cam->wq_stream);
  383. if( signal_pending(current) ) return -EINTR;
  384. DBG("%dn", cam->image_ready);
  385. }
  386. } else {
  387. if (ReverseSetup(cam, 1)) {
  388. DBG("unable to ReverseSetupn");
  389. return -EIO;
  390. }
  391. }
  392. endseen = 0;
  393. block_size = PARPORT_CHUNK_SIZE;
  394. while( !cam->image_complete ) {
  395. if(current->need_resched)  schedule();
  397. new_bytes = cpia_pp_read(cam->port, buffer, block_size );
  398. if( new_bytes <= 0 ) {
  399. break;
  400. }
  401. i=-1;
  402. while(++i<new_bytes && endseen<4) {
  403.          if(*buffer==EOI) {
  404.                  endseen++;
  405.                 } else {
  406.                  endseen=0;
  407.                 }
  408. buffer++;
  409. }
  410. read_bytes += i;
  411. if( endseen==4 ) {
  412. cam->image_complete=1;
  413. break;
  414. }
  415. if( CPIA_MAX_IMAGE_SIZE-read_bytes <= PARPORT_CHUNK_SIZE ) {
  416. block_size=CPIA_MAX_IMAGE_SIZE-read_bytes;
  417. }
  418. }
  419. EndTransferMode(cam);
  420. return cam->image_complete ? read_bytes : -EIO;
  421. }
  423. /****************************************************************************
  424.  *
  425.  *  cpia_pp_transferCmd
  426.  *
  427.  ***************************************************************************/
  428. static int cpia_pp_transferCmd(void *privdata, u8 *command, u8 *data)
  429. {
  430. int err;
  431. int retval=0;
  432. int databytes;
  433. struct pp_cam_entry *cam = privdata;
  435. if(cam == NULL) {
  436. DBG("Internal driver error: cam is NULLn");
  437. return -EINVAL;
  438. }
  439. if(command == NULL) {
  440. DBG("Internal driver error: command is NULLn");
  441. return -EINVAL;
  442. }
  443. databytes = (((int)command[7])<<8) | command[6];
  444. if ((err = WritePacket(cam, command, PACKET_LENGTH)) < 0) {
  445. DBG("Error writing commandn");
  446. return err;
  447. }
  448. if(command[0] == DATA_IN) {
  449. u8 buffer[8];
  450. if(data == NULL) {
  451. DBG("Internal driver error: data is NULLn");
  452. return -EINVAL;
  453. }
  454. if((err = ReadPacket(cam, buffer, 8)) < 0) {
  455. return err;
  456. DBG("Error reading command resultn");
  457. }
  458. memcpy(data, buffer, databytes);
  459. } else if(command[0] == DATA_OUT) {
  460. if(databytes > 0) {
  461. if(data == NULL) {
  462. DBG("Internal driver error: data is NULLn");
  463. retval = -EINVAL;
  464. } else {
  465. if((err=WritePacket(cam, data, databytes)) < 0){
  466. DBG("Error writing command datan");
  467. return err;
  468. }
  469. }
  470. }
  471. } else {
  472. DBG("Unexpected first byte of command: %xn", command[0]);
  473. retval = -EINVAL;
  474. }
  475. return retval;
  476. }
  478. /****************************************************************************
  479.  *
  480.  *  cpia_pp_open
  481.  *
  482.  ***************************************************************************/
  483. static int cpia_pp_open(void *privdata)
  484. {
  485. struct pp_cam_entry *cam = (struct pp_cam_entry *)privdata;
  487. if (cam == NULL)
  488. return -EINVAL;
  490. if(cam->open_count == 0) {
  491. if (parport_claim(cam->pdev)) {
  492. DBG("failed to claim the portn");
  493. return -EBUSY;
  494. }
  495. parport_negotiate(cam->port, IEEE1284_MODE_COMPAT);
  496. parport_data_forward(cam->port);
  497. parport_write_control(cam->port, PARPORT_CONTROL_SELECT);
  498. udelay(50);
  499. parport_write_control(cam->port,
  500.                       PARPORT_CONTROL_SELECT
  501.                       | PARPORT_CONTROL_INIT);
  502. }
  504. ++cam->open_count;
  506. return 0;
  507. }
  509. /****************************************************************************
  510.  *
  511.  *  cpia_pp_registerCallback
  512.  *
  513.  ***************************************************************************/
  514. static int cpia_pp_registerCallback(void *privdata, void (*cb)(void *cbdata), void *cbdata)
  515. {
  516. struct pp_cam_entry *cam = privdata;
  517. int retval = 0;
  519. if(cam->port->irq != PARPORT_IRQ_NONE) {
  520. cam->cb_task.routine = cb;
  521. cam->cb_task.data = cbdata;
  522. } else {
  523. retval = -1;
  524. }
  525. return retval;
  526. }
  528. /****************************************************************************
  529.  *
  530.  *  cpia_pp_close
  531.  *
  532.  ***************************************************************************/
  533. static int cpia_pp_close(void *privdata)
  534. {
  535. struct pp_cam_entry *cam = privdata;
  536. if (--cam->open_count == 0) {
  537. parport_release(cam->pdev);
  538. }
  539. return 0;
  540. }
  542. /****************************************************************************
  543.  *
  544.  *  cpia_pp_register
  545.  *
  546.  ***************************************************************************/
  547. static int cpia_pp_register(struct parport *port)
  548. {
  549. struct pardevice *pdev = NULL;
  550. struct pp_cam_entry *cam;
  551. struct cam_data *cpia;
  553. if (!(port->modes & PARPORT_MODE_ECP) &&
  554.     !(port->modes & PARPORT_MODE_TRISTATE)) {
  555. LOG("port is not ECP capablen");
  556. return -ENXIO;
  557. }
  559. cam = kmalloc(sizeof(struct pp_cam_entry), GFP_KERNEL);
  560. if (cam == NULL) {
  561. LOG("failed to allocate camera structuren");
  562. return -ENOMEM;
  563. }
  564. memset(cam,0,sizeof(struct pp_cam_entry));
  566. pdev = parport_register_device(port, "cpia_pp", NULL, NULL,
  567.                                NULL, 0, cam);
  569. if (!pdev) {
  570. LOG("failed to parport_register_devicen");
  571. kfree(cam);
  572. return -ENXIO;
  573. }
  575. cam->pdev = pdev;
  576. cam->port = port;
  577. init_waitqueue_head(&cam->wq_stream);
  579. cam->streaming = 0;
  580. cam->stream_irq = 0;
  582. if((cpia = cpia_register_camera(&cpia_pp_ops, cam)) == NULL) {
  583. LOG("failed to cpia_register_cameran");
  584. parport_unregister_device(pdev);
  585. kfree(cam);
  586. return -ENXIO;
  587. }
  588. spin_lock( &cam_list_lock_pp );
  589. cpia_add_to_list(cam_list, cpia);
  590. spin_unlock( &cam_list_lock_pp );
  592. return 0;
  593. }
  595. static void cpia_pp_detach (struct parport *port)
  596. {
  597. struct cam_data *cpia;
  599. spin_lock( &cam_list_lock_pp );
  600. for(cpia = cam_list; cpia != NULL; cpia = cpia->next) {
  601. struct pp_cam_entry *cam = cpia->lowlevel_data;
  602. if (cam && cam->port->number == port->number) {
  603. cpia_remove_from_list(cpia);
  604. spin_unlock( &cam_list_lock_pp );
  605. cpia_unregister_camera(cpia);
  607. if(cam->open_count > 0) {
  608. cpia_pp_close(cam);
  609. }
  611. parport_unregister_device(cam->pdev);
  613. kfree(cam);
  614. cpia->lowlevel_data = NULL;
  615. break;
  616. }
  617. }
  618. }
  620. static void cpia_pp_attach (struct parport *port)
  621. {
  622. unsigned int i;
  624. switch (parport_nr[0])
  625. {
  626. case PPCPIA_PARPORT_UNSPEC:
  627. case PPCPIA_PARPORT_AUTO:
  628. if (port->probe_info[0].class != PARPORT_CLASS_MEDIA ||
  629.     port->probe_info[0].cmdset == NULL ||
  630.     strncmp(port->probe_info[0].cmdset, "CPIA_1", 6) != 0)
  631. return;
  633. cpia_pp_register(port);
  635. break;
  637. default:
  638. for (i = 0; i < PARPORT_MAX; ++i) {
  639. if (port->number == parport_nr[i]) {
  640. cpia_pp_register(port);
  641. break;
  642. }
  643. }
  644. break;
  645. }
  646. }
  648. static struct parport_driver cpia_pp_driver = {
  649. "cpia_pp",
  650. cpia_pp_attach,
  651. cpia_pp_detach,
  652. NULL
  653. };
  655. int cpia_pp_init(void)
  656. {
  657. printk(KERN_INFO "%s v%d.%d.%dn",ABOUT, 
  658.        CPIA_PP_MAJ_VER,CPIA_PP_MIN_VER,CPIA_PP_PATCH_VER);
  660. if(parport_nr[0] == PPCPIA_PARPORT_OFF) {
  661. printk("  disabledn");
  662. return 0;
  663. }
  665. if (parport_register_driver (&cpia_pp_driver)) {
  666. LOG ("unable to register with parportn");
  667. return -EIO;
  668. }
  670. cam_list = NULL;
  671. spin_lock_init( &cam_list_lock_pp );
  673. return 0;
  674. }
  676. #ifdef MODULE
  677. int init_module(void)
  678. {
  679. if (parport[0]) {
  680. /* The user gave some parameters.  Let's see what they were. */
  681. if (!strncmp(parport[0], "auto", 4)) {
  682. parport_nr[0] = PPCPIA_PARPORT_AUTO;
  683. } else {
  684. int n;
  685. for (n = 0; n < PARPORT_MAX && parport[n]; n++) {
  686. if (!strncmp(parport[n], "none", 4)) {
  687. parport_nr[n] = PPCPIA_PARPORT_NONE;
  688. } else {
  689. char *ep;
  690. unsigned long r = simple_strtoul(parport[n], &ep, 0);
  691. if (ep != parport[n]) {
  692. parport_nr[n] = r;
  693. } else {
  694. LOG("bad port specifier `%s'n", parport[n]);
  695. return -ENODEV;
  696. }
  697. }
  698. }
  699. }
  700. }
  701. #if defined(CONFIG_KMOD) && defined(CONFIG_PNP_PARPORT_MODULE)
  702. if(parport_enumerate() && !parport_enumerate()->probe_info.model) {
  703. request_module("parport_probe");
  704. }
  705. #endif
  706. return cpia_pp_init();
  707. }
  709. void cleanup_module(void)
  710. {
  711. parport_unregister_driver (&cpia_pp_driver);
  712. return;
  713. }
  715. #else /* !MODULE */
  717. static int __init cpia_pp_setup(char *str)
  718. {
  719. #if 0
  720. /* Is this only a 2.2ism? -jerdfelt */
  721. if (!str) {
  722. if (ints[0] == 0 || ints[1] == 0) {
  723. /* disable driver on "cpia_pp=" or "cpia_pp=0" */
  724. parport_nr[0] = PPCPIA_PARPORT_OFF;
  725. }
  726. } else
  727. #endif
  728. if (!strncmp(str, "parport", 7)) {
  729. int n = simple_strtoul(str + 7, NULL, 10);
  730. if (parport_ptr < PARPORT_MAX) {
  731. parport_nr[parport_ptr++] = n;
  732. } else {
  733. LOG("too many ports, %s ignored.n", str);
  734. }
  735. } else if (!strcmp(str, "auto")) {
  736. parport_nr[0] = PPCPIA_PARPORT_AUTO;
  737. } else if (!strcmp(str, "none")) {
  738. parport_nr[parport_ptr++] = PPCPIA_PARPORT_NONE;
  739. }
  741. return 0;
  742. }
  744. __setup("cpia_pp=", cpia_pp_setup);
  746. #endif /* !MODULE */