sx8.c 40 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764
  1. /*
  2. * sx8.c: Driver for Promise SATA SX8 looks-like-I2O hardware
  3. *
  4. * Copyright 2004-2005 Red Hat, Inc.
  5. *
  6. * Author/maintainer: Jeff Garzik <jgarzik@pobox.com>
  7. *
  8. * This file is subject to the terms and conditions of the GNU General Public
  9. * License. See the file "COPYING" in the main directory of this archive
  10. * for more details.
  11. */
  12. #include <linux/kernel.h>
  13. #include <linux/module.h>
  14. #include <linux/init.h>
  15. #include <linux/pci.h>
  16. #include <linux/slab.h>
  17. #include <linux/spinlock.h>
  18. #include <linux/blkdev.h>
  19. #include <linux/sched.h>
  20. #include <linux/interrupt.h>
  21. #include <linux/compiler.h>
  22. #include <linux/workqueue.h>
  23. #include <linux/bitops.h>
  24. #include <linux/delay.h>
  25. #include <linux/time.h>
  26. #include <linux/hdreg.h>
  27. #include <linux/dma-mapping.h>
  28. #include <linux/completion.h>
  29. #include <linux/scatterlist.h>
  30. #include <asm/io.h>
  31. #include <asm/uaccess.h>
  32. #if 0
  33. #define CARM_DEBUG
  34. #define CARM_VERBOSE_DEBUG
  35. #else
  36. #undef CARM_DEBUG
  37. #undef CARM_VERBOSE_DEBUG
  38. #endif
  39. #undef CARM_NDEBUG
  40. #define DRV_NAME "sx8"
  41. #define DRV_VERSION "1.0"
  42. #define PFX DRV_NAME ": "
  43. MODULE_AUTHOR("Jeff Garzik");
  44. MODULE_LICENSE("GPL");
  45. MODULE_DESCRIPTION("Promise SATA SX8 block driver");
  46. MODULE_VERSION(DRV_VERSION);
  47. /*
  48. * SX8 hardware has a single message queue for all ATA ports.
  49. * When this driver was written, the hardware (firmware?) would
  50. * corrupt data eventually, if more than one request was outstanding.
  51. * As one can imagine, having 8 ports bottlenecking on a single
  52. * command hurts performance.
  53. *
  54. * Based on user reports, later versions of the hardware (firmware?)
  55. * seem to be able to survive with more than one command queued.
  56. *
  57. * Therefore, we default to the safe option -- 1 command -- but
  58. * allow the user to increase this.
  59. *
  60. * SX8 should be able to support up to ~60 queued commands (CARM_MAX_REQ),
  61. * but problems seem to occur when you exceed ~30, even on newer hardware.
  62. */
  63. static int max_queue = 1;
  64. module_param(max_queue, int, 0444);
  65. MODULE_PARM_DESC(max_queue, "Maximum number of queued commands. (min==1, max==30, safe==1)");
  66. #define NEXT_RESP(idx) ((idx + 1) % RMSG_Q_LEN)
  67. /* 0xf is just arbitrary, non-zero noise; this is sorta like poisoning */
  68. #define TAG_ENCODE(tag) (((tag) << 16) | 0xf)
  69. #define TAG_DECODE(tag) (((tag) >> 16) & 0x1f)
  70. #define TAG_VALID(tag) ((((tag) & 0xf) == 0xf) && (TAG_DECODE(tag) < 32))
  71. /* note: prints function name for you */
  72. #ifdef CARM_DEBUG
  73. #define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
  74. #ifdef CARM_VERBOSE_DEBUG
  75. #define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
  76. #else
  77. #define VPRINTK(fmt, args...)
  78. #endif /* CARM_VERBOSE_DEBUG */
  79. #else
  80. #define DPRINTK(fmt, args...)
  81. #define VPRINTK(fmt, args...)
  82. #endif /* CARM_DEBUG */
  83. #ifdef CARM_NDEBUG
  84. #define assert(expr)
  85. #else
  86. #define assert(expr) \
  87. if(unlikely(!(expr))) { \
  88. printk(KERN_ERR "Assertion failed! %s,%s,%s,line=%d\n", \
  89. #expr, __FILE__, __func__, __LINE__); \
  90. }
  91. #endif
  92. /* defines only for the constants which don't work well as enums */
  93. struct carm_host;
  94. enum {
  95. /* adapter-wide limits */
  96. CARM_MAX_PORTS = 8,
  97. CARM_SHM_SIZE = (4096 << 7),
  98. CARM_MINORS_PER_MAJOR = 256 / CARM_MAX_PORTS,
  99. CARM_MAX_WAIT_Q = CARM_MAX_PORTS + 1,
  100. /* command message queue limits */
  101. CARM_MAX_REQ = 64, /* max command msgs per host */
  102. CARM_MSG_LOW_WATER = (CARM_MAX_REQ / 4), /* refill mark */
  103. /* S/G limits, host-wide and per-request */
  104. CARM_MAX_REQ_SG = 32, /* max s/g entries per request */
  105. CARM_MAX_HOST_SG = 600, /* max s/g entries per host */
  106. CARM_SG_LOW_WATER = (CARM_MAX_HOST_SG / 4), /* re-fill mark */
  107. /* hardware registers */
  108. CARM_IHQP = 0x1c,
  109. CARM_INT_STAT = 0x10, /* interrupt status */
  110. CARM_INT_MASK = 0x14, /* interrupt mask */
  111. CARM_HMUC = 0x18, /* host message unit control */
  112. RBUF_ADDR_LO = 0x20, /* response msg DMA buf low 32 bits */
  113. RBUF_ADDR_HI = 0x24, /* response msg DMA buf high 32 bits */
  114. RBUF_BYTE_SZ = 0x28,
  115. CARM_RESP_IDX = 0x2c,
  116. CARM_CMS0 = 0x30, /* command message size reg 0 */
  117. CARM_LMUC = 0x48,
  118. CARM_HMPHA = 0x6c,
  119. CARM_INITC = 0xb5,
  120. /* bits in CARM_INT_{STAT,MASK} */
  121. INT_RESERVED = 0xfffffff0,
  122. INT_WATCHDOG = (1 << 3), /* watchdog timer */
  123. INT_Q_OVERFLOW = (1 << 2), /* cmd msg q overflow */
  124. INT_Q_AVAILABLE = (1 << 1), /* cmd msg q has free space */
  125. INT_RESPONSE = (1 << 0), /* response msg available */
  126. INT_ACK_MASK = INT_WATCHDOG | INT_Q_OVERFLOW,
  127. INT_DEF_MASK = INT_RESERVED | INT_Q_OVERFLOW |
  128. INT_RESPONSE,
  129. /* command messages, and related register bits */
  130. CARM_HAVE_RESP = 0x01,
  131. CARM_MSG_READ = 1,
  132. CARM_MSG_WRITE = 2,
  133. CARM_MSG_VERIFY = 3,
  134. CARM_MSG_GET_CAPACITY = 4,
  135. CARM_MSG_FLUSH = 5,
  136. CARM_MSG_IOCTL = 6,
  137. CARM_MSG_ARRAY = 8,
  138. CARM_MSG_MISC = 9,
  139. CARM_CME = (1 << 2),
  140. CARM_RME = (1 << 1),
  141. CARM_WZBC = (1 << 0),
  142. CARM_RMI = (1 << 0),
  143. CARM_Q_FULL = (1 << 3),
  144. CARM_MSG_SIZE = 288,
  145. CARM_Q_LEN = 48,
  146. /* CARM_MSG_IOCTL messages */
  147. CARM_IOC_SCAN_CHAN = 5, /* scan channels for devices */
  148. CARM_IOC_GET_TCQ = 13, /* get tcq/ncq depth */
  149. CARM_IOC_SET_TCQ = 14, /* set tcq/ncq depth */
  150. IOC_SCAN_CHAN_NODEV = 0x1f,
  151. IOC_SCAN_CHAN_OFFSET = 0x40,
  152. /* CARM_MSG_ARRAY messages */
  153. CARM_ARRAY_INFO = 0,
  154. ARRAY_NO_EXIST = (1 << 31),
  155. /* response messages */
  156. RMSG_SZ = 8, /* sizeof(struct carm_response) */
  157. RMSG_Q_LEN = 48, /* resp. msg list length */
  158. RMSG_OK = 1, /* bit indicating msg was successful */
  159. /* length of entire resp. msg buffer */
  160. RBUF_LEN = RMSG_SZ * RMSG_Q_LEN,
  161. PDC_SHM_SIZE = (4096 << 7), /* length of entire h/w buffer */
  162. /* CARM_MSG_MISC messages */
  163. MISC_GET_FW_VER = 2,
  164. MISC_ALLOC_MEM = 3,
  165. MISC_SET_TIME = 5,
  166. /* MISC_GET_FW_VER feature bits */
  167. FW_VER_4PORT = (1 << 2), /* 1=4 ports, 0=8 ports */
  168. FW_VER_NON_RAID = (1 << 1), /* 1=non-RAID firmware, 0=RAID */
  169. FW_VER_ZCR = (1 << 0), /* zero channel RAID (whatever that is) */
  170. /* carm_host flags */
  171. FL_NON_RAID = FW_VER_NON_RAID,
  172. FL_4PORT = FW_VER_4PORT,
  173. FL_FW_VER_MASK = (FW_VER_NON_RAID | FW_VER_4PORT),
  174. FL_DAC = (1 << 16),
  175. FL_DYN_MAJOR = (1 << 17),
  176. };
  177. enum {
  178. CARM_SG_BOUNDARY = 0xffffUL, /* s/g segment boundary */
  179. };
  180. enum scatter_gather_types {
  181. SGT_32BIT = 0,
  182. SGT_64BIT = 1,
  183. };
  184. enum host_states {
  185. HST_INVALID, /* invalid state; never used */
  186. HST_ALLOC_BUF, /* setting up master SHM area */
  187. HST_ERROR, /* we never leave here */
  188. HST_PORT_SCAN, /* start dev scan */
  189. HST_DEV_SCAN_START, /* start per-device probe */
  190. HST_DEV_SCAN, /* continue per-device probe */
  191. HST_DEV_ACTIVATE, /* activate devices we found */
  192. HST_PROBE_FINISHED, /* probe is complete */
  193. HST_PROBE_START, /* initiate probe */
  194. HST_SYNC_TIME, /* tell firmware what time it is */
  195. HST_GET_FW_VER, /* get firmware version, adapter port cnt */
  196. };
  197. #ifdef CARM_DEBUG
  198. static const char *state_name[] = {
  199. "HST_INVALID",
  200. "HST_ALLOC_BUF",
  201. "HST_ERROR",
  202. "HST_PORT_SCAN",
  203. "HST_DEV_SCAN_START",
  204. "HST_DEV_SCAN",
  205. "HST_DEV_ACTIVATE",
  206. "HST_PROBE_FINISHED",
  207. "HST_PROBE_START",
  208. "HST_SYNC_TIME",
  209. "HST_GET_FW_VER",
  210. };
  211. #endif
  212. struct carm_port {
  213. unsigned int port_no;
  214. struct gendisk *disk;
  215. struct carm_host *host;
  216. /* attached device characteristics */
  217. u64 capacity;
  218. char name[41];
  219. u16 dev_geom_head;
  220. u16 dev_geom_sect;
  221. u16 dev_geom_cyl;
  222. };
  223. struct carm_request {
  224. unsigned int tag;
  225. int n_elem;
  226. unsigned int msg_type;
  227. unsigned int msg_subtype;
  228. unsigned int msg_bucket;
  229. struct request *rq;
  230. struct carm_port *port;
  231. struct scatterlist sg[CARM_MAX_REQ_SG];
  232. };
  233. struct carm_host {
  234. unsigned long flags;
  235. void __iomem *mmio;
  236. void *shm;
  237. dma_addr_t shm_dma;
  238. int major;
  239. int id;
  240. char name[32];
  241. spinlock_t lock;
  242. struct pci_dev *pdev;
  243. unsigned int state;
  244. u32 fw_ver;
  245. struct request_queue *oob_q;
  246. unsigned int n_oob;
  247. unsigned int hw_sg_used;
  248. unsigned int resp_idx;
  249. unsigned int wait_q_prod;
  250. unsigned int wait_q_cons;
  251. struct request_queue *wait_q[CARM_MAX_WAIT_Q];
  252. unsigned int n_msgs;
  253. u64 msg_alloc;
  254. struct carm_request req[CARM_MAX_REQ];
  255. void *msg_base;
  256. dma_addr_t msg_dma;
  257. int cur_scan_dev;
  258. unsigned long dev_active;
  259. unsigned long dev_present;
  260. struct carm_port port[CARM_MAX_PORTS];
  261. struct work_struct fsm_task;
  262. struct completion probe_comp;
  263. };
  264. struct carm_response {
  265. __le32 ret_handle;
  266. __le32 status;
  267. } __attribute__((packed));
  268. struct carm_msg_sg {
  269. __le32 start;
  270. __le32 len;
  271. } __attribute__((packed));
  272. struct carm_msg_rw {
  273. u8 type;
  274. u8 id;
  275. u8 sg_count;
  276. u8 sg_type;
  277. __le32 handle;
  278. __le32 lba;
  279. __le16 lba_count;
  280. __le16 lba_high;
  281. struct carm_msg_sg sg[32];
  282. } __attribute__((packed));
  283. struct carm_msg_allocbuf {
  284. u8 type;
  285. u8 subtype;
  286. u8 n_sg;
  287. u8 sg_type;
  288. __le32 handle;
  289. __le32 addr;
  290. __le32 len;
  291. __le32 evt_pool;
  292. __le32 n_evt;
  293. __le32 rbuf_pool;
  294. __le32 n_rbuf;
  295. __le32 msg_pool;
  296. __le32 n_msg;
  297. struct carm_msg_sg sg[8];
  298. } __attribute__((packed));
  299. struct carm_msg_ioctl {
  300. u8 type;
  301. u8 subtype;
  302. u8 array_id;
  303. u8 reserved1;
  304. __le32 handle;
  305. __le32 data_addr;
  306. u32 reserved2;
  307. } __attribute__((packed));
  308. struct carm_msg_sync_time {
  309. u8 type;
  310. u8 subtype;
  311. u16 reserved1;
  312. __le32 handle;
  313. u32 reserved2;
  314. __le32 timestamp;
  315. } __attribute__((packed));
  316. struct carm_msg_get_fw_ver {
  317. u8 type;
  318. u8 subtype;
  319. u16 reserved1;
  320. __le32 handle;
  321. __le32 data_addr;
  322. u32 reserved2;
  323. } __attribute__((packed));
  324. struct carm_fw_ver {
  325. __le32 version;
  326. u8 features;
  327. u8 reserved1;
  328. u16 reserved2;
  329. } __attribute__((packed));
  330. struct carm_array_info {
  331. __le32 size;
  332. __le16 size_hi;
  333. __le16 stripe_size;
  334. __le32 mode;
  335. __le16 stripe_blk_sz;
  336. __le16 reserved1;
  337. __le16 cyl;
  338. __le16 head;
  339. __le16 sect;
  340. u8 array_id;
  341. u8 reserved2;
  342. char name[40];
  343. __le32 array_status;
  344. /* device list continues beyond this point? */
  345. } __attribute__((packed));
  346. static int carm_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
  347. static void carm_remove_one (struct pci_dev *pdev);
  348. static int carm_bdev_getgeo(struct block_device *bdev, struct hd_geometry *geo);
  349. static struct pci_device_id carm_pci_tbl[] = {
  350. { PCI_VENDOR_ID_PROMISE, 0x8000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, },
  351. { PCI_VENDOR_ID_PROMISE, 0x8002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, },
  352. { } /* terminate list */
  353. };
  354. MODULE_DEVICE_TABLE(pci, carm_pci_tbl);
  355. static struct pci_driver carm_driver = {
  356. .name = DRV_NAME,
  357. .id_table = carm_pci_tbl,
  358. .probe = carm_init_one,
  359. .remove = carm_remove_one,
  360. };
  361. static struct block_device_operations carm_bd_ops = {
  362. .owner = THIS_MODULE,
  363. .getgeo = carm_bdev_getgeo,
  364. };
  365. static unsigned int carm_host_id;
  366. static unsigned long carm_major_alloc;
  367. static int carm_bdev_getgeo(struct block_device *bdev, struct hd_geometry *geo)
  368. {
  369. struct carm_port *port = bdev->bd_disk->private_data;
  370. geo->heads = (u8) port->dev_geom_head;
  371. geo->sectors = (u8) port->dev_geom_sect;
  372. geo->cylinders = port->dev_geom_cyl;
  373. return 0;
  374. }
  375. static const u32 msg_sizes[] = { 32, 64, 128, CARM_MSG_SIZE };
  376. static inline int carm_lookup_bucket(u32 msg_size)
  377. {
  378. int i;
  379. for (i = 0; i < ARRAY_SIZE(msg_sizes); i++)
  380. if (msg_size <= msg_sizes[i])
  381. return i;
  382. return -ENOENT;
  383. }
  384. static void carm_init_buckets(void __iomem *mmio)
  385. {
  386. unsigned int i;
  387. for (i = 0; i < ARRAY_SIZE(msg_sizes); i++)
  388. writel(msg_sizes[i], mmio + CARM_CMS0 + (4 * i));
  389. }
  390. static inline void *carm_ref_msg(struct carm_host *host,
  391. unsigned int msg_idx)
  392. {
  393. return host->msg_base + (msg_idx * CARM_MSG_SIZE);
  394. }
  395. static inline dma_addr_t carm_ref_msg_dma(struct carm_host *host,
  396. unsigned int msg_idx)
  397. {
  398. return host->msg_dma + (msg_idx * CARM_MSG_SIZE);
  399. }
  400. static int carm_send_msg(struct carm_host *host,
  401. struct carm_request *crq)
  402. {
  403. void __iomem *mmio = host->mmio;
  404. u32 msg = (u32) carm_ref_msg_dma(host, crq->tag);
  405. u32 cm_bucket = crq->msg_bucket;
  406. u32 tmp;
  407. int rc = 0;
  408. VPRINTK("ENTER\n");
  409. tmp = readl(mmio + CARM_HMUC);
  410. if (tmp & CARM_Q_FULL) {
  411. #if 0
  412. tmp = readl(mmio + CARM_INT_MASK);
  413. tmp |= INT_Q_AVAILABLE;
  414. writel(tmp, mmio + CARM_INT_MASK);
  415. readl(mmio + CARM_INT_MASK); /* flush */
  416. #endif
  417. DPRINTK("host msg queue full\n");
  418. rc = -EBUSY;
  419. } else {
  420. writel(msg | (cm_bucket << 1), mmio + CARM_IHQP);
  421. readl(mmio + CARM_IHQP); /* flush */
  422. }
  423. return rc;
  424. }
  425. static struct carm_request *carm_get_request(struct carm_host *host)
  426. {
  427. unsigned int i;
  428. /* obey global hardware limit on S/G entries */
  429. if (host->hw_sg_used >= (CARM_MAX_HOST_SG - CARM_MAX_REQ_SG))
  430. return NULL;
  431. for (i = 0; i < max_queue; i++)
  432. if ((host->msg_alloc & (1ULL << i)) == 0) {
  433. struct carm_request *crq = &host->req[i];
  434. crq->port = NULL;
  435. crq->n_elem = 0;
  436. host->msg_alloc |= (1ULL << i);
  437. host->n_msgs++;
  438. assert(host->n_msgs <= CARM_MAX_REQ);
  439. sg_init_table(crq->sg, CARM_MAX_REQ_SG);
  440. return crq;
  441. }
  442. DPRINTK("no request available, returning NULL\n");
  443. return NULL;
  444. }
  445. static int carm_put_request(struct carm_host *host, struct carm_request *crq)
  446. {
  447. assert(crq->tag < max_queue);
  448. if (unlikely((host->msg_alloc & (1ULL << crq->tag)) == 0))
  449. return -EINVAL; /* tried to clear a tag that was not active */
  450. assert(host->hw_sg_used >= crq->n_elem);
  451. host->msg_alloc &= ~(1ULL << crq->tag);
  452. host->hw_sg_used -= crq->n_elem;
  453. host->n_msgs--;
  454. return 0;
  455. }
  456. static struct carm_request *carm_get_special(struct carm_host *host)
  457. {
  458. unsigned long flags;
  459. struct carm_request *crq = NULL;
  460. struct request *rq;
  461. int tries = 5000;
  462. while (tries-- > 0) {
  463. spin_lock_irqsave(&host->lock, flags);
  464. crq = carm_get_request(host);
  465. spin_unlock_irqrestore(&host->lock, flags);
  466. if (crq)
  467. break;
  468. msleep(10);
  469. }
  470. if (!crq)
  471. return NULL;
  472. rq = blk_get_request(host->oob_q, WRITE /* bogus */, GFP_KERNEL);
  473. if (!rq) {
  474. spin_lock_irqsave(&host->lock, flags);
  475. carm_put_request(host, crq);
  476. spin_unlock_irqrestore(&host->lock, flags);
  477. return NULL;
  478. }
  479. crq->rq = rq;
  480. return crq;
  481. }
  482. static int carm_array_info (struct carm_host *host, unsigned int array_idx)
  483. {
  484. struct carm_msg_ioctl *ioc;
  485. unsigned int idx;
  486. u32 msg_data;
  487. dma_addr_t msg_dma;
  488. struct carm_request *crq;
  489. int rc;
  490. crq = carm_get_special(host);
  491. if (!crq) {
  492. rc = -ENOMEM;
  493. goto err_out;
  494. }
  495. idx = crq->tag;
  496. ioc = carm_ref_msg(host, idx);
  497. msg_dma = carm_ref_msg_dma(host, idx);
  498. msg_data = (u32) (msg_dma + sizeof(struct carm_array_info));
  499. crq->msg_type = CARM_MSG_ARRAY;
  500. crq->msg_subtype = CARM_ARRAY_INFO;
  501. rc = carm_lookup_bucket(sizeof(struct carm_msg_ioctl) +
  502. sizeof(struct carm_array_info));
  503. BUG_ON(rc < 0);
  504. crq->msg_bucket = (u32) rc;
  505. memset(ioc, 0, sizeof(*ioc));
  506. ioc->type = CARM_MSG_ARRAY;
  507. ioc->subtype = CARM_ARRAY_INFO;
  508. ioc->array_id = (u8) array_idx;
  509. ioc->handle = cpu_to_le32(TAG_ENCODE(idx));
  510. ioc->data_addr = cpu_to_le32(msg_data);
  511. spin_lock_irq(&host->lock);
  512. assert(host->state == HST_DEV_SCAN_START ||
  513. host->state == HST_DEV_SCAN);
  514. spin_unlock_irq(&host->lock);
  515. DPRINTK("blk_insert_request, tag == %u\n", idx);
  516. blk_insert_request(host->oob_q, crq->rq, 1, crq);
  517. return 0;
  518. err_out:
  519. spin_lock_irq(&host->lock);
  520. host->state = HST_ERROR;
  521. spin_unlock_irq(&host->lock);
  522. return rc;
  523. }
  524. typedef unsigned int (*carm_sspc_t)(struct carm_host *, unsigned int, void *);
  525. static int carm_send_special (struct carm_host *host, carm_sspc_t func)
  526. {
  527. struct carm_request *crq;
  528. struct carm_msg_ioctl *ioc;
  529. void *mem;
  530. unsigned int idx, msg_size;
  531. int rc;
  532. crq = carm_get_special(host);
  533. if (!crq)
  534. return -ENOMEM;
  535. idx = crq->tag;
  536. mem = carm_ref_msg(host, idx);
  537. msg_size = func(host, idx, mem);
  538. ioc = mem;
  539. crq->msg_type = ioc->type;
  540. crq->msg_subtype = ioc->subtype;
  541. rc = carm_lookup_bucket(msg_size);
  542. BUG_ON(rc < 0);
  543. crq->msg_bucket = (u32) rc;
  544. DPRINTK("blk_insert_request, tag == %u\n", idx);
  545. blk_insert_request(host->oob_q, crq->rq, 1, crq);
  546. return 0;
  547. }
  548. static unsigned int carm_fill_sync_time(struct carm_host *host,
  549. unsigned int idx, void *mem)
  550. {
  551. struct timeval tv;
  552. struct carm_msg_sync_time *st = mem;
  553. do_gettimeofday(&tv);
  554. memset(st, 0, sizeof(*st));
  555. st->type = CARM_MSG_MISC;
  556. st->subtype = MISC_SET_TIME;
  557. st->handle = cpu_to_le32(TAG_ENCODE(idx));
  558. st->timestamp = cpu_to_le32(tv.tv_sec);
  559. return sizeof(struct carm_msg_sync_time);
  560. }
  561. static unsigned int carm_fill_alloc_buf(struct carm_host *host,
  562. unsigned int idx, void *mem)
  563. {
  564. struct carm_msg_allocbuf *ab = mem;
  565. memset(ab, 0, sizeof(*ab));
  566. ab->type = CARM_MSG_MISC;
  567. ab->subtype = MISC_ALLOC_MEM;
  568. ab->handle = cpu_to_le32(TAG_ENCODE(idx));
  569. ab->n_sg = 1;
  570. ab->sg_type = SGT_32BIT;
  571. ab->addr = cpu_to_le32(host->shm_dma + (PDC_SHM_SIZE >> 1));
  572. ab->len = cpu_to_le32(PDC_SHM_SIZE >> 1);
  573. ab->evt_pool = cpu_to_le32(host->shm_dma + (16 * 1024));
  574. ab->n_evt = cpu_to_le32(1024);
  575. ab->rbuf_pool = cpu_to_le32(host->shm_dma);
  576. ab->n_rbuf = cpu_to_le32(RMSG_Q_LEN);
  577. ab->msg_pool = cpu_to_le32(host->shm_dma + RBUF_LEN);
  578. ab->n_msg = cpu_to_le32(CARM_Q_LEN);
  579. ab->sg[0].start = cpu_to_le32(host->shm_dma + (PDC_SHM_SIZE >> 1));
  580. ab->sg[0].len = cpu_to_le32(65536);
  581. return sizeof(struct carm_msg_allocbuf);
  582. }
  583. static unsigned int carm_fill_scan_channels(struct carm_host *host,
  584. unsigned int idx, void *mem)
  585. {
  586. struct carm_msg_ioctl *ioc = mem;
  587. u32 msg_data = (u32) (carm_ref_msg_dma(host, idx) +
  588. IOC_SCAN_CHAN_OFFSET);
  589. memset(ioc, 0, sizeof(*ioc));
  590. ioc->type = CARM_MSG_IOCTL;
  591. ioc->subtype = CARM_IOC_SCAN_CHAN;
  592. ioc->handle = cpu_to_le32(TAG_ENCODE(idx));
  593. ioc->data_addr = cpu_to_le32(msg_data);
  594. /* fill output data area with "no device" default values */
  595. mem += IOC_SCAN_CHAN_OFFSET;
  596. memset(mem, IOC_SCAN_CHAN_NODEV, CARM_MAX_PORTS);
  597. return IOC_SCAN_CHAN_OFFSET + CARM_MAX_PORTS;
  598. }
  599. static unsigned int carm_fill_get_fw_ver(struct carm_host *host,
  600. unsigned int idx, void *mem)
  601. {
  602. struct carm_msg_get_fw_ver *ioc = mem;
  603. u32 msg_data = (u32) (carm_ref_msg_dma(host, idx) + sizeof(*ioc));
  604. memset(ioc, 0, sizeof(*ioc));
  605. ioc->type = CARM_MSG_MISC;
  606. ioc->subtype = MISC_GET_FW_VER;
  607. ioc->handle = cpu_to_le32(TAG_ENCODE(idx));
  608. ioc->data_addr = cpu_to_le32(msg_data);
  609. return sizeof(struct carm_msg_get_fw_ver) +
  610. sizeof(struct carm_fw_ver);
  611. }
  612. static inline void carm_end_request_queued(struct carm_host *host,
  613. struct carm_request *crq,
  614. int error)
  615. {
  616. struct request *req = crq->rq;
  617. int rc;
  618. __blk_end_request_all(req, error);
  619. rc = carm_put_request(host, crq);
  620. assert(rc == 0);
  621. }
  622. static inline void carm_push_q (struct carm_host *host, struct request_queue *q)
  623. {
  624. unsigned int idx = host->wait_q_prod % CARM_MAX_WAIT_Q;
  625. blk_stop_queue(q);
  626. VPRINTK("STOPPED QUEUE %p\n", q);
  627. host->wait_q[idx] = q;
  628. host->wait_q_prod++;
  629. BUG_ON(host->wait_q_prod == host->wait_q_cons); /* overrun */
  630. }
  631. static inline struct request_queue *carm_pop_q(struct carm_host *host)
  632. {
  633. unsigned int idx;
  634. if (host->wait_q_prod == host->wait_q_cons)
  635. return NULL;
  636. idx = host->wait_q_cons % CARM_MAX_WAIT_Q;
  637. host->wait_q_cons++;
  638. return host->wait_q[idx];
  639. }
  640. static inline void carm_round_robin(struct carm_host *host)
  641. {
  642. struct request_queue *q = carm_pop_q(host);
  643. if (q) {
  644. blk_start_queue(q);
  645. VPRINTK("STARTED QUEUE %p\n", q);
  646. }
  647. }
  648. static inline void carm_end_rq(struct carm_host *host, struct carm_request *crq,
  649. int error)
  650. {
  651. carm_end_request_queued(host, crq, error);
  652. if (max_queue == 1)
  653. carm_round_robin(host);
  654. else if ((host->n_msgs <= CARM_MSG_LOW_WATER) &&
  655. (host->hw_sg_used <= CARM_SG_LOW_WATER)) {
  656. carm_round_robin(host);
  657. }
  658. }
  659. static void carm_oob_rq_fn(struct request_queue *q)
  660. {
  661. struct carm_host *host = q->queuedata;
  662. struct carm_request *crq;
  663. struct request *rq;
  664. int rc;
  665. while (1) {
  666. DPRINTK("get req\n");
  667. rq = elv_next_request(q);
  668. if (!rq)
  669. break;
  670. blkdev_dequeue_request(rq);
  671. crq = rq->special;
  672. assert(crq != NULL);
  673. assert(crq->rq == rq);
  674. crq->n_elem = 0;
  675. DPRINTK("send req\n");
  676. rc = carm_send_msg(host, crq);
  677. if (rc) {
  678. blk_requeue_request(q, rq);
  679. carm_push_q(host, q);
  680. return; /* call us again later, eventually */
  681. }
  682. }
  683. }
  684. static void carm_rq_fn(struct request_queue *q)
  685. {
  686. struct carm_port *port = q->queuedata;
  687. struct carm_host *host = port->host;
  688. struct carm_msg_rw *msg;
  689. struct carm_request *crq;
  690. struct request *rq;
  691. struct scatterlist *sg;
  692. int writing = 0, pci_dir, i, n_elem, rc;
  693. u32 tmp;
  694. unsigned int msg_size;
  695. queue_one_request:
  696. VPRINTK("get req\n");
  697. rq = elv_next_request(q);
  698. if (!rq)
  699. return;
  700. crq = carm_get_request(host);
  701. if (!crq) {
  702. carm_push_q(host, q);
  703. return; /* call us again later, eventually */
  704. }
  705. crq->rq = rq;
  706. blkdev_dequeue_request(rq);
  707. if (rq_data_dir(rq) == WRITE) {
  708. writing = 1;
  709. pci_dir = PCI_DMA_TODEVICE;
  710. } else {
  711. pci_dir = PCI_DMA_FROMDEVICE;
  712. }
  713. /* get scatterlist from block layer */
  714. sg = &crq->sg[0];
  715. n_elem = blk_rq_map_sg(q, rq, sg);
  716. if (n_elem <= 0) {
  717. carm_end_rq(host, crq, -EIO);
  718. return; /* request with no s/g entries? */
  719. }
  720. /* map scatterlist to PCI bus addresses */
  721. n_elem = pci_map_sg(host->pdev, sg, n_elem, pci_dir);
  722. if (n_elem <= 0) {
  723. carm_end_rq(host, crq, -EIO);
  724. return; /* request with no s/g entries? */
  725. }
  726. crq->n_elem = n_elem;
  727. crq->port = port;
  728. host->hw_sg_used += n_elem;
  729. /*
  730. * build read/write message
  731. */
  732. VPRINTK("build msg\n");
  733. msg = (struct carm_msg_rw *) carm_ref_msg(host, crq->tag);
  734. if (writing) {
  735. msg->type = CARM_MSG_WRITE;
  736. crq->msg_type = CARM_MSG_WRITE;
  737. } else {
  738. msg->type = CARM_MSG_READ;
  739. crq->msg_type = CARM_MSG_READ;
  740. }
  741. msg->id = port->port_no;
  742. msg->sg_count = n_elem;
  743. msg->sg_type = SGT_32BIT;
  744. msg->handle = cpu_to_le32(TAG_ENCODE(crq->tag));
  745. msg->lba = cpu_to_le32(blk_rq_pos(rq) & 0xffffffff);
  746. tmp = (blk_rq_pos(rq) >> 16) >> 16;
  747. msg->lba_high = cpu_to_le16( (u16) tmp );
  748. msg->lba_count = cpu_to_le16(blk_rq_sectors(rq));
  749. msg_size = sizeof(struct carm_msg_rw) - sizeof(msg->sg);
  750. for (i = 0; i < n_elem; i++) {
  751. struct carm_msg_sg *carm_sg = &msg->sg[i];
  752. carm_sg->start = cpu_to_le32(sg_dma_address(&crq->sg[i]));
  753. carm_sg->len = cpu_to_le32(sg_dma_len(&crq->sg[i]));
  754. msg_size += sizeof(struct carm_msg_sg);
  755. }
  756. rc = carm_lookup_bucket(msg_size);
  757. BUG_ON(rc < 0);
  758. crq->msg_bucket = (u32) rc;
  759. /*
  760. * queue read/write message to hardware
  761. */
  762. VPRINTK("send msg, tag == %u\n", crq->tag);
  763. rc = carm_send_msg(host, crq);
  764. if (rc) {
  765. carm_put_request(host, crq);
  766. blk_requeue_request(q, rq);
  767. carm_push_q(host, q);
  768. return; /* call us again later, eventually */
  769. }
  770. goto queue_one_request;
  771. }
  772. static void carm_handle_array_info(struct carm_host *host,
  773. struct carm_request *crq, u8 *mem,
  774. int error)
  775. {
  776. struct carm_port *port;
  777. u8 *msg_data = mem + sizeof(struct carm_array_info);
  778. struct carm_array_info *desc = (struct carm_array_info *) msg_data;
  779. u64 lo, hi;
  780. int cur_port;
  781. size_t slen;
  782. DPRINTK("ENTER\n");
  783. carm_end_rq(host, crq, error);
  784. if (error)
  785. goto out;
  786. if (le32_to_cpu(desc->array_status) & ARRAY_NO_EXIST)
  787. goto out;
  788. cur_port = host->cur_scan_dev;
  789. /* should never occur */
  790. if ((cur_port < 0) || (cur_port >= CARM_MAX_PORTS)) {
  791. printk(KERN_ERR PFX "BUG: cur_scan_dev==%d, array_id==%d\n",
  792. cur_port, (int) desc->array_id);
  793. goto out;
  794. }
  795. port = &host->port[cur_port];
  796. lo = (u64) le32_to_cpu(desc->size);
  797. hi = (u64) le16_to_cpu(desc->size_hi);
  798. port->capacity = lo | (hi << 32);
  799. port->dev_geom_head = le16_to_cpu(desc->head);
  800. port->dev_geom_sect = le16_to_cpu(desc->sect);
  801. port->dev_geom_cyl = le16_to_cpu(desc->cyl);
  802. host->dev_active |= (1 << cur_port);
  803. strncpy(port->name, desc->name, sizeof(port->name));
  804. port->name[sizeof(port->name) - 1] = 0;
  805. slen = strlen(port->name);
  806. while (slen && (port->name[slen - 1] == ' ')) {
  807. port->name[slen - 1] = 0;
  808. slen--;
  809. }
  810. printk(KERN_INFO DRV_NAME "(%s): port %u device %Lu sectors\n",
  811. pci_name(host->pdev), port->port_no,
  812. (unsigned long long) port->capacity);
  813. printk(KERN_INFO DRV_NAME "(%s): port %u device \"%s\"\n",
  814. pci_name(host->pdev), port->port_no, port->name);
  815. out:
  816. assert(host->state == HST_DEV_SCAN);
  817. schedule_work(&host->fsm_task);
  818. }
  819. static void carm_handle_scan_chan(struct carm_host *host,
  820. struct carm_request *crq, u8 *mem,
  821. int error)
  822. {
  823. u8 *msg_data = mem + IOC_SCAN_CHAN_OFFSET;
  824. unsigned int i, dev_count = 0;
  825. int new_state = HST_DEV_SCAN_START;
  826. DPRINTK("ENTER\n");
  827. carm_end_rq(host, crq, error);
  828. if (error) {
  829. new_state = HST_ERROR;
  830. goto out;
  831. }
  832. /* TODO: scan and support non-disk devices */
  833. for (i = 0; i < 8; i++)
  834. if (msg_data[i] == 0) { /* direct-access device (disk) */
  835. host->dev_present |= (1 << i);
  836. dev_count++;
  837. }
  838. printk(KERN_INFO DRV_NAME "(%s): found %u interesting devices\n",
  839. pci_name(host->pdev), dev_count);
  840. out:
  841. assert(host->state == HST_PORT_SCAN);
  842. host->state = new_state;
  843. schedule_work(&host->fsm_task);
  844. }
  845. static void carm_handle_generic(struct carm_host *host,
  846. struct carm_request *crq, int error,
  847. int cur_state, int next_state)
  848. {
  849. DPRINTK("ENTER\n");
  850. carm_end_rq(host, crq, error);
  851. assert(host->state == cur_state);
  852. if (error)
  853. host->state = HST_ERROR;
  854. else
  855. host->state = next_state;
  856. schedule_work(&host->fsm_task);
  857. }
  858. static inline void carm_handle_rw(struct carm_host *host,
  859. struct carm_request *crq, int error)
  860. {
  861. int pci_dir;
  862. VPRINTK("ENTER\n");
  863. if (rq_data_dir(crq->rq) == WRITE)
  864. pci_dir = PCI_DMA_TODEVICE;
  865. else
  866. pci_dir = PCI_DMA_FROMDEVICE;
  867. pci_unmap_sg(host->pdev, &crq->sg[0], crq->n_elem, pci_dir);
  868. carm_end_rq(host, crq, error);
  869. }
  870. static inline void carm_handle_resp(struct carm_host *host,
  871. __le32 ret_handle_le, u32 status)
  872. {
  873. u32 handle = le32_to_cpu(ret_handle_le);
  874. unsigned int msg_idx;
  875. struct carm_request *crq;
  876. int error = (status == RMSG_OK) ? 0 : -EIO;
  877. u8 *mem;
  878. VPRINTK("ENTER, handle == 0x%x\n", handle);
  879. if (unlikely(!TAG_VALID(handle))) {
  880. printk(KERN_ERR DRV_NAME "(%s): BUG: invalid tag 0x%x\n",
  881. pci_name(host->pdev), handle);
  882. return;
  883. }
  884. msg_idx = TAG_DECODE(handle);
  885. VPRINTK("tag == %u\n", msg_idx);
  886. crq = &host->req[msg_idx];
  887. /* fast path */
  888. if (likely(crq->msg_type == CARM_MSG_READ ||
  889. crq->msg_type == CARM_MSG_WRITE)) {
  890. carm_handle_rw(host, crq, error);
  891. return;
  892. }
  893. mem = carm_ref_msg(host, msg_idx);
  894. switch (crq->msg_type) {
  895. case CARM_MSG_IOCTL: {
  896. switch (crq->msg_subtype) {
  897. case CARM_IOC_SCAN_CHAN:
  898. carm_handle_scan_chan(host, crq, mem, error);
  899. break;
  900. default:
  901. /* unknown / invalid response */
  902. goto err_out;
  903. }
  904. break;
  905. }
  906. case CARM_MSG_MISC: {
  907. switch (crq->msg_subtype) {
  908. case MISC_ALLOC_MEM:
  909. carm_handle_generic(host, crq, error,
  910. HST_ALLOC_BUF, HST_SYNC_TIME);
  911. break;
  912. case MISC_SET_TIME:
  913. carm_handle_generic(host, crq, error,
  914. HST_SYNC_TIME, HST_GET_FW_VER);
  915. break;
  916. case MISC_GET_FW_VER: {
  917. struct carm_fw_ver *ver = (struct carm_fw_ver *)
  918. mem + sizeof(struct carm_msg_get_fw_ver);
  919. if (!error) {
  920. host->fw_ver = le32_to_cpu(ver->version);
  921. host->flags |= (ver->features & FL_FW_VER_MASK);
  922. }
  923. carm_handle_generic(host, crq, error,
  924. HST_GET_FW_VER, HST_PORT_SCAN);
  925. break;
  926. }
  927. default:
  928. /* unknown / invalid response */
  929. goto err_out;
  930. }
  931. break;
  932. }
  933. case CARM_MSG_ARRAY: {
  934. switch (crq->msg_subtype) {
  935. case CARM_ARRAY_INFO:
  936. carm_handle_array_info(host, crq, mem, error);
  937. break;
  938. default:
  939. /* unknown / invalid response */
  940. goto err_out;
  941. }
  942. break;
  943. }
  944. default:
  945. /* unknown / invalid response */
  946. goto err_out;
  947. }
  948. return;
  949. err_out:
  950. printk(KERN_WARNING DRV_NAME "(%s): BUG: unhandled message type %d/%d\n",
  951. pci_name(host->pdev), crq->msg_type, crq->msg_subtype);
  952. carm_end_rq(host, crq, -EIO);
  953. }
  954. static inline void carm_handle_responses(struct carm_host *host)
  955. {
  956. void __iomem *mmio = host->mmio;
  957. struct carm_response *resp = (struct carm_response *) host->shm;
  958. unsigned int work = 0;
  959. unsigned int idx = host->resp_idx % RMSG_Q_LEN;
  960. while (1) {
  961. u32 status = le32_to_cpu(resp[idx].status);
  962. if (status == 0xffffffff) {
  963. VPRINTK("ending response on index %u\n", idx);
  964. writel(idx << 3, mmio + CARM_RESP_IDX);
  965. break;
  966. }
  967. /* response to a message we sent */
  968. else if ((status & (1 << 31)) == 0) {
  969. VPRINTK("handling msg response on index %u\n", idx);
  970. carm_handle_resp(host, resp[idx].ret_handle, status);
  971. resp[idx].status = cpu_to_le32(0xffffffff);
  972. }
  973. /* asynchronous events the hardware throws our way */
  974. else if ((status & 0xff000000) == (1 << 31)) {
  975. u8 *evt_type_ptr = (u8 *) &resp[idx];
  976. u8 evt_type = *evt_type_ptr;
  977. printk(KERN_WARNING DRV_NAME "(%s): unhandled event type %d\n",
  978. pci_name(host->pdev), (int) evt_type);
  979. resp[idx].status = cpu_to_le32(0xffffffff);
  980. }
  981. idx = NEXT_RESP(idx);
  982. work++;
  983. }
  984. VPRINTK("EXIT, work==%u\n", work);
  985. host->resp_idx += work;
  986. }
  987. static irqreturn_t carm_interrupt(int irq, void *__host)
  988. {
  989. struct carm_host *host = __host;
  990. void __iomem *mmio;
  991. u32 mask;
  992. int handled = 0;
  993. unsigned long flags;
  994. if (!host) {
  995. VPRINTK("no host\n");
  996. return IRQ_NONE;
  997. }
  998. spin_lock_irqsave(&host->lock, flags);
  999. mmio = host->mmio;
  1000. /* reading should also clear interrupts */
  1001. mask = readl(mmio + CARM_INT_STAT);
  1002. if (mask == 0 || mask == 0xffffffff) {
  1003. VPRINTK("no work, mask == 0x%x\n", mask);
  1004. goto out;
  1005. }
  1006. if (mask & INT_ACK_MASK)
  1007. writel(mask, mmio + CARM_INT_STAT);
  1008. if (unlikely(host->state == HST_INVALID)) {
  1009. VPRINTK("not initialized yet, mask = 0x%x\n", mask);
  1010. goto out;
  1011. }
  1012. if (mask & CARM_HAVE_RESP) {
  1013. handled = 1;
  1014. carm_handle_responses(host);
  1015. }
  1016. out:
  1017. spin_unlock_irqrestore(&host->lock, flags);
  1018. VPRINTK("EXIT\n");
  1019. return IRQ_RETVAL(handled);
  1020. }
  1021. static void carm_fsm_task (struct work_struct *work)
  1022. {
  1023. struct carm_host *host =
  1024. container_of(work, struct carm_host, fsm_task);
  1025. unsigned long flags;
  1026. unsigned int state;
  1027. int rc, i, next_dev;
  1028. int reschedule = 0;
  1029. int new_state = HST_INVALID;
  1030. spin_lock_irqsave(&host->lock, flags);
  1031. state = host->state;
  1032. spin_unlock_irqrestore(&host->lock, flags);
  1033. DPRINTK("ENTER, state == %s\n", state_name[state]);
  1034. switch (state) {
  1035. case HST_PROBE_START:
  1036. new_state = HST_ALLOC_BUF;
  1037. reschedule = 1;
  1038. break;
  1039. case HST_ALLOC_BUF:
  1040. rc = carm_send_special(host, carm_fill_alloc_buf);
  1041. if (rc) {
  1042. new_state = HST_ERROR;
  1043. reschedule = 1;
  1044. }
  1045. break;
  1046. case HST_SYNC_TIME:
  1047. rc = carm_send_special(host, carm_fill_sync_time);
  1048. if (rc) {
  1049. new_state = HST_ERROR;
  1050. reschedule = 1;
  1051. }
  1052. break;
  1053. case HST_GET_FW_VER:
  1054. rc = carm_send_special(host, carm_fill_get_fw_ver);
  1055. if (rc) {
  1056. new_state = HST_ERROR;
  1057. reschedule = 1;
  1058. }
  1059. break;
  1060. case HST_PORT_SCAN:
  1061. rc = carm_send_special(host, carm_fill_scan_channels);
  1062. if (rc) {
  1063. new_state = HST_ERROR;
  1064. reschedule = 1;
  1065. }
  1066. break;
  1067. case HST_DEV_SCAN_START:
  1068. host->cur_scan_dev = -1;
  1069. new_state = HST_DEV_SCAN;
  1070. reschedule = 1;
  1071. break;
  1072. case HST_DEV_SCAN:
  1073. next_dev = -1;
  1074. for (i = host->cur_scan_dev + 1; i < CARM_MAX_PORTS; i++)
  1075. if (host->dev_present & (1 << i)) {
  1076. next_dev = i;
  1077. break;
  1078. }
  1079. if (next_dev >= 0) {
  1080. host->cur_scan_dev = next_dev;
  1081. rc = carm_array_info(host, next_dev);
  1082. if (rc) {
  1083. new_state = HST_ERROR;
  1084. reschedule = 1;
  1085. }
  1086. } else {
  1087. new_state = HST_DEV_ACTIVATE;
  1088. reschedule = 1;
  1089. }
  1090. break;
  1091. case HST_DEV_ACTIVATE: {
  1092. int activated = 0;
  1093. for (i = 0; i < CARM_MAX_PORTS; i++)
  1094. if (host->dev_active & (1 << i)) {
  1095. struct carm_port *port = &host->port[i];
  1096. struct gendisk *disk = port->disk;
  1097. set_capacity(disk, port->capacity);
  1098. add_disk(disk);
  1099. activated++;
  1100. }
  1101. printk(KERN_INFO DRV_NAME "(%s): %d ports activated\n",
  1102. pci_name(host->pdev), activated);
  1103. new_state = HST_PROBE_FINISHED;
  1104. reschedule = 1;
  1105. break;
  1106. }
  1107. case HST_PROBE_FINISHED:
  1108. complete(&host->probe_comp);
  1109. break;
  1110. case HST_ERROR:
  1111. /* FIXME: TODO */
  1112. break;
  1113. default:
  1114. /* should never occur */
  1115. printk(KERN_ERR PFX "BUG: unknown state %d\n", state);
  1116. assert(0);
  1117. break;
  1118. }
  1119. if (new_state != HST_INVALID) {
  1120. spin_lock_irqsave(&host->lock, flags);
  1121. host->state = new_state;
  1122. spin_unlock_irqrestore(&host->lock, flags);
  1123. }
  1124. if (reschedule)
  1125. schedule_work(&host->fsm_task);
  1126. }
  1127. static int carm_init_wait(void __iomem *mmio, u32 bits, unsigned int test_bit)
  1128. {
  1129. unsigned int i;
  1130. for (i = 0; i < 50000; i++) {
  1131. u32 tmp = readl(mmio + CARM_LMUC);
  1132. udelay(100);
  1133. if (test_bit) {
  1134. if ((tmp & bits) == bits)
  1135. return 0;
  1136. } else {
  1137. if ((tmp & bits) == 0)
  1138. return 0;
  1139. }
  1140. cond_resched();
  1141. }
  1142. printk(KERN_ERR PFX "carm_init_wait timeout, bits == 0x%x, test_bit == %s\n",
  1143. bits, test_bit ? "yes" : "no");
  1144. return -EBUSY;
  1145. }
  1146. static void carm_init_responses(struct carm_host *host)
  1147. {
  1148. void __iomem *mmio = host->mmio;
  1149. unsigned int i;
  1150. struct carm_response *resp = (struct carm_response *) host->shm;
  1151. for (i = 0; i < RMSG_Q_LEN; i++)
  1152. resp[i].status = cpu_to_le32(0xffffffff);
  1153. writel(0, mmio + CARM_RESP_IDX);
  1154. }
  1155. static int carm_init_host(struct carm_host *host)
  1156. {
  1157. void __iomem *mmio = host->mmio;
  1158. u32 tmp;
  1159. u8 tmp8;
  1160. int rc;
  1161. DPRINTK("ENTER\n");
  1162. writel(0, mmio + CARM_INT_MASK);
  1163. tmp8 = readb(mmio + CARM_INITC);
  1164. if (tmp8 & 0x01) {
  1165. tmp8 &= ~0x01;
  1166. writeb(tmp8, mmio + CARM_INITC);
  1167. readb(mmio + CARM_INITC); /* flush */
  1168. DPRINTK("snooze...\n");
  1169. msleep(5000);
  1170. }
  1171. tmp = readl(mmio + CARM_HMUC);
  1172. if (tmp & CARM_CME) {
  1173. DPRINTK("CME bit present, waiting\n");
  1174. rc = carm_init_wait(mmio, CARM_CME, 1);
  1175. if (rc) {
  1176. DPRINTK("EXIT, carm_init_wait 1 failed\n");
  1177. return rc;
  1178. }
  1179. }
  1180. if (tmp & CARM_RME) {
  1181. DPRINTK("RME bit present, waiting\n");
  1182. rc = carm_init_wait(mmio, CARM_RME, 1);
  1183. if (rc) {
  1184. DPRINTK("EXIT, carm_init_wait 2 failed\n");
  1185. return rc;
  1186. }
  1187. }
  1188. tmp &= ~(CARM_RME | CARM_CME);
  1189. writel(tmp, mmio + CARM_HMUC);
  1190. readl(mmio + CARM_HMUC); /* flush */
  1191. rc = carm_init_wait(mmio, CARM_RME | CARM_CME, 0);
  1192. if (rc) {
  1193. DPRINTK("EXIT, carm_init_wait 3 failed\n");
  1194. return rc;
  1195. }
  1196. carm_init_buckets(mmio);
  1197. writel(host->shm_dma & 0xffffffff, mmio + RBUF_ADDR_LO);
  1198. writel((host->shm_dma >> 16) >> 16, mmio + RBUF_ADDR_HI);
  1199. writel(RBUF_LEN, mmio + RBUF_BYTE_SZ);
  1200. tmp = readl(mmio + CARM_HMUC);
  1201. tmp |= (CARM_RME | CARM_CME | CARM_WZBC);
  1202. writel(tmp, mmio + CARM_HMUC);
  1203. readl(mmio + CARM_HMUC); /* flush */
  1204. rc = carm_init_wait(mmio, CARM_RME | CARM_CME, 1);
  1205. if (rc) {
  1206. DPRINTK("EXIT, carm_init_wait 4 failed\n");
  1207. return rc;
  1208. }
  1209. writel(0, mmio + CARM_HMPHA);
  1210. writel(INT_DEF_MASK, mmio + CARM_INT_MASK);
  1211. carm_init_responses(host);
  1212. /* start initialization, probing state machine */
  1213. spin_lock_irq(&host->lock);
  1214. assert(host->state == HST_INVALID);
  1215. host->state = HST_PROBE_START;
  1216. spin_unlock_irq(&host->lock);
  1217. schedule_work(&host->fsm_task);
  1218. DPRINTK("EXIT\n");
  1219. return 0;
  1220. }
  1221. static int carm_init_disks(struct carm_host *host)
  1222. {
  1223. unsigned int i;
  1224. int rc = 0;
  1225. for (i = 0; i < CARM_MAX_PORTS; i++) {
  1226. struct gendisk *disk;
  1227. struct request_queue *q;
  1228. struct carm_port *port;
  1229. port = &host->port[i];
  1230. port->host = host;
  1231. port->port_no = i;
  1232. disk = alloc_disk(CARM_MINORS_PER_MAJOR);
  1233. if (!disk) {
  1234. rc = -ENOMEM;
  1235. break;
  1236. }
  1237. port->disk = disk;
  1238. sprintf(disk->disk_name, DRV_NAME "/%u",
  1239. (unsigned int) (host->id * CARM_MAX_PORTS) + i);
  1240. disk->major = host->major;
  1241. disk->first_minor = i * CARM_MINORS_PER_MAJOR;
  1242. disk->fops = &carm_bd_ops;
  1243. disk->private_data = port;
  1244. q = blk_init_queue(carm_rq_fn, &host->lock);
  1245. if (!q) {
  1246. rc = -ENOMEM;
  1247. break;
  1248. }
  1249. disk->queue = q;
  1250. blk_queue_max_hw_segments(q, CARM_MAX_REQ_SG);
  1251. blk_queue_max_phys_segments(q, CARM_MAX_REQ_SG);
  1252. blk_queue_segment_boundary(q, CARM_SG_BOUNDARY);
  1253. q->queuedata = port;
  1254. }
  1255. return rc;
  1256. }
  1257. static void carm_free_disks(struct carm_host *host)
  1258. {
  1259. unsigned int i;
  1260. for (i = 0; i < CARM_MAX_PORTS; i++) {
  1261. struct gendisk *disk = host->port[i].disk;
  1262. if (disk) {
  1263. struct request_queue *q = disk->queue;
  1264. if (disk->flags & GENHD_FL_UP)
  1265. del_gendisk(disk);
  1266. if (q)
  1267. blk_cleanup_queue(q);
  1268. put_disk(disk);
  1269. }
  1270. }
  1271. }
  1272. static int carm_init_shm(struct carm_host *host)
  1273. {
  1274. host->shm = pci_alloc_consistent(host->pdev, CARM_SHM_SIZE,
  1275. &host->shm_dma);
  1276. if (!host->shm)
  1277. return -ENOMEM;
  1278. host->msg_base = host->shm + RBUF_LEN;
  1279. host->msg_dma = host->shm_dma + RBUF_LEN;
  1280. memset(host->shm, 0xff, RBUF_LEN);
  1281. memset(host->msg_base, 0, PDC_SHM_SIZE - RBUF_LEN);
  1282. return 0;
  1283. }
  1284. static int carm_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
  1285. {
  1286. static unsigned int printed_version;
  1287. struct carm_host *host;
  1288. unsigned int pci_dac;
  1289. int rc;
  1290. struct request_queue *q;
  1291. unsigned int i;
  1292. if (!printed_version++)
  1293. printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
  1294. rc = pci_enable_device(pdev);
  1295. if (rc)
  1296. return rc;
  1297. rc = pci_request_regions(pdev, DRV_NAME);
  1298. if (rc)
  1299. goto err_out;
  1300. #ifdef IF_64BIT_DMA_IS_POSSIBLE /* grrrr... */
  1301. rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
  1302. if (!rc) {
  1303. rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
  1304. if (rc) {
  1305. printk(KERN_ERR DRV_NAME "(%s): consistent DMA mask failure\n",
  1306. pci_name(pdev));
  1307. goto err_out_regions;
  1308. }
  1309. pci_dac = 1;
  1310. } else {
  1311. #endif
  1312. rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
  1313. if (rc) {
  1314. printk(KERN_ERR DRV_NAME "(%s): DMA mask failure\n",
  1315. pci_name(pdev));
  1316. goto err_out_regions;
  1317. }
  1318. pci_dac = 0;
  1319. #ifdef IF_64BIT_DMA_IS_POSSIBLE /* grrrr... */
  1320. }
  1321. #endif
  1322. host = kzalloc(sizeof(*host), GFP_KERNEL);
  1323. if (!host) {
  1324. printk(KERN_ERR DRV_NAME "(%s): memory alloc failure\n",
  1325. pci_name(pdev));
  1326. rc = -ENOMEM;
  1327. goto err_out_regions;
  1328. }
  1329. host->pdev = pdev;
  1330. host->flags = pci_dac ? FL_DAC : 0;
  1331. spin_lock_init(&host->lock);
  1332. INIT_WORK(&host->fsm_task, carm_fsm_task);
  1333. init_completion(&host->probe_comp);
  1334. for (i = 0; i < ARRAY_SIZE(host->req); i++)
  1335. host->req[i].tag = i;
  1336. host->mmio = ioremap(pci_resource_start(pdev, 0),
  1337. pci_resource_len(pdev, 0));
  1338. if (!host->mmio) {
  1339. printk(KERN_ERR DRV_NAME "(%s): MMIO alloc failure\n",
  1340. pci_name(pdev));
  1341. rc = -ENOMEM;
  1342. goto err_out_kfree;
  1343. }
  1344. rc = carm_init_shm(host);
  1345. if (rc) {
  1346. printk(KERN_ERR DRV_NAME "(%s): DMA SHM alloc failure\n",
  1347. pci_name(pdev));
  1348. goto err_out_iounmap;
  1349. }
  1350. q = blk_init_queue(carm_oob_rq_fn, &host->lock);
  1351. if (!q) {
  1352. printk(KERN_ERR DRV_NAME "(%s): OOB queue alloc failure\n",
  1353. pci_name(pdev));
  1354. rc = -ENOMEM;
  1355. goto err_out_pci_free;
  1356. }
  1357. host->oob_q = q;
  1358. q->queuedata = host;
  1359. /*
  1360. * Figure out which major to use: 160, 161, or dynamic
  1361. */
  1362. if (!test_and_set_bit(0, &carm_major_alloc))
  1363. host->major = 160;
  1364. else if (!test_and_set_bit(1, &carm_major_alloc))
  1365. host->major = 161;
  1366. else
  1367. host->flags |= FL_DYN_MAJOR;
  1368. host->id = carm_host_id;
  1369. sprintf(host->name, DRV_NAME "%d", carm_host_id);
  1370. rc = register_blkdev(host->major, host->name);
  1371. if (rc < 0)
  1372. goto err_out_free_majors;
  1373. if (host->flags & FL_DYN_MAJOR)
  1374. host->major = rc;
  1375. rc = carm_init_disks(host);
  1376. if (rc)
  1377. goto err_out_blkdev_disks;
  1378. pci_set_master(pdev);
  1379. rc = request_irq(pdev->irq, carm_interrupt, IRQF_SHARED, DRV_NAME, host);
  1380. if (rc) {
  1381. printk(KERN_ERR DRV_NAME "(%s): irq alloc failure\n",
  1382. pci_name(pdev));
  1383. goto err_out_blkdev_disks;
  1384. }
  1385. rc = carm_init_host(host);
  1386. if (rc)
  1387. goto err_out_free_irq;
  1388. DPRINTK("waiting for probe_comp\n");
  1389. wait_for_completion(&host->probe_comp);
  1390. printk(KERN_INFO "%s: pci %s, ports %d, io %llx, irq %u, major %d\n",
  1391. host->name, pci_name(pdev), (int) CARM_MAX_PORTS,
  1392. (unsigned long long)pci_resource_start(pdev, 0),
  1393. pdev->irq, host->major);
  1394. carm_host_id++;
  1395. pci_set_drvdata(pdev, host);
  1396. return 0;
  1397. err_out_free_irq:
  1398. free_irq(pdev->irq, host);
  1399. err_out_blkdev_disks:
  1400. carm_free_disks(host);
  1401. unregister_blkdev(host->major, host->name);
  1402. err_out_free_majors:
  1403. if (host->major == 160)
  1404. clear_bit(0, &carm_major_alloc);
  1405. else if (host->major == 161)
  1406. clear_bit(1, &carm_major_alloc);
  1407. blk_cleanup_queue(host->oob_q);
  1408. err_out_pci_free:
  1409. pci_free_consistent(pdev, CARM_SHM_SIZE, host->shm, host->shm_dma);
  1410. err_out_iounmap:
  1411. iounmap(host->mmio);
  1412. err_out_kfree:
  1413. kfree(host);
  1414. err_out_regions:
  1415. pci_release_regions(pdev);
  1416. err_out:
  1417. pci_disable_device(pdev);
  1418. return rc;
  1419. }
  1420. static void carm_remove_one (struct pci_dev *pdev)
  1421. {
  1422. struct carm_host *host = pci_get_drvdata(pdev);
  1423. if (!host) {
  1424. printk(KERN_ERR PFX "BUG: no host data for PCI(%s)\n",
  1425. pci_name(pdev));
  1426. return;
  1427. }
  1428. free_irq(pdev->irq, host);
  1429. carm_free_disks(host);
  1430. unregister_blkdev(host->major, host->name);
  1431. if (host->major == 160)
  1432. clear_bit(0, &carm_major_alloc);
  1433. else if (host->major == 161)
  1434. clear_bit(1, &carm_major_alloc);
  1435. blk_cleanup_queue(host->oob_q);
  1436. pci_free_consistent(pdev, CARM_SHM_SIZE, host->shm, host->shm_dma);
  1437. iounmap(host->mmio);
  1438. kfree(host);
  1439. pci_release_regions(pdev);
  1440. pci_disable_device(pdev);
  1441. pci_set_drvdata(pdev, NULL);
  1442. }
  1443. static int __init carm_init(void)
  1444. {
  1445. return pci_register_driver(&carm_driver);
  1446. }
  1447. static void __exit carm_exit(void)
  1448. {
  1449. pci_unregister_driver(&carm_driver);
  1450. }
  1451. module_init(carm_init);
  1452. module_exit(carm_exit);