fw-sbp2.c 47 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630
  1. /*
  2. * SBP2 driver (SCSI over IEEE1394)
  3. *
  4. * Copyright (C) 2005-2007 Kristian Hoegsberg <krh@bitplanet.net>
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License as published by
  8. * the Free Software Foundation; either version 2 of the License, or
  9. * (at your option) any later version.
  10. *
  11. * This program is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. * GNU General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program; if not, write to the Free Software Foundation,
  18. * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19. */
  20. /*
  21. * The basic structure of this driver is based on the old storage driver,
  22. * drivers/ieee1394/sbp2.c, originally written by
  23. * James Goodwin <jamesg@filanet.com>
  24. * with later contributions and ongoing maintenance from
  25. * Ben Collins <bcollins@debian.org>,
  26. * Stefan Richter <stefanr@s5r6.in-berlin.de>
  27. * and many others.
  28. */
  29. #include <linux/blkdev.h>
  30. #include <linux/bug.h>
  31. #include <linux/delay.h>
  32. #include <linux/device.h>
  33. #include <linux/dma-mapping.h>
  34. #include <linux/kernel.h>
  35. #include <linux/mod_devicetable.h>
  36. #include <linux/module.h>
  37. #include <linux/moduleparam.h>
  38. #include <linux/scatterlist.h>
  39. #include <linux/string.h>
  40. #include <linux/stringify.h>
  41. #include <linux/timer.h>
  42. #include <linux/workqueue.h>
  43. #include <asm/system.h>
  44. #include <scsi/scsi.h>
  45. #include <scsi/scsi_cmnd.h>
  46. #include <scsi/scsi_device.h>
  47. #include <scsi/scsi_host.h>
  48. #include "fw-device.h"
  49. #include "fw-topology.h"
  50. #include "fw-transaction.h"
  51. /*
  52. * So far only bridges from Oxford Semiconductor are known to support
  53. * concurrent logins. Depending on firmware, four or two concurrent logins
  54. * are possible on OXFW911 and newer Oxsemi bridges.
  55. *
  56. * Concurrent logins are useful together with cluster filesystems.
  57. */
  58. static int sbp2_param_exclusive_login = 1;
  59. module_param_named(exclusive_login, sbp2_param_exclusive_login, bool, 0644);
  60. MODULE_PARM_DESC(exclusive_login, "Exclusive login to sbp2 device "
  61. "(default = Y, use N for concurrent initiators)");
  62. /*
  63. * Flags for firmware oddities
  64. *
  65. * - 128kB max transfer
  66. * Limit transfer size. Necessary for some old bridges.
  67. *
  68. * - 36 byte inquiry
  69. * When scsi_mod probes the device, let the inquiry command look like that
  70. * from MS Windows.
  71. *
  72. * - skip mode page 8
  73. * Suppress sending of mode_sense for mode page 8 if the device pretends to
  74. * support the SCSI Primary Block commands instead of Reduced Block Commands.
  75. *
  76. * - fix capacity
  77. * Tell sd_mod to correct the last sector number reported by read_capacity.
  78. * Avoids access beyond actual disk limits on devices with an off-by-one bug.
  79. * Don't use this with devices which don't have this bug.
  80. *
  81. * - delay inquiry
  82. * Wait extra SBP2_INQUIRY_DELAY seconds after login before SCSI inquiry.
  83. *
  84. * - power condition
  85. * Set the power condition field in the START STOP UNIT commands sent by
  86. * sd_mod on suspend, resume, and shutdown (if manage_start_stop is on).
  87. * Some disks need this to spin down or to resume properly.
  88. *
  89. * - override internal blacklist
  90. * Instead of adding to the built-in blacklist, use only the workarounds
  91. * specified in the module load parameter.
  92. * Useful if a blacklist entry interfered with a non-broken device.
  93. */
  94. #define SBP2_WORKAROUND_128K_MAX_TRANS 0x1
  95. #define SBP2_WORKAROUND_INQUIRY_36 0x2
  96. #define SBP2_WORKAROUND_MODE_SENSE_8 0x4
  97. #define SBP2_WORKAROUND_FIX_CAPACITY 0x8
  98. #define SBP2_WORKAROUND_DELAY_INQUIRY 0x10
  99. #define SBP2_INQUIRY_DELAY 12
  100. #define SBP2_WORKAROUND_POWER_CONDITION 0x20
  101. #define SBP2_WORKAROUND_OVERRIDE 0x100
  102. static int sbp2_param_workarounds;
  103. module_param_named(workarounds, sbp2_param_workarounds, int, 0644);
  104. MODULE_PARM_DESC(workarounds, "Work around device bugs (default = 0"
  105. ", 128kB max transfer = " __stringify(SBP2_WORKAROUND_128K_MAX_TRANS)
  106. ", 36 byte inquiry = " __stringify(SBP2_WORKAROUND_INQUIRY_36)
  107. ", skip mode page 8 = " __stringify(SBP2_WORKAROUND_MODE_SENSE_8)
  108. ", fix capacity = " __stringify(SBP2_WORKAROUND_FIX_CAPACITY)
  109. ", delay inquiry = " __stringify(SBP2_WORKAROUND_DELAY_INQUIRY)
  110. ", set power condition in start stop unit = "
  111. __stringify(SBP2_WORKAROUND_POWER_CONDITION)
  112. ", override internal blacklist = " __stringify(SBP2_WORKAROUND_OVERRIDE)
  113. ", or a combination)");
  114. /* I don't know why the SCSI stack doesn't define something like this... */
  115. typedef void (*scsi_done_fn_t)(struct scsi_cmnd *);
  116. static const char sbp2_driver_name[] = "sbp2";
  117. /*
  118. * We create one struct sbp2_logical_unit per SBP-2 Logical Unit Number Entry
  119. * and one struct scsi_device per sbp2_logical_unit.
  120. */
  121. struct sbp2_logical_unit {
  122. struct sbp2_target *tgt;
  123. struct list_head link;
  124. struct fw_address_handler address_handler;
  125. struct list_head orb_list;
  126. u64 command_block_agent_address;
  127. u16 lun;
  128. int login_id;
  129. /*
  130. * The generation is updated once we've logged in or reconnected
  131. * to the logical unit. Thus, I/O to the device will automatically
  132. * fail and get retried if it happens in a window where the device
  133. * is not ready, e.g. after a bus reset but before we reconnect.
  134. */
  135. int generation;
  136. int retries;
  137. struct delayed_work work;
  138. bool has_sdev;
  139. bool blocked;
  140. };
  141. /*
  142. * We create one struct sbp2_target per IEEE 1212 Unit Directory
  143. * and one struct Scsi_Host per sbp2_target.
  144. */
  145. struct sbp2_target {
  146. struct kref kref;
  147. struct fw_unit *unit;
  148. const char *bus_id;
  149. struct list_head lu_list;
  150. u64 management_agent_address;
  151. u64 guid;
  152. int directory_id;
  153. int node_id;
  154. int address_high;
  155. unsigned int workarounds;
  156. unsigned int mgt_orb_timeout;
  157. int dont_block; /* counter for each logical unit */
  158. int blocked; /* ditto */
  159. };
  160. /*
  161. * Per section 7.4.8 of the SBP-2 spec, a mgt_ORB_timeout value can be
  162. * provided in the config rom. Most devices do provide a value, which
  163. * we'll use for login management orbs, but with some sane limits.
  164. */
  165. #define SBP2_MIN_LOGIN_ORB_TIMEOUT 5000U /* Timeout in ms */
  166. #define SBP2_MAX_LOGIN_ORB_TIMEOUT 40000U /* Timeout in ms */
  167. #define SBP2_ORB_TIMEOUT 2000U /* Timeout in ms */
  168. #define SBP2_ORB_NULL 0x80000000
  169. #define SBP2_RETRY_LIMIT 0xf /* 15 retries */
  170. #define SBP2_CYCLE_LIMIT (0xc8 << 12) /* 200 125us cycles */
  171. /*
  172. * The default maximum s/g segment size of a FireWire controller is
  173. * usually 0x10000, but SBP-2 only allows 0xffff. Since buffers have to
  174. * be quadlet-aligned, we set the length limit to 0xffff & ~3.
  175. */
  176. #define SBP2_MAX_SEG_SIZE 0xfffc
  177. /* Unit directory keys */
  178. #define SBP2_CSR_UNIT_CHARACTERISTICS 0x3a
  179. #define SBP2_CSR_FIRMWARE_REVISION 0x3c
  180. #define SBP2_CSR_LOGICAL_UNIT_NUMBER 0x14
  181. #define SBP2_CSR_LOGICAL_UNIT_DIRECTORY 0xd4
  182. /* Management orb opcodes */
  183. #define SBP2_LOGIN_REQUEST 0x0
  184. #define SBP2_QUERY_LOGINS_REQUEST 0x1
  185. #define SBP2_RECONNECT_REQUEST 0x3
  186. #define SBP2_SET_PASSWORD_REQUEST 0x4
  187. #define SBP2_LOGOUT_REQUEST 0x7
  188. #define SBP2_ABORT_TASK_REQUEST 0xb
  189. #define SBP2_ABORT_TASK_SET 0xc
  190. #define SBP2_LOGICAL_UNIT_RESET 0xe
  191. #define SBP2_TARGET_RESET_REQUEST 0xf
  192. /* Offsets for command block agent registers */
  193. #define SBP2_AGENT_STATE 0x00
  194. #define SBP2_AGENT_RESET 0x04
  195. #define SBP2_ORB_POINTER 0x08
  196. #define SBP2_DOORBELL 0x10
  197. #define SBP2_UNSOLICITED_STATUS_ENABLE 0x14
  198. /* Status write response codes */
  199. #define SBP2_STATUS_REQUEST_COMPLETE 0x0
  200. #define SBP2_STATUS_TRANSPORT_FAILURE 0x1
  201. #define SBP2_STATUS_ILLEGAL_REQUEST 0x2
  202. #define SBP2_STATUS_VENDOR_DEPENDENT 0x3
  203. #define STATUS_GET_ORB_HIGH(v) ((v).status & 0xffff)
  204. #define STATUS_GET_SBP_STATUS(v) (((v).status >> 16) & 0xff)
  205. #define STATUS_GET_LEN(v) (((v).status >> 24) & 0x07)
  206. #define STATUS_GET_DEAD(v) (((v).status >> 27) & 0x01)
  207. #define STATUS_GET_RESPONSE(v) (((v).status >> 28) & 0x03)
  208. #define STATUS_GET_SOURCE(v) (((v).status >> 30) & 0x03)
  209. #define STATUS_GET_ORB_LOW(v) ((v).orb_low)
  210. #define STATUS_GET_DATA(v) ((v).data)
  211. struct sbp2_status {
  212. u32 status;
  213. u32 orb_low;
  214. u8 data[24];
  215. };
  216. struct sbp2_pointer {
  217. __be32 high;
  218. __be32 low;
  219. };
  220. struct sbp2_orb {
  221. struct fw_transaction t;
  222. struct kref kref;
  223. dma_addr_t request_bus;
  224. int rcode;
  225. struct sbp2_pointer pointer;
  226. void (*callback)(struct sbp2_orb * orb, struct sbp2_status * status);
  227. struct list_head link;
  228. };
  229. #define MANAGEMENT_ORB_LUN(v) ((v))
  230. #define MANAGEMENT_ORB_FUNCTION(v) ((v) << 16)
  231. #define MANAGEMENT_ORB_RECONNECT(v) ((v) << 20)
  232. #define MANAGEMENT_ORB_EXCLUSIVE(v) ((v) ? 1 << 28 : 0)
  233. #define MANAGEMENT_ORB_REQUEST_FORMAT(v) ((v) << 29)
  234. #define MANAGEMENT_ORB_NOTIFY ((1) << 31)
  235. #define MANAGEMENT_ORB_RESPONSE_LENGTH(v) ((v))
  236. #define MANAGEMENT_ORB_PASSWORD_LENGTH(v) ((v) << 16)
  237. struct sbp2_management_orb {
  238. struct sbp2_orb base;
  239. struct {
  240. struct sbp2_pointer password;
  241. struct sbp2_pointer response;
  242. __be32 misc;
  243. __be32 length;
  244. struct sbp2_pointer status_fifo;
  245. } request;
  246. __be32 response[4];
  247. dma_addr_t response_bus;
  248. struct completion done;
  249. struct sbp2_status status;
  250. };
  251. struct sbp2_login_response {
  252. __be32 misc;
  253. struct sbp2_pointer command_block_agent;
  254. __be32 reconnect_hold;
  255. };
  256. #define COMMAND_ORB_DATA_SIZE(v) ((v))
  257. #define COMMAND_ORB_PAGE_SIZE(v) ((v) << 16)
  258. #define COMMAND_ORB_PAGE_TABLE_PRESENT ((1) << 19)
  259. #define COMMAND_ORB_MAX_PAYLOAD(v) ((v) << 20)
  260. #define COMMAND_ORB_SPEED(v) ((v) << 24)
  261. #define COMMAND_ORB_DIRECTION ((1) << 27)
  262. #define COMMAND_ORB_REQUEST_FORMAT(v) ((v) << 29)
  263. #define COMMAND_ORB_NOTIFY ((1) << 31)
  264. struct sbp2_command_orb {
  265. struct sbp2_orb base;
  266. struct {
  267. struct sbp2_pointer next;
  268. struct sbp2_pointer data_descriptor;
  269. __be32 misc;
  270. u8 command_block[12];
  271. } request;
  272. struct scsi_cmnd *cmd;
  273. scsi_done_fn_t done;
  274. struct sbp2_logical_unit *lu;
  275. struct sbp2_pointer page_table[SG_ALL] __attribute__((aligned(8)));
  276. dma_addr_t page_table_bus;
  277. };
  278. /*
  279. * List of devices with known bugs.
  280. *
  281. * The firmware_revision field, masked with 0xffff00, is the best
  282. * indicator for the type of bridge chip of a device. It yields a few
  283. * false positives but this did not break correctly behaving devices
  284. * so far. We use ~0 as a wildcard, since the 24 bit values we get
  285. * from the config rom can never match that.
  286. */
  287. static const struct {
  288. u32 firmware_revision;
  289. u32 model;
  290. unsigned int workarounds;
  291. } sbp2_workarounds_table[] = {
  292. /* DViCO Momobay CX-1 with TSB42AA9 bridge */ {
  293. .firmware_revision = 0x002800,
  294. .model = 0x001010,
  295. .workarounds = SBP2_WORKAROUND_INQUIRY_36 |
  296. SBP2_WORKAROUND_MODE_SENSE_8 |
  297. SBP2_WORKAROUND_POWER_CONDITION,
  298. },
  299. /* DViCO Momobay FX-3A with TSB42AA9A bridge */ {
  300. .firmware_revision = 0x002800,
  301. .model = 0x000000,
  302. .workarounds = SBP2_WORKAROUND_DELAY_INQUIRY |
  303. SBP2_WORKAROUND_POWER_CONDITION,
  304. },
  305. /* Initio bridges, actually only needed for some older ones */ {
  306. .firmware_revision = 0x000200,
  307. .model = ~0,
  308. .workarounds = SBP2_WORKAROUND_INQUIRY_36,
  309. },
  310. /* PL-3507 bridge with Prolific firmware */ {
  311. .firmware_revision = 0x012800,
  312. .model = ~0,
  313. .workarounds = SBP2_WORKAROUND_POWER_CONDITION,
  314. },
  315. /* Symbios bridge */ {
  316. .firmware_revision = 0xa0b800,
  317. .model = ~0,
  318. .workarounds = SBP2_WORKAROUND_128K_MAX_TRANS,
  319. },
  320. /* Datafab MD2-FW2 with Symbios/LSILogic SYM13FW500 bridge */ {
  321. .firmware_revision = 0x002600,
  322. .model = ~0,
  323. .workarounds = SBP2_WORKAROUND_128K_MAX_TRANS,
  324. },
  325. /*
  326. * There are iPods (2nd gen, 3rd gen) with model_id == 0, but
  327. * these iPods do not feature the read_capacity bug according
  328. * to one report. Read_capacity behaviour as well as model_id
  329. * could change due to Apple-supplied firmware updates though.
  330. */
  331. /* iPod 4th generation. */ {
  332. .firmware_revision = 0x0a2700,
  333. .model = 0x000021,
  334. .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
  335. },
  336. /* iPod mini */ {
  337. .firmware_revision = 0x0a2700,
  338. .model = 0x000023,
  339. .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
  340. },
  341. /* iPod Photo */ {
  342. .firmware_revision = 0x0a2700,
  343. .model = 0x00007e,
  344. .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
  345. }
  346. };
  347. static void
  348. free_orb(struct kref *kref)
  349. {
  350. struct sbp2_orb *orb = container_of(kref, struct sbp2_orb, kref);
  351. kfree(orb);
  352. }
  353. static void
  354. sbp2_status_write(struct fw_card *card, struct fw_request *request,
  355. int tcode, int destination, int source,
  356. int generation, int speed,
  357. unsigned long long offset,
  358. void *payload, size_t length, void *callback_data)
  359. {
  360. struct sbp2_logical_unit *lu = callback_data;
  361. struct sbp2_orb *orb;
  362. struct sbp2_status status;
  363. size_t header_size;
  364. unsigned long flags;
  365. if (tcode != TCODE_WRITE_BLOCK_REQUEST ||
  366. length == 0 || length > sizeof(status)) {
  367. fw_send_response(card, request, RCODE_TYPE_ERROR);
  368. return;
  369. }
  370. header_size = min(length, 2 * sizeof(u32));
  371. fw_memcpy_from_be32(&status, payload, header_size);
  372. if (length > header_size)
  373. memcpy(status.data, payload + 8, length - header_size);
  374. if (STATUS_GET_SOURCE(status) == 2 || STATUS_GET_SOURCE(status) == 3) {
  375. fw_notify("non-orb related status write, not handled\n");
  376. fw_send_response(card, request, RCODE_COMPLETE);
  377. return;
  378. }
  379. /* Lookup the orb corresponding to this status write. */
  380. spin_lock_irqsave(&card->lock, flags);
  381. list_for_each_entry(orb, &lu->orb_list, link) {
  382. if (STATUS_GET_ORB_HIGH(status) == 0 &&
  383. STATUS_GET_ORB_LOW(status) == orb->request_bus) {
  384. orb->rcode = RCODE_COMPLETE;
  385. list_del(&orb->link);
  386. break;
  387. }
  388. }
  389. spin_unlock_irqrestore(&card->lock, flags);
  390. if (&orb->link != &lu->orb_list)
  391. orb->callback(orb, &status);
  392. else
  393. fw_error("status write for unknown orb\n");
  394. kref_put(&orb->kref, free_orb);
  395. fw_send_response(card, request, RCODE_COMPLETE);
  396. }
  397. static void
  398. complete_transaction(struct fw_card *card, int rcode,
  399. void *payload, size_t length, void *data)
  400. {
  401. struct sbp2_orb *orb = data;
  402. unsigned long flags;
  403. /*
  404. * This is a little tricky. We can get the status write for
  405. * the orb before we get this callback. The status write
  406. * handler above will assume the orb pointer transaction was
  407. * successful and set the rcode to RCODE_COMPLETE for the orb.
  408. * So this callback only sets the rcode if it hasn't already
  409. * been set and only does the cleanup if the transaction
  410. * failed and we didn't already get a status write.
  411. */
  412. spin_lock_irqsave(&card->lock, flags);
  413. if (orb->rcode == -1)
  414. orb->rcode = rcode;
  415. if (orb->rcode != RCODE_COMPLETE) {
  416. list_del(&orb->link);
  417. spin_unlock_irqrestore(&card->lock, flags);
  418. orb->callback(orb, NULL);
  419. } else {
  420. spin_unlock_irqrestore(&card->lock, flags);
  421. }
  422. kref_put(&orb->kref, free_orb);
  423. }
  424. static void
  425. sbp2_send_orb(struct sbp2_orb *orb, struct sbp2_logical_unit *lu,
  426. int node_id, int generation, u64 offset)
  427. {
  428. struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
  429. unsigned long flags;
  430. orb->pointer.high = 0;
  431. orb->pointer.low = cpu_to_be32(orb->request_bus);
  432. spin_lock_irqsave(&device->card->lock, flags);
  433. list_add_tail(&orb->link, &lu->orb_list);
  434. spin_unlock_irqrestore(&device->card->lock, flags);
  435. /* Take a ref for the orb list and for the transaction callback. */
  436. kref_get(&orb->kref);
  437. kref_get(&orb->kref);
  438. fw_send_request(device->card, &orb->t, TCODE_WRITE_BLOCK_REQUEST,
  439. node_id, generation, device->max_speed, offset,
  440. &orb->pointer, sizeof(orb->pointer),
  441. complete_transaction, orb);
  442. }
  443. static int sbp2_cancel_orbs(struct sbp2_logical_unit *lu)
  444. {
  445. struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
  446. struct sbp2_orb *orb, *next;
  447. struct list_head list;
  448. unsigned long flags;
  449. int retval = -ENOENT;
  450. INIT_LIST_HEAD(&list);
  451. spin_lock_irqsave(&device->card->lock, flags);
  452. list_splice_init(&lu->orb_list, &list);
  453. spin_unlock_irqrestore(&device->card->lock, flags);
  454. list_for_each_entry_safe(orb, next, &list, link) {
  455. retval = 0;
  456. if (fw_cancel_transaction(device->card, &orb->t) == 0)
  457. continue;
  458. orb->rcode = RCODE_CANCELLED;
  459. orb->callback(orb, NULL);
  460. }
  461. return retval;
  462. }
  463. static void
  464. complete_management_orb(struct sbp2_orb *base_orb, struct sbp2_status *status)
  465. {
  466. struct sbp2_management_orb *orb =
  467. container_of(base_orb, struct sbp2_management_orb, base);
  468. if (status)
  469. memcpy(&orb->status, status, sizeof(*status));
  470. complete(&orb->done);
  471. }
  472. static int
  473. sbp2_send_management_orb(struct sbp2_logical_unit *lu, int node_id,
  474. int generation, int function, int lun_or_login_id,
  475. void *response)
  476. {
  477. struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
  478. struct sbp2_management_orb *orb;
  479. unsigned int timeout;
  480. int retval = -ENOMEM;
  481. if (function == SBP2_LOGOUT_REQUEST && fw_device_is_shutdown(device))
  482. return 0;
  483. orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
  484. if (orb == NULL)
  485. return -ENOMEM;
  486. kref_init(&orb->base.kref);
  487. orb->response_bus =
  488. dma_map_single(device->card->device, &orb->response,
  489. sizeof(orb->response), DMA_FROM_DEVICE);
  490. if (dma_mapping_error(device->card->device, orb->response_bus))
  491. goto fail_mapping_response;
  492. orb->request.response.high = 0;
  493. orb->request.response.low = cpu_to_be32(orb->response_bus);
  494. orb->request.misc = cpu_to_be32(
  495. MANAGEMENT_ORB_NOTIFY |
  496. MANAGEMENT_ORB_FUNCTION(function) |
  497. MANAGEMENT_ORB_LUN(lun_or_login_id));
  498. orb->request.length = cpu_to_be32(
  499. MANAGEMENT_ORB_RESPONSE_LENGTH(sizeof(orb->response)));
  500. orb->request.status_fifo.high =
  501. cpu_to_be32(lu->address_handler.offset >> 32);
  502. orb->request.status_fifo.low =
  503. cpu_to_be32(lu->address_handler.offset);
  504. if (function == SBP2_LOGIN_REQUEST) {
  505. /* Ask for 2^2 == 4 seconds reconnect grace period */
  506. orb->request.misc |= cpu_to_be32(
  507. MANAGEMENT_ORB_RECONNECT(2) |
  508. MANAGEMENT_ORB_EXCLUSIVE(sbp2_param_exclusive_login));
  509. timeout = lu->tgt->mgt_orb_timeout;
  510. } else {
  511. timeout = SBP2_ORB_TIMEOUT;
  512. }
  513. init_completion(&orb->done);
  514. orb->base.callback = complete_management_orb;
  515. orb->base.request_bus =
  516. dma_map_single(device->card->device, &orb->request,
  517. sizeof(orb->request), DMA_TO_DEVICE);
  518. if (dma_mapping_error(device->card->device, orb->base.request_bus))
  519. goto fail_mapping_request;
  520. sbp2_send_orb(&orb->base, lu, node_id, generation,
  521. lu->tgt->management_agent_address);
  522. wait_for_completion_timeout(&orb->done, msecs_to_jiffies(timeout));
  523. retval = -EIO;
  524. if (sbp2_cancel_orbs(lu) == 0) {
  525. fw_error("%s: orb reply timed out, rcode=0x%02x\n",
  526. lu->tgt->bus_id, orb->base.rcode);
  527. goto out;
  528. }
  529. if (orb->base.rcode != RCODE_COMPLETE) {
  530. fw_error("%s: management write failed, rcode 0x%02x\n",
  531. lu->tgt->bus_id, orb->base.rcode);
  532. goto out;
  533. }
  534. if (STATUS_GET_RESPONSE(orb->status) != 0 ||
  535. STATUS_GET_SBP_STATUS(orb->status) != 0) {
  536. fw_error("%s: error status: %d:%d\n", lu->tgt->bus_id,
  537. STATUS_GET_RESPONSE(orb->status),
  538. STATUS_GET_SBP_STATUS(orb->status));
  539. goto out;
  540. }
  541. retval = 0;
  542. out:
  543. dma_unmap_single(device->card->device, orb->base.request_bus,
  544. sizeof(orb->request), DMA_TO_DEVICE);
  545. fail_mapping_request:
  546. dma_unmap_single(device->card->device, orb->response_bus,
  547. sizeof(orb->response), DMA_FROM_DEVICE);
  548. fail_mapping_response:
  549. if (response)
  550. memcpy(response, orb->response, sizeof(orb->response));
  551. kref_put(&orb->base.kref, free_orb);
  552. return retval;
  553. }
  554. static void sbp2_agent_reset(struct sbp2_logical_unit *lu)
  555. {
  556. struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
  557. __be32 d = 0;
  558. fw_run_transaction(device->card, TCODE_WRITE_QUADLET_REQUEST,
  559. lu->tgt->node_id, lu->generation, device->max_speed,
  560. lu->command_block_agent_address + SBP2_AGENT_RESET,
  561. &d, sizeof(d));
  562. }
  563. static void
  564. complete_agent_reset_write_no_wait(struct fw_card *card, int rcode,
  565. void *payload, size_t length, void *data)
  566. {
  567. kfree(data);
  568. }
  569. static void sbp2_agent_reset_no_wait(struct sbp2_logical_unit *lu)
  570. {
  571. struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
  572. struct fw_transaction *t;
  573. static __be32 d;
  574. t = kmalloc(sizeof(*t), GFP_ATOMIC);
  575. if (t == NULL)
  576. return;
  577. fw_send_request(device->card, t, TCODE_WRITE_QUADLET_REQUEST,
  578. lu->tgt->node_id, lu->generation, device->max_speed,
  579. lu->command_block_agent_address + SBP2_AGENT_RESET,
  580. &d, sizeof(d), complete_agent_reset_write_no_wait, t);
  581. }
  582. static void sbp2_set_generation(struct sbp2_logical_unit *lu, int generation)
  583. {
  584. struct fw_card *card = fw_device(lu->tgt->unit->device.parent)->card;
  585. unsigned long flags;
  586. /* serialize with comparisons of lu->generation and card->generation */
  587. spin_lock_irqsave(&card->lock, flags);
  588. lu->generation = generation;
  589. spin_unlock_irqrestore(&card->lock, flags);
  590. }
  591. static inline void sbp2_allow_block(struct sbp2_logical_unit *lu)
  592. {
  593. /*
  594. * We may access dont_block without taking card->lock here:
  595. * All callers of sbp2_allow_block() and all callers of sbp2_unblock()
  596. * are currently serialized against each other.
  597. * And a wrong result in sbp2_conditionally_block()'s access of
  598. * dont_block is rather harmless, it simply misses its first chance.
  599. */
  600. --lu->tgt->dont_block;
  601. }
  602. /*
  603. * Blocks lu->tgt if all of the following conditions are met:
  604. * - Login, INQUIRY, and high-level SCSI setup of all of the target's
  605. * logical units have been finished (indicated by dont_block == 0).
  606. * - lu->generation is stale.
  607. *
  608. * Note, scsi_block_requests() must be called while holding card->lock,
  609. * otherwise it might foil sbp2_[conditionally_]unblock()'s attempt to
  610. * unblock the target.
  611. */
  612. static void sbp2_conditionally_block(struct sbp2_logical_unit *lu)
  613. {
  614. struct sbp2_target *tgt = lu->tgt;
  615. struct fw_card *card = fw_device(tgt->unit->device.parent)->card;
  616. struct Scsi_Host *shost =
  617. container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
  618. unsigned long flags;
  619. spin_lock_irqsave(&card->lock, flags);
  620. if (!tgt->dont_block && !lu->blocked &&
  621. lu->generation != card->generation) {
  622. lu->blocked = true;
  623. if (++tgt->blocked == 1)
  624. scsi_block_requests(shost);
  625. }
  626. spin_unlock_irqrestore(&card->lock, flags);
  627. }
  628. /*
  629. * Unblocks lu->tgt as soon as all its logical units can be unblocked.
  630. * Note, it is harmless to run scsi_unblock_requests() outside the
  631. * card->lock protected section. On the other hand, running it inside
  632. * the section might clash with shost->host_lock.
  633. */
  634. static void sbp2_conditionally_unblock(struct sbp2_logical_unit *lu)
  635. {
  636. struct sbp2_target *tgt = lu->tgt;
  637. struct fw_card *card = fw_device(tgt->unit->device.parent)->card;
  638. struct Scsi_Host *shost =
  639. container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
  640. unsigned long flags;
  641. bool unblock = false;
  642. spin_lock_irqsave(&card->lock, flags);
  643. if (lu->blocked && lu->generation == card->generation) {
  644. lu->blocked = false;
  645. unblock = --tgt->blocked == 0;
  646. }
  647. spin_unlock_irqrestore(&card->lock, flags);
  648. if (unblock)
  649. scsi_unblock_requests(shost);
  650. }
  651. /*
  652. * Prevents future blocking of tgt and unblocks it.
  653. * Note, it is harmless to run scsi_unblock_requests() outside the
  654. * card->lock protected section. On the other hand, running it inside
  655. * the section might clash with shost->host_lock.
  656. */
  657. static void sbp2_unblock(struct sbp2_target *tgt)
  658. {
  659. struct fw_card *card = fw_device(tgt->unit->device.parent)->card;
  660. struct Scsi_Host *shost =
  661. container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
  662. unsigned long flags;
  663. spin_lock_irqsave(&card->lock, flags);
  664. ++tgt->dont_block;
  665. spin_unlock_irqrestore(&card->lock, flags);
  666. scsi_unblock_requests(shost);
  667. }
  668. static int sbp2_lun2int(u16 lun)
  669. {
  670. struct scsi_lun eight_bytes_lun;
  671. memset(&eight_bytes_lun, 0, sizeof(eight_bytes_lun));
  672. eight_bytes_lun.scsi_lun[0] = (lun >> 8) & 0xff;
  673. eight_bytes_lun.scsi_lun[1] = lun & 0xff;
  674. return scsilun_to_int(&eight_bytes_lun);
  675. }
  676. static void sbp2_release_target(struct kref *kref)
  677. {
  678. struct sbp2_target *tgt = container_of(kref, struct sbp2_target, kref);
  679. struct sbp2_logical_unit *lu, *next;
  680. struct Scsi_Host *shost =
  681. container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
  682. struct scsi_device *sdev;
  683. struct fw_device *device = fw_device(tgt->unit->device.parent);
  684. /* prevent deadlocks */
  685. sbp2_unblock(tgt);
  686. list_for_each_entry_safe(lu, next, &tgt->lu_list, link) {
  687. sdev = scsi_device_lookup(shost, 0, 0, sbp2_lun2int(lu->lun));
  688. if (sdev) {
  689. scsi_remove_device(sdev);
  690. scsi_device_put(sdev);
  691. }
  692. sbp2_send_management_orb(lu, tgt->node_id, lu->generation,
  693. SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
  694. fw_core_remove_address_handler(&lu->address_handler);
  695. list_del(&lu->link);
  696. kfree(lu);
  697. }
  698. scsi_remove_host(shost);
  699. fw_notify("released %s, target %d:0:0\n", tgt->bus_id, shost->host_no);
  700. fw_unit_put(tgt->unit);
  701. scsi_host_put(shost);
  702. fw_device_put(device);
  703. }
  704. static struct workqueue_struct *sbp2_wq;
  705. /*
  706. * Always get the target's kref when scheduling work on one its units.
  707. * Each workqueue job is responsible to call sbp2_target_put() upon return.
  708. */
  709. static void sbp2_queue_work(struct sbp2_logical_unit *lu, unsigned long delay)
  710. {
  711. if (queue_delayed_work(sbp2_wq, &lu->work, delay))
  712. kref_get(&lu->tgt->kref);
  713. }
  714. static void sbp2_target_put(struct sbp2_target *tgt)
  715. {
  716. kref_put(&tgt->kref, sbp2_release_target);
  717. }
  718. /*
  719. * Write retransmit retry values into the BUSY_TIMEOUT register.
  720. * - The single-phase retry protocol is supported by all SBP-2 devices, but the
  721. * default retry_limit value is 0 (i.e. never retry transmission). We write a
  722. * saner value after logging into the device.
  723. * - The dual-phase retry protocol is optional to implement, and if not
  724. * supported, writes to the dual-phase portion of the register will be
  725. * ignored. We try to write the original 1394-1995 default here.
  726. * - In the case of devices that are also SBP-3-compliant, all writes are
  727. * ignored, as the register is read-only, but contains single-phase retry of
  728. * 15, which is what we're trying to set for all SBP-2 device anyway, so this
  729. * write attempt is safe and yields more consistent behavior for all devices.
  730. *
  731. * See section 8.3.2.3.5 of the 1394-1995 spec, section 6.2 of the SBP-2 spec,
  732. * and section 6.4 of the SBP-3 spec for further details.
  733. */
  734. static void sbp2_set_busy_timeout(struct sbp2_logical_unit *lu)
  735. {
  736. struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
  737. __be32 d = cpu_to_be32(SBP2_CYCLE_LIMIT | SBP2_RETRY_LIMIT);
  738. fw_run_transaction(device->card, TCODE_WRITE_QUADLET_REQUEST,
  739. lu->tgt->node_id, lu->generation, device->max_speed,
  740. CSR_REGISTER_BASE + CSR_BUSY_TIMEOUT,
  741. &d, sizeof(d));
  742. }
  743. static void sbp2_reconnect(struct work_struct *work);
  744. static void sbp2_login(struct work_struct *work)
  745. {
  746. struct sbp2_logical_unit *lu =
  747. container_of(work, struct sbp2_logical_unit, work.work);
  748. struct sbp2_target *tgt = lu->tgt;
  749. struct fw_device *device = fw_device(tgt->unit->device.parent);
  750. struct Scsi_Host *shost;
  751. struct scsi_device *sdev;
  752. struct sbp2_login_response response;
  753. int generation, node_id, local_node_id;
  754. if (fw_device_is_shutdown(device))
  755. goto out;
  756. generation = device->generation;
  757. smp_rmb(); /* node_id must not be older than generation */
  758. node_id = device->node_id;
  759. local_node_id = device->card->node_id;
  760. /* If this is a re-login attempt, log out, or we might be rejected. */
  761. if (lu->has_sdev)
  762. sbp2_send_management_orb(lu, device->node_id, generation,
  763. SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
  764. if (sbp2_send_management_orb(lu, node_id, generation,
  765. SBP2_LOGIN_REQUEST, lu->lun, &response) < 0) {
  766. if (lu->retries++ < 5) {
  767. sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
  768. } else {
  769. fw_error("%s: failed to login to LUN %04x\n",
  770. tgt->bus_id, lu->lun);
  771. /* Let any waiting I/O fail from now on. */
  772. sbp2_unblock(lu->tgt);
  773. }
  774. goto out;
  775. }
  776. tgt->node_id = node_id;
  777. tgt->address_high = local_node_id << 16;
  778. sbp2_set_generation(lu, generation);
  779. lu->command_block_agent_address =
  780. ((u64)(be32_to_cpu(response.command_block_agent.high) & 0xffff)
  781. << 32) | be32_to_cpu(response.command_block_agent.low);
  782. lu->login_id = be32_to_cpu(response.misc) & 0xffff;
  783. fw_notify("%s: logged in to LUN %04x (%d retries)\n",
  784. tgt->bus_id, lu->lun, lu->retries);
  785. /* set appropriate retry limit(s) in BUSY_TIMEOUT register */
  786. sbp2_set_busy_timeout(lu);
  787. PREPARE_DELAYED_WORK(&lu->work, sbp2_reconnect);
  788. sbp2_agent_reset(lu);
  789. /* This was a re-login. */
  790. if (lu->has_sdev) {
  791. sbp2_cancel_orbs(lu);
  792. sbp2_conditionally_unblock(lu);
  793. goto out;
  794. }
  795. if (lu->tgt->workarounds & SBP2_WORKAROUND_DELAY_INQUIRY)
  796. ssleep(SBP2_INQUIRY_DELAY);
  797. shost = container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
  798. sdev = __scsi_add_device(shost, 0, 0, sbp2_lun2int(lu->lun), lu);
  799. /*
  800. * FIXME: We are unable to perform reconnects while in sbp2_login().
  801. * Therefore __scsi_add_device() will get into trouble if a bus reset
  802. * happens in parallel. It will either fail or leave us with an
  803. * unusable sdev. As a workaround we check for this and retry the
  804. * whole login and SCSI probing.
  805. */
  806. /* Reported error during __scsi_add_device() */
  807. if (IS_ERR(sdev))
  808. goto out_logout_login;
  809. /* Unreported error during __scsi_add_device() */
  810. smp_rmb(); /* get current card generation */
  811. if (generation != device->card->generation) {
  812. scsi_remove_device(sdev);
  813. scsi_device_put(sdev);
  814. goto out_logout_login;
  815. }
  816. /* No error during __scsi_add_device() */
  817. lu->has_sdev = true;
  818. scsi_device_put(sdev);
  819. sbp2_allow_block(lu);
  820. goto out;
  821. out_logout_login:
  822. smp_rmb(); /* generation may have changed */
  823. generation = device->generation;
  824. smp_rmb(); /* node_id must not be older than generation */
  825. sbp2_send_management_orb(lu, device->node_id, generation,
  826. SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
  827. /*
  828. * If a bus reset happened, sbp2_update will have requeued
  829. * lu->work already. Reset the work from reconnect to login.
  830. */
  831. PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
  832. out:
  833. sbp2_target_put(tgt);
  834. }
  835. static int sbp2_add_logical_unit(struct sbp2_target *tgt, int lun_entry)
  836. {
  837. struct sbp2_logical_unit *lu;
  838. lu = kmalloc(sizeof(*lu), GFP_KERNEL);
  839. if (!lu)
  840. return -ENOMEM;
  841. lu->address_handler.length = 0x100;
  842. lu->address_handler.address_callback = sbp2_status_write;
  843. lu->address_handler.callback_data = lu;
  844. if (fw_core_add_address_handler(&lu->address_handler,
  845. &fw_high_memory_region) < 0) {
  846. kfree(lu);
  847. return -ENOMEM;
  848. }
  849. lu->tgt = tgt;
  850. lu->lun = lun_entry & 0xffff;
  851. lu->retries = 0;
  852. lu->has_sdev = false;
  853. lu->blocked = false;
  854. ++tgt->dont_block;
  855. INIT_LIST_HEAD(&lu->orb_list);
  856. INIT_DELAYED_WORK(&lu->work, sbp2_login);
  857. list_add_tail(&lu->link, &tgt->lu_list);
  858. return 0;
  859. }
  860. static int sbp2_scan_logical_unit_dir(struct sbp2_target *tgt, u32 *directory)
  861. {
  862. struct fw_csr_iterator ci;
  863. int key, value;
  864. fw_csr_iterator_init(&ci, directory);
  865. while (fw_csr_iterator_next(&ci, &key, &value))
  866. if (key == SBP2_CSR_LOGICAL_UNIT_NUMBER &&
  867. sbp2_add_logical_unit(tgt, value) < 0)
  868. return -ENOMEM;
  869. return 0;
  870. }
  871. static int sbp2_scan_unit_dir(struct sbp2_target *tgt, u32 *directory,
  872. u32 *model, u32 *firmware_revision)
  873. {
  874. struct fw_csr_iterator ci;
  875. int key, value;
  876. unsigned int timeout;
  877. fw_csr_iterator_init(&ci, directory);
  878. while (fw_csr_iterator_next(&ci, &key, &value)) {
  879. switch (key) {
  880. case CSR_DEPENDENT_INFO | CSR_OFFSET:
  881. tgt->management_agent_address =
  882. CSR_REGISTER_BASE + 4 * value;
  883. break;
  884. case CSR_DIRECTORY_ID:
  885. tgt->directory_id = value;
  886. break;
  887. case CSR_MODEL:
  888. *model = value;
  889. break;
  890. case SBP2_CSR_FIRMWARE_REVISION:
  891. *firmware_revision = value;
  892. break;
  893. case SBP2_CSR_UNIT_CHARACTERISTICS:
  894. /* the timeout value is stored in 500ms units */
  895. timeout = ((unsigned int) value >> 8 & 0xff) * 500;
  896. timeout = max(timeout, SBP2_MIN_LOGIN_ORB_TIMEOUT);
  897. tgt->mgt_orb_timeout =
  898. min(timeout, SBP2_MAX_LOGIN_ORB_TIMEOUT);
  899. if (timeout > tgt->mgt_orb_timeout)
  900. fw_notify("%s: config rom contains %ds "
  901. "management ORB timeout, limiting "
  902. "to %ds\n", tgt->bus_id,
  903. timeout / 1000,
  904. tgt->mgt_orb_timeout / 1000);
  905. break;
  906. case SBP2_CSR_LOGICAL_UNIT_NUMBER:
  907. if (sbp2_add_logical_unit(tgt, value) < 0)
  908. return -ENOMEM;
  909. break;
  910. case SBP2_CSR_LOGICAL_UNIT_DIRECTORY:
  911. /* Adjust for the increment in the iterator */
  912. if (sbp2_scan_logical_unit_dir(tgt, ci.p - 1 + value) < 0)
  913. return -ENOMEM;
  914. break;
  915. }
  916. }
  917. return 0;
  918. }
  919. static void sbp2_init_workarounds(struct sbp2_target *tgt, u32 model,
  920. u32 firmware_revision)
  921. {
  922. int i;
  923. unsigned int w = sbp2_param_workarounds;
  924. if (w)
  925. fw_notify("Please notify linux1394-devel@lists.sourceforge.net "
  926. "if you need the workarounds parameter for %s\n",
  927. tgt->bus_id);
  928. if (w & SBP2_WORKAROUND_OVERRIDE)
  929. goto out;
  930. for (i = 0; i < ARRAY_SIZE(sbp2_workarounds_table); i++) {
  931. if (sbp2_workarounds_table[i].firmware_revision !=
  932. (firmware_revision & 0xffffff00))
  933. continue;
  934. if (sbp2_workarounds_table[i].model != model &&
  935. sbp2_workarounds_table[i].model != ~0)
  936. continue;
  937. w |= sbp2_workarounds_table[i].workarounds;
  938. break;
  939. }
  940. out:
  941. if (w)
  942. fw_notify("Workarounds for %s: 0x%x "
  943. "(firmware_revision 0x%06x, model_id 0x%06x)\n",
  944. tgt->bus_id, w, firmware_revision, model);
  945. tgt->workarounds = w;
  946. }
  947. static struct scsi_host_template scsi_driver_template;
  948. static int sbp2_probe(struct device *dev)
  949. {
  950. struct fw_unit *unit = fw_unit(dev);
  951. struct fw_device *device = fw_device(unit->device.parent);
  952. struct sbp2_target *tgt;
  953. struct sbp2_logical_unit *lu;
  954. struct Scsi_Host *shost;
  955. u32 model, firmware_revision;
  956. if (dma_get_max_seg_size(device->card->device) > SBP2_MAX_SEG_SIZE)
  957. BUG_ON(dma_set_max_seg_size(device->card->device,
  958. SBP2_MAX_SEG_SIZE));
  959. shost = scsi_host_alloc(&scsi_driver_template, sizeof(*tgt));
  960. if (shost == NULL)
  961. return -ENOMEM;
  962. tgt = (struct sbp2_target *)shost->hostdata;
  963. unit->device.driver_data = tgt;
  964. tgt->unit = unit;
  965. kref_init(&tgt->kref);
  966. INIT_LIST_HEAD(&tgt->lu_list);
  967. tgt->bus_id = unit->device.bus_id;
  968. tgt->guid = (u64)device->config_rom[3] << 32 | device->config_rom[4];
  969. if (fw_device_enable_phys_dma(device) < 0)
  970. goto fail_shost_put;
  971. if (scsi_add_host(shost, &unit->device) < 0)
  972. goto fail_shost_put;
  973. fw_device_get(device);
  974. fw_unit_get(unit);
  975. /* Initialize to values that won't match anything in our table. */
  976. firmware_revision = 0xff000000;
  977. model = 0xff000000;
  978. /* implicit directory ID */
  979. tgt->directory_id = ((unit->directory - device->config_rom) * 4
  980. + CSR_CONFIG_ROM) & 0xffffff;
  981. if (sbp2_scan_unit_dir(tgt, unit->directory, &model,
  982. &firmware_revision) < 0)
  983. goto fail_tgt_put;
  984. sbp2_init_workarounds(tgt, model, firmware_revision);
  985. /* Do the login in a workqueue so we can easily reschedule retries. */
  986. list_for_each_entry(lu, &tgt->lu_list, link)
  987. sbp2_queue_work(lu, 0);
  988. return 0;
  989. fail_tgt_put:
  990. sbp2_target_put(tgt);
  991. return -ENOMEM;
  992. fail_shost_put:
  993. scsi_host_put(shost);
  994. return -ENOMEM;
  995. }
  996. static int sbp2_remove(struct device *dev)
  997. {
  998. struct fw_unit *unit = fw_unit(dev);
  999. struct sbp2_target *tgt = unit->device.driver_data;
  1000. sbp2_target_put(tgt);
  1001. return 0;
  1002. }
  1003. static void sbp2_reconnect(struct work_struct *work)
  1004. {
  1005. struct sbp2_logical_unit *lu =
  1006. container_of(work, struct sbp2_logical_unit, work.work);
  1007. struct sbp2_target *tgt = lu->tgt;
  1008. struct fw_device *device = fw_device(tgt->unit->device.parent);
  1009. int generation, node_id, local_node_id;
  1010. if (fw_device_is_shutdown(device))
  1011. goto out;
  1012. generation = device->generation;
  1013. smp_rmb(); /* node_id must not be older than generation */
  1014. node_id = device->node_id;
  1015. local_node_id = device->card->node_id;
  1016. if (sbp2_send_management_orb(lu, node_id, generation,
  1017. SBP2_RECONNECT_REQUEST,
  1018. lu->login_id, NULL) < 0) {
  1019. /*
  1020. * If reconnect was impossible even though we are in the
  1021. * current generation, fall back and try to log in again.
  1022. *
  1023. * We could check for "Function rejected" status, but
  1024. * looking at the bus generation as simpler and more general.
  1025. */
  1026. smp_rmb(); /* get current card generation */
  1027. if (generation == device->card->generation ||
  1028. lu->retries++ >= 5) {
  1029. fw_error("%s: failed to reconnect\n", tgt->bus_id);
  1030. lu->retries = 0;
  1031. PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
  1032. }
  1033. sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
  1034. goto out;
  1035. }
  1036. tgt->node_id = node_id;
  1037. tgt->address_high = local_node_id << 16;
  1038. sbp2_set_generation(lu, generation);
  1039. fw_notify("%s: reconnected to LUN %04x (%d retries)\n",
  1040. tgt->bus_id, lu->lun, lu->retries);
  1041. sbp2_agent_reset(lu);
  1042. sbp2_cancel_orbs(lu);
  1043. sbp2_conditionally_unblock(lu);
  1044. out:
  1045. sbp2_target_put(tgt);
  1046. }
  1047. static void sbp2_update(struct fw_unit *unit)
  1048. {
  1049. struct sbp2_target *tgt = unit->device.driver_data;
  1050. struct sbp2_logical_unit *lu;
  1051. fw_device_enable_phys_dma(fw_device(unit->device.parent));
  1052. /*
  1053. * Fw-core serializes sbp2_update() against sbp2_remove().
  1054. * Iteration over tgt->lu_list is therefore safe here.
  1055. */
  1056. list_for_each_entry(lu, &tgt->lu_list, link) {
  1057. sbp2_conditionally_block(lu);
  1058. lu->retries = 0;
  1059. sbp2_queue_work(lu, 0);
  1060. }
  1061. }
  1062. #define SBP2_UNIT_SPEC_ID_ENTRY 0x0000609e
  1063. #define SBP2_SW_VERSION_ENTRY 0x00010483
  1064. static const struct fw_device_id sbp2_id_table[] = {
  1065. {
  1066. .match_flags = FW_MATCH_SPECIFIER_ID | FW_MATCH_VERSION,
  1067. .specifier_id = SBP2_UNIT_SPEC_ID_ENTRY,
  1068. .version = SBP2_SW_VERSION_ENTRY,
  1069. },
  1070. { }
  1071. };
  1072. static struct fw_driver sbp2_driver = {
  1073. .driver = {
  1074. .owner = THIS_MODULE,
  1075. .name = sbp2_driver_name,
  1076. .bus = &fw_bus_type,
  1077. .probe = sbp2_probe,
  1078. .remove = sbp2_remove,
  1079. },
  1080. .update = sbp2_update,
  1081. .id_table = sbp2_id_table,
  1082. };
  1083. static unsigned int
  1084. sbp2_status_to_sense_data(u8 *sbp2_status, u8 *sense_data)
  1085. {
  1086. int sam_status;
  1087. sense_data[0] = 0x70;
  1088. sense_data[1] = 0x0;
  1089. sense_data[2] = sbp2_status[1];
  1090. sense_data[3] = sbp2_status[4];
  1091. sense_data[4] = sbp2_status[5];
  1092. sense_data[5] = sbp2_status[6];
  1093. sense_data[6] = sbp2_status[7];
  1094. sense_data[7] = 10;
  1095. sense_data[8] = sbp2_status[8];
  1096. sense_data[9] = sbp2_status[9];
  1097. sense_data[10] = sbp2_status[10];
  1098. sense_data[11] = sbp2_status[11];
  1099. sense_data[12] = sbp2_status[2];
  1100. sense_data[13] = sbp2_status[3];
  1101. sense_data[14] = sbp2_status[12];
  1102. sense_data[15] = sbp2_status[13];
  1103. sam_status = sbp2_status[0] & 0x3f;
  1104. switch (sam_status) {
  1105. case SAM_STAT_GOOD:
  1106. case SAM_STAT_CHECK_CONDITION:
  1107. case SAM_STAT_CONDITION_MET:
  1108. case SAM_STAT_BUSY:
  1109. case SAM_STAT_RESERVATION_CONFLICT:
  1110. case SAM_STAT_COMMAND_TERMINATED:
  1111. return DID_OK << 16 | sam_status;
  1112. default:
  1113. return DID_ERROR << 16;
  1114. }
  1115. }
  1116. static void
  1117. complete_command_orb(struct sbp2_orb *base_orb, struct sbp2_status *status)
  1118. {
  1119. struct sbp2_command_orb *orb =
  1120. container_of(base_orb, struct sbp2_command_orb, base);
  1121. struct fw_device *device = fw_device(orb->lu->tgt->unit->device.parent);
  1122. int result;
  1123. if (status != NULL) {
  1124. if (STATUS_GET_DEAD(*status))
  1125. sbp2_agent_reset_no_wait(orb->lu);
  1126. switch (STATUS_GET_RESPONSE(*status)) {
  1127. case SBP2_STATUS_REQUEST_COMPLETE:
  1128. result = DID_OK << 16;
  1129. break;
  1130. case SBP2_STATUS_TRANSPORT_FAILURE:
  1131. result = DID_BUS_BUSY << 16;
  1132. break;
  1133. case SBP2_STATUS_ILLEGAL_REQUEST:
  1134. case SBP2_STATUS_VENDOR_DEPENDENT:
  1135. default:
  1136. result = DID_ERROR << 16;
  1137. break;
  1138. }
  1139. if (result == DID_OK << 16 && STATUS_GET_LEN(*status) > 1)
  1140. result = sbp2_status_to_sense_data(STATUS_GET_DATA(*status),
  1141. orb->cmd->sense_buffer);
  1142. } else {
  1143. /*
  1144. * If the orb completes with status == NULL, something
  1145. * went wrong, typically a bus reset happened mid-orb
  1146. * or when sending the write (less likely).
  1147. */
  1148. result = DID_BUS_BUSY << 16;
  1149. sbp2_conditionally_block(orb->lu);
  1150. }
  1151. dma_unmap_single(device->card->device, orb->base.request_bus,
  1152. sizeof(orb->request), DMA_TO_DEVICE);
  1153. if (scsi_sg_count(orb->cmd) > 0)
  1154. dma_unmap_sg(device->card->device, scsi_sglist(orb->cmd),
  1155. scsi_sg_count(orb->cmd),
  1156. orb->cmd->sc_data_direction);
  1157. if (orb->page_table_bus != 0)
  1158. dma_unmap_single(device->card->device, orb->page_table_bus,
  1159. sizeof(orb->page_table), DMA_TO_DEVICE);
  1160. orb->cmd->result = result;
  1161. orb->done(orb->cmd);
  1162. }
  1163. static int
  1164. sbp2_map_scatterlist(struct sbp2_command_orb *orb, struct fw_device *device,
  1165. struct sbp2_logical_unit *lu)
  1166. {
  1167. struct scatterlist *sg = scsi_sglist(orb->cmd);
  1168. int i, n;
  1169. n = dma_map_sg(device->card->device, sg, scsi_sg_count(orb->cmd),
  1170. orb->cmd->sc_data_direction);
  1171. if (n == 0)
  1172. goto fail;
  1173. /*
  1174. * Handle the special case where there is only one element in
  1175. * the scatter list by converting it to an immediate block
  1176. * request. This is also a workaround for broken devices such
  1177. * as the second generation iPod which doesn't support page
  1178. * tables.
  1179. */
  1180. if (n == 1) {
  1181. orb->request.data_descriptor.high =
  1182. cpu_to_be32(lu->tgt->address_high);
  1183. orb->request.data_descriptor.low =
  1184. cpu_to_be32(sg_dma_address(sg));
  1185. orb->request.misc |=
  1186. cpu_to_be32(COMMAND_ORB_DATA_SIZE(sg_dma_len(sg)));
  1187. return 0;
  1188. }
  1189. for_each_sg(sg, sg, n, i) {
  1190. orb->page_table[i].high = cpu_to_be32(sg_dma_len(sg) << 16);
  1191. orb->page_table[i].low = cpu_to_be32(sg_dma_address(sg));
  1192. }
  1193. orb->page_table_bus =
  1194. dma_map_single(device->card->device, orb->page_table,
  1195. sizeof(orb->page_table), DMA_TO_DEVICE);
  1196. if (dma_mapping_error(device->card->device, orb->page_table_bus))
  1197. goto fail_page_table;
  1198. /*
  1199. * The data_descriptor pointer is the one case where we need
  1200. * to fill in the node ID part of the address. All other
  1201. * pointers assume that the data referenced reside on the
  1202. * initiator (i.e. us), but data_descriptor can refer to data
  1203. * on other nodes so we need to put our ID in descriptor.high.
  1204. */
  1205. orb->request.data_descriptor.high = cpu_to_be32(lu->tgt->address_high);
  1206. orb->request.data_descriptor.low = cpu_to_be32(orb->page_table_bus);
  1207. orb->request.misc |= cpu_to_be32(COMMAND_ORB_PAGE_TABLE_PRESENT |
  1208. COMMAND_ORB_DATA_SIZE(n));
  1209. return 0;
  1210. fail_page_table:
  1211. dma_unmap_sg(device->card->device, scsi_sglist(orb->cmd),
  1212. scsi_sg_count(orb->cmd), orb->cmd->sc_data_direction);
  1213. fail:
  1214. return -ENOMEM;
  1215. }
  1216. /* SCSI stack integration */
  1217. static int sbp2_scsi_queuecommand(struct scsi_cmnd *cmd, scsi_done_fn_t done)
  1218. {
  1219. struct sbp2_logical_unit *lu = cmd->device->hostdata;
  1220. struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
  1221. struct sbp2_command_orb *orb;
  1222. unsigned int max_payload;
  1223. int generation, retval = SCSI_MLQUEUE_HOST_BUSY;
  1224. /*
  1225. * Bidirectional commands are not yet implemented, and unknown
  1226. * transfer direction not handled.
  1227. */
  1228. if (cmd->sc_data_direction == DMA_BIDIRECTIONAL) {
  1229. fw_error("Can't handle DMA_BIDIRECTIONAL, rejecting command\n");
  1230. cmd->result = DID_ERROR << 16;
  1231. done(cmd);
  1232. return 0;
  1233. }
  1234. orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
  1235. if (orb == NULL) {
  1236. fw_notify("failed to alloc orb\n");
  1237. return SCSI_MLQUEUE_HOST_BUSY;
  1238. }
  1239. /* Initialize rcode to something not RCODE_COMPLETE. */
  1240. orb->base.rcode = -1;
  1241. kref_init(&orb->base.kref);
  1242. orb->lu = lu;
  1243. orb->done = done;
  1244. orb->cmd = cmd;
  1245. orb->request.next.high = cpu_to_be32(SBP2_ORB_NULL);
  1246. /*
  1247. * At speed 100 we can do 512 bytes per packet, at speed 200,
  1248. * 1024 bytes per packet etc. The SBP-2 max_payload field
  1249. * specifies the max payload size as 2 ^ (max_payload + 2), so
  1250. * if we set this to max_speed + 7, we get the right value.
  1251. */
  1252. max_payload = min(device->max_speed + 7,
  1253. device->card->max_receive - 1);
  1254. orb->request.misc = cpu_to_be32(
  1255. COMMAND_ORB_MAX_PAYLOAD(max_payload) |
  1256. COMMAND_ORB_SPEED(device->max_speed) |
  1257. COMMAND_ORB_NOTIFY);
  1258. if (cmd->sc_data_direction == DMA_FROM_DEVICE)
  1259. orb->request.misc |= cpu_to_be32(COMMAND_ORB_DIRECTION);
  1260. generation = device->generation;
  1261. smp_rmb(); /* sbp2_map_scatterlist looks at tgt->address_high */
  1262. if (scsi_sg_count(cmd) && sbp2_map_scatterlist(orb, device, lu) < 0)
  1263. goto out;
  1264. memcpy(orb->request.command_block, cmd->cmnd, cmd->cmd_len);
  1265. orb->base.callback = complete_command_orb;
  1266. orb->base.request_bus =
  1267. dma_map_single(device->card->device, &orb->request,
  1268. sizeof(orb->request), DMA_TO_DEVICE);
  1269. if (dma_mapping_error(device->card->device, orb->base.request_bus))
  1270. goto out;
  1271. sbp2_send_orb(&orb->base, lu, lu->tgt->node_id, generation,
  1272. lu->command_block_agent_address + SBP2_ORB_POINTER);
  1273. retval = 0;
  1274. out:
  1275. kref_put(&orb->base.kref, free_orb);
  1276. return retval;
  1277. }
  1278. static int sbp2_scsi_slave_alloc(struct scsi_device *sdev)
  1279. {
  1280. struct sbp2_logical_unit *lu = sdev->hostdata;
  1281. /* (Re-)Adding logical units via the SCSI stack is not supported. */
  1282. if (!lu)
  1283. return -ENOSYS;
  1284. sdev->allow_restart = 1;
  1285. /* SBP-2 requires quadlet alignment of the data buffers. */
  1286. blk_queue_update_dma_alignment(sdev->request_queue, 4 - 1);
  1287. if (lu->tgt->workarounds & SBP2_WORKAROUND_INQUIRY_36)
  1288. sdev->inquiry_len = 36;
  1289. return 0;
  1290. }
  1291. static int sbp2_scsi_slave_configure(struct scsi_device *sdev)
  1292. {
  1293. struct sbp2_logical_unit *lu = sdev->hostdata;
  1294. sdev->use_10_for_rw = 1;
  1295. if (sbp2_param_exclusive_login)
  1296. sdev->manage_start_stop = 1;
  1297. if (sdev->type == TYPE_ROM)
  1298. sdev->use_10_for_ms = 1;
  1299. if (sdev->type == TYPE_DISK &&
  1300. lu->tgt->workarounds & SBP2_WORKAROUND_MODE_SENSE_8)
  1301. sdev->skip_ms_page_8 = 1;
  1302. if (lu->tgt->workarounds & SBP2_WORKAROUND_FIX_CAPACITY)
  1303. sdev->fix_capacity = 1;
  1304. if (lu->tgt->workarounds & SBP2_WORKAROUND_POWER_CONDITION)
  1305. sdev->start_stop_pwr_cond = 1;
  1306. if (lu->tgt->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
  1307. blk_queue_max_sectors(sdev->request_queue, 128 * 1024 / 512);
  1308. blk_queue_max_segment_size(sdev->request_queue, SBP2_MAX_SEG_SIZE);
  1309. return 0;
  1310. }
  1311. /*
  1312. * Called by scsi stack when something has really gone wrong. Usually
  1313. * called when a command has timed-out for some reason.
  1314. */
  1315. static int sbp2_scsi_abort(struct scsi_cmnd *cmd)
  1316. {
  1317. struct sbp2_logical_unit *lu = cmd->device->hostdata;
  1318. fw_notify("%s: sbp2_scsi_abort\n", lu->tgt->bus_id);
  1319. sbp2_agent_reset(lu);
  1320. sbp2_cancel_orbs(lu);
  1321. return SUCCESS;
  1322. }
  1323. /*
  1324. * Format of /sys/bus/scsi/devices/.../ieee1394_id:
  1325. * u64 EUI-64 : u24 directory_ID : u16 LUN (all printed in hexadecimal)
  1326. *
  1327. * This is the concatenation of target port identifier and logical unit
  1328. * identifier as per SAM-2...SAM-4 annex A.
  1329. */
  1330. static ssize_t
  1331. sbp2_sysfs_ieee1394_id_show(struct device *dev, struct device_attribute *attr,
  1332. char *buf)
  1333. {
  1334. struct scsi_device *sdev = to_scsi_device(dev);
  1335. struct sbp2_logical_unit *lu;
  1336. if (!sdev)
  1337. return 0;
  1338. lu = sdev->hostdata;
  1339. return sprintf(buf, "%016llx:%06x:%04x\n",
  1340. (unsigned long long)lu->tgt->guid,
  1341. lu->tgt->directory_id, lu->lun);
  1342. }
  1343. static DEVICE_ATTR(ieee1394_id, S_IRUGO, sbp2_sysfs_ieee1394_id_show, NULL);
  1344. static struct device_attribute *sbp2_scsi_sysfs_attrs[] = {
  1345. &dev_attr_ieee1394_id,
  1346. NULL
  1347. };
  1348. static struct scsi_host_template scsi_driver_template = {
  1349. .module = THIS_MODULE,
  1350. .name = "SBP-2 IEEE-1394",
  1351. .proc_name = sbp2_driver_name,
  1352. .queuecommand = sbp2_scsi_queuecommand,
  1353. .slave_alloc = sbp2_scsi_slave_alloc,
  1354. .slave_configure = sbp2_scsi_slave_configure,
  1355. .eh_abort_handler = sbp2_scsi_abort,
  1356. .this_id = -1,
  1357. .sg_tablesize = SG_ALL,
  1358. .use_clustering = ENABLE_CLUSTERING,
  1359. .cmd_per_lun = 1,
  1360. .can_queue = 1,
  1361. .sdev_attrs = sbp2_scsi_sysfs_attrs,
  1362. };
  1363. MODULE_AUTHOR("Kristian Hoegsberg <krh@bitplanet.net>");
  1364. MODULE_DESCRIPTION("SCSI over IEEE1394");
  1365. MODULE_LICENSE("GPL");
  1366. MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);
  1367. /* Provide a module alias so root-on-sbp2 initrds don't break. */
  1368. #ifndef CONFIG_IEEE1394_SBP2_MODULE
  1369. MODULE_ALIAS("sbp2");
  1370. #endif
  1371. static int __init sbp2_init(void)
  1372. {
  1373. sbp2_wq = create_singlethread_workqueue(KBUILD_MODNAME);
  1374. if (!sbp2_wq)
  1375. return -ENOMEM;
  1376. return driver_register(&sbp2_driver.driver);
  1377. }
  1378. static void __exit sbp2_cleanup(void)
  1379. {
  1380. driver_unregister(&sbp2_driver.driver);
  1381. destroy_workqueue(sbp2_wq);
  1382. }
  1383. module_init(sbp2_init);
  1384. module_exit(sbp2_cleanup);