blob: f9879d400d0e609cb901e88587347d19b06bd453 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Christof Schmittfa04c282008-06-10 18:20:56 +02002 * zfcp device driver
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Christof Schmittfa04c282008-06-10 18:20:56 +02004 * Registration and callback for the s390 common I/O layer.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
Heiko Carstensa53c8fa2012-07-20 11:15:04 +02006 * Copyright IBM Corp. 2002, 2010
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 */
8
Christof Schmittecf39d42008-12-25 13:39:53 +01009#define KMSG_COMPONENT "zfcp"
10#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11
Heiko Carstens3a4c5d52011-07-30 09:25:15 +020012#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include "zfcp_ext.h"
Christof Schmittb6bd2fb2010-02-17 11:18:50 +010014#include "zfcp_reqlist.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070015
Christof Schmitt6fcf41d2009-05-15 13:18:21 +020016#define ZFCP_MODEL_PRIV 0x4
17
Swen Schilligde3dc572009-11-24 16:54:00 +010018static DEFINE_SPINLOCK(zfcp_ccw_adapter_ref_lock);
19
20struct zfcp_adapter *zfcp_ccw_adapter_by_cdev(struct ccw_device *cdev)
21{
22 struct zfcp_adapter *adapter;
23 unsigned long flags;
24
25 spin_lock_irqsave(&zfcp_ccw_adapter_ref_lock, flags);
26 adapter = dev_get_drvdata(&cdev->dev);
27 if (adapter)
28 kref_get(&adapter->ref);
29 spin_unlock_irqrestore(&zfcp_ccw_adapter_ref_lock, flags);
30 return adapter;
31}
32
33void zfcp_ccw_adapter_put(struct zfcp_adapter *adapter)
34{
35 unsigned long flags;
36
37 spin_lock_irqsave(&zfcp_ccw_adapter_ref_lock, flags);
38 kref_put(&adapter->ref, zfcp_adapter_release);
39 spin_unlock_irqrestore(&zfcp_ccw_adapter_ref_lock, flags);
40}
41
Steffen Maiercb452142012-09-04 15:23:32 +020042/**
43 * zfcp_ccw_activate - activate adapter and wait for it to finish
44 * @cdev: pointer to belonging ccw device
45 * @clear: Status flags to clear.
46 * @tag: s390dbf trace record tag
47 */
48static int zfcp_ccw_activate(struct ccw_device *cdev, int clear, char *tag)
Martin Petermanndaa70fa2009-06-16 10:30:34 +020049{
Swen Schilligde3dc572009-11-24 16:54:00 +010050 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
Martin Petermanndaa70fa2009-06-16 10:30:34 +020051
Christof Schmitt143bb6b2009-08-18 15:43:27 +020052 if (!adapter)
53 return 0;
54
Steffen Maiercb452142012-09-04 15:23:32 +020055 zfcp_erp_clear_adapter_status(adapter, clear);
Swen Schilligedaed852010-09-08 14:40:01 +020056 zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
Martin Petermanndaa70fa2009-06-16 10:30:34 +020057 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
Steffen Maiercb452142012-09-04 15:23:32 +020058 tag);
Martin Petermanndaa70fa2009-06-16 10:30:34 +020059 zfcp_erp_wait(adapter);
Steffen Maier43f60cb2012-09-04 15:23:35 +020060 flush_work(&adapter->scan_work); /* ok to call even if nothing queued */
Martin Petermanndaa70fa2009-06-16 10:30:34 +020061
Swen Schilligde3dc572009-11-24 16:54:00 +010062 zfcp_ccw_adapter_put(adapter);
63
Martin Petermanndaa70fa2009-06-16 10:30:34 +020064 return 0;
65}
66
Christof Schmitt6fcf41d2009-05-15 13:18:21 +020067static struct ccw_device_id zfcp_ccw_device_id[] = {
68 { CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, 0x3) },
69 { CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, ZFCP_MODEL_PRIV) },
70 {},
71};
72MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id);
73
74/**
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 * zfcp_ccw_probe - probe function of zfcp driver
Swen Schilligde3dc572009-11-24 16:54:00 +010076 * @cdev: pointer to belonging ccw device
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 *
Christof Schmitt143bb6b2009-08-18 15:43:27 +020078 * This function gets called by the common i/o layer for each FCP
79 * device found on the current system. This is only a stub to make cio
80 * work: To only allocate adapter resources for devices actually used,
81 * the allocation is deferred to the first call to ccw_set_online.
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 */
Swen Schilligde3dc572009-11-24 16:54:00 +010083static int zfcp_ccw_probe(struct ccw_device *cdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070084{
Christof Schmitt143bb6b2009-08-18 15:43:27 +020085 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086}
87
88/**
89 * zfcp_ccw_remove - remove function of zfcp driver
Swen Schilligde3dc572009-11-24 16:54:00 +010090 * @cdev: pointer to belonging ccw device
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 *
92 * This function gets called by the common i/o layer and removes an adapter
93 * from the system. Task of this function is to get rid of all units and
94 * ports that belong to this adapter. And in addition all resources of this
95 * adapter will be freed too.
96 */
Swen Schilligde3dc572009-11-24 16:54:00 +010097static void zfcp_ccw_remove(struct ccw_device *cdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070098{
99 struct zfcp_adapter *adapter;
100 struct zfcp_port *port, *p;
101 struct zfcp_unit *unit, *u;
Christof Schmitt04062892008-10-01 12:42:20 +0200102 LIST_HEAD(unit_remove_lh);
103 LIST_HEAD(port_remove_lh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
Swen Schilligde3dc572009-11-24 16:54:00 +0100105 ccw_device_set_offline(cdev);
Christof Schmitt143bb6b2009-08-18 15:43:27 +0200106
Swen Schilligde3dc572009-11-24 16:54:00 +0100107 adapter = zfcp_ccw_adapter_by_cdev(cdev);
Swen Schilligecf0c772009-11-24 16:53:58 +0100108 if (!adapter)
109 return;
110
Swen Schilligecf0c772009-11-24 16:53:58 +0100111 write_lock_irq(&adapter->port_list_lock);
112 list_for_each_entry_safe(port, p, &adapter->port_list, list) {
113 write_lock(&port->unit_list_lock);
Swen Schillig6b1833342009-11-24 16:54:05 +0100114 list_for_each_entry_safe(unit, u, &port->unit_list, list)
Swen Schilligecf0c772009-11-24 16:53:58 +0100115 list_move(&unit->list, &unit_remove_lh);
Swen Schilligecf0c772009-11-24 16:53:58 +0100116 write_unlock(&port->unit_list_lock);
Swen Schilligecf0c772009-11-24 16:53:58 +0100117 list_move(&port->list, &port_remove_lh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 }
Swen Schilligecf0c772009-11-24 16:53:58 +0100119 write_unlock_irq(&adapter->port_list_lock);
Swen Schilligde3dc572009-11-24 16:54:00 +0100120 zfcp_ccw_adapter_put(adapter); /* put from zfcp_ccw_adapter_by_cdev */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121
Swen Schilligf3450c72009-11-24 16:53:59 +0100122 list_for_each_entry_safe(unit, u, &unit_remove_lh, list)
Sebastian Ott86bdf212013-04-26 16:13:49 +0200123 device_unregister(&unit->dev);
Swen Schilligf3450c72009-11-24 16:53:59 +0100124
125 list_for_each_entry_safe(port, p, &port_remove_lh, list)
Sebastian Ott83d4e1c2013-04-26 16:13:48 +0200126 device_unregister(&port->dev);
Swen Schilligf3450c72009-11-24 16:53:59 +0100127
Swen Schilligde3dc572009-11-24 16:54:00 +0100128 zfcp_adapter_unregister(adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129}
130
131/**
132 * zfcp_ccw_set_online - set_online function of zfcp driver
Swen Schilligde3dc572009-11-24 16:54:00 +0100133 * @cdev: pointer to belonging ccw device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 *
Christof Schmitt143bb6b2009-08-18 15:43:27 +0200135 * This function gets called by the common i/o layer and sets an
136 * adapter into state online. The first call will allocate all
137 * adapter resources that will be retained until the device is removed
138 * via zfcp_ccw_remove.
139 *
140 * Setting an fcp device online means that it will be registered with
141 * the SCSI stack, that the QDIO queues will be set up and that the
142 * adapter will be opened.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 */
Swen Schilligde3dc572009-11-24 16:54:00 +0100144static int zfcp_ccw_set_online(struct ccw_device *cdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145{
Swen Schilligde3dc572009-11-24 16:54:00 +0100146 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
Christof Schmitt143bb6b2009-08-18 15:43:27 +0200148 if (!adapter) {
Swen Schilligde3dc572009-11-24 16:54:00 +0100149 adapter = zfcp_adapter_enqueue(cdev);
150
151 if (IS_ERR(adapter)) {
152 dev_err(&cdev->dev,
Christof Schmitt143bb6b2009-08-18 15:43:27 +0200153 "Setting up data structures for the "
154 "FCP adapter failed\n");
Swen Schilligde3dc572009-11-24 16:54:00 +0100155 return PTR_ERR(adapter);
Christof Schmitt143bb6b2009-08-18 15:43:27 +0200156 }
Swen Schilligde3dc572009-11-24 16:54:00 +0100157 kref_get(&adapter->ref);
Christof Schmitt143bb6b2009-08-18 15:43:27 +0200158 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
Volker Sameskefea9d6c2006-08-02 11:05:16 +0200160 /* initialize request counter */
Christof Schmittb6bd2fb2010-02-17 11:18:50 +0100161 BUG_ON(!zfcp_reqlist_isempty(adapter->req_list));
Volker Sameskefea9d6c2006-08-02 11:05:16 +0200162 adapter->req_no = 0;
163
Steffen Maiercb452142012-09-04 15:23:32 +0200164 zfcp_ccw_activate(cdev, 0, "ccsonl1");
Steffen Maier43f60cb2012-09-04 15:23:35 +0200165 /* scan for remote ports
166 either at the end of any successful adapter recovery
167 or only after the adapter recovery for setting a device online */
168 zfcp_fc_inverse_conditional_port_scan(adapter);
169 flush_work(&adapter->scan_work); /* ok to call even if nothing queued */
Steffen Maiercb452142012-09-04 15:23:32 +0200170 zfcp_ccw_adapter_put(adapter);
171 return 0;
172}
173
174/**
175 * zfcp_ccw_offline_sync - shut down adapter and wait for it to finish
176 * @cdev: pointer to belonging ccw device
177 * @set: Status flags to set.
178 * @tag: s390dbf trace record tag
179 *
180 * This function gets called by the common i/o layer and sets an adapter
181 * into state offline.
182 */
183static int zfcp_ccw_offline_sync(struct ccw_device *cdev, int set, char *tag)
184{
185 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
186
187 if (!adapter)
188 return 0;
189
190 zfcp_erp_set_adapter_status(adapter, set);
191 zfcp_erp_adapter_shutdown(adapter, 0, tag);
192 zfcp_erp_wait(adapter);
193
Swen Schilligde3dc572009-11-24 16:54:00 +0100194 zfcp_ccw_adapter_put(adapter);
195 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196}
197
198/**
199 * zfcp_ccw_set_offline - set_offline function of zfcp driver
Swen Schilligde3dc572009-11-24 16:54:00 +0100200 * @cdev: pointer to belonging ccw device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 *
202 * This function gets called by the common i/o layer and sets an adapter
Michael Loehr9f287452007-05-09 11:01:24 +0200203 * into state offline.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 */
Swen Schilligde3dc572009-11-24 16:54:00 +0100205static int zfcp_ccw_set_offline(struct ccw_device *cdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206{
Steffen Maiercb452142012-09-04 15:23:32 +0200207 return zfcp_ccw_offline_sync(cdev, 0, "ccsoff1");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208}
209
210/**
Christof Schmittfa04c282008-06-10 18:20:56 +0200211 * zfcp_ccw_notify - ccw notify function
Swen Schilligde3dc572009-11-24 16:54:00 +0100212 * @cdev: pointer to belonging ccw device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 * @event: indicates if adapter was detached or attached
214 *
215 * This function gets called by the common i/o layer if an adapter has gone
216 * or reappeared.
217 */
Swen Schilligde3dc572009-11-24 16:54:00 +0100218static int zfcp_ccw_notify(struct ccw_device *cdev, int event)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
Swen Schilligde3dc572009-11-24 16:54:00 +0100220 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
221
222 if (!adapter)
223 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 switch (event) {
226 case CIO_GONE:
Steffen Maiercb452142012-09-04 15:23:32 +0200227 if (atomic_read(&adapter->status) &
228 ZFCP_STATUS_ADAPTER_SUSPENDED) { /* notification ignore */
229 zfcp_dbf_hba_basic("ccnigo1", adapter);
230 break;
231 }
Swen Schilligde3dc572009-11-24 16:54:00 +0100232 dev_warn(&cdev->dev, "The FCP device has been detached\n");
Swen Schilligea4a3a62010-12-02 15:16:16 +0100233 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 break;
235 case CIO_NO_PATH:
Swen Schilligde3dc572009-11-24 16:54:00 +0100236 dev_warn(&cdev->dev,
Christof Schmittff3b24f2008-10-01 12:42:15 +0200237 "The CHPID for the FCP device is offline\n");
Swen Schilligea4a3a62010-12-02 15:16:16 +0100238 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 break;
240 case CIO_OPER:
Steffen Maiercb452142012-09-04 15:23:32 +0200241 if (atomic_read(&adapter->status) &
242 ZFCP_STATUS_ADAPTER_SUSPENDED) { /* notification ignore */
243 zfcp_dbf_hba_basic("ccniop1", adapter);
244 break;
245 }
Swen Schilligde3dc572009-11-24 16:54:00 +0100246 dev_info(&cdev->dev, "The FCP device is operational again\n");
Swen Schilligedaed852010-09-08 14:40:01 +0200247 zfcp_erp_set_adapter_status(adapter,
248 ZFCP_STATUS_COMMON_RUNNING);
Martin Peschke1f6f7122008-04-18 12:51:55 +0200249 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
Swen Schilligea4a3a62010-12-02 15:16:16 +0100250 "ccnoti4");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 break;
Sebastian Ott47593bf2009-03-31 19:16:05 +0200252 case CIO_BOXED:
Swen Schilligde3dc572009-11-24 16:54:00 +0100253 dev_warn(&cdev->dev, "The FCP device did not respond within "
254 "the specified time\n");
Swen Schilligea4a3a62010-12-02 15:16:16 +0100255 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5");
Sebastian Ott47593bf2009-03-31 19:16:05 +0200256 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 }
Swen Schilligde3dc572009-11-24 16:54:00 +0100258
259 zfcp_ccw_adapter_put(adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 return 1;
261}
262
263/**
Christof Schmittfa04c282008-06-10 18:20:56 +0200264 * zfcp_ccw_shutdown - handle shutdown from cio
265 * @cdev: device for adapter to shutdown.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 */
Christof Schmittfa04c282008-06-10 18:20:56 +0200267static void zfcp_ccw_shutdown(struct ccw_device *cdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268{
Swen Schilligde3dc572009-11-24 16:54:00 +0100269 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
Christof Schmitt1f99bd42009-09-24 10:23:23 +0200271 if (!adapter)
Swen Schilligde3dc572009-11-24 16:54:00 +0100272 return;
Christof Schmitt1f99bd42009-09-24 10:23:23 +0200273
Swen Schilligea4a3a62010-12-02 15:16:16 +0100274 zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 zfcp_erp_wait(adapter);
Christof Schmitt143bb6b2009-08-18 15:43:27 +0200276 zfcp_erp_thread_kill(adapter);
Swen Schilligde3dc572009-11-24 16:54:00 +0100277
278 zfcp_ccw_adapter_put(adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279}
280
Steffen Maiercb452142012-09-04 15:23:32 +0200281static int zfcp_ccw_suspend(struct ccw_device *cdev)
282{
283 zfcp_ccw_offline_sync(cdev, ZFCP_STATUS_ADAPTER_SUSPENDED, "ccsusp1");
284 return 0;
285}
286
287static int zfcp_ccw_thaw(struct ccw_device *cdev)
288{
289 /* trace records for thaw and final shutdown during suspend
290 can only be found in system dump until the end of suspend
291 but not after resume because it's based on the memory image
292 right after the very first suspend (freeze) callback */
293 zfcp_ccw_activate(cdev, 0, "ccthaw1");
294 return 0;
295}
296
297static int zfcp_ccw_resume(struct ccw_device *cdev)
298{
299 zfcp_ccw_activate(cdev, ZFCP_STATUS_ADAPTER_SUSPENDED, "ccresu1");
300 return 0;
301}
302
Christof Schmittc5afd812009-09-24 10:23:22 +0200303struct ccw_driver zfcp_ccw_driver = {
Sebastian Ott3bda0582011-03-23 10:16:02 +0100304 .driver = {
305 .owner = THIS_MODULE,
306 .name = "zfcp",
307 },
Christof Schmittfa04c282008-06-10 18:20:56 +0200308 .ids = zfcp_ccw_device_id,
309 .probe = zfcp_ccw_probe,
310 .remove = zfcp_ccw_remove,
311 .set_online = zfcp_ccw_set_online,
312 .set_offline = zfcp_ccw_set_offline,
313 .notify = zfcp_ccw_notify,
314 .shutdown = zfcp_ccw_shutdown,
Steffen Maiercb452142012-09-04 15:23:32 +0200315 .freeze = zfcp_ccw_suspend,
316 .thaw = zfcp_ccw_thaw,
317 .restore = zfcp_ccw_resume,
Christof Schmittfa04c282008-06-10 18:20:56 +0200318};