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

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

嵌入式Linux

开发平台：

Unix_Linux

mesh.c：源码内容
  1. /*
  2.  * SCSI low-level driver for the MESH (Macintosh Enhanced SCSI Hardware)
  3.  * bus adaptor found on Power Macintosh computers.
  4.  * We assume the MESH is connected to a DBDMA (descriptor-based DMA)
  5.  * controller.
  6.  *
  7.  * Paul Mackerras, August 1996.
  8.  * Copyright (C) 1996 Paul Mackerras.
  9.  */
  10. #include <linux/config.h>
  11. #include <linux/kernel.h>
  12. #include <linux/delay.h>
  13. #include <linux/types.h>
  14. #include <linux/string.h>
  15. #include <linux/slab.h>
  16. #include <linux/blk.h>
  17. #include <linux/proc_fs.h>
  18. #include <linux/stat.h>
  19. #include <linux/tqueue.h>
  20. #include <linux/interrupt.h>
  21. #include <linux/reboot.h>
  22. #include <linux/spinlock.h>
  23. #include <asm/dbdma.h>
  24. #include <asm/io.h>
  25. #include <asm/pgtable.h>
  26. #include <asm/prom.h>
  27. #include <asm/system.h>
  28. #include <asm/irq.h>
  29. #include <asm/hydra.h>
  30. #include <asm/processor.h>
  31. #include <asm/machdep.h>
  32. #include <asm/pmac_feature.h>
  33. #ifdef CONFIG_PMAC_PBOOK
  34. #include <linux/adb.h>
  35. #include <linux/pmu.h>
  36. #endif
  38. #include "scsi.h"
  39. #include "hosts.h"
  40. #include "mesh.h"
  42. /*
  43.  * To do:
  44.  * - handle aborts correctly
  45.  * - retry arbitration if lost (unless higher levels do this for us)
  46.  */
  48. #define MESH_NEW_STYLE_EH
  50. #if 1
  51. #undef KERN_DEBUG
  52. #define KERN_DEBUG KERN_WARNING
  53. #endif
  55. #if CONFIG_SCSI_MESH_SYNC_RATE == 0
  56. int mesh_sync_period = 100;
  57. int mesh_sync_offset = 0;
  58. #else
  59. int mesh_sync_period = 1000 / CONFIG_SCSI_MESH_SYNC_RATE; /* ns */
  60. int mesh_sync_offset = 15;
  61. #endif
  63. int mesh_sync_targets = 0xff; /* targets to set synchronous (bitmap) */
  64. int mesh_resel_targets = 0xff; /* targets that we let disconnect (bitmap) */
  65. int mesh_debug_targets = 0; /* print debug for these targets */
  66. unsigned char use_active_neg = 0;  /* bit mask for SEQ_ACTIVE_NEG if used */
  68. #define ALLOW_SYNC(tgt) ((mesh_sync_targets >> (tgt)) & 1)
  69. #define ALLOW_RESEL(tgt) ((mesh_resel_targets >> (tgt)) & 1)
  70. #define ALLOW_DEBUG(tgt) ((mesh_debug_targets >> (tgt)) & 1)
  71. #define DEBUG_TARGET(cmd) ((cmd) && ALLOW_DEBUG((cmd)->target))
  73. #undef MESH_DBG
  74. #define N_DBG_LOG 50
  75. #define N_DBG_SLOG 20
  76. #define NUM_DBG_EVENTS 13
  77. #undef DBG_USE_TB /* bombs on 601 */
  79. struct dbglog {
  80. char *fmt;
  81. u32 tb;
  82. u8 phase;
  83. u8 bs0;
  84. u8 bs1;
  85. u8 tgt;
  86. int d;
  87. };
  89. enum mesh_phase {
  90. idle,
  91. arbitrating,
  92. selecting,
  93. commanding,
  94. dataing,
  95. statusing,
  96. busfreeing,
  97. disconnecting,
  98. reselecting
  99. };
  101. enum msg_phase {
  102. msg_none,
  103. msg_out,
  104. msg_out_xxx,
  105. msg_out_last,
  106. msg_in,
  107. msg_in_bad,
  108. };
  110. enum sdtr_phase {
  111. do_sdtr,
  112. sdtr_sent,
  113. sdtr_done
  114. };
  116. struct mesh_target {
  117. enum sdtr_phase sdtr_state;
  118. int sync_params;
  119. int data_goes_out; /* guess as to data direction */
  120. Scsi_Cmnd *current_req;
  121. u32 saved_ptr;
  122. int want_abort;
  123. #ifdef MESH_DBG
  124. int log_ix;
  125. int n_log;
  126. struct dbglog log[N_DBG_LOG];
  127. #endif
  128. };
  130. struct mesh_state {
  131. volatile struct mesh_regs *mesh;
  132. int meshintr;
  133. volatile struct dbdma_regs *dma;
  134. int dmaintr;
  135. struct Scsi_Host *host;
  136. struct mesh_state *next;
  137. Scsi_Cmnd *request_q;
  138. Scsi_Cmnd *request_qtail;
  139. enum mesh_phase phase; /* what we're currently trying to do */
  140. enum msg_phase msgphase;
  141. int conn_tgt; /* target we're connected to */
  142. Scsi_Cmnd *current_req; /* req we're currently working on */
  143. int data_ptr;
  144. int dma_started;
  145. int dma_count;
  146. int stat;
  147. int aborting;
  148. int expect_reply;
  149. int n_msgin;
  150. u8 msgin[16];
  151. int n_msgout;
  152. int last_n_msgout;
  153. u8 msgout[16];
  154. struct dbdma_cmd *dma_cmds; /* space for dbdma commands, aligned */
  155. int clk_freq;
  156. struct mesh_target tgts[8];
  157. void *dma_cmd_space;
  158. struct device_node *ofnode;
  159. #ifndef MESH_NEW_STYLE_EH
  160. Scsi_Cmnd *completed_q;
  161. Scsi_Cmnd *completed_qtail;
  162. struct tq_struct tqueue;
  163. #endif
  164. #ifdef MESH_DBG
  165. int log_ix;
  166. int n_log;
  167. struct dbglog log[N_DBG_SLOG];
  168. #endif
  169. };
  171. #ifdef MESH_DBG
  173. static void dlog(struct mesh_state *ms, char *fmt, int a);
  174. static void dumplog(struct mesh_state *ms, int tgt);
  175. static void dumpslog(struct mesh_state *ms);
  177. #else
  178. static inline void dlog(struct mesh_state *ms, char *fmt, int a)
  179. {}
  180. static inline void dumplog(struct mesh_state *ms, int tgt)
  181. {}
  182. static inline void dumpslog(struct mesh_state *ms)
  183. {}
  185. #endif /* MESH_DBG */
  186. #define MKWORD(a, b, c, d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
  188. static struct mesh_state *all_meshes;
  190. static void mesh_init(struct mesh_state *);
  191. static int mesh_notify_reboot(struct notifier_block *, unsigned long, void *);
  192. static void mesh_dump_regs(struct mesh_state *);
  193. static void mesh_start(struct mesh_state *);
  194. static void mesh_start_cmd(struct mesh_state *, Scsi_Cmnd *);
  195. #ifndef MESH_NEW_STYLE_EH
  196. static void finish_cmds(void *);
  197. #endif
  198. static void add_sdtr_msg(struct mesh_state *);
  199. static void set_sdtr(struct mesh_state *, int, int);
  200. static void start_phase(struct mesh_state *);
  201. static void get_msgin(struct mesh_state *);
  202. static int msgin_length(struct mesh_state *);
  203. static void cmd_complete(struct mesh_state *);
  204. static void phase_mismatch(struct mesh_state *);
  205. static void reselected(struct mesh_state *);
  206. static void handle_reset(struct mesh_state *);
  207. static void handle_error(struct mesh_state *);
  208. static void handle_exception(struct mesh_state *);
  209. static void mesh_interrupt(int, void *, struct pt_regs *);
  210. static void do_mesh_interrupt(int, void *, struct pt_regs *);
  211. static void handle_msgin(struct mesh_state *);
  212. static void mesh_done(struct mesh_state *, int);
  213. static void mesh_completed(struct mesh_state *, Scsi_Cmnd *);
  214. static void set_dma_cmds(struct mesh_state *, Scsi_Cmnd *);
  215. static void halt_dma(struct mesh_state *);
  216. static int data_goes_out(Scsi_Cmnd *);
  217. static void do_abort(struct mesh_state *ms);
  218. static void set_mesh_power(struct mesh_state *ms, int state);
  220. #ifdef CONFIG_PMAC_PBOOK
  221. static int mesh_notify_sleep(struct pmu_sleep_notifier *self, int when);
  222. static struct pmu_sleep_notifier mesh_sleep_notifier = {
  223. mesh_notify_sleep,
  224. SLEEP_LEVEL_BLOCK,
  225. };
  226. #endif
  228. static struct notifier_block mesh_notifier = {
  229. mesh_notify_reboot,
  230. NULL,
  231. 0
  232. };
  234. int
  235. mesh_detect(Scsi_Host_Template *tp)
  236. {
  237. struct device_node *mesh;
  238. int nmeshes, tgt, *cfp, minper;
  239. struct mesh_state *ms, **prev_statep;
  240. struct Scsi_Host *mesh_host;
  241. void *dma_cmd_space;
  243. if (_machine == _MACH_Pmac) {
  244.     use_active_neg = (find_devices("mac-io") ? 0 : SEQ_ACTIVE_NEG);
  245. } else {
  246.     /* CHRP mac-io */
  247.     use_active_neg = SEQ_ACTIVE_NEG;
  248. }
  250. nmeshes = 0;
  251. prev_statep = &all_meshes;
  252. /*
  253.  * On powermacs, the MESH node has device_type "mesh".
  254.  * On chrp machines, its device_type is "scsi" with
  255.  * "chrp,mesh0" as its `compatible' property.
  256.  */
  257. mesh = find_devices("mesh");
  258. if (mesh == 0)
  259. mesh = find_compatible_devices("scsi", "chrp,mesh0");
  260. for (; mesh != 0; mesh = mesh->next) {
  261. if (mesh->n_addrs != 2 || mesh->n_intrs != 2) {
  262. printk(KERN_ERR "mesh: expected 2 addrs and 2 intrs"
  263.        " (got %d,%d)", mesh->n_addrs, mesh->n_intrs);
  264. continue;
  265. }
  266. mesh_host = scsi_register(tp, sizeof(struct mesh_state));
  267. if (mesh_host == 0) {
  268. printk(KERN_ERR "mesh: couldn't register host");
  269. continue;
  270. }
  271. mesh_host->unique_id = nmeshes;
  272. #if !defined(MODULE)
  273. note_scsi_host(mesh, mesh_host);
  274. #endif
  276. ms = (struct mesh_state *) mesh_host->hostdata;
  277. if (ms == 0)
  278. panic("no mesh state");
  279. memset(ms, 0, sizeof(*ms));
  280. ms->host = mesh_host;
  281. ms->ofnode = mesh;
  282. ms->mesh = (volatile struct mesh_regs *)
  283. ioremap(mesh->addrs[0].address, 0x1000);
  284. ms->dma = (volatile struct dbdma_regs *)
  285. ioremap(mesh->addrs[1].address, 0x1000);
  286. ms->meshintr = mesh->intrs[0].line;
  287. ms->dmaintr = mesh->intrs[1].line;
  289. /* Space for dma command list: +1 for stop command,
  290.    +1 to allow for aligning. */
  291. dma_cmd_space = kmalloc((mesh_host->sg_tablesize + 2) *
  292. sizeof(struct dbdma_cmd), GFP_KERNEL);
  293. if (dma_cmd_space == 0)
  294. panic("mesh: couldn't allocate dma command space");
  295. ms->dma_cmds = (struct dbdma_cmd *) DBDMA_ALIGN(dma_cmd_space);
  296. memset(ms->dma_cmds, 0, (mesh_host->sg_tablesize + 1)
  297.        * sizeof(struct dbdma_cmd));
  298. ms->dma_cmd_space = dma_cmd_space;
  300. ms->current_req = 0;
  301. for (tgt = 0; tgt < 8; ++tgt) {
  302. ms->tgts[tgt].sdtr_state = do_sdtr;
  303. ms->tgts[tgt].sync_params = ASYNC_PARAMS;
  304. ms->tgts[tgt].current_req = 0;
  305. }
  306. #ifndef MESH_NEW_STYLE_EH
  307. ms->tqueue.routine = finish_cmds;
  308. ms->tqueue.data = ms;
  309. #endif
  310. *prev_statep = ms;
  311. prev_statep = &ms->next;
  313. if ((cfp = (int *) get_property(mesh, "clock-frequency",
  314. NULL))) {
  315. ms->clk_freq = *cfp;
  316. } else {
  317. printk(KERN_INFO "mesh: assuming 50MHz clock frequencyn");
  318. ms->clk_freq = 50000000;
  319. }
  320. /* The maximum sync rate is clock / 5; increase
  321.    mesh_sync_period if necessary. */
  322. minper = 1000000000 / (ms->clk_freq / 5); /* ns */
  323. if (mesh_sync_period < minper)
  324. mesh_sync_period = minper;
  326. set_mesh_power(ms, 1);
  328. mesh_init(ms);
  330. if (request_irq(ms->meshintr, do_mesh_interrupt, 0, "MESH", ms)) {
  331. printk(KERN_ERR "MESH: can't get irq %dn", ms->meshintr);
  332. }
  334. ++nmeshes;
  335. }
  337. if ((_machine == _MACH_Pmac) && (nmeshes > 0)) {
  338. #ifdef CONFIG_PMAC_PBOOK
  339. pmu_register_sleep_notifier(&mesh_sleep_notifier);
  340. #endif /* CONFIG_PMAC_PBOOK */
  341. register_reboot_notifier(&mesh_notifier);
  342. }
  344. return nmeshes;
  345. }
  347. int
  348. mesh_release(struct Scsi_Host *host)
  349. {
  350. struct mesh_state *ms = (struct mesh_state *) host->hostdata;
  352. if (ms == 0)
  353. return 0;
  354. if (ms->mesh)
  355. iounmap((void *) ms->mesh);
  356. if (ms->dma)
  357. iounmap((void *) ms->dma);
  358. kfree(ms->dma_cmd_space);
  359. free_irq(ms->meshintr, ms);
  360. pmac_call_feature(PMAC_FTR_MESH_ENABLE, ms->ofnode, 0, 0);
  361. return 0;
  362. }
  364. static void
  365. set_mesh_power(struct mesh_state *ms, int state)
  366. {
  367. if (_machine != _MACH_Pmac)
  368. return;
  369. if (state) {
  370. pmac_call_feature(PMAC_FTR_MESH_ENABLE, ms->ofnode, 0, 1);
  371. mdelay(200);
  372. } else {
  373. pmac_call_feature(PMAC_FTR_MESH_ENABLE, ms->ofnode, 0, 0);
  374. mdelay(10);
  375. }
  376. }
  378. #ifdef CONFIG_PMAC_PBOOK
  379. /*
  380.  * notify clients before sleep and reset bus afterwards
  381.  */
  382. int
  383. mesh_notify_sleep(struct pmu_sleep_notifier *self, int when)
  384. {
  385. struct mesh_state *ms;
  387. switch (when) {
  388. case PBOOK_SLEEP_REQUEST:
  389. /* XXX We should wait for current transactions and queue
  390.  * new ones that would be posted beyond this point 
  391.  */ 
  392. break;
  393. case PBOOK_SLEEP_REJECT:
  394. break;
  396. case PBOOK_SLEEP_NOW:
  397. for (ms = all_meshes; ms != 0; ms = ms->next) {
  398. disable_irq(ms->meshintr);
  399. set_mesh_power(ms, 0);
  400. }
  401. break;
  402. case PBOOK_WAKE:
  403. for (ms = all_meshes; ms != 0; ms = ms->next) {
  404. set_mesh_power(ms, 1);
  405. mesh_init(ms);
  406. enable_irq(ms->meshintr);
  407. }
  408. break;
  409. }
  410. return PBOOK_SLEEP_OK;
  411. }
  412. #endif /* CONFIG_PMAC_PBOOK */
  414. int
  415. mesh_queue(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
  416. {
  417. unsigned long flags;
  418. struct mesh_state *ms;
  420. cmd->scsi_done = done;
  421. cmd->host_scribble = NULL;
  423. ms = (struct mesh_state *) cmd->host->hostdata;
  425. save_flags(flags);
  426. cli();
  427. if (ms->request_q == NULL)
  428. ms->request_q = cmd;
  429. else
  430. ms->request_qtail->host_scribble = (void *) cmd;
  431. ms->request_qtail = cmd;
  433. if (ms->phase == idle)
  434. mesh_start(ms);
  436. restore_flags(flags);
  437. return 0;
  438. }
  440. int
  441. mesh_abort(Scsi_Cmnd *cmd)
  442. {
  443. struct mesh_state *ms = (struct mesh_state *) cmd->host->hostdata;
  445. printk(KERN_DEBUG "mesh_abort(%p)n", cmd);
  446. mesh_dump_regs(ms);
  447. dumplog(ms, cmd->target);
  448. dumpslog(ms);
  449. return SCSI_ABORT_SNOOZE;
  450. }
  452. static void
  453. mesh_dump_regs(struct mesh_state *ms)
  454. {
  455. volatile struct mesh_regs *mr = ms->mesh;
  456. volatile struct dbdma_regs *md = ms->dma;
  457. int t;
  458. struct mesh_target *tp;
  460. printk(KERN_DEBUG "mesh: state at %p, regs at %p, dma at %pn",
  461.        ms, mr, md);
  462. printk(KERN_DEBUG "    ct=%4x seq=%2x bs=%4x fc=%2x "
  463.        "exc=%2x err=%2x im=%2x int=%2x sp=%2xn",
  464.        (mr->count_hi << 8) + mr->count_lo, mr->sequence,
  465.        (mr->bus_status1 << 8) + mr->bus_status0, mr->fifo_count,
  466.        mr->exception, mr->error, mr->intr_mask, mr->interrupt,
  467.        mr->sync_params);
  468. while(in_8(&mr->fifo_count))
  469. printk(KERN_DEBUG " fifo data=%.2xn",in_8(&mr->fifo));
  470. printk(KERN_DEBUG "    dma stat=%x cmdptr=%xn",
  471.        in_le32(&md->status), in_le32(&md->cmdptr));
  472. printk(KERN_DEBUG "    phase=%d msgphase=%d conn_tgt=%d data_ptr=%dn",
  473.        ms->phase, ms->msgphase, ms->conn_tgt, ms->data_ptr);
  474. printk(KERN_DEBUG "    dma_st=%d dma_ct=%d n_msgout=%dn",
  475.        ms->dma_started, ms->dma_count, ms->n_msgout);
  476. for (t = 0; t < 8; ++t) {
  477. tp = &ms->tgts[t];
  478. if (tp->current_req == NULL)
  479. continue;
  480. printk(KERN_DEBUG "    target %d: req=%p goes_out=%d saved_ptr=%dn",
  481.        t, tp->current_req, tp->data_goes_out, tp->saved_ptr);
  482. }
  483. }
  485. int
  486. mesh_reset(Scsi_Cmnd *cmd, unsigned how)
  487. {
  488. struct mesh_state *ms = (struct mesh_state *) cmd->host->hostdata;
  489. volatile struct mesh_regs *mr = ms->mesh;
  490. volatile struct dbdma_regs *md = ms->dma;
  491. unsigned long flags;
  492. int ret;
  494. printk(KERN_DEBUG "mesh_reset %xn", how);
  495. ret = SCSI_RESET_BUS_RESET;
  496. save_flags(flags);
  497. cli();
  498. out_le32(&md->control, (RUN|PAUSE|FLUSH|WAKE) << 16); /* stop dma */
  499. out_8(&mr->exception, 0xff); /* clear all exception bits */
  500. out_8(&mr->error, 0xff); /* clear all error bits */
  501. if (how & SCSI_RESET_SUGGEST_HOST_RESET) {
  502. out_8(&mr->sequence, SEQ_RESETMESH);
  503. ret |= SCSI_RESET_HOST_RESET;
  504. udelay(1);
  505. out_8(&mr->intr_mask, INT_ERROR | INT_EXCEPTION | INT_CMDDONE);
  506. out_8(&mr->source_id, ms->host->this_id);
  507. out_8(&mr->sel_timeout, 25); /* 250ms */
  508. out_8(&mr->sync_params, ASYNC_PARAMS);
  509. }
  510. out_8(&mr->bus_status1, BS1_RST); /* assert RST */
  511. udelay(30); /* leave it on for >= 25us */
  512. out_8(&mr->bus_status1, 0); /* negate RST */
  513. #ifdef DO_ASYNC_RESET
  514. if (how & SCSI_RESET_ASYNCHRONOUS) {
  515. restore_flags(flags);
  516. ret |= SCSI_RESET_PENDING;
  517. } else
  518. #endif
  519. {
  520. handle_reset(ms);
  521. restore_flags(flags);
  522. #ifndef MESH_NEW_STYLE_EH
  523. finish_cmds(ms);
  524. #endif
  525. ret |= SCSI_RESET_SUCCESS;
  526. }
  527. return ret;
  528. }
  530. /*
  531.  * If we leave drives set for synchronous transfers (especially
  532.  * CDROMs), and reboot to MacOS, it gets confused, poor thing.
  533.  * So, on reboot we reset the SCSI bus.
  534.  */
  535. static int
  536. mesh_notify_reboot(struct notifier_block *this, unsigned long code, void *x)
  537. {
  538. struct mesh_state *ms;
  539. volatile struct mesh_regs *mr;
  541. if (code == SYS_DOWN) {
  542. printk(KERN_INFO "resetting MESH scsi bus(es)n");
  543. for (ms = all_meshes; ms != 0; ms = ms->next) {
  544. mr = ms->mesh;
  545. out_8(&mr->intr_mask, 0);
  546. out_8(&mr->interrupt,
  547.       INT_ERROR | INT_EXCEPTION | INT_CMDDONE);
  548. out_8(&mr->bus_status1, BS1_RST);
  549. udelay(30);
  550. out_8(&mr->bus_status1, 0);
  551. }
  552. }
  553. return NOTIFY_DONE;
  554. }
  556. int
  557. mesh_command(Scsi_Cmnd *cmd)
  558. {
  559. printk(KERN_WARNING "whoops... mesh_command calledn");
  560. return -1;
  561. }
  563. static void
  564. mesh_init(struct mesh_state *ms)
  565. {
  566. volatile struct mesh_regs *mr = ms->mesh;
  567. volatile struct dbdma_regs *md = ms->dma;
  569. udelay(100);
  571. out_le32(&md->control, (RUN|PAUSE|FLUSH|WAKE) << 16); /* stop dma */
  572. out_8(&mr->exception, 0xff); /* clear all exception bits */
  573. out_8(&mr->error, 0xff); /* clear all error bits */
  574. out_8(&mr->sequence, SEQ_RESETMESH);
  575. udelay(10);
  576. out_8(&mr->intr_mask, INT_ERROR | INT_EXCEPTION | INT_CMDDONE);
  577. out_8(&mr->source_id, ms->host->this_id);
  578. out_8(&mr->sel_timeout, 25); /* 250ms */
  579. out_8(&mr->sync_params, ASYNC_PARAMS);
  581. out_8(&mr->bus_status1, BS1_RST); /* assert RST */
  582. udelay(30); /* leave it on for >= 25us */
  583. out_8(&mr->bus_status1, 0); /* negate RST */
  585. out_8(&mr->sequence, SEQ_FLUSHFIFO);
  586. udelay(1);
  587. out_8(&mr->sync_params, ASYNC_PARAMS);
  588. out_8(&mr->sequence, SEQ_ENBRESEL);
  589. out_8(&mr->interrupt, 0xff); /* clear all interrupt bits */
  590. }
  592. /*
  593.  * Start the next command for a MESH.
  594.  * Should be called with interrupts disabled.
  595.  */
  596. static void
  597. mesh_start(struct mesh_state *ms)
  598. {
  599. Scsi_Cmnd *cmd, *prev, *next;
  601. if (ms->phase != idle || ms->current_req != NULL) {
  602. printk(KERN_ERR "inappropriate mesh_start (phase=%d, ms=%p)",
  603.        ms->phase, ms);
  604. return;
  605. }
  607. while (ms->phase == idle) {
  608. prev = NULL;
  609. for (cmd = ms->request_q; ; cmd = (Scsi_Cmnd *) cmd->host_scribble) {
  610. if (cmd == NULL)
  611. return;
  612. if (ms->tgts[cmd->target].current_req == NULL)
  613. break;
  614. prev = cmd;
  615. }
  616. next = (Scsi_Cmnd *) cmd->host_scribble;
  617. if (prev == NULL)
  618. ms->request_q = next;
  619. else
  620. prev->host_scribble = (void *) next;
  621. if (next == NULL)
  622. ms->request_qtail = prev;
  624. mesh_start_cmd(ms, cmd);
  625. }
  626. }
  628. static void
  629. mesh_start_cmd(struct mesh_state *ms, Scsi_Cmnd *cmd)
  630. {
  631. volatile struct mesh_regs *mr = ms->mesh;
  632. int t;
  634. ms->current_req = cmd;
  635. ms->tgts[cmd->target].data_goes_out = data_goes_out(cmd);
  636. ms->tgts[cmd->target].current_req = cmd;
  638. #if 1
  639. if (DEBUG_TARGET(cmd)) {
  640. int i;
  641. printk(KERN_DEBUG "mesh_start: %p ser=%lu tgt=%d cmd=",
  642.        cmd, cmd->serial_number, cmd->target);
  643. for (i = 0; i < cmd->cmd_len; ++i)
  644. printk(" %x", cmd->cmnd[i]);
  645. printk(" use_sg=%d buffer=%p bufflen=%un",
  646.        cmd->use_sg, cmd->request_buffer, cmd->request_bufflen);
  647. }
  648. #endif
  650. ms->phase = arbitrating;
  651. ms->msgphase = msg_none;
  652. ms->data_ptr = 0;
  653. ms->dma_started = 0;
  654. ms->n_msgout = 0;
  655. ms->last_n_msgout = 0;
  656. ms->expect_reply = 0;
  657. ms->conn_tgt = cmd->target;
  658. ms->tgts[cmd->target].saved_ptr = 0;
  659. ms->stat = DID_OK;
  660. ms->aborting = 0;
  661. #ifdef MESH_DBG
  662. ms->tgts[cmd->target].n_log = 0;
  663. dlog(ms, "start cmd=%x", (int) cmd);
  664. #endif
  666. /* Off we go */
  667. dlog(ms, "about to arb, intr/exc/err/fc=%.8x",
  668.      MKWORD(mr->interrupt, mr->exception, mr->error, mr->fifo_count));
  669. out_8(&mr->interrupt, INT_CMDDONE);
  670. out_8(&mr->sequence, SEQ_ENBRESEL);
  671. udelay(1);
  673. if (mr->bus_status1 & (BS1_BSY | BS1_SEL)) {
  674. /*
  675.  * Some other device has the bus or is arbitrating for it -
  676.  * probably a target which is about to reselect us.
  677.  */
  678. dlog(ms, "busy b4 arb, intr/exc/err/fc=%.8x",
  679.      MKWORD(mr->interrupt, mr->exception,
  680.     mr->error, mr->fifo_count));
  681. for (t = 100; t > 0; --t) {
  682. if ((mr->bus_status1 & (BS1_BSY | BS1_SEL)) == 0)
  683. break;
  684. if (in_8(&mr->interrupt) != 0) {
  685. dlog(ms, "intr b4 arb, intr/exc/err/fc=%.8x",
  686.      MKWORD(mr->interrupt, mr->exception,
  687.     mr->error, mr->fifo_count));
  688. mesh_interrupt(0, (void *)ms, 0);
  689. if (ms->phase != arbitrating)
  690. return;
  691. }
  692. udelay(1);
  693. }
  694. if (mr->bus_status1 & (BS1_BSY | BS1_SEL)) {
  695. /* XXX should try again in a little while */
  696. ms->stat = DID_BUS_BUSY;
  697. ms->phase = idle;
  698. mesh_done(ms, 0);
  699. return;
  700. }
  701. }
  703. /*
  704.  * Apparently the mesh has a bug where it will assert both its
  705.  * own bit and the target's bit on the bus during arbitration.
  706.  */
  707. out_8(&mr->dest_id, mr->source_id);
  709. /*
  710.  * There appears to be a race with reselection sometimes,
  711.  * where a target reselects us just as we issue the
  712.  * arbitrate command.  It seems that then the arbitrate
  713.  * command just hangs waiting for the bus to be free
  714.  * without giving us a reselection exception.
  715.  * The only way I have found to get it to respond correctly
  716.  * is this: disable reselection before issuing the arbitrate
  717.  * command, then after issuing it, if it looks like a target
  718.  * is trying to reselect us, reset the mesh and then enable
  719.  * reselection.
  720.  */
  721. out_8(&mr->sequence, SEQ_DISRESEL);
  722. if (in_8(&mr->interrupt) != 0) {
  723. dlog(ms, "intr after disresel, intr/exc/err/fc=%.8x",
  724.      MKWORD(mr->interrupt, mr->exception,
  725.     mr->error, mr->fifo_count));
  726. mesh_interrupt(0, (void *)ms, 0);
  727. if (ms->phase != arbitrating)
  728. return;
  729. dlog(ms, "after intr after disresel, intr/exc/err/fc=%.8x",
  730.      MKWORD(mr->interrupt, mr->exception,
  731.     mr->error, mr->fifo_count));
  732. }
  734. out_8(&mr->sequence, SEQ_ARBITRATE);
  736. for (t = 230; t > 0; --t) {
  737. if (in_8(&mr->interrupt) != 0)
  738. break;
  739. udelay(1);
  740. }
  741. dlog(ms, "after arb, intr/exc/err/fc=%.8x",
  742.      MKWORD(mr->interrupt, mr->exception, mr->error, mr->fifo_count));
  743. if (mr->interrupt == 0 && (mr->bus_status1 & BS1_SEL)
  744.     && (mr->bus_status0 & BS0_IO)) {
  745. /* looks like a reselection - try resetting the mesh */
  746. dlog(ms, "resel? after arb, intr/exc/err/fc=%.8x",
  747.      MKWORD(mr->interrupt, mr->exception, mr->error, mr->fifo_count));
  748. out_8(&mr->sequence, SEQ_RESETMESH);
  749. udelay(10);
  750. out_8(&mr->interrupt, INT_ERROR | INT_EXCEPTION | INT_CMDDONE);
  751. out_8(&mr->intr_mask, INT_ERROR | INT_EXCEPTION | INT_CMDDONE);
  752. out_8(&mr->sequence, SEQ_ENBRESEL);
  753. for (t = 10; t > 0 && mr->interrupt == 0; --t)
  754. udelay(1);
  755. dlog(ms, "tried reset after arb, intr/exc/err/fc=%.8x",
  756.      MKWORD(mr->interrupt, mr->exception, mr->error, mr->fifo_count));
  757. #ifndef MESH_MULTIPLE_HOSTS
  758. if (mr->interrupt == 0 && (mr->bus_status1 & BS1_SEL)
  759.     && (mr->bus_status0 & BS0_IO)) {
  760. printk(KERN_ERR "mesh: controller not responding"
  761.        " to reselection!n");
  762. /*
  763.  * If this is a target reselecting us, and the
  764.  * mesh isn't responding, the higher levels of
  765.  * the scsi code will eventually time out and
  766.  * reset the bus.
  767.  */
  768. }
  769. #endif
  770. }
  771. }
  773. #ifndef MESH_NEW_STYLE_EH
  774. static void
  775. finish_cmds(void *data)
  776. {
  777. struct mesh_state *ms = data;
  778. Scsi_Cmnd *cmd;
  779. unsigned long flags;
  781. for (;;) {
  782. spin_lock_irqsave(&io_request_lock, flags);
  783. cmd = ms->completed_q;
  784. if (cmd == NULL) {
  785. spin_unlock_irqrestore(&io_request_lock, flags);
  786. break;
  787. }
  788. ms->completed_q = (Scsi_Cmnd *) cmd->host_scribble;
  789. (*cmd->scsi_done)(cmd);
  790. spin_unlock_irqrestore(&io_request_lock, flags);
  791. }
  792. }
  793. #endif /* MESH_NEW_STYLE_EH */
  795. static inline void
  796. add_sdtr_msg(struct mesh_state *ms)
  797. {
  798. int i = ms->n_msgout;
  800. ms->msgout[i] = EXTENDED_MESSAGE;
  801. ms->msgout[i+1] = 3;
  802. ms->msgout[i+2] = EXTENDED_SDTR;
  803. ms->msgout[i+3] = mesh_sync_period/4;
  804. ms->msgout[i+4] = (ALLOW_SYNC(ms->conn_tgt)? mesh_sync_offset: 0);
  805. ms->n_msgout = i + 5;
  806. }
  808. static void
  809. set_sdtr(struct mesh_state *ms, int period, int offset)
  810. {
  811. struct mesh_target *tp = &ms->tgts[ms->conn_tgt];
  812. volatile struct mesh_regs *mr = ms->mesh;
  813. int v, tr;
  815. tp->sdtr_state = sdtr_done;
  816. if (offset == 0) {
  817. /* asynchronous */
  818. if (SYNC_OFF(tp->sync_params))
  819. printk(KERN_INFO "mesh: target %d now asynchronousn",
  820.        ms->conn_tgt);
  821. tp->sync_params = ASYNC_PARAMS;
  822. out_8(&mr->sync_params, ASYNC_PARAMS);
  823. return;
  824. }
  825. /*
  826.  * We need to compute ceil(clk_freq * period / 500e6) - 2
  827.  * without incurring overflow.
  828.  */
  829. v = (ms->clk_freq / 5000) * period;
  830. if (v <= 250000) {
  831. /* special case: sync_period == 5 * clk_period */
  832. v = 0;
  833. /* units of tr are 100kB/s */
  834. tr = (ms->clk_freq + 250000) / 500000;
  835. } else {
  836. /* sync_period == (v + 2) * 2 * clk_period */
  837. v = (v + 99999) / 100000 - 2;
  838. if (v > 15)
  839. v = 15; /* oops */
  840. tr = ((ms->clk_freq / (v + 2)) + 199999) / 200000;
  841. }
  842. if (offset > 15)
  843. offset = 15; /* can't happen */
  844. tp->sync_params = SYNC_PARAMS(offset, v);
  845. out_8(&mr->sync_params, tp->sync_params);
  846. printk(KERN_INFO "mesh: target %d synchronous at %d.%d MB/sn",
  847.        ms->conn_tgt, tr/10, tr%10);
  848. }
  850. static void
  851. start_phase(struct mesh_state *ms)
  852. {
  853. int i, seq, nb;
  854. volatile struct mesh_regs *mr = ms->mesh;
  855. volatile struct dbdma_regs *md = ms->dma;
  856. Scsi_Cmnd *cmd = ms->current_req;
  857. struct mesh_target *tp = &ms->tgts[ms->conn_tgt];
  859. dlog(ms, "start_phase nmo/exc/fc/seq = %.8x",
  860.      MKWORD(ms->n_msgout, mr->exception, mr->fifo_count, mr->sequence));
  861. out_8(&mr->interrupt, INT_ERROR | INT_EXCEPTION | INT_CMDDONE);
  862. seq = use_active_neg + (ms->n_msgout? SEQ_ATN: 0);
  863. switch (ms->msgphase) {
  864. case msg_none:
  865. break;
  867. case msg_in:
  868. out_8(&mr->count_hi, 0);
  869. out_8(&mr->count_lo, 1);
  870. out_8(&mr->sequence, SEQ_MSGIN + seq);
  871. ms->n_msgin = 0;
  872. return;
  874. case msg_out:
  875. /*
  876.  * To make sure ATN drops before we assert ACK for
  877.  * the last byte of the message, we have to do the
  878.  * last byte specially.
  879.  */
  880. if (ms->n_msgout <= 0) {
  881. printk(KERN_ERR "mesh: msg_out but n_msgout=%dn",
  882.        ms->n_msgout);
  883. mesh_dump_regs(ms);
  884. ms->msgphase = msg_none;
  885. break;
  886. }
  887. if (ALLOW_DEBUG(ms->conn_tgt)) {
  888. printk(KERN_DEBUG "mesh: sending %d msg bytes:",
  889.        ms->n_msgout);
  890. for (i = 0; i < ms->n_msgout; ++i)
  891. printk(" %x", ms->msgout[i]);
  892. printk("n");
  893. }
  894. dlog(ms, "msgout msg=%.8x", MKWORD(ms->n_msgout, ms->msgout[0],
  895. ms->msgout[1], ms->msgout[2]));
  896. out_8(&mr->count_hi, 0);
  897. out_8(&mr->sequence, SEQ_FLUSHFIFO);
  898. udelay(1);
  899. /*
  900.  * If ATN is not already asserted, we assert it, then
  901.  * issue a SEQ_MSGOUT to get the mesh to drop ACK.
  902.  */
  903. if ((mr->bus_status0 & BS0_ATN) == 0) {
  904. dlog(ms, "bus0 was %.2x explictly asserting ATN", mr->bus_status0);
  905. out_8(&mr->bus_status0, BS0_ATN); /* explicit ATN */
  906. udelay(1);
  907. out_8(&mr->count_lo, 1);
  908. out_8(&mr->sequence, SEQ_MSGOUT + seq);
  909. out_8(&mr->bus_status0, 0); /* release explicit ATN */
  910. dlog(ms,"hace: after explicit ATN bus0=%.2x",mr->bus_status0);
  911. }
  912. if (ms->n_msgout == 1) {
  913. /*
  914.  * We can't issue the SEQ_MSGOUT without ATN
  915.  * until the target has asserted REQ.  The logic
  916.  * in cmd_complete handles both situations:
  917.  * REQ already asserted or not.
  918.  */
  919. cmd_complete(ms);
  920. } else {
  921. out_8(&mr->count_lo, ms->n_msgout - 1);
  922. out_8(&mr->sequence, SEQ_MSGOUT + seq);
  923. for (i = 0; i < ms->n_msgout - 1; ++i)
  924. out_8(&mr->fifo, ms->msgout[i]);
  925. }
  926. return;
  928. default:
  929. printk(KERN_ERR "mesh bug: start_phase msgphase=%dn",
  930.        ms->msgphase);
  931. }
  933. switch (ms->phase) {
  934. case selecting:
  935. out_8(&mr->dest_id, ms->conn_tgt);
  936. out_8(&mr->sequence, SEQ_SELECT + SEQ_ATN);
  937. break;
  938. case commanding:
  939. out_8(&mr->sync_params, tp->sync_params);
  940. out_8(&mr->count_hi, 0);
  941. if (cmd) {
  942. out_8(&mr->count_lo, cmd->cmd_len);
  943. out_8(&mr->sequence, SEQ_COMMAND + seq);
  944. for (i = 0; i < cmd->cmd_len; ++i)
  945. out_8(&mr->fifo, cmd->cmnd[i]);
  946. } else {
  947. out_8(&mr->count_lo, 6);
  948. out_8(&mr->sequence, SEQ_COMMAND + seq);
  949. for (i = 0; i < 6; ++i)
  950. out_8(&mr->fifo, 0);
  951. }
  952. break;
  953. case dataing:
  954. /* transfer data, if any */
  955. if (!ms->dma_started) {
  956. set_dma_cmds(ms, cmd);
  957. out_le32(&md->cmdptr, virt_to_phys(ms->dma_cmds));
  958. out_le32(&md->control, (RUN << 16) | RUN);
  959. ms->dma_started = 1;
  960. }
  961. nb = ms->dma_count;
  962. if (nb > 0xfff0)
  963. nb = 0xfff0;
  964. ms->dma_count -= nb;
  965. ms->data_ptr += nb;
  966. out_8(&mr->count_lo, nb);
  967. out_8(&mr->count_hi, nb >> 8);
  968. out_8(&mr->sequence, (tp->data_goes_out?
  969. SEQ_DATAOUT: SEQ_DATAIN) + SEQ_DMA_MODE + seq);
  970. break;
  971. case statusing:
  972. out_8(&mr->count_hi, 0);
  973. out_8(&mr->count_lo, 1);
  974. out_8(&mr->sequence, SEQ_STATUS + seq);
  975. break;
  976. case busfreeing:
  977. case disconnecting:
  978. out_8(&mr->sequence, SEQ_ENBRESEL);
  979. udelay(1);
  980. dlog(ms, "enbresel intr/exc/err/fc=%.8x",
  981.      MKWORD(mr->interrupt, mr->exception, mr->error,
  982.     mr->fifo_count));
  983. out_8(&mr->sequence, SEQ_BUSFREE);
  984. break;
  985. default:
  986. printk(KERN_ERR "mesh: start_phase called with phase=%dn",
  987.        ms->phase);
  988. dumpslog(ms);
  989. }
  991. }
  993. static inline void
  994. get_msgin(struct mesh_state *ms)
  995. {
  996. volatile struct mesh_regs *mr = ms->mesh;
  997. int i, n;
  999. n = mr->fifo_count;
  1000. if (n != 0) {
  1001. i = ms->n_msgin;
  1002. ms->n_msgin = i + n;
  1003. for (; n > 0; --n)
  1004. ms->msgin[i++] = in_8(&mr->fifo);
  1005. }
  1006. }
  1008. static inline int
  1009. msgin_length(struct mesh_state *ms)
  1010. {
  1011. int b, n;
  1013. n = 1;
  1014. if (ms->n_msgin > 0) {
  1015. b = ms->msgin[0];
  1016. if (b == 1) {
  1017. /* extended message */
  1018. n = ms->n_msgin < 2? 2: ms->msgin[1] + 2;
  1019. } else if (0x20 <= b && b <= 0x2f) {
  1020. /* 2-byte message */
  1021. n = 2;
  1022. }
  1023. }
  1024. return n;
  1025. }
  1027. static void
  1028. cmd_complete(struct mesh_state *ms)
  1029. {
  1030. volatile struct mesh_regs *mr = ms->mesh;
  1031. Scsi_Cmnd *cmd = ms->current_req;
  1032. struct mesh_target *tp = &ms->tgts[ms->conn_tgt];
  1033. int seq, n, t;
  1035. dlog(ms, "cmd_complete fc=%x", mr->fifo_count);
  1036. seq = use_active_neg + (ms->n_msgout? SEQ_ATN: 0);
  1037. switch (ms->msgphase) {
  1038. case msg_out_xxx:
  1039. /* huh?  we expected a phase mismatch */
  1040. ms->n_msgin = 0;
  1041. ms->msgphase = msg_in;
  1042. /* fall through */
  1044. case msg_in:
  1045. /* should have some message bytes in fifo */
  1046. get_msgin(ms);
  1047. n = msgin_length(ms);
  1048. if (ms->n_msgin < n) {
  1049. out_8(&mr->count_lo, n - ms->n_msgin);
  1050. out_8(&mr->sequence, SEQ_MSGIN + seq);
  1051. } else {
  1052. ms->msgphase = msg_none;
  1053. handle_msgin(ms);
  1054. start_phase(ms);
  1055. }
  1056. break;
  1058. case msg_in_bad:
  1059. out_8(&mr->sequence, SEQ_FLUSHFIFO);
  1060. udelay(1);
  1061. out_8(&mr->count_lo, 1);
  1062. out_8(&mr->sequence, SEQ_MSGIN + SEQ_ATN + use_active_neg);
  1063. break;
  1065. case msg_out:
  1066. /*
  1067.  * To get the right timing on ATN wrt ACK, we have
  1068.  * to get the MESH to drop ACK, wait until REQ gets
  1069.  * asserted, then drop ATN.  To do this we first
  1070.  * issue a SEQ_MSGOUT with ATN and wait for REQ,
  1071.  * then change the command to a SEQ_MSGOUT w/o ATN.
  1072.  * If we don't see REQ in a reasonable time, we
  1073.  * change the command to SEQ_MSGIN with ATN,
  1074.  * wait for the phase mismatch interrupt, then
  1075.  * issue the SEQ_MSGOUT without ATN.
  1076.  */
  1077. out_8(&mr->count_lo, 1);
  1078. out_8(&mr->sequence, SEQ_MSGOUT + use_active_neg + SEQ_ATN);
  1079. t = 30; /* wait up to 30us */
  1080. while ((mr->bus_status0 & BS0_REQ) == 0 && --t >= 0)
  1081. udelay(1);
  1082. dlog(ms, "last_mbyte err/exc/fc/cl=%.8x",
  1083.      MKWORD(mr->error, mr->exception,
  1084.     mr->fifo_count, mr->count_lo));
  1085. if (in_8(&mr->interrupt) & (INT_ERROR | INT_EXCEPTION)) {
  1086. /* whoops, target didn't do what we expected */
  1087. ms->last_n_msgout = ms->n_msgout;
  1088. ms->n_msgout = 0;
  1089. if (in_8(&mr->interrupt) & INT_ERROR) {
  1090. printk(KERN_ERR "mesh: error %x in msg_outn",
  1091.        in_8(&mr->error));
  1092. handle_error(ms);
  1093. return;
  1094. }
  1095. if (in_8(&mr->exception) != EXC_PHASEMM)
  1096. printk(KERN_ERR "mesh: exc %x in msg_outn",
  1097.        in_8(&mr->exception));
  1098. else
  1099. printk(KERN_DEBUG "mesh: bs0=%x in msg_outn",
  1100.        in_8(&mr->bus_status0));
  1101. handle_exception(ms);
  1102. return;
  1103. }
  1104. if (mr->bus_status0 & BS0_REQ) {
  1105. out_8(&mr->sequence, SEQ_MSGOUT + use_active_neg);
  1106. udelay(1);
  1107. out_8(&mr->fifo, ms->msgout[ms->n_msgout-1]);
  1108. ms->msgphase = msg_out_last;
  1109. } else {
  1110. out_8(&mr->sequence, SEQ_MSGIN + use_active_neg + SEQ_ATN);
  1111. ms->msgphase = msg_out_xxx;
  1112. }
  1113. break;
  1115. case msg_out_last:
  1116. ms->last_n_msgout = ms->n_msgout;
  1117. ms->n_msgout = 0;
  1118. ms->msgphase = ms->expect_reply? msg_in: msg_none;
  1119. start_phase(ms);
  1120. break;
  1122. case msg_none:
  1123. switch (ms->phase) {
  1124. case idle:
  1125. printk(KERN_ERR "mesh: interrupt in idle phase?n");
  1126. dumpslog(ms);
  1127. return;
  1128. case selecting:
  1129. dlog(ms, "Selecting phase at command completion",0);
  1130. ms->msgout[0] = IDENTIFY(ALLOW_RESEL(ms->conn_tgt),
  1131.  (cmd? cmd->lun: 0));
  1132. ms->n_msgout = 1;
  1133. ms->expect_reply = 0;
  1134. if (ms->aborting) {
  1135. ms->msgout[0] = ABORT;
  1136. ms->n_msgout++;
  1137. } else if (tp->sdtr_state == do_sdtr) {
  1138. /* add SDTR message */
  1139. add_sdtr_msg(ms);
  1140. ms->expect_reply = 1;
  1141. tp->sdtr_state = sdtr_sent;
  1142. }
  1143. ms->msgphase = msg_out;
  1144. /*
  1145.  * We need to wait for REQ before dropping ATN.
  1146.  * We wait for at most 30us, then fall back to
  1147.  * a scheme where we issue a SEQ_COMMAND with ATN,
  1148.  * which will give us a phase mismatch interrupt
  1149.  * when REQ does come, and then we send the message.
  1150.  */
  1151. t = 230; /* wait up to 230us */
  1152. while ((mr->bus_status0 & BS0_REQ) == 0) {
  1153. if (--t < 0) {
  1154. dlog(ms, "impatient for req", ms->n_msgout);
  1155. ms->msgphase = msg_none;
  1156. break;
  1157. }
  1158. udelay(1);
  1159. }
  1160. break;
  1161. case dataing:
  1162. if (ms->dma_count != 0) {
  1163. start_phase(ms);
  1164. return;
  1165. }
  1166. /*
  1167.  * We can get a phase mismatch here if the target
  1168.  * changes to the status phase, even though we have
  1169.  * had a command complete interrupt.  Then, if we
  1170.  * issue the SEQ_STATUS command, we'll get a sequence
  1171.  * error interrupt.  Which isn't so bad except that
  1172.  * occasionally the mesh actually executes the
  1173.  * SEQ_STATUS *as well as* giving us the sequence
  1174.  * error and phase mismatch exception.
  1175.  */
  1176. out_8(&mr->sequence, 0);
  1177. out_8(&mr->interrupt,
  1178.       INT_ERROR | INT_EXCEPTION | INT_CMDDONE);
  1179. halt_dma(ms);
  1180. break;
  1181. case statusing:
  1182. if (cmd) {
  1183. cmd->SCp.Status = mr->fifo;
  1184. if (DEBUG_TARGET(cmd))
  1185. printk(KERN_DEBUG "mesh: status is %xn",
  1186.        cmd->SCp.Status);
  1187. }
  1188. ms->msgphase = msg_in;
  1189. break;
  1190. case busfreeing:
  1191. mesh_done(ms, 1);
  1192. return;
  1193. case disconnecting:
  1194. ms->current_req = 0;
  1195. ms->phase = idle;
  1196. mesh_start(ms);
  1197. return;
  1198. default:
  1199. break;
  1200. }
  1201. ++ms->phase;
  1202. start_phase(ms);
  1203. break;
  1204. }
  1205. }
  1207. static void phase_mismatch(struct mesh_state *ms)
  1208. {
  1209. volatile struct mesh_regs *mr = ms->mesh;
  1210. int phase;
  1212. dlog(ms, "phasemm ch/cl/seq/fc=%.8x",
  1213.      MKWORD(mr->count_hi, mr->count_lo, mr->sequence, mr->fifo_count));
  1214. phase = mr->bus_status0 & BS0_PHASE;
  1215. if (ms->msgphase == msg_out_xxx && phase == BP_MSGOUT) {
  1216. /* output the last byte of the message, without ATN */
  1217. out_8(&mr->count_lo, 1);
  1218. out_8(&mr->sequence, SEQ_MSGOUT + use_active_neg);
  1219. udelay(1);
  1220. out_8(&mr->fifo, ms->msgout[ms->n_msgout-1]);
  1221. ms->msgphase = msg_out_last;
  1222. return;
  1223. }
  1225. if (ms->msgphase == msg_in) {
  1226. get_msgin(ms);
  1227. if (ms->n_msgin)
  1228. handle_msgin(ms);
  1229. }
  1231. if (ms->dma_started)
  1232. halt_dma(ms);
  1233. if (mr->fifo_count) {
  1234. out_8(&mr->sequence, SEQ_FLUSHFIFO);
  1235. udelay(1);
  1236. }
  1238. ms->msgphase = msg_none;
  1239. switch (phase) {
  1240. case BP_DATAIN:
  1241. ms->tgts[ms->conn_tgt].data_goes_out = 0;
  1242. ms->phase = dataing;
  1243. break;
  1244. case BP_DATAOUT:
  1245. ms->tgts[ms->conn_tgt].data_goes_out = 1;
  1246. ms->phase = dataing;
  1247. break;
  1248. case BP_COMMAND:
  1249. ms->phase = commanding;
  1250. break;
  1251. case BP_STATUS:
  1252. ms->phase = statusing;
  1253. break;
  1254. case BP_MSGIN:
  1255. ms->msgphase = msg_in;
  1256. ms->n_msgin = 0;
  1257. break;
  1258. case BP_MSGOUT:
  1259. ms->msgphase = msg_out;
  1260. if (ms->n_msgout == 0) {
  1261. if (ms->aborting) {
  1262. do_abort(ms);
  1263. } else {
  1264. if (ms->last_n_msgout == 0) {
  1265. printk(KERN_DEBUG
  1266.        "mesh: no msg to repeatn");
  1267. ms->msgout[0] = NOP;
  1268. ms->last_n_msgout = 1;
  1269. }
  1270. ms->n_msgout = ms->last_n_msgout;
  1271. }
  1272. }
  1273. break;
  1274. default:
  1275. printk(KERN_DEBUG "mesh: unknown scsi phase %xn", phase);
  1276. ms->stat = DID_ERROR;
  1277. mesh_done(ms, 1);
  1278. return;
  1279. }
  1281. start_phase(ms);
  1282. }
  1284. static void
  1285. reselected(struct mesh_state *ms)
  1286. {
  1287. volatile struct mesh_regs *mr = ms->mesh;
  1288. Scsi_Cmnd *cmd;
  1289. struct mesh_target *tp;
  1290. int b, t, prev;
  1292. switch (ms->phase) {
  1293. case idle:
  1294. break;
  1295. case arbitrating:
  1296. if ((cmd = ms->current_req) != NULL) {
  1297. /* put the command back on the queue */
  1298. cmd->host_scribble = (void *) ms->request_q;
  1299. if (ms->request_q == NULL)
  1300. ms->request_qtail = cmd;
  1301. ms->request_q = cmd;
  1302. tp = &ms->tgts[cmd->target];
  1303. tp->current_req = NULL;
  1304. }
  1305. break;
  1306. case busfreeing:
  1307. ms->phase = reselecting;
  1308. mesh_done(ms, 0);
  1309. break;
  1310. case disconnecting:
  1311. break;
  1312. default:
  1313. printk(KERN_ERR "mesh: reselected in phase %d/%d tgt %dn",
  1314.        ms->msgphase, ms->phase, ms->conn_tgt);
  1315. dumplog(ms, ms->conn_tgt);
  1316. dumpslog(ms);
  1317. }
  1319. ms->current_req = NULL;
  1320. ms->phase = dataing;
  1321. ms->msgphase = msg_in;
  1322. ms->dma_started = 0;
  1323. ms->n_msgout = 0;
  1324. ms->last_n_msgout = 0;
  1325. prev = ms->conn_tgt;
  1327. /*
  1328.  * We seem to get abortive reselections sometimes.
  1329.  */
  1330. while ((mr->bus_status1 & BS1_BSY) == 0) {
  1331. static int mesh_aborted_resels;
  1332. mesh_aborted_resels++;
  1333. out_8(&mr->interrupt, INT_ERROR | INT_EXCEPTION | INT_CMDDONE);
  1334. udelay(1);
  1335. out_8(&mr->sequence, SEQ_ENBRESEL);
  1336. udelay(5);
  1337. dlog(ms, "extra resel err/exc/fc = %.6x",
  1338.      MKWORD(0, mr->error, mr->exception, mr->fifo_count));
  1339. }
  1340. out_8(&mr->interrupt, INT_ERROR | INT_EXCEPTION | INT_CMDDONE);
  1341. udelay(1);
  1342. out_8(&mr->sequence, SEQ_ENBRESEL);
  1343. udelay(1);
  1344. out_8(&mr->sync_params, ASYNC_PARAMS);
  1346. /*
  1347.  * Find out who reselected us.
  1348.  */
  1349. if (mr->fifo_count == 0) {
  1350. printk(KERN_ERR "mesh: reselection but nothing in fifo?n");
  1351. ms->conn_tgt = ms->host->this_id;
  1352. goto bogus;
  1353. }
  1354. /* get the last byte in the fifo */
  1355. do {
  1356. b = in_8(&mr->fifo);
  1357. dlog(ms, "reseldata %x", b);
  1358. } while (in_8(&mr->fifo_count));
  1359. for (t = 0; t < 8; ++t)
  1360. if ((b & (1 << t)) != 0 && t != ms->host->this_id)
  1361. break;
  1362. if (b != (1 << t) + (1 << ms->host->this_id)) {
  1363. printk(KERN_ERR "mesh: bad reselection data %xn", b);
  1364. ms->conn_tgt = ms->host->this_id;
  1365. goto bogus;
  1366. }
  1369. /*
  1370.  * Set up to continue with that target's transfer.
  1371.  */
  1372. ms->conn_tgt = t;
  1373. tp = &ms->tgts[t];
  1374. out_8(&mr->sync_params, tp->sync_params);
  1375. if (ALLOW_DEBUG(t)) {
  1376. printk(KERN_DEBUG "mesh: reselected by target %dn", t);
  1377. printk(KERN_DEBUG "mesh: saved_ptr=%x goes_out=%d cmd=%pn",
  1378.        tp->saved_ptr, tp->data_goes_out, tp->current_req);
  1379. }
  1380. ms->current_req = tp->current_req;
  1381. if (tp->current_req == NULL) {
  1382. printk(KERN_ERR "mesh: reselected by tgt %d but no cmd!n", t);
  1383. goto bogus;
  1384. }
  1385. ms->data_ptr = tp->saved_ptr;
  1386. dlog(ms, "resel prev tgt=%d", prev);
  1387. dlog(ms, "resel err/exc=%.4x", MKWORD(0, 0, mr->error, mr->exception));
  1388. start_phase(ms);
  1389. return;
  1391. bogus:
  1392. dumplog(ms, ms->conn_tgt);
  1393. dumpslog(ms);
  1394. ms->data_ptr = 0;
  1395. ms->aborting = 1;
  1396. start_phase(ms);
  1397. }
  1399. static void do_abort(struct mesh_state *ms)
  1400. {
  1401. ms->msgout[0] = ABORT;
  1402. ms->n_msgout = 1;
  1403. ms->aborting = 1;
  1404. ms->stat = DID_ABORT;
  1405. dlog(ms, "abort", 0);
  1406. }
  1408. static void
  1409. handle_reset(struct mesh_state *ms)
  1410. {
  1411. int tgt;
  1412. struct mesh_target *tp;
  1413. Scsi_Cmnd *cmd;
  1414. volatile struct mesh_regs *mr = ms->mesh;
  1416. for (tgt = 0; tgt < 8; ++tgt) {
  1417. tp = &ms->tgts[tgt];
  1418. if ((cmd = tp->current_req) != NULL) {
  1419. cmd->result = DID_RESET << 16;
  1420. tp->current_req = NULL;
  1421. mesh_completed(ms, cmd);
  1422. }
  1423. ms->tgts[tgt].sdtr_state = do_sdtr;
  1424. ms->tgts[tgt].sync_params = ASYNC_PARAMS;
  1425. }
  1426. ms->current_req = NULL;
  1427. while ((cmd = ms->request_q) != NULL) {
  1428. ms->request_q = (Scsi_Cmnd *) cmd->host_scribble;
  1429. cmd->result = DID_RESET << 16;
  1430. mesh_completed(ms, cmd);
  1431. }
  1432. ms->phase = idle;
  1433. ms->msgphase = msg_none;
  1434. out_8(&mr->interrupt, INT_ERROR | INT_EXCEPTION | INT_CMDDONE);
  1435. out_8(&mr->sequence, SEQ_FLUSHFIFO);
  1436. udelay(1);
  1437. out_8(&mr->sync_params, ASYNC_PARAMS);
  1438. out_8(&mr->sequence, SEQ_ENBRESEL);
  1439. }
  1441. static void
  1442. do_mesh_interrupt(int irq, void *dev_id, struct pt_regs *ptregs)
  1443. {
  1444. unsigned long flags;
  1446. spin_lock_irqsave(&io_request_lock, flags);
  1447. mesh_interrupt(irq, dev_id, ptregs);
  1448. spin_unlock_irqrestore(&io_request_lock, flags);
  1449. }
  1451. static void handle_error(struct mesh_state *ms)
  1452. {
  1453. int err, exc, count;
  1454. volatile struct mesh_regs *mr = ms->mesh;
  1456. err = in_8(&mr->error);
  1457. exc = in_8(&mr->exception);
  1458. out_8(&mr->interrupt, INT_ERROR | INT_EXCEPTION | INT_CMDDONE);
  1459. dlog(ms, "error err/exc/fc/cl=%.8x",
  1460.      MKWORD(err, exc, mr->fifo_count, mr->count_lo));
  1461. if (err & ERR_SCSIRESET) {
  1462. /* SCSI bus was reset */
  1463. printk(KERN_INFO "mesh: SCSI bus reset detected: "
  1464.        "waiting for end...");
  1465. while ((mr->bus_status1 & BS1_RST) != 0)
  1466. udelay(1);
  1467. printk("donen");
  1468. handle_reset(ms);
  1469. /* request_q is empty, no point in mesh_start() */
  1470. return;
  1471. }
  1472. if (err & ERR_UNEXPDISC) {
  1473. /* Unexpected disconnect */
  1474. if (exc & EXC_RESELECTED) {
  1475. reselected(ms);
  1476. return;
  1477. }
  1478. if (!ms->aborting) {
  1479. printk(KERN_WARNING "mesh: target %d abortedn",
  1480.        ms->conn_tgt);
  1481. dumplog(ms, ms->conn_tgt);
  1482. dumpslog(ms);
  1483. }
  1484. out_8(&mr->interrupt, INT_CMDDONE);
  1485. ms->stat = DID_ABORT;
  1486. mesh_done(ms, 1);
  1487. return;
  1488. }
  1489. if (err & ERR_PARITY) {
  1490. if (ms->msgphase == msg_in) {
  1491. printk(KERN_ERR "mesh: msg parity error, target %dn",
  1492.        ms->conn_tgt);
  1493. ms->msgout[0] = MSG_PARITY_ERROR;
  1494. ms->n_msgout = 1;
  1495. ms->msgphase = msg_in_bad;
  1496. cmd_complete(ms);
  1497. return;
  1498. }
  1499. if (ms->stat == DID_OK) {
  1500. printk(KERN_ERR "mesh: parity error, target %dn",
  1501.        ms->conn_tgt);
  1502. ms->stat = DID_PARITY;
  1503. }
  1504. count = (mr->count_hi << 8) + mr->count_lo;
  1505. if (count == 0) {
  1506. cmd_complete(ms);
  1507. } else {
  1508. /* reissue the data transfer command */
  1509. out_8(&mr->sequence, mr->sequence);
  1510. }
  1511. return;
  1512. }
  1513. if (err & ERR_SEQERR) {
  1514. if (exc & EXC_RESELECTED) {
  1515. /* This can happen if we issue a command to
  1516.    get the bus just after the target reselects us. */
  1517. static int mesh_resel_seqerr;
  1518. mesh_resel_seqerr++;
  1519. reselected(ms);
  1520. return;
  1521. }
  1522. if (exc == EXC_PHASEMM) {
  1523. static int mesh_phasemm_seqerr;
  1524. mesh_phasemm_seqerr++;
  1525. phase_mismatch(ms);
  1526. return;
  1527. }
  1528. printk(KERN_ERR "mesh: sequence error (err=%x exc=%x)n",
  1529.        err, exc);
  1530. } else {
  1531. printk(KERN_ERR "mesh: unknown error %x (exc=%x)n", err, exc);
  1532. }
  1533. mesh_dump_regs(ms);
  1534. dumplog(ms, ms->conn_tgt);
  1535. if (ms->phase > selecting && (mr->bus_status1 & BS1_BSY)) {
  1536. /* try to do what the target wants */
  1537. do_abort(ms);
  1538. phase_mismatch(ms);
  1539. return;
  1540. }
  1541. ms->stat = DID_ERROR;
  1542. mesh_done(ms, 1);
  1543. }
  1545. static void handle_exception(struct mesh_state *ms)
  1546. {
  1547. int exc;
  1548. volatile struct mesh_regs *mr = ms->mesh;
  1550. exc = in_8(&mr->exception);
  1551. out_8(&mr->interrupt, INT_EXCEPTION | INT_CMDDONE);
  1552. if (exc & EXC_RESELECTED) {
  1553. static int mesh_resel_exc;
  1554. mesh_resel_exc++;
  1555. reselected(ms);
  1556. } else if (exc == EXC_ARBLOST) {
  1557. printk(KERN_DEBUG "mesh: lost arbitrationn");
  1558. ms->stat = DID_BUS_BUSY;
  1559. mesh_done(ms, 1);
  1560. } else if (exc == EXC_SELTO) {
  1561. /* selection timed out */
  1562. ms->stat = DID_BAD_TARGET;
  1563. mesh_done(ms, 1);
  1564. } else if (exc == EXC_PHASEMM) {
  1565. /* target wants to do something different:
  1566.    find out what it wants and do it. */
  1567. phase_mismatch(ms);
  1568. } else {
  1569. printk(KERN_ERR "mesh: can't cope with exception %xn", exc);
  1570. mesh_dump_regs(ms);
  1571. dumplog(ms, ms->conn_tgt);
  1572. do_abort(ms);
  1573. phase_mismatch(ms);
  1574. }
  1575. }
  1577. static void
  1578. mesh_interrupt(int irq, void *dev_id, struct pt_regs *ptregs)
  1579. {
  1580. struct mesh_state *ms = (struct mesh_state *) dev_id;
  1581. volatile struct mesh_regs *mr = ms->mesh;
  1582. int intr;
  1584. #if 0
  1585. if (ALLOW_DEBUG(ms->conn_tgt))
  1586. printk(KERN_DEBUG "mesh_intr, bs0=%x int=%x exc=%x err=%x "
  1587.        "phase=%d msgphase=%dn", mr->bus_status0,
  1588.        mr->interrupt, mr->exception, mr->error,
  1589.        ms->phase, ms->msgphase);
  1590. #endif
  1591. while ((intr = in_8(&mr->interrupt)) != 0) {
  1592. dlog(ms, "interrupt intr/err/exc/seq=%.8x", 
  1593.      MKWORD(intr, mr->error, mr->exception, mr->sequence));
  1594. if (intr & INT_ERROR) {
  1595. handle_error(ms);
  1596. } else if (intr & INT_EXCEPTION) {
  1597. handle_exception(ms);
  1598. } else if (intr & INT_CMDDONE) {
  1599. out_8(&mr->interrupt, INT_CMDDONE);
  1600. cmd_complete(ms);
  1601. }
  1602. }
  1603. }
  1605. static void
  1606. handle_msgin(struct mesh_state *ms)
  1607. {
  1608. int i, code;
  1609. Scsi_Cmnd *cmd = ms->current_req;
  1610. struct mesh_target *tp = &ms->tgts[ms->conn_tgt];
  1612. if (ms->n_msgin == 0)
  1613. return;
  1614. code = ms->msgin[0];
  1615. if (ALLOW_DEBUG(ms->conn_tgt)) {
  1616. printk(KERN_DEBUG "got %d message bytes:", ms->n_msgin);
  1617. for (i = 0; i < ms->n_msgin; ++i)
  1618. printk(" %x", ms->msgin[i]);
  1619. printk("n");
  1620. }
  1621. dlog(ms, "msgin msg=%.8x",
  1622.      MKWORD(ms->n_msgin, code, ms->msgin[1], ms->msgin[2]));
  1624. ms->expect_reply = 0;
  1625. ms->n_msgout = 0;
  1626. if (ms->n_msgin < msgin_length(ms))
  1627. goto reject;
  1628. if (cmd)
  1629. cmd->SCp.Message = code;
  1630. switch (code) {
  1631. case COMMAND_COMPLETE:
  1632. break;
  1633. case EXTENDED_MESSAGE:
  1634. switch (ms->msgin[2]) {
  1635. case EXTENDED_MODIFY_DATA_POINTER:
  1636. ms->data_ptr += (ms->msgin[3] << 24) + ms->msgin[6]
  1637. + (ms->msgin[4] << 16) + (ms->msgin[5] << 8);
  1638. break;
  1639. case EXTENDED_SDTR:
  1640. if (tp->sdtr_state != sdtr_sent) {
  1641. /* reply with an SDTR */
  1642. add_sdtr_msg(ms);
  1643. /* limit period to at least his value,
  1644.    offset to no more than his */
  1645. if (ms->msgout[3] < ms->msgin[3])
  1646. ms->msgout[3] = ms->msgin[3];
  1647. if (ms->msgout[4] > ms->msgin[4])
  1648. ms->msgout[4] = ms->msgin[4];
  1649. set_sdtr(ms, ms->msgout[3], ms->msgout[4]);
  1650. ms->msgphase = msg_out;
  1651. } else {
  1652. set_sdtr(ms, ms->msgin[3], ms->msgin[4]);
  1653. }
  1654. break;
  1655. default:
  1656. goto reject;
  1657. }
  1658. break;
  1659. case SAVE_POINTERS:
  1660. tp->saved_ptr = ms->data_ptr;
  1661. break;
  1662. case RESTORE_POINTERS:
  1663. ms->data_ptr = tp->saved_ptr;
  1664. break;
  1665. case DISCONNECT:
  1666. ms->phase = disconnecting;
  1667. break;
  1668. case ABORT:
  1669. break;
  1670. case MESSAGE_REJECT:
  1671. if (tp->sdtr_state == sdtr_sent)
  1672. set_sdtr(ms, 0, 0);
  1673. break;
  1674. case NOP:
  1675. break;
  1676. default:
  1677. if (IDENTIFY_BASE <= code && code <= IDENTIFY_BASE + 7) {
  1678. if (cmd == NULL) {
  1679. do_abort(ms);
  1680. ms->msgphase = msg_out;
  1681. } else if (code != cmd->lun + IDENTIFY_BASE) {
  1682. printk(KERN_WARNING "mesh: lun mismatch "
  1683.        "(%d != %d) on reselection from "
  1684.        "target %dn", i, cmd->lun,
  1685.        ms->conn_tgt);
  1686. }
  1687. break;
  1688. }
  1689. goto reject;
  1690. }
  1691. return;
  1693.  reject:
  1694. printk(KERN_WARNING "mesh: rejecting message from target %d:",
  1695.        ms->conn_tgt);
  1696. for (i = 0; i < ms->n_msgin; ++i)
  1697. printk(" %x", ms->msgin[i]);
  1698. printk("n");
  1699. ms->msgout[0] = MESSAGE_REJECT;
  1700. ms->n_msgout = 1;
  1701. ms->msgphase = msg_out;
  1702. }
  1704. static void
  1705. mesh_done(struct mesh_state *ms, int start_next)
  1706. {
  1707. Scsi_Cmnd *cmd;
  1708. struct mesh_target *tp = &ms->tgts[ms->conn_tgt];
  1710. cmd = ms->current_req;
  1711. ms->current_req = 0;
  1712. tp->current_req = 0;
  1713. if (cmd) {
  1714. cmd->result = (ms->stat << 16) + cmd->SCp.Status;
  1715. if (ms->stat == DID_OK)
  1716. cmd->result += (cmd->SCp.Message << 8);
  1717. if (DEBUG_TARGET(cmd)) {
  1718. printk(KERN_DEBUG "mesh_done: result = %x, data_ptr=%d, buflen=%dn",
  1719.        cmd->result, ms->data_ptr, cmd->request_bufflen);
  1720. if ((cmd->cmnd[0] == 0 || cmd->cmnd[0] == 0x12 || cmd->cmnd[0] == 3)
  1721.     && cmd->request_buffer != 0) {
  1722. unsigned char *b = cmd->request_buffer;
  1723. printk(KERN_DEBUG "buffer = %x %x %x %x %x %x %x %xn",
  1724.        b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]);
  1725. }
  1726. }
  1727. cmd->SCp.this_residual -= ms->data_ptr;
  1728. mesh_completed(ms, cmd);
  1729. }
  1730. if (start_next) {
  1731. out_8(&ms->mesh->sequence, SEQ_ENBRESEL);
  1732. udelay(1);
  1733. ms->phase = idle;
  1734. mesh_start(ms);
  1735. }
  1736. }
  1738. static void
  1739. mesh_completed(struct mesh_state *ms, Scsi_Cmnd *cmd)
  1740. {
  1741. #ifdef MESH_NEW_STYLE_EH
  1742. (*cmd->scsi_done)(cmd);
  1743. #else
  1744. if (ms->completed_q == NULL)
  1745. ms->completed_q = cmd;
  1746. else
  1747. ms->completed_qtail->host_scribble = (void *) cmd;
  1748. ms->completed_qtail = cmd;
  1749. cmd->host_scribble = NULL;
  1750. queue_task(&ms->tqueue, &tq_immediate);
  1751. mark_bh(IMMEDIATE_BH);
  1752. #endif /* MESH_NEW_STYLE_EH */
  1753. }
  1755. /*
  1756.  * Set up DMA commands for transferring data.
  1757.  */
  1758. static void
  1759. set_dma_cmds(struct mesh_state *ms, Scsi_Cmnd *cmd)
  1760. {
  1761. int i, dma_cmd, total, off, dtot;
  1762. struct scatterlist *scl;
  1763. struct dbdma_cmd *dcmds;
  1765. dma_cmd = ms->tgts[ms->conn_tgt].data_goes_out?
  1766. OUTPUT_MORE: INPUT_MORE;
  1767. dcmds = ms->dma_cmds;
  1768. dtot = 0;
  1769. if (cmd) {
  1770. cmd->SCp.this_residual = cmd->request_bufflen;
  1771. if (cmd->use_sg > 0) {
  1772. total = 0;
  1773. scl = (struct scatterlist *) cmd->buffer;
  1774. off = ms->data_ptr;
  1775. for (i = 0; i < cmd->use_sg; ++i, ++scl) {
  1776. total += scl->length;
  1777. if (off >= scl->length) {
  1778. off -= scl->length;
  1779. continue;
  1780. }
  1781. if (scl->length > 0xffff)
  1782. panic("mesh: scatterlist element >= 64k");
  1783. st_le16(&dcmds->req_count, scl->length - off);
  1784. st_le16(&dcmds->command, dma_cmd);
  1785. st_le32(&dcmds->phy_addr,
  1786. virt_to_phys(scl->address) + off);
  1787. dcmds->xfer_status = 0;
  1788. ++dcmds;
  1789. dtot += scl->length - off;
  1790. off = 0;
  1791. }
  1792. } else if (ms->data_ptr < cmd->request_bufflen) {
  1793. dtot = cmd->request_bufflen - ms->data_ptr;
  1794. if (dtot > 0xffff)
  1795. panic("mesh: transfer size >= 64k");
  1796. st_le16(&dcmds->req_count, dtot);
  1797. st_le32(&dcmds->phy_addr,
  1798. virt_to_phys(cmd->request_buffer) + ms->data_ptr);
  1799. dcmds->xfer_status = 0;
  1800. ++dcmds;
  1801. }
  1802. }
  1803. if (dtot == 0) {
  1804. /* Either the target has overrun our buffer,
  1805.    or the caller didn't provide a buffer. */
  1806. static char mesh_extra_buf[64];
  1808. dtot = sizeof(mesh_extra_buf);
  1809. st_le16(&dcmds->req_count, dtot);
  1810. st_le32(&dcmds->phy_addr, virt_to_phys(mesh_extra_buf));
  1811. dcmds->xfer_status = 0;
  1812. ++dcmds;
  1813. }
  1814. dma_cmd += OUTPUT_LAST - OUTPUT_MORE;
  1815. st_le16(&dcmds[-1].command, dma_cmd);
  1816. memset(dcmds, 0, sizeof(*dcmds));
  1817. st_le16(&dcmds->command, DBDMA_STOP);
  1818. ms->dma_count = dtot;
  1819. }
  1821. static void
  1822. halt_dma(struct mesh_state *ms)
  1823. {
  1824. volatile struct dbdma_regs *md = ms->dma;
  1825. volatile struct mesh_regs *mr = ms->mesh;
  1826. Scsi_Cmnd *cmd = ms->current_req;
  1827. int t, nb;
  1829. if (!ms->tgts[ms->conn_tgt].data_goes_out) {
  1830. /* wait a little while until the fifo drains */
  1831. t = 50;
  1832. while (t > 0 && mr->fifo_count != 0
  1833.        && (in_le32(&md->status) & ACTIVE) != 0) {
  1834. --t;
  1835. udelay(1);
  1836. }
  1837. }
  1838. out_le32(&md->control, RUN << 16); /* turn off RUN bit */
  1839. nb = (mr->count_hi << 8) + mr->count_lo;
  1840. dlog(ms, "halt_dma fc/count=%.6x",
  1841.      MKWORD(0, mr->fifo_count, 0, nb));
  1842. if (ms->tgts[ms->conn_tgt].data_goes_out)
  1843. nb += mr->fifo_count;
  1844. /* nb is the number of bytes not yet transferred
  1845.    to/from the target. */
  1846. ms->data_ptr -= nb;
  1847. dlog(ms, "data_ptr %x", ms->data_ptr);
  1848. if (ms->data_ptr < 0) {
  1849. printk(KERN_ERR "mesh: halt_dma: data_ptr=%d (nb=%d, ms=%p)n",
  1850.        ms->data_ptr, nb, ms);
  1851. ms->data_ptr = 0;
  1852. #ifdef MESH_DBG
  1853. dumplog(ms, ms->conn_tgt);
  1854. dumpslog(ms);
  1855. #endif /* MESH_DBG */
  1856. } else if (cmd && cmd->request_bufflen != 0 &&
  1857.    ms->data_ptr > cmd->request_bufflen) {
  1858. printk(KERN_DEBUG "mesh: target %d overrun, "
  1859.        "data_ptr=%x total=%x goes_out=%dn",
  1860.        ms->conn_tgt, ms->data_ptr, cmd->request_bufflen,
  1861.        ms->tgts[ms->conn_tgt].data_goes_out);
  1862. }
  1863. ms->dma_started = 0;
  1864. }
  1866. /*
  1867.  * Work out whether we expect data to go out from the host adaptor or into it.
  1868.  * (If this information is available from somewhere else in the scsi
  1869.  * code, somebody please let me know :-)
  1870.  */
  1871. static int
  1872. data_goes_out(Scsi_Cmnd *cmd)
  1873. {
  1874. switch (cmd->cmnd[0]) {
  1875. case CHANGE_DEFINITION: 
  1876. case COMPARE:   
  1877. case COPY:
  1878. case COPY_VERIFY:     
  1879. case FORMAT_UNIT:  
  1880. case LOG_SELECT:
  1881. case MEDIUM_SCAN:   
  1882. case MODE_SELECT:
  1883. case MODE_SELECT_10:
  1884. case REASSIGN_BLOCKS: 
  1885. case RESERVE:
  1886. case SEARCH_EQUAL:   
  1887. case SEARCH_EQUAL_12: 
  1888. case SEARCH_HIGH:  
  1889. case SEARCH_HIGH_12:  
  1890. case SEARCH_LOW:
  1891. case SEARCH_LOW_12:
  1892. case SEND_DIAGNOSTIC: 
  1893. case SEND_VOLUME_TAG:      
  1894. case SET_WINDOW: 
  1895. case UPDATE_BLOCK:
  1896. case WRITE_BUFFER:
  1897.   case WRITE_6:
  1898. case WRITE_10:
  1899. case WRITE_12:   
  1900. case WRITE_LONG:
  1901. case WRITE_LONG_2:      /* alternate code for WRITE_LONG */
  1902. case WRITE_SAME:
  1903. case WRITE_VERIFY:
  1904. case WRITE_VERIFY_12:
  1905. return 1;
  1906. default:
  1907. return 0;
  1908. }
  1909. }
  1911. #ifdef MESH_DBG
  1912. static inline u32 readtb(void)
  1913. {
  1914. u32 tb;
  1916. #ifdef DBG_USE_TB
  1917. /* Beware: if you enable this, it will crash on 601s. */
  1918. asm ("mftb %0" : "=r" (tb) : );
  1919. #else
  1920. tb = 0;
  1921. #endif
  1922. return tb;
  1923. }
  1925. static void dlog(struct mesh_state *ms, char *fmt, int a)
  1926. {
  1927. struct mesh_target *tp = &ms->tgts[ms->conn_tgt];
  1928. struct dbglog *tlp, *slp;
  1930. tlp = &tp->log[tp->log_ix];
  1931. slp = &ms->log[ms->log_ix];
  1932. tlp->fmt = fmt;
  1933. tlp->tb = readtb();
  1934. tlp->phase = (ms->msgphase << 4) + ms->phase;
  1935. tlp->bs0 = ms->mesh->bus_status0;
  1936. tlp->bs1 = ms->mesh->bus_status1;
  1937. tlp->tgt = ms->conn_tgt;
  1938. tlp->d = a;
  1939. *slp = *tlp;
  1940. if (++tp->log_ix >= N_DBG_LOG)
  1941. tp->log_ix = 0;
  1942. if (tp->n_log < N_DBG_LOG)
  1943. ++tp->n_log;
  1944. if (++ms->log_ix >= N_DBG_SLOG)
  1945. ms->log_ix = 0;
  1946. if (ms->n_log < N_DBG_SLOG)
  1947. ++ms->n_log;
  1948. }
  1950. static void dumplog(struct mesh_state *ms, int t)
  1951. {
  1952. struct mesh_target *tp = &ms->tgts[t];
  1953. struct dbglog *lp;
  1954. int i;
  1956. if (tp->n_log == 0)
  1957. return;
  1958. i = tp->log_ix - tp->n_log;
  1959. if (i < 0)
  1960. i += N_DBG_LOG;
  1961. tp->n_log = 0;
  1962. do {
  1963. lp = &tp->log[i];
  1964. printk(KERN_DEBUG "mesh log %d: bs=%.2x%.2x ph=%.2x ",
  1965.        t, lp->bs1, lp->bs0, lp->phase);
  1966. #ifdef DBG_USE_TB
  1967. printk("tb=%10u ", lp->tb);
  1968. #endif
  1969. printk(lp->fmt, lp->d);
  1970. printk("n");
  1971. if (++i >= N_DBG_LOG)
  1972. i = 0;
  1973. } while (i != tp->log_ix);
  1974. }
  1976. static void dumpslog(struct mesh_state *ms)
  1977. {
  1978. struct dbglog *lp;
  1979. int i;
  1981. if (ms->n_log == 0)
  1982. return;
  1983. i = ms->log_ix - ms->n_log;
  1984. if (i < 0)
  1985. i += N_DBG_SLOG;
  1986. ms->n_log = 0;
  1987. do {
  1988. lp = &ms->log[i];
  1989. printk(KERN_DEBUG "mesh log: bs=%.2x%.2x ph=%.2x t%d ",
  1990.        lp->bs1, lp->bs0, lp->phase, lp->tgt);
  1991. #ifdef DBG_USE_TB
  1992. printk("tb=%10u ", lp->tb);
  1993. #endif
  1994. printk(lp->fmt, lp->d);
  1995. printk("n");
  1996. if (++i >= N_DBG_SLOG)
  1997. i = 0;
  1998. } while (i != ms->log_ix);
  1999. }
  2000. #endif /* MESH_DBG */
  2002. static Scsi_Host_Template driver_template = SCSI_MESH;
  2004. #include "scsi_module.c"