Merge branch 'task_killable' of git://git.kernel.org/pub/scm/linux/kernel/git/willy...
[linux-2.6] / drivers / s390 / scsi / zfcp_ccw.c
1 /*
2  * This file is part of the zfcp device driver for
3  * FCP adapters for IBM System z9 and zSeries.
4  *
5  * (C) Copyright IBM Corp. 2002, 2006
6  *
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
22 #include "zfcp_ext.h"
23
24 #define ZFCP_LOG_AREA                   ZFCP_LOG_AREA_CONFIG
25
26 static int zfcp_ccw_probe(struct ccw_device *);
27 static void zfcp_ccw_remove(struct ccw_device *);
28 static int zfcp_ccw_set_online(struct ccw_device *);
29 static int zfcp_ccw_set_offline(struct ccw_device *);
30 static int zfcp_ccw_notify(struct ccw_device *, int);
31 static void zfcp_ccw_shutdown(struct ccw_device *);
32
33 static 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
45 static 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         .shutdown    = zfcp_ccw_shutdown,
55         .driver = {
56                 .groups = zfcp_driver_attr_groups,
57         },
58 };
59
60 MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id);
61
62 /**
63  * zfcp_ccw_probe - probe function of zfcp driver
64  * @ccw_device: pointer to belonging ccw device
65  *
66  * This function gets called by the common i/o layer and sets up the initial
67  * data structures for each fcp adapter, which was detected by the system.
68  * Also the sysfs files for this adapter will be created by this function.
69  * In addition the nameserver port will be added to the ports of the adapter
70  * and its sysfs representation will be created too.
71  */
72 static int
73 zfcp_ccw_probe(struct ccw_device *ccw_device)
74 {
75         struct zfcp_adapter *adapter;
76         int retval = 0;
77
78         down(&zfcp_data.config_sema);
79         adapter = zfcp_adapter_enqueue(ccw_device);
80         if (!adapter)
81                 retval = -EINVAL;
82         else
83                 ZFCP_LOG_DEBUG("Probed adapter %s\n",
84                                zfcp_get_busid_by_adapter(adapter));
85         up(&zfcp_data.config_sema);
86         return retval;
87 }
88
89 /**
90  * zfcp_ccw_remove - remove function of zfcp driver
91  * @ccw_device: pointer to belonging ccw device
92  *
93  * This function gets called by the common i/o layer and removes an adapter
94  * from the system. Task of this function is to get rid of all units and
95  * ports that belong to this adapter. And in addition all resources of this
96  * adapter will be freed too.
97  */
98 static void
99 zfcp_ccw_remove(struct ccw_device *ccw_device)
100 {
101         struct zfcp_adapter *adapter;
102         struct zfcp_port *port, *p;
103         struct zfcp_unit *unit, *u;
104
105         ccw_device_set_offline(ccw_device);
106         down(&zfcp_data.config_sema);
107         adapter = dev_get_drvdata(&ccw_device->dev);
108
109         ZFCP_LOG_DEBUG("Removing adapter %s\n",
110                        zfcp_get_busid_by_adapter(adapter));
111         write_lock_irq(&zfcp_data.config_lock);
112         list_for_each_entry_safe(port, p, &adapter->port_list_head, list) {
113                 list_for_each_entry_safe(unit, u, &port->unit_list_head, list) {
114                         list_move(&unit->list, &port->unit_remove_lh);
115                         atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE,
116                                         &unit->status);
117                 }
118                 list_move(&port->list, &adapter->port_remove_lh);
119                 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
120         }
121         atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
122         write_unlock_irq(&zfcp_data.config_lock);
123
124         list_for_each_entry_safe(port, p, &adapter->port_remove_lh, list) {
125                 list_for_each_entry_safe(unit, u, &port->unit_remove_lh, list) {
126                         if (atomic_test_mask(ZFCP_STATUS_UNIT_REGISTERED,
127                                 &unit->status))
128                                 scsi_remove_device(unit->device);
129                         zfcp_unit_dequeue(unit);
130                 }
131                 zfcp_port_dequeue(port);
132         }
133         zfcp_adapter_wait(adapter);
134         zfcp_adapter_dequeue(adapter);
135
136         up(&zfcp_data.config_sema);
137 }
138
139 /**
140  * zfcp_ccw_set_online - set_online function of zfcp driver
141  * @ccw_device: pointer to belonging ccw device
142  *
143  * This function gets called by the common i/o layer and sets an adapter
144  * into state online. Setting an fcp device online means that it will be
145  * registered with the SCSI stack, that the QDIO queues will be set up
146  * and that the adapter will be opened (asynchronously).
147  */
148 static int
149 zfcp_ccw_set_online(struct ccw_device *ccw_device)
150 {
151         struct zfcp_adapter *adapter;
152         int retval;
153
154         down(&zfcp_data.config_sema);
155         adapter = dev_get_drvdata(&ccw_device->dev);
156
157         retval = zfcp_erp_thread_setup(adapter);
158         if (retval) {
159                 ZFCP_LOG_INFO("error: start of error recovery thread for "
160                               "adapter %s failed\n",
161                               zfcp_get_busid_by_adapter(adapter));
162                 goto out;
163         }
164
165         retval = zfcp_adapter_scsi_register(adapter);
166         if (retval)
167                 goto out_scsi_register;
168
169         /* initialize request counter */
170         BUG_ON(!zfcp_reqlist_isempty(adapter));
171         adapter->req_no = 0;
172
173         zfcp_erp_modify_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING,
174                                        ZFCP_SET);
175         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
176         zfcp_erp_wait(adapter);
177         goto out;
178
179  out_scsi_register:
180         zfcp_erp_thread_kill(adapter);
181  out:
182         up(&zfcp_data.config_sema);
183         return retval;
184 }
185
186 /**
187  * zfcp_ccw_set_offline - set_offline function of zfcp driver
188  * @ccw_device: pointer to belonging ccw device
189  *
190  * This function gets called by the common i/o layer and sets an adapter
191  * into state offline.
192  */
193 static int
194 zfcp_ccw_set_offline(struct ccw_device *ccw_device)
195 {
196         struct zfcp_adapter *adapter;
197
198         down(&zfcp_data.config_sema);
199         adapter = dev_get_drvdata(&ccw_device->dev);
200         zfcp_erp_adapter_shutdown(adapter, 0);
201         zfcp_erp_wait(adapter);
202         zfcp_erp_thread_kill(adapter);
203         up(&zfcp_data.config_sema);
204         return 0;
205 }
206
207 /**
208  * zfcp_ccw_notify
209  * @ccw_device: pointer to belonging ccw device
210  * @event: indicates if adapter was detached or attached
211  *
212  * This function gets called by the common i/o layer if an adapter has gone
213  * or reappeared.
214  */
215 static int
216 zfcp_ccw_notify(struct ccw_device *ccw_device, int event)
217 {
218         struct zfcp_adapter *adapter;
219
220         down(&zfcp_data.config_sema);
221         adapter = dev_get_drvdata(&ccw_device->dev);
222         switch (event) {
223         case CIO_GONE:
224                 ZFCP_LOG_NORMAL("adapter %s: device gone\n",
225                                 zfcp_get_busid_by_adapter(adapter));
226                 debug_text_event(adapter->erp_dbf,1,"dev_gone");
227                 zfcp_erp_adapter_shutdown(adapter, 0);
228                 break;
229         case CIO_NO_PATH:
230                 ZFCP_LOG_NORMAL("adapter %s: no path\n",
231                                 zfcp_get_busid_by_adapter(adapter));
232                 debug_text_event(adapter->erp_dbf,1,"no_path");
233                 zfcp_erp_adapter_shutdown(adapter, 0);
234                 break;
235         case CIO_OPER:
236                 ZFCP_LOG_NORMAL("adapter %s: operational again\n",
237                                 zfcp_get_busid_by_adapter(adapter));
238                 debug_text_event(adapter->erp_dbf,1,"dev_oper");
239                 zfcp_erp_modify_adapter_status(adapter,
240                                                ZFCP_STATUS_COMMON_RUNNING,
241                                                ZFCP_SET);
242                 zfcp_erp_adapter_reopen(adapter,
243                                         ZFCP_STATUS_COMMON_ERP_FAILED);
244                 break;
245         }
246         zfcp_erp_wait(adapter);
247         up(&zfcp_data.config_sema);
248         return 1;
249 }
250
251 /**
252  * zfcp_ccw_register - ccw register function
253  *
254  * Registers the driver at the common i/o layer. This function will be called
255  * at module load time/system start.
256  */
257 int __init
258 zfcp_ccw_register(void)
259 {
260         return ccw_driver_register(&zfcp_ccw_driver);
261 }
262
263 /**
264  * zfcp_ccw_shutdown - gets called on reboot/shutdown
265  *
266  * Makes sure that QDIO queues are down when the system gets stopped.
267  */
268 static void
269 zfcp_ccw_shutdown(struct ccw_device *cdev)
270 {
271         struct zfcp_adapter *adapter;
272
273         down(&zfcp_data.config_sema);
274         adapter = dev_get_drvdata(&cdev->dev);
275         zfcp_erp_adapter_shutdown(adapter, 0);
276         zfcp_erp_wait(adapter);
277         up(&zfcp_data.config_sema);
278 }
279
280 #undef ZFCP_LOG_AREA