blob: 1c8f71a59855b26b2123e611b3ce3978ee6d5dd2 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Andreas Herrmann4a9d2d82006-05-22 18:14:08 +02002 * This file is part of the zfcp device driver for
3 * FCP adapters for IBM System z9 and zSeries.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Andreas Herrmann4a9d2d82006-05-22 18:14:08 +02005 * (C) Copyright IBM Corp. 2002, 2006
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2, or (at your option)
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include "zfcp_ext.h"
23
24#define ZFCP_LOG_AREA ZFCP_LOG_AREA_CONFIG
25
26static int zfcp_ccw_probe(struct ccw_device *);
27static void zfcp_ccw_remove(struct ccw_device *);
28static int zfcp_ccw_set_online(struct ccw_device *);
29static int zfcp_ccw_set_offline(struct ccw_device *);
30static int zfcp_ccw_notify(struct ccw_device *, int);
31static void zfcp_ccw_shutdown(struct device *);
32
33static struct ccw_device_id zfcp_ccw_device_id[] = {
34 {CCW_DEVICE_DEVTYPE(ZFCP_CONTROL_UNIT_TYPE,
35 ZFCP_CONTROL_UNIT_MODEL,
36 ZFCP_DEVICE_TYPE,
37 ZFCP_DEVICE_MODEL)},
38 {CCW_DEVICE_DEVTYPE(ZFCP_CONTROL_UNIT_TYPE,
39 ZFCP_CONTROL_UNIT_MODEL,
40 ZFCP_DEVICE_TYPE,
41 ZFCP_DEVICE_MODEL_PRIV)},
42 {},
43};
44
45static struct ccw_driver zfcp_ccw_driver = {
46 .owner = THIS_MODULE,
47 .name = ZFCP_NAME,
48 .ids = zfcp_ccw_device_id,
49 .probe = zfcp_ccw_probe,
50 .remove = zfcp_ccw_remove,
51 .set_online = zfcp_ccw_set_online,
52 .set_offline = zfcp_ccw_set_offline,
53 .notify = zfcp_ccw_notify,
54 .driver = {
55 .shutdown = zfcp_ccw_shutdown,
56 },
57};
58
59MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id);
60
61/**
62 * zfcp_ccw_probe - probe function of zfcp driver
63 * @ccw_device: pointer to belonging ccw device
64 *
65 * This function gets called by the common i/o layer and sets up the initial
66 * data structures for each fcp adapter, which was detected by the system.
67 * Also the sysfs files for this adapter will be created by this function.
68 * In addition the nameserver port will be added to the ports of the adapter
69 * and its sysfs representation will be created too.
70 */
71static int
72zfcp_ccw_probe(struct ccw_device *ccw_device)
73{
74 struct zfcp_adapter *adapter;
75 int retval = 0;
76
77 down(&zfcp_data.config_sema);
78 adapter = zfcp_adapter_enqueue(ccw_device);
79 if (!adapter)
80 retval = -EINVAL;
81 else
82 ZFCP_LOG_DEBUG("Probed adapter %s\n",
83 zfcp_get_busid_by_adapter(adapter));
84 up(&zfcp_data.config_sema);
85 return retval;
86}
87
88/**
89 * zfcp_ccw_remove - remove function of zfcp driver
90 * @ccw_device: pointer to belonging ccw device
91 *
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 */
97static void
98zfcp_ccw_remove(struct ccw_device *ccw_device)
99{
100 struct zfcp_adapter *adapter;
101 struct zfcp_port *port, *p;
102 struct zfcp_unit *unit, *u;
103
104 ccw_device_set_offline(ccw_device);
105 down(&zfcp_data.config_sema);
106 adapter = dev_get_drvdata(&ccw_device->dev);
107
108 ZFCP_LOG_DEBUG("Removing adapter %s\n",
109 zfcp_get_busid_by_adapter(adapter));
110 write_lock_irq(&zfcp_data.config_lock);
111 list_for_each_entry_safe(port, p, &adapter->port_list_head, list) {
112 list_for_each_entry_safe(unit, u, &port->unit_list_head, list) {
113 list_move(&unit->list, &port->unit_remove_lh);
114 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE,
115 &unit->status);
116 }
117 list_move(&port->list, &adapter->port_remove_lh);
118 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
119 }
120 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
121 write_unlock_irq(&zfcp_data.config_lock);
122
123 list_for_each_entry_safe(port, p, &adapter->port_remove_lh, list) {
124 list_for_each_entry_safe(unit, u, &port->unit_remove_lh, list) {
125 zfcp_unit_dequeue(unit);
126 }
127 zfcp_port_dequeue(port);
128 }
129 zfcp_adapter_wait(adapter);
130 zfcp_adapter_dequeue(adapter);
131
132 up(&zfcp_data.config_sema);
133}
134
135/**
136 * zfcp_ccw_set_online - set_online function of zfcp driver
137 * @ccw_device: pointer to belonging ccw device
138 *
139 * This function gets called by the common i/o layer and sets an adapter
140 * into state online. Setting an fcp device online means that it will be
141 * registered with the SCSI stack, that the QDIO queues will be set up
142 * and that the adapter will be opened (asynchronously).
143 */
144static int
145zfcp_ccw_set_online(struct ccw_device *ccw_device)
146{
147 struct zfcp_adapter *adapter;
148 int retval;
149
150 down(&zfcp_data.config_sema);
151 adapter = dev_get_drvdata(&ccw_device->dev);
152
153 retval = zfcp_adapter_debug_register(adapter);
154 if (retval)
155 goto out;
156 retval = zfcp_erp_thread_setup(adapter);
157 if (retval) {
158 ZFCP_LOG_INFO("error: start of error recovery thread for "
159 "adapter %s failed\n",
160 zfcp_get_busid_by_adapter(adapter));
161 goto out_erp_thread;
162 }
163
164 retval = zfcp_adapter_scsi_register(adapter);
165 if (retval)
166 goto out_scsi_register;
Volker Sameskefea9d6c2006-08-02 11:05:16 +0200167
168 /* initialize request counter */
169 BUG_ON(!zfcp_reqlist_isempty(adapter));
170 adapter->req_no = 0;
171
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 zfcp_erp_modify_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING,
173 ZFCP_SET);
174 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
175 zfcp_erp_wait(adapter);
176 goto out;
177
178 out_scsi_register:
179 zfcp_erp_thread_kill(adapter);
180 out_erp_thread:
181 zfcp_adapter_debug_unregister(adapter);
182 out:
183 up(&zfcp_data.config_sema);
184 return retval;
185}
186
187/**
188 * zfcp_ccw_set_offline - set_offline function of zfcp driver
189 * @ccw_device: pointer to belonging ccw device
190 *
191 * This function gets called by the common i/o layer and sets an adapter
Michael Loehr9f287452007-05-09 11:01:24 +0200192 * into state offline.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 */
194static int
195zfcp_ccw_set_offline(struct ccw_device *ccw_device)
196{
197 struct zfcp_adapter *adapter;
198
199 down(&zfcp_data.config_sema);
200 adapter = dev_get_drvdata(&ccw_device->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 zfcp_erp_adapter_shutdown(adapter, 0);
202 zfcp_erp_wait(adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 zfcp_erp_thread_kill(adapter);
204 zfcp_adapter_debug_unregister(adapter);
205 up(&zfcp_data.config_sema);
206 return 0;
207}
208
209/**
210 * zfcp_ccw_notify
211 * @ccw_device: pointer to belonging ccw device
212 * @event: indicates if adapter was detached or attached
213 *
214 * This function gets called by the common i/o layer if an adapter has gone
215 * or reappeared.
216 */
217static int
218zfcp_ccw_notify(struct ccw_device *ccw_device, int event)
219{
220 struct zfcp_adapter *adapter;
221
222 down(&zfcp_data.config_sema);
223 adapter = dev_get_drvdata(&ccw_device->dev);
224 switch (event) {
225 case CIO_GONE:
226 ZFCP_LOG_NORMAL("adapter %s: device gone\n",
227 zfcp_get_busid_by_adapter(adapter));
228 debug_text_event(adapter->erp_dbf,1,"dev_gone");
229 zfcp_erp_adapter_shutdown(adapter, 0);
230 break;
231 case CIO_NO_PATH:
232 ZFCP_LOG_NORMAL("adapter %s: no path\n",
233 zfcp_get_busid_by_adapter(adapter));
234 debug_text_event(adapter->erp_dbf,1,"no_path");
235 zfcp_erp_adapter_shutdown(adapter, 0);
236 break;
237 case CIO_OPER:
238 ZFCP_LOG_NORMAL("adapter %s: operational again\n",
239 zfcp_get_busid_by_adapter(adapter));
240 debug_text_event(adapter->erp_dbf,1,"dev_oper");
241 zfcp_erp_modify_adapter_status(adapter,
242 ZFCP_STATUS_COMMON_RUNNING,
243 ZFCP_SET);
244 zfcp_erp_adapter_reopen(adapter,
245 ZFCP_STATUS_COMMON_ERP_FAILED);
246 break;
247 }
248 zfcp_erp_wait(adapter);
249 up(&zfcp_data.config_sema);
250 return 1;
251}
252
253/**
254 * zfcp_ccw_register - ccw register function
255 *
256 * Registers the driver at the common i/o layer. This function will be called
257 * at module load time/system start.
258 */
259int __init
260zfcp_ccw_register(void)
261{
262 int retval;
263
264 retval = ccw_driver_register(&zfcp_ccw_driver);
265 if (retval)
266 goto out;
267 retval = zfcp_sysfs_driver_create_files(&zfcp_ccw_driver.driver);
268 if (retval)
269 ccw_driver_unregister(&zfcp_ccw_driver);
270 out:
271 return retval;
272}
273
274/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 * zfcp_ccw_shutdown - gets called on reboot/shutdown
276 *
277 * Makes sure that QDIO queues are down when the system gets stopped.
278 */
279static void
280zfcp_ccw_shutdown(struct device *dev)
281{
282 struct zfcp_adapter *adapter;
283
284 down(&zfcp_data.config_sema);
285 adapter = dev_get_drvdata(dev);
286 zfcp_erp_adapter_shutdown(adapter, 0);
287 zfcp_erp_wait(adapter);
288 up(&zfcp_data.config_sema);
289}
290
291#undef ZFCP_LOG_AREA