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

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

嵌入式Linux

开发平台：

Unix_Linux

hpusbscsi.c：源码内容
  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/sched.h>
  4. #include <linux/signal.h>
  5. #include <linux/errno.h>
  6. #include <linux/init.h>
  7. #include <linux/slab.h>
  8. #include <linux/spinlock.h>
  9. #include <linux/smp_lock.h>
  10. #include <linux/usb.h>
  11. #include <asm/atomic.h>
  12. #include <linux/blk.h>
  13. #include "../scsi/scsi.h"
  14. #include "../scsi/hosts.h"
  15. #include "../scsi/sd.h"
  17. #include "hpusbscsi.h"
  19. #define DEBUG(x...) 
  20. printk( KERN_DEBUG x )
  22. static char *states[]={"FREE", "BEGINNING", "WORKING", "ERROR", "WAIT", "PREMATURE"};
  24. #define TRACE_STATE printk(KERN_DEBUG"hpusbscsi->state = %s at line %dn", states[hpusbscsi->state], __LINE__)
  26. /* global variables */
  28. struct list_head hpusbscsi_devices;
  29. //LIST_HEAD(hpusbscsi_devices);
  31. /* USB related parts */
  33. static void *
  34. hpusbscsi_usb_probe (struct usb_device *dev, unsigned int interface,
  35.      const struct usb_device_id *id)
  36. {
  37. struct hpusbscsi *new;
  38. struct usb_interface_descriptor *altsetting =
  39. &(dev->actconfig->interface[interface].altsetting[0]);
  41. int i, result;
  43. /* basic check */
  45. if (altsetting->bNumEndpoints != 3) {
  46. printk (KERN_ERR "Wrong number of endpointsn");
  47. return NULL;
  48. }
  50. /* descriptor allocation */
  52. new =
  53. (struct hpusbscsi *) kmalloc (sizeof (struct hpusbscsi),
  54.       GFP_KERNEL);
  55. if (new == NULL)
  56. return NULL;
  57. DEBUG ("Allocated memoryn");
  58. memset (new, 0, sizeof (struct hpusbscsi));
  59. spin_lock_init (&new->dataurb.lock);
  60. spin_lock_init (&new->controlurb.lock);
  61. new->dev = dev;
  62. init_waitqueue_head (&new->pending);
  63. init_waitqueue_head (&new->deathrow);
  64. INIT_LIST_HEAD (&new->lh);
  68. /* finding endpoints */
  70. for (i = 0; i < altsetting->bNumEndpoints; i++) {
  71. if (
  72.     (altsetting->endpoint[i].
  73.      bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
  74.     USB_ENDPOINT_XFER_BULK) {
  75. if (altsetting->endpoint[i].
  76.     bEndpointAddress & USB_DIR_IN) {
  77. new->ep_in =
  78. altsetting->endpoint[i].
  79. bEndpointAddress &
  80. USB_ENDPOINT_NUMBER_MASK;
  81. } else {
  82. new->ep_out =
  83. altsetting->endpoint[i].
  84. bEndpointAddress &
  85. USB_ENDPOINT_NUMBER_MASK;
  86. }
  87. } else {
  88. new->ep_int =
  89. altsetting->endpoint[i].
  90. bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
  91. new->interrupt_interval= altsetting->endpoint[i].bInterval;
  92. }
  93. }
  95. /* USB initialisation magic for the simple case */
  97. result = usb_set_interface (dev, altsetting->bInterfaceNumber, 0);
  99. switch (result) {
  100. case 0: /* no error */
  101. break;
  103. case -EPIPE:
  104. usb_clear_halt (dev, usb_sndctrlpipe (dev, 0));
  105. break;
  107. default:
  108. printk (KERN_ERR "unknown error %d from usb_set_interfacen",
  109.  result);
  110. goto err_out;
  111. }
  113. /* making a template for the scsi layer to fake detection of a scsi device */
  115. memcpy (&(new->ctempl), &hpusbscsi_scsi_host_template,
  116. sizeof (hpusbscsi_scsi_host_template));
  117. (struct hpusbscsi *) new->ctempl.proc_dir = new;
  118. new->ctempl.module = THIS_MODULE;
  120. if (scsi_register_module (MODULE_SCSI_HA, &(new->ctempl)))
  121. goto err_out;
  123. /* adding to list for module unload */
  124. list_add (&hpusbscsi_devices, &new->lh);
  126. return new;
  128.       err_out:
  129. kfree (new);
  130. return NULL;
  131. }
  133. static void
  134. hpusbscsi_usb_disconnect (struct usb_device *dev, void *ptr)
  135. {
  136.                  usb_unlink_urb(&(((struct hpusbscsi *) ptr)->controlurb));
  137. ((struct hpusbscsi *) ptr)->dev = NULL;
  138. }
  140. static struct usb_device_id hpusbscsi_usb_ids[] = {
  141. {USB_DEVICE (0x03f0, 0x0701)}, /* HP 53xx */
  142. {USB_DEVICE (0x03f0, 0x0801)}, /* HP 7400 */
  143. {USB_DEVICE (0x0638, 0x026a)}, /*Scan Dual II */
  144. {} /* Terminating entry */
  145. };
  147. MODULE_DEVICE_TABLE (usb, hpusbscsi_usb_ids);
  148. MODULE_LICENSE("GPL");
  151. static struct usb_driver hpusbscsi_usb_driver = {
  152. name:"hpusbscsi",
  153. probe:hpusbscsi_usb_probe,
  154. disconnect:hpusbscsi_usb_disconnect,
  155. id_table:hpusbscsi_usb_ids,
  156. };
  158. /* module initialisation */
  160. int __init
  161. hpusbscsi_init (void)
  162. {
  163. int result;
  165. INIT_LIST_HEAD (&hpusbscsi_devices);
  166. DEBUG ("Driver loadedn");
  168. if ((result = usb_register (&hpusbscsi_usb_driver)) < 0) {
  169. printk (KERN_ERR "hpusbscsi: driver registration failedn");
  170. return -1;
  171. } else {
  172. return 0;
  173. }
  174. }
  176. void __exit
  177. hpusbscsi_exit (void)
  178. {
  179. struct list_head *tmp;
  180. struct list_head *old;
  181. struct hpusbscsi * o;
  183. for (tmp = hpusbscsi_devices.next; tmp != &hpusbscsi_devices;/*nothing */) {
  184. old = tmp;
  185. tmp = tmp->next;
  186. o = (struct hpusbscsi *)old;
  187. usb_unlink_urb(&o->controlurb);
  188. scsi_unregister_module(MODULE_SCSI_HA,&o->ctempl);
  189. kfree(old);
  190. }
  192. usb_deregister (&hpusbscsi_usb_driver);
  193. }
  195. module_init (hpusbscsi_init);
  196. module_exit (hpusbscsi_exit);
  198. /* interface to the scsi layer */
  200. static int
  201. hpusbscsi_scsi_detect (struct SHT *sht)
  202. {
  203. /* Whole function stolen from usb-storage */
  205. struct hpusbscsi *desc = (struct hpusbscsi *) sht->proc_dir;
  206. /* What a hideous hack! */
  208. char local_name[48];
  211. /* set up the name of our subdirectory under /proc/scsi/ */
  212. sprintf (local_name, "hpusbscsi-%d", desc->number);
  213. sht->proc_name = kmalloc (strlen (local_name) + 1, GFP_KERNEL);
  214. /* FIXME: where is this freed ? */
  216. if (!sht->proc_name) {
  217. return 0;
  218. }
  220. strcpy (sht->proc_name, local_name);
  222. sht->proc_dir = NULL;
  224. /* build and submit an interrupt URB for status byte handling */
  225.   FILL_INT_URB(&desc->controlurb,
  226. desc->dev,
  227. usb_rcvintpipe(desc->dev,desc->ep_int),
  228. &desc->scsi_state_byte,
  229. 1,
  230. control_interrupt_callback,
  231. desc,
  232. desc->interrupt_interval
  233. );
  235. if ( 0  >  usb_submit_urb(&desc->controlurb)) {
  236. kfree(sht->proc_name);
  237. return 0;
  238. }
  240. /* In host->hostdata we store a pointer to desc */
  241. desc->host = scsi_register (sht, sizeof (desc));
  242. if (desc->host == NULL) {
  243. kfree (sht->proc_name);
  244. usb_unlink_urb(&desc->controlurb);
  245. return 0;
  246. }
  247. desc->host->hostdata[0] = (unsigned long) desc;
  250. return 1;
  251. }
  253. static int hpusbscsi_scsi_queuecommand (Scsi_Cmnd *srb, scsi_callback callback)
  254. {
  255. struct hpusbscsi* hpusbscsi = (struct hpusbscsi*)(srb->host->hostdata[0]);
  256. usb_urb_callback usb_callback;
  257. int res;
  259. hpusbscsi->use_count++;
  261. /* we don't answer for anything but our single device on any faked host controller */
  262. if ( srb->device->lun || srb->device->id || srb->device->channel ) {
  263. if (callback) {
  264. srb->result = DID_BAD_TARGET;
  265. callback(srb);
  266. }
  267.                  goto out;
  268. }
  270. /* Now we need to decide which callback to give to the urb we send the command with */
  272. if (!srb->bufflen) {
  273. usb_callback = simple_command_callback;
  274. } else {
  275.          if (srb->use_sg) {
  276. usb_callback = scatter_gather_callback;
  277. hpusbscsi->fragment = 0;
  278. } else {
  279.                  usb_callback = simple_payload_callback;
  280. }
  281. /* Now we find out which direction data is to be transfered in */
  282. hpusbscsi->current_data_pipe = DIRECTION_IS_IN(srb->cmnd[0]) ?
  283. usb_rcvbulkpipe(hpusbscsi->dev, hpusbscsi->ep_in)
  284. :
  285. usb_sndbulkpipe(hpusbscsi->dev, hpusbscsi->ep_out)
  286. ;
  287. }
  290. TRACE_STATE;
  291. if (hpusbscsi->state != HP_STATE_FREE) {
  292. printk(KERN_CRIT"hpusbscsi - Ouch: queueing violation!n");
  293. return 1; /* This must not happen */
  294. }
  296.         /* We zero the sense buffer to avoid confusing user space */
  297.         memset(srb->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
  299. hpusbscsi->state = HP_STATE_BEGINNING;
  300. TRACE_STATE;
  302. /* We prepare the urb for writing out the scsi command */
  303. FILL_BULK_URB(
  304. &hpusbscsi->dataurb,
  305. hpusbscsi->dev,
  306. usb_sndbulkpipe(hpusbscsi->dev,hpusbscsi->ep_out),
  307. srb->cmnd,
  308. srb->cmd_len,
  309. usb_callback,
  310. hpusbscsi
  311. );
  312. hpusbscsi->scallback = callback;
  313. hpusbscsi->srb = srb;
  315. res = usb_submit_urb(&hpusbscsi->dataurb);
  316. if (res) {
  317. hpusbscsi->state = HP_STATE_FREE;
  318. TRACE_STATE;
  319. if (callback) {
  320. srb->result = DID_ERROR;
  321. callback(srb);
  322. }
  323. }
  325. out:
  326. hpusbscsi->use_count--;
  327. return 0;
  328. }
  330. static int hpusbscsi_scsi_host_reset (Scsi_Cmnd *srb)
  331. {
  332. struct hpusbscsi* hpusbscsi = (struct hpusbscsi*)(srb->host->hostdata[0]);
  334. printk(KERN_DEBUG"SCSI reset requested.n");
  335. usb_reset_device(hpusbscsi->dev);
  336. printk(KERN_DEBUG"SCSI reset completed.n");
  337. hpusbscsi->state = HP_STATE_FREE;
  339. return 0;
  340. }
  342. static int hpusbscsi_scsi_abort (Scsi_Cmnd *srb)
  343. {
  344. struct hpusbscsi* hpusbscsi = (struct hpusbscsi*)(srb->host->hostdata[0]);
  345. printk(KERN_DEBUG"Requested is canceled.n");
  347. usb_unlink_urb(&hpusbscsi->dataurb);
  348. usb_unlink_urb(&hpusbscsi->controlurb);
  349. hpusbscsi->state = HP_STATE_FREE;
  351. return SCSI_ABORT_PENDING;
  352. }
  354. /* usb interrupt handlers - they are all running IN INTERRUPT ! */
  356. static void handle_usb_error (struct hpusbscsi *hpusbscsi)
  357. {
  358. if (hpusbscsi->scallback != NULL) {
  359. hpusbscsi->srb->result = DID_ERROR;
  360. hpusbscsi->scallback(hpusbscsi->srb);
  361. }
  362. hpusbscsi->state = HP_STATE_FREE;
  363. }
  365. static void  control_interrupt_callback (struct urb *u)
  366. {
  367. struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
  369. DEBUG("Getting status byte %d n",hpusbscsi->scsi_state_byte);
  370. if(u->status < 0) {
  371.                 if (hpusbscsi->state != HP_STATE_FREE)
  372.                         handle_usb_error(hpusbscsi);
  373. return;
  374. }
  375. hpusbscsi->srb->result &= SCSI_ERR_MASK;
  376. hpusbscsi->srb->result |= hpusbscsi->scsi_state_byte<<1;
  378. if (hpusbscsi->scallback != NULL && hpusbscsi->state == HP_STATE_WAIT)
  379. /* we do a callback to the scsi layer if and only if all data has been transfered */
  380. hpusbscsi->scallback(hpusbscsi->srb);
  382. TRACE_STATE;
  383. switch (hpusbscsi->state) {
  384. case HP_STATE_WAIT:
  385. hpusbscsi->state = HP_STATE_FREE;
  386. TRACE_STATE;
  387. break;
  388. case HP_STATE_WORKING:
  389. case HP_STATE_BEGINNING:
  390. hpusbscsi->state = HP_STATE_PREMATURE;
  391. TRACE_STATE;
  392. break;
  393. default:
  394. printk(KERN_ERR"hpusbscsi: Unexpected status report.n");
  395. TRACE_STATE;
  396. hpusbscsi->state = HP_STATE_FREE;
  397. TRACE_STATE;
  398. break;
  399. }
  400. }
  402. static void simple_command_callback(struct urb *u)
  403. {
  404. struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
  405. if (u->status<0) {
  406. handle_usb_error(hpusbscsi);
  407. return;
  408.         }
  409. TRACE_STATE;
  410. if (hpusbscsi->state != HP_STATE_PREMATURE) {
  411.         TRACE_STATE;
  412. hpusbscsi->state = HP_STATE_WAIT;
  413. } else {
  414. if (hpusbscsi->scallback != NULL)
  415. hpusbscsi->scallback(hpusbscsi->srb);
  416. hpusbscsi->state = HP_STATE_FREE;
  417. TRACE_STATE;
  418. }
  419. }
  421. static void scatter_gather_callback(struct urb *u)
  422. {
  423. struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
  424.         struct scatterlist *sg = hpusbscsi->srb->buffer;
  425.         usb_urb_callback callback;
  426.         int res;
  428.         DEBUG("Going through scatter/gathern");
  429.         if (u->status < 0) {
  430.                 handle_usb_error(hpusbscsi);
  431.                 return;
  432.         }
  434.         if (hpusbscsi->fragment + 1 != hpusbscsi->srb->use_sg)
  435.                 callback = scatter_gather_callback;
  436.         else
  437.                 callback = simple_done;
  439. TRACE_STATE;
  440.         if (hpusbscsi->state != HP_STATE_PREMATURE)
  441. hpusbscsi->state = HP_STATE_WORKING;
  442. TRACE_STATE;
  444.         FILL_BULK_URB(
  445.                 u,
  446.                 hpusbscsi->dev,
  447.                 hpusbscsi->current_data_pipe,
  448.                 sg[hpusbscsi->fragment].address,
  449.                 sg[hpusbscsi->fragment++].length,
  450.                 callback,
  451.                 hpusbscsi
  452.         );
  454.         res = usb_submit_urb(u);
  455.         if (res)
  456.                 hpusbscsi->state = HP_STATE_ERROR;
  457. TRACE_STATE;
  458. }
  460. static void simple_done (struct urb *u)
  461. {
  462. struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
  464.         if (u->status < 0) {
  465.                 handle_usb_error(hpusbscsi);
  466.                 return;
  467.         }
  468.         DEBUG("Data transfer donen");
  469. TRACE_STATE;
  470. if (hpusbscsi->state != HP_STATE_PREMATURE) {
  471. if (u->status < 0)
  472. hpusbscsi->state = HP_STATE_ERROR;
  473. else
  474. hpusbscsi->state = HP_STATE_WAIT;
  475. TRACE_STATE;
  476. } else {
  477. if (hpusbscsi->scallback != NULL)
  478. hpusbscsi->scallback(hpusbscsi->srb);
  479. hpusbscsi->state = HP_STATE_FREE;
  480. }
  481. }
  483. static void simple_payload_callback (struct urb *u)
  484. {
  485. struct hpusbscsi * hpusbscsi = (struct hpusbscsi *)u->context;
  486. int res;
  488. if (u->status<0) {
  489.                 handle_usb_error(hpusbscsi);
  490. return;
  491.         }
  493. FILL_BULK_URB(
  494. u,
  495. hpusbscsi->dev,
  496. hpusbscsi->current_data_pipe,
  497. hpusbscsi->srb->buffer,
  498. hpusbscsi->srb->bufflen,
  499. simple_done,
  500. hpusbscsi
  501. );
  503. res = usb_submit_urb(u);
  504. if (res) {
  505.                 handle_usb_error(hpusbscsi);
  506. return;
  507.         }
  508. TRACE_STATE;
  509. if (hpusbscsi->state != HP_STATE_PREMATURE) {
  510. hpusbscsi->state = HP_STATE_WORKING;
  511. TRACE_STATE;
  512. } else {
  513. if (hpusbscsi->scallback != NULL)
  514. hpusbscsi->scallback(hpusbscsi->srb);
  515. hpusbscsi->state = HP_STATE_FREE;
  516. TRACE_STATE;
  517. }
  518. }